Revert "fix: snip infinite type recursion"

This reverts commit 38d4f26d03.

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

@@ -94,7 +94,7 @@ jobs:
             fi
           done
       - name: Install Deno
-        uses: denoland/setup-deno@v2
+        uses: denoland/setup-deno@v1
         with:
           deno-version: v1.x
       - name: Maybe install gtk-rs dependencies

Cargo.toml

@@ -40,36 +40,36 @@ members = [
 exclude = ["benchmarks", "examples", "projects"]
 
 [workspace.package]
-version = "0.7.0-rc1"
+version = "0.7.0-beta6"
 edition = "2021"
 rust-version = "1.76"
 
 [workspace.dependencies]
-throw_error = { path = "./any_error/", version = "0.2.0-rc1" }
+throw_error = { path = "./any_error/", version = "0.2.0-beta6" }
 any_spawner = { path = "./any_spawner/", version = "0.1.0" }
 const_str_slice_concat = { path = "./const_str_slice_concat", version = "0.1.0" }
 either_of = { path = "./either_of/", version = "0.1.0" }
-hydration_context = { path = "./hydration_context", version = "0.2.0-rc1" }
-leptos = { path = "./leptos", version = "0.7.0-rc1" }
-leptos_config = { path = "./leptos_config", version = "0.7.0-rc1" }
-leptos_dom = { path = "./leptos_dom", version = "0.7.0-rc1" }
-leptos_hot_reload = { path = "./leptos_hot_reload", version = "0.7.0-rc1" }
-leptos_integration_utils = { path = "./integrations/utils", version = "0.7.0-rc1" }
-leptos_macro = { path = "./leptos_macro", version = "0.7.0-rc1" }
-leptos_router = { path = "./router", version = "0.7.0-rc1" }
-leptos_router_macro = { path = "./router_macro", version = "0.7.0-rc1" }
-leptos_server = { path = "./leptos_server", version = "0.7.0-rc1" }
-leptos_meta = { path = "./meta", version = "0.7.0-rc1" }
-next_tuple = { path = "./next_tuple", version = "0.1.0-rc1" }
+hydration_context = { path = "./hydration_context", version = "0.2.0-beta6" }
+leptos = { path = "./leptos", version = "0.7.0-beta6" }
+leptos_config = { path = "./leptos_config", version = "0.7.0-beta6" }
+leptos_dom = { path = "./leptos_dom", version = "0.7.0-beta6" }
+leptos_hot_reload = { path = "./leptos_hot_reload", version = "0.7.0-beta6" }
+leptos_integration_utils = { path = "./integrations/utils", version = "0.7.0-beta6" }
+leptos_macro = { path = "./leptos_macro", version = "0.7.0-beta6" }
+leptos_router = { path = "./router", version = "0.7.0-beta6" }
+leptos_router_macro = { path = "./router_macro", version = "0.7.0-beta6" }
+leptos_server = { path = "./leptos_server", version = "0.7.0-beta6" }
+leptos_meta = { path = "./meta", version = "0.7.0-beta6" }
+next_tuple = { path = "./next_tuple", version = "0.1.0-beta6" }
 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.0-rc1" }
-reactive_stores = { path = "./reactive_stores", version = "0.1.0-rc1" }
-reactive_stores_macro = { path = "./reactive_stores_macro", version = "0.1.0-rc1" }
-server_fn = { path = "./server_fn", version = "0.7.0-rc1" }
-server_fn_macro = { path = "./server_fn_macro", version = "0.7.0-rc1" }
-server_fn_macro_default = { path = "./server_fn/server_fn_macro_default", version = "0.7.0-rc1" }
-tachys = { path = "./tachys", version = "0.1.0-rc1" }
+reactive_graph = { path = "./reactive_graph", version = "0.1.0-beta6" }
+reactive_stores = { path = "./reactive_stores", version = "0.1.0-beta6" }
+reactive_stores_macro = { path = "./reactive_stores_macro", version = "0.1.0-beta6" }
+server_fn = { path = "./server_fn", version = "0.7.0-beta6" }
+server_fn_macro = { path = "./server_fn_macro", version = "0.7.0-beta6" }
+server_fn_macro_default = { path = "./server_fn/server_fn_macro_default", version = "0.7.0-beta6" }
+tachys = { path = "./tachys", version = "0.1.0-beta6" }
 
 [profile.release]
 codegen-units = 1

any_error/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "throw_error"
-version = "0.2.0-rc1"
+version = "0.2.0-beta6"
 authors = ["Greg Johnston"]
 license = "MIT"
 readme = "../README.md"

any_spawner/Cargo.toml

@@ -9,7 +9,6 @@ description = "Spawn asynchronous tasks in an executor-independent way."
 edition.workspace = true
 
 [dependencies]
-async-executor = { version = "1.13.1", optional = true }
 futures = "0.3.30"
 glib = { version = "0.20.0", optional = true }
 thiserror = "1.0"
@@ -20,14 +19,12 @@ tracing = { version = "0.1.40", optional = true }
 wasm-bindgen-futures = { version = "0.4.42", optional = true }
 
 [features]
-async-executor = ["dep:async-executor"]
 tracing = ["dep:tracing"]
 tokio = ["dep:tokio"]
 glib = ["dep:glib"]
 wasm-bindgen = ["dep:wasm-bindgen-futures"]
 futures-executor = ["futures/thread-pool", "futures/executor"]
 
-
 [package.metadata.docs.rs]
 all-features = true
 rustdoc-args = ["--cfg", "docsrs"]

any_spawner/src/lib.rs

@@ -32,14 +32,11 @@
 use std::{future::Future, pin::Pin, sync::OnceLock};
 use thiserror::Error;
 
-/// A future that has been pinned.
-pub type PinnedFuture<T> = Pin<Box<dyn Future<Output = T> + Send>>;
-/// A future that has been pinned.
-pub type PinnedLocalFuture<T> = Pin<Box<dyn Future<Output = T>>>;
+pub(crate) type PinnedFuture<T> = Pin<Box<dyn Future<Output = T> + Send>>;
+pub(crate) type PinnedLocalFuture<T> = Pin<Box<dyn Future<Output = T>>>;
 
 static SPAWN: OnceLock<fn(PinnedFuture<()>)> = OnceLock::new();
 static SPAWN_LOCAL: OnceLock<fn(PinnedLocalFuture<()>)> = OnceLock::new();
-static POLL_LOCAL: OnceLock<fn()> = OnceLock::new();
 
 /// Errors that can occur when using the executor.
 #[derive(Error, Debug)]
@@ -118,14 +115,6 @@ impl Executor {
         });
         _ = rx.await;
     }
-
-    /// Polls the current async executor.
-    /// Not all async executors support polling, so this function may not do anything.
-    pub fn poll_local() {
-        if let Some(poller) = POLL_LOCAL.get() {
-            poller()
-        }
-    }
 }
 
 impl Executor {
@@ -204,15 +193,13 @@ impl Executor {
     #[cfg_attr(docsrs, doc(cfg(feature = "futures-executor")))]
     pub fn init_futures_executor() -> Result<(), ExecutorError> {
         use futures::{
-            executor::{LocalPool, LocalSpawner, ThreadPool},
+            executor::{LocalPool, ThreadPool},
             task::{LocalSpawnExt, SpawnExt},
         };
-        use std::cell::RefCell;
 
         static THREAD_POOL: OnceLock<ThreadPool> = OnceLock::new();
         thread_local! {
-            static LOCAL_POOL: RefCell<LocalPool> = RefCell::new(LocalPool::new());
-            static SPAWNER: LocalSpawner = LOCAL_POOL.with(|pool| pool.borrow().spawner());
+            static LOCAL_POOL: LocalPool = LocalPool::new();
         }
 
         fn get_thread_pool() -> &'static ThreadPool {
@@ -231,131 +218,28 @@ impl Executor {
             .map_err(|_| ExecutorError::AlreadySet)?;
         SPAWN_LOCAL
             .set(|fut| {
-                SPAWNER.with(|spawner| {
+                LOCAL_POOL.with(|pool| {
+                    let spawner = pool.spawner();
                     spawner.spawn_local(fut).expect("failed to spawn future");
                 });
             })
             .map_err(|_| ExecutorError::AlreadySet)?;
-        POLL_LOCAL
-            .set(|| {
-                LOCAL_POOL.with(|pool| {
-                    if let Ok(mut pool) = pool.try_borrow_mut() {
-                        pool.run_until_stalled();
-                    }
-                    // If we couldn't borrow_mut, we're in a nested call to poll, so we don't need to do anything.
-                });
-            })
-            .map_err(|_| ExecutorError::AlreadySet)?;
-        Ok(())
-    }
-
-    /// Globally sets the [`async_executor`] executor as the executor used to spawn tasks,
-    /// lazily creating a thread pool to spawn tasks into.
-    ///
-    /// Returns `Err(_)` if an executor has already been set.
-    ///
-    /// Requires the `async-executor` feature to be activated on this crate.
-    #[cfg(feature = "async-executor")]
-    #[cfg_attr(docsrs, doc(cfg(feature = "async-executor")))]
-    pub fn init_async_executor() -> Result<(), ExecutorError> {
-        use async_executor::{Executor, LocalExecutor};
-
-        static THREAD_POOL: OnceLock<Executor> = OnceLock::new();
-        thread_local! {
-            static LOCAL_POOL: LocalExecutor<'static> = const { LocalExecutor::new() };
-        }
-
-        fn get_thread_pool() -> &'static Executor<'static> {
-            THREAD_POOL.get_or_init(Executor::new)
-        }
-
-        SPAWN
-            .set(|fut| {
-                get_thread_pool().spawn(fut).detach();
-            })
-            .map_err(|_| ExecutorError::AlreadySet)?;
-        SPAWN_LOCAL
-            .set(|fut| {
-                LOCAL_POOL.with(|pool| pool.spawn(fut).detach());
-            })
-            .map_err(|_| ExecutorError::AlreadySet)?;
-        POLL_LOCAL
-            .set(|| {
-                LOCAL_POOL.with(|pool| pool.try_tick());
-            })
-            .map_err(|_| ExecutorError::AlreadySet)?;
-        Ok(())
-    }
-
-    /// Globally sets a custom executor as the executor used to spawn tasks.
-    ///
-    /// Returns `Err(_)` if an executor has already been set.
-    pub fn init_custom_executor(
-        custom_executor: impl CustomExecutor + Send + Sync + 'static,
-    ) -> Result<(), ExecutorError> {
-        static EXECUTOR: OnceLock<Box<dyn CustomExecutor + Send + Sync>> =
-            OnceLock::new();
-        EXECUTOR
-            .set(Box::new(custom_executor))
-            .map_err(|_| ExecutorError::AlreadySet)?;
-
-        SPAWN
-            .set(|fut| {
-                EXECUTOR.get().unwrap().spawn(fut);
-            })
-            .map_err(|_| ExecutorError::AlreadySet)?;
-        SPAWN_LOCAL
-            .set(|fut| EXECUTOR.get().unwrap().spawn_local(fut))
-            .map_err(|_| ExecutorError::AlreadySet)?;
-        POLL_LOCAL
-            .set(|| EXECUTOR.get().unwrap().poll_local())
-            .map_err(|_| ExecutorError::AlreadySet)?;
-        Ok(())
-    }
-
-    /// Locally sets a custom executor as the executor used to spawn tasks
-    /// in the current thread.
-    ///
-    /// Returns `Err(_)` if an executor has already been set.
-    pub fn init_local_custom_executor(
-        custom_executor: impl CustomExecutor + 'static,
-    ) -> Result<(), ExecutorError> {
-        thread_local! {
-            static EXECUTOR: OnceLock<Box<dyn CustomExecutor>> = OnceLock::new();
-        }
-        EXECUTOR.with(|this| {
-            this.set(Box::new(custom_executor))
-                .map_err(|_| ExecutorError::AlreadySet)
-        })?;
-
-        SPAWN
-            .set(|fut| {
-                EXECUTOR.with(|this| this.get().unwrap().spawn(fut));
-            })
-            .map_err(|_| ExecutorError::AlreadySet)?;
-        SPAWN_LOCAL
-            .set(|fut| {
-                EXECUTOR.with(|this| this.get().unwrap().spawn_local(fut));
-            })
-            .map_err(|_| ExecutorError::AlreadySet)?;
-        POLL_LOCAL
-            .set(|| {
-                EXECUTOR.with(|this| this.get().unwrap().poll_local());
-            })
-            .map_err(|_| ExecutorError::AlreadySet)?;
         Ok(())
     }
 }
 
-/// A trait for custom executors.
-/// Custom executors can be used to integrate with any executor that supports spawning futures.
-///  
-/// All methods can be called recursively.
-pub trait CustomExecutor {
-    /// Spawns a future, usually on a thread pool.
-    fn spawn(&self, fut: PinnedFuture<()>);
-    /// Spawns a local future. May require calling `poll_local` to make progress.
-    fn spawn_local(&self, fut: PinnedLocalFuture<()>);
-    /// Polls the executor, if it supports polling.
-    fn poll_local(&self);
+#[cfg(test)]
+mod tests {
+    #[cfg(feature = "futures-executor")]
+    #[test]
+    fn can_spawn_local_future() {
+        use crate::Executor;
+        use std::rc::Rc;
+        Executor::init_futures_executor().expect("couldn't set executor");
+        let rc = Rc::new(());
+        Executor::spawn_local(async {
+            _ = rc;
+        });
+        Executor::spawn(async {});
+    }
 }

any_spawner/tests/custom_runtime.rs

@@ -1,55 +0,0 @@
-#[cfg(feature = "futures-executor")]
-use any_spawner::{CustomExecutor, Executor, PinnedFuture, PinnedLocalFuture};
-#[cfg(feature = "futures-executor")]
-#[test]
-fn can_create_custom_executor() {
-    use futures::{
-        executor::{LocalPool, LocalSpawner},
-        task::LocalSpawnExt,
-    };
-    use std::{
-        cell::RefCell,
-        sync::{
-            atomic::{AtomicUsize, Ordering},
-            Arc,
-        },
-    };
-
-    thread_local! {
-        static LOCAL_POOL: RefCell<LocalPool> = RefCell::new(LocalPool::new());
-        static SPAWNER: LocalSpawner = LOCAL_POOL.with(|pool| pool.borrow().spawner());
-    }
-
-    struct CustomFutureExecutor;
-    impl CustomExecutor for CustomFutureExecutor {
-        fn spawn(&self, _fut: PinnedFuture<()>) {
-            panic!("not supported in this test");
-        }
-
-        fn spawn_local(&self, fut: PinnedLocalFuture<()>) {
-            SPAWNER.with(|spawner| {
-                spawner.spawn_local(fut).expect("failed to spawn future");
-            });
-        }
-
-        fn poll_local(&self) {
-            LOCAL_POOL.with(|pool| {
-                if let Ok(mut pool) = pool.try_borrow_mut() {
-                    pool.run_until_stalled();
-                }
-                // If we couldn't borrow_mut, we're in a nested call to poll, so we don't need to do anything.
-            });
-        }
-    }
-
-    Executor::init_custom_executor(CustomFutureExecutor)
-        .expect("couldn't set executor");
-
-    let counter = Arc::new(AtomicUsize::new(0));
-    let counter_clone = Arc::clone(&counter);
-    Executor::spawn_local(async move {
-        counter_clone.store(1, Ordering::Release);
-    });
-    Executor::poll_local();
-    assert_eq!(counter.load(Ordering::Acquire), 1);
-}

any_spawner/tests/futures_runtime.rs

@@ -1,38 +0,0 @@
-#[cfg(feature = "futures-executor")]
-use any_spawner::Executor;
-// All tests in this file use the same executor.
-
-#[cfg(feature = "futures-executor")]
-#[test]
-fn can_spawn_local_future() {
-    use std::rc::Rc;
-
-    let _ = Executor::init_futures_executor();
-    let rc = Rc::new(());
-    Executor::spawn_local(async {
-        _ = rc;
-    });
-    Executor::spawn(async {});
-}
-
-#[cfg(feature = "futures-executor")]
-#[test]
-fn can_make_local_progress() {
-    use std::sync::{
-        atomic::{AtomicUsize, Ordering},
-        Arc,
-    };
-    let _ = Executor::init_futures_executor();
-    let counter = Arc::new(AtomicUsize::new(0));
-    Executor::spawn_local({
-        let counter = Arc::clone(&counter);
-        async move {
-            assert_eq!(counter.fetch_add(1, Ordering::AcqRel), 0);
-            Executor::spawn_local(async {
-                // Should not crash
-            });
-        }
-    });
-    Executor::poll_local();
-    assert_eq!(counter.load(Ordering::Acquire), 1);
-}

examples/axum_js_ssr/src/main.rs

@@ -26,7 +26,6 @@ async fn main() {
     };
     use axum_js_ssr::app::*;
     use http_body_util::BodyExt;
-    use leptos::logging::log;
     use leptos::prelude::*;
     use leptos_axum::{generate_route_list, LeptosRoutes};
 

examples/counter/tests/web.rs

@@ -1,7 +1,7 @@
 use counter::*;
 use leptos::mount::mount_to;
 use leptos::prelude::*;
-use leptos::task::tick;
+use leptos::spawn::tick;
 use wasm_bindgen::JsCast;
 use wasm_bindgen_test::*;
 

examples/counter_isomorphic/src/counters.rs

@@ -1,4 +1,4 @@
-use leptos::prelude::*;
+use leptos::{prelude::*, reactive_graph::actions::Action};
 use leptos_router::{
     components::{FlatRoutes, Route, Router, A},
     StaticSegment,

examples/counter_isomorphic/src/main.rs

@@ -63,7 +63,7 @@ async fn main() -> std::io::Result<()> {
                         </html>
                     }
             }})
-            .service(Files::new("/", site_root.as_ref()))
+            .service(Files::new("/", site_root))
     })
     .bind(&addr)?
     .run()

examples/counter_without_macros/tests/web.rs

@@ -1,5 +1,5 @@
 use counter_without_macros::counter;
-use leptos::{prelude::*, task::tick};
+use leptos::{prelude::*, spawn::tick};
 use pretty_assertions::assert_eq;
 use wasm_bindgen::JsCast;
 use wasm_bindgen_test::*;

examples/counters/tests/web.rs

@@ -4,7 +4,7 @@ use wasm_bindgen_test::*;
 wasm_bindgen_test_configure!(run_in_browser);
 use counters::Counters;
 use leptos::prelude::*;
-use leptos::task::tick;
+use leptos::spawn::tick;
 use web_sys::HtmlElement;
 
 #[wasm_bindgen_test]

examples/directives/tests/web.rs

@@ -1,5 +1,5 @@
 use directives::App;
-use leptos::{prelude::*, task::tick};
+use leptos::{prelude::*, spawn::tick};
 use wasm_bindgen::JsCast;
 use wasm_bindgen_test::*;
 use web_sys::HtmlElement;

examples/errors_axum/src/error_template.rs

@@ -6,7 +6,9 @@ use leptos_axum::ResponseOptions;
 // A basic function to display errors served by the error boundaries.
 // Feel free to do more complicated things here than just displaying them.
 #[component]
-pub fn ErrorTemplate(#[prop(into)] errors: Signal<Errors>) -> impl IntoView {
+pub fn ErrorTemplate(
+    #[prop(into)] errors: MaybeSignal<Errors>,
+) -> impl IntoView {
     // Get Errors from Signal
     // Downcast lets us take a type that implements `std::error::Error`
     let errors = Memo::new(move |_| {

examples/gtk/Cargo.toml

@@ -0,0 +1,18 @@
+[package]
+name = "gtk"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+leptos = { path = "../../leptos" }
+throw_error = { path = "../../any_error/" }
+
+# these are used to build the integration
+gtk = { version = "0.9.0", package = "gtk4" }
+next_tuple = { path = "../../next_tuple/" }
+paste = "1.0"
+
+# we want to support using glib for the reactive runtime event loop
+any_spawner = { path = "../../any_spawner/", features = ["glib"] }
+# yes, we want effects to run: this is a "frontend," not a backend
+reactive_graph = { path = "../../reactive_graph", features = ["effects"] }

examples/gtk/Makefile.toml

@@ -0,0 +1 @@
+extend = [{ path = "../cargo-make/main.toml" }]

examples/gtk/index.html

@@ -0,0 +1,8 @@
+<!DOCTYPE html>
+<html>
+	<head>
+		<meta name="color-scheme" content="dark">
+		<link rel="css" href="style.css" data-trunk>
+	</head>
+	<body></body>
+</html>

examples/gtk/src/leptos_gtk.rs

@@ -0,0 +1,645 @@
+use self::properties::Connect;
+use gtk::{
+    glib::{
+        object::{IsA, IsClass, ObjectExt},
+        Object, Value,
+    },
+    prelude::{Cast, WidgetExt},
+    Label, Orientation, Widget,
+};
+use leptos::{
+    reactive_graph::effect::RenderEffect,
+    tachys::{
+        renderer::{CastFrom, Renderer},
+        view::{Mountable, Render},
+    },
+};
+use next_tuple::NextTuple;
+use std::marker::PhantomData;
+
+#[derive(Debug)]
+pub struct LeptosGtk;
+
+#[derive(Debug, Clone)]
+pub struct Element(pub Widget);
+
+impl Element {
+    pub fn remove(&self) {
+        self.0.unparent();
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct Text(pub Element);
+
+impl<T> From<T> for Element
+where
+    T: Into<Widget>,
+{
+    fn from(value: T) -> Self {
+        Element(value.into())
+    }
+}
+
+impl Mountable<LeptosGtk> for Element {
+    fn unmount(&mut self) {
+        self.remove()
+    }
+
+    fn mount(
+        &mut self,
+        parent: &<LeptosGtk as Renderer>::Element,
+        marker: Option<&<LeptosGtk as Renderer>::Node>,
+    ) {
+        self.0
+            .insert_before(&parent.0, marker.as_ref().map(|m| &m.0));
+    }
+
+    fn insert_before_this(&self, child: &mut dyn Mountable<LeptosGtk>) -> bool {
+        if let Some(parent) = self.0.parent() {
+            child.mount(&Element(parent), Some(self));
+            return true;
+        }
+        false
+    }
+}
+
+impl Mountable<LeptosGtk> for Text {
+    fn unmount(&mut self) {
+        self.0.remove()
+    }
+
+    fn mount(
+        &mut self,
+        parent: &<LeptosGtk as Renderer>::Element,
+        marker: Option<&<LeptosGtk as Renderer>::Node>,
+    ) {
+        self.0
+             .0
+            .insert_before(&parent.0, marker.as_ref().map(|m| &m.0));
+    }
+
+    fn insert_before_this(&self, child: &mut dyn Mountable<LeptosGtk>) -> bool {
+        self.0.insert_before_this(child)
+    }
+}
+
+impl CastFrom<Element> for Element {
+    fn cast_from(source: Element) -> Option<Self> {
+        Some(source)
+    }
+}
+
+impl CastFrom<Element> for Text {
+    fn cast_from(source: Element) -> Option<Self> {
+        source
+            .0
+            .downcast::<Label>()
+            .ok()
+            .map(|n| Text(Element::from(n)))
+    }
+}
+
+impl AsRef<Element> for Element {
+    fn as_ref(&self) -> &Element {
+        self
+    }
+}
+
+impl AsRef<Element> for Text {
+    fn as_ref(&self) -> &Element {
+        &self.0
+    }
+}
+
+impl Renderer for LeptosGtk {
+    type Node = Element;
+    type Element = Element;
+    type Text = Text;
+    type Placeholder = Element;
+
+    fn intern(text: &str) -> &str {
+        text
+    }
+
+    fn create_text_node(text: &str) -> Self::Text {
+        Text(Element::from(Label::new(Some(text))))
+    }
+
+    fn create_placeholder() -> Self::Placeholder {
+        let label = Label::new(None);
+        label.set_visible(false);
+        Element::from(label)
+    }
+
+    fn set_text(node: &Self::Text, text: &str) {
+        let node_as_text = node.0 .0.downcast_ref::<Label>().unwrap();
+        node_as_text.set_label(text);
+    }
+
+    fn set_attribute(node: &Self::Element, name: &str, value: &str) {
+        node.0.set_property(name, value);
+    }
+
+    fn remove_attribute(node: &Self::Element, name: &str) {
+        node.0.set_property(name, None::<&str>);
+    }
+
+    fn insert_node(
+        parent: &Self::Element,
+        new_child: &Self::Node,
+        marker: Option<&Self::Node>,
+    ) {
+        new_child
+            .0
+            .insert_before(&parent.0, marker.as_ref().map(|n| &n.0));
+    }
+
+    fn remove_node(
+        _parent: &Self::Element,
+        _child: &Self::Node,
+    ) -> Option<Self::Node> {
+        todo!()
+    }
+
+    fn remove(_node: &Self::Node) {
+        todo!()
+    }
+
+    fn get_parent(node: &Self::Node) -> Option<Self::Node> {
+        node.0.parent().map(Element::from)
+    }
+
+    fn first_child(_node: &Self::Node) -> Option<Self::Node> {
+        todo!()
+    }
+
+    fn next_sibling(_node: &Self::Node) -> Option<Self::Node> {
+        todo!()
+    }
+
+    fn log_node(node: &Self::Node) {
+        println!("{node:?}");
+    }
+
+    fn clear_children(_parent: &Self::Element) {
+        todo!()
+    }
+}
+
+pub fn root<Chil>(children: Chil) -> (Widget, impl Mountable<LeptosGtk>)
+where
+    Chil: Render<LeptosGtk>,
+{
+    let state = r#box()
+        .orientation(Orientation::Vertical)
+        .spacing(12)
+        .child(children)
+        .build();
+    (state.as_widget().clone(), state)
+}
+
+pub trait WidgetClass {
+    type Widget: Into<Widget> + IsA<Object> + IsClass;
+}
+
+pub struct LGtkWidget<Widg, Props, Chil> {
+    widget: PhantomData<Widg>,
+    properties: Props,
+    children: Chil,
+}
+
+impl<Widg, Props, Chil> LGtkWidget<Widg, Props, Chil>
+where
+    Widg: WidgetClass,
+    Chil: NextTuple,
+{
+    pub fn child<T>(
+        self,
+        child: T,
+    ) -> LGtkWidget<Widg, Props, Chil::Output<T>> {
+        let LGtkWidget {
+            widget,
+            properties,
+            children,
+        } = self;
+        LGtkWidget {
+            widget,
+            properties,
+            children: children.next_tuple(child),
+        }
+    }
+}
+impl<Widg, Props, Chil> LGtkWidget<Widg, Props, Chil>
+where
+    Widg: WidgetClass,
+    Props: NextTuple,
+    Chil: Render<LeptosGtk>,
+{
+    pub fn connect<F>(
+        self,
+        signal_name: &'static str,
+        callback: F,
+    ) -> LGtkWidget<Widg, Props::Output<Connect<F>>, Chil>
+    where
+        F: Fn(&[Value]) -> Option<Value> + Send + Sync + 'static,
+    {
+        let LGtkWidget {
+            widget,
+            properties,
+            children,
+        } = self;
+        LGtkWidget {
+            widget,
+            properties: properties.next_tuple(Connect {
+                signal_name,
+                callback,
+            }),
+            children,
+        }
+    }
+}
+
+pub struct LGtkWidgetState<Widg, Props, Chil>
+where
+    Chil: Render<LeptosGtk>,
+    Props: Property,
+    Widg: WidgetClass,
+{
+    ty: PhantomData<Widg>,
+    widget: Element,
+    properties: Props::State,
+    children: Chil::State,
+}
+
+impl<Widg, Props, Chil> LGtkWidgetState<Widg, Props, Chil>
+where
+    Chil: Render<LeptosGtk>,
+    Props: Property,
+    Widg: WidgetClass,
+{
+    pub fn as_widget(&self) -> &Widget {
+        &self.widget.0
+    }
+}
+
+impl<Widg, Props, Chil> Render<LeptosGtk> for LGtkWidget<Widg, Props, Chil>
+where
+    Widg: WidgetClass,
+    Props: Property,
+    Chil: Render<LeptosGtk>,
+{
+    type State = LGtkWidgetState<Widg, Props, Chil>;
+
+    fn build(self) -> Self::State {
+        let widget = Object::new::<Widg::Widget>();
+        let widget = Element::from(widget);
+        let properties = self.properties.build(&widget);
+        let mut children = self.children.build();
+        children.mount(&widget, None);
+        LGtkWidgetState {
+            ty: PhantomData,
+            widget,
+            properties,
+            children,
+        }
+    }
+
+    fn rebuild(self, state: &mut Self::State) {
+        self.properties
+            .rebuild(&state.widget, &mut state.properties);
+        self.children.rebuild(&mut state.children);
+    }
+}
+
+impl<Widg, Props, Chil> Mountable<LeptosGtk>
+    for LGtkWidgetState<Widg, Props, Chil>
+where
+    Widg: WidgetClass,
+    Props: Property,
+    Chil: Render<LeptosGtk>,
+{
+    fn unmount(&mut self) {
+        self.children.unmount();
+        self.widget.remove();
+    }
+
+    fn mount(
+        &mut self,
+        parent: &<LeptosGtk as Renderer>::Element,
+        marker: Option<&<LeptosGtk as Renderer>::Node>,
+    ) {
+        self.children.mount(&self.widget, None);
+        LeptosGtk::insert_node(parent, &self.widget, marker);
+    }
+
+    fn insert_before_this(&self, child: &mut dyn Mountable<LeptosGtk>) -> bool {
+        self.widget.insert_before_this(child)
+    }
+}
+
+pub trait Property {
+    type State;
+
+    fn build(self, element: &Element) -> Self::State;
+
+    fn rebuild(self, element: &Element, state: &mut Self::State);
+}
+
+impl<T, F> Property for F
+where
+    T: Property,
+    T::State: 'static,
+    F: Fn() -> T + 'static,
+{
+    type State = RenderEffect<T::State>;
+
+    fn build(self, widget: &Element) -> Self::State {
+        let widget = widget.clone();
+        RenderEffect::new(move |prev| {
+            let value = self();
+            if let Some(mut prev) = prev {
+                value.rebuild(&widget, &mut prev);
+                prev
+            } else {
+                value.build(&widget)
+            }
+        })
+    }
+
+    fn rebuild(self, widget: &Element, state: &mut Self::State) {
+        let prev_value = state.take_value();
+        let widget = widget.to_owned();
+        *state = RenderEffect::new_with_value(
+            move |prev| {
+                let value = self();
+                if let Some(mut state) = prev {
+                    value.rebuild(&widget, &mut state);
+                    state
+                } else {
+                    unreachable!()
+                }
+            },
+            prev_value,
+        );
+    }
+}
+
+pub fn button() -> LGtkWidget<gtk::Button, (), ()> {
+    LGtkWidget {
+        widget: PhantomData,
+        properties: (),
+        children: (),
+    }
+}
+
+pub fn r#box() -> LGtkWidget<gtk::Box, (), ()> {
+    LGtkWidget {
+        widget: PhantomData,
+        properties: (),
+        children: (),
+    }
+}
+
+mod widgets {
+    use super::WidgetClass;
+
+    impl WidgetClass for gtk::Button {
+        type Widget = Self;
+    }
+
+    impl WidgetClass for gtk::Box {
+        type Widget = Self;
+    }
+}
+
+pub mod properties {
+    #![allow(dead_code)]
+
+    use super::{Element, LGtkWidget, LeptosGtk, Property, WidgetClass};
+    use gtk::glib::{object::ObjectExt, Value};
+    use leptos::tachys::{renderer::Renderer, view::Render};
+    use next_tuple::NextTuple;
+
+    pub struct Connect<F>
+    where
+        F: Fn(&[Value]) -> Option<Value> + Send + Sync + 'static,
+    {
+        pub signal_name: &'static str,
+        pub callback: F,
+    }
+
+    impl<F> Property for Connect<F>
+    where
+        F: Fn(&[Value]) -> Option<Value> + Send + Sync + 'static,
+    {
+        type State = ();
+
+        fn build(self, element: &Element) -> Self::State {
+            element.0.connect(self.signal_name, false, self.callback);
+        }
+
+        fn rebuild(self, _element: &Element, _state: &mut Self::State) {
+            // TODO we want to *remove* the previous listener, and reconnect with this new one
+        }
+    }
+
+    /* examples for macro */
+    pub struct Orientation {
+        value: gtk::Orientation,
+    }
+
+    pub struct OrientationState {
+        value: gtk::Orientation,
+    }
+
+    impl Property for Orientation {
+        type State = OrientationState;
+
+        fn build(self, element: &Element) -> Self::State {
+            element.0.set_property("orientation", self.value);
+            OrientationState { value: self.value }
+        }
+
+        fn rebuild(self, element: &Element, state: &mut Self::State) {
+            if self.value != state.value {
+                element.0.set_property("orientation", self.value);
+                state.value = self.value;
+            }
+        }
+    }
+
+    impl<Widg, Props, Chil> LGtkWidget<Widg, Props, Chil>
+    where
+        Widg: WidgetClass,
+        Props: NextTuple,
+        Chil: Render<LeptosGtk>,
+    {
+        pub fn orientation(
+            self,
+            value: impl Into<gtk::Orientation>,
+        ) -> LGtkWidget<Widg, Props::Output<Orientation>, Chil> {
+            let LGtkWidget {
+                widget,
+                properties,
+                children,
+            } = self;
+            LGtkWidget {
+                widget,
+                properties: properties.next_tuple(Orientation {
+                    value: value.into(),
+                }),
+                children,
+            }
+        }
+    }
+
+    pub struct Spacing {
+        value: i32,
+    }
+
+    pub struct SpacingState {
+        value: i32,
+    }
+
+    impl Property for Spacing {
+        type State = SpacingState;
+
+        fn build(self, element: &Element) -> Self::State {
+            element.0.set_property("spacing", self.value);
+            SpacingState { value: self.value }
+        }
+
+        fn rebuild(self, element: &Element, state: &mut Self::State) {
+            if self.value != state.value {
+                element.0.set_property("spacing", self.value);
+                state.value = self.value;
+            }
+        }
+    }
+
+    impl<Widg, Props, Chil> LGtkWidget<Widg, Props, Chil>
+    where
+        Widg: WidgetClass,
+        Props: NextTuple,
+        Chil: Render<LeptosGtk>,
+    {
+        pub fn spacing(
+            self,
+            value: impl Into<i32>,
+        ) -> LGtkWidget<Widg, Props::Output<Spacing>, Chil> {
+            let LGtkWidget {
+                widget,
+                properties,
+                children,
+            } = self;
+            LGtkWidget {
+                widget,
+                properties: properties.next_tuple(Spacing {
+                    value: value.into(),
+                }),
+                children,
+            }
+        }
+    }
+
+    /* end examples for properties macro */
+    #[derive(Debug)]
+    pub struct Label {
+        value: String,
+    }
+
+    impl Label {
+        pub fn new(value: impl Into<String>) -> Self {
+            Self {
+                value: value.into(),
+            }
+        }
+    }
+
+    pub struct LabelState {
+        value: String,
+    }
+
+    impl Property for Label {
+        type State = LabelState;
+
+        fn build(self, element: &Element) -> Self::State {
+            LeptosGtk::set_attribute(element, "label", &self.value);
+            LabelState { value: self.value }
+        }
+
+        fn rebuild(self, element: &Element, state: &mut Self::State) {
+            if self.value != state.value {
+                LeptosGtk::set_attribute(element, "label", &self.value);
+            }
+        }
+    }
+
+    impl Property for () {
+        type State = ();
+
+        fn build(self, _element: &Element) -> Self::State {}
+
+        fn rebuild(self, _element: &Element, _state: &mut Self::State) {}
+    }
+
+    macro_rules! tuples {
+        ($($ty:ident),* $(,)?) => {
+            impl<$($ty,)*> Property for ($($ty,)*)
+                where $($ty: Property,)*
+            {
+                type State = ($($ty::State,)*);
+
+                fn build(self, element: &Element) -> Self::State {
+                    #[allow(non_snake_case)]
+                    let ($($ty,)*) = self;
+                    ($($ty.build(element),)*)
+                }
+
+                fn rebuild(self, element: &Element, state: &mut Self::State) {
+                    paste::paste! {
+                        #[allow(non_snake_case)]
+                        let ($($ty,)*) = self;
+                        #[allow(non_snake_case)]
+                        let ($([<state_ $ty:lower>],)*) = state;
+                        $($ty.rebuild(element, [<state_ $ty:lower>]));*
+                    }
+                }
+            }
+        }
+    }
+
+    tuples!(A);
+    tuples!(A, B);
+    tuples!(A, B, C);
+    tuples!(A, B, C, D);
+    tuples!(A, B, C, D, E);
+    tuples!(A, B, C, D, E, F);
+    tuples!(A, B, C, D, E, F, G);
+    tuples!(A, B, C, D, E, F, G, H);
+    tuples!(A, B, C, D, E, F, G, H, I);
+    tuples!(A, B, C, D, E, F, G, H, I, J);
+    tuples!(A, B, C, D, E, F, G, H, I, J, K);
+    tuples!(A, B, C, D, E, F, G, H, I, J, K, L);
+    tuples!(A, B, C, D, E, F, G, H, I, J, K, L, M);
+    tuples!(A, B, C, D, E, F, G, H, I, J, K, L, M, N);
+    tuples!(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O);
+    tuples!(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P);
+    tuples!(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q);
+    tuples!(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R);
+    tuples!(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S);
+    tuples!(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T);
+    tuples!(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U);
+    tuples!(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V);
+    tuples!(
+        A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W
+    );
+    tuples!(
+        A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X
+    );
+    tuples!(
+        A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X,
+        Y
+    );
+}

examples/gtk/src/main.rs

@@ -0,0 +1,107 @@
+use any_spawner::Executor;
+use gtk::{prelude::*, Application, ApplicationWindow, Orientation};
+use leptos::prelude::*;
+use leptos_gtk::LeptosGtk;
+use std::{mem, thread, time::Duration};
+mod leptos_gtk;
+
+const APP_ID: &str = "dev.leptos.Counter";
+
+// Basic GTK app setup from https://gtk-rs.org/gtk4-rs/stable/latest/book/hello_world.html
+fn main() {
+    // use the glib event loop to power the reactive system
+    _ = Executor::init_glib();
+    let app = Application::builder().application_id(APP_ID).build();
+
+    app.connect_startup(|_| load_css());
+
+    app.connect_activate(|app| {
+        // Connect to "activate" signal of `app`
+        let owner = Owner::new();
+        let view = owner.with(ui);
+        let (root, state) = leptos_gtk::root(view);
+
+        let window = ApplicationWindow::builder()
+            .application(app)
+            .title("TachyGTK")
+            .child(&root)
+            .build();
+        // Present window
+        window.present();
+        mem::forget((owner, state));
+    });
+
+    app.run();
+}
+
+fn ui() -> impl Render<LeptosGtk> {
+    let value = RwSignal::new(0);
+    let rows = RwSignal::new(vec![1, 2, 3, 4, 5]);
+
+    Effect::new(move |_| {
+        println!("value = {}", value.get());
+    });
+
+    // just an example of multithreaded reactivity
+    thread::spawn(move || loop {
+        thread::sleep(Duration::from_millis(250));
+        value.update(|n| *n += 1);
+    });
+
+    vstack((
+        hstack((
+            button("-1", move || {
+                println!("clicked -1");
+                value.update(|n| *n -= 1);
+            }),
+            move || value.get().to_string(),
+            button("+1", move || value.update(|n| *n += 1)),
+        )),
+        button("Swap", move || {
+            rows.update(|items| {
+                items.swap(1, 3);
+            })
+        }),
+        hstack(rows),
+    ))
+}
+
+fn button(
+    label: impl Render<LeptosGtk>,
+    callback: impl Fn() + Send + Sync + 'static,
+) -> impl Render<LeptosGtk> {
+    leptos_gtk::button()
+        .child(label)
+        .connect("clicked", move |_| {
+            callback();
+            None
+        })
+}
+
+fn vstack(children: impl Render<LeptosGtk>) -> impl Render<LeptosGtk> {
+    leptos_gtk::r#box()
+        .orientation(Orientation::Vertical)
+        .spacing(12)
+        .child(children)
+}
+
+fn hstack(children: impl Render<LeptosGtk>) -> impl Render<LeptosGtk> {
+    leptos_gtk::r#box()
+        .orientation(Orientation::Horizontal)
+        .spacing(12)
+        .child(children)
+}
+
+fn load_css() {
+    use gtk::{gdk::Display, CssProvider};
+
+    let provider = CssProvider::new();
+    provider.load_from_path("style.css");
+
+    // Add the provider to the default screen
+    gtk::style_context_add_provider_for_display(
+        &Display::default().expect("Could not connect to a display."),
+        &provider,
+        gtk::STYLE_PROVIDER_PRIORITY_APPLICATION,
+    );
+}

examples/hackernews/src/lib.rs

@@ -4,7 +4,7 @@ mod routes;
 use leptos_meta::{provide_meta_context, Link, Meta, Stylesheet};
 use leptos_router::{
     components::{FlatRoutes, Route, Router, RoutingProgress},
-    OptionalParamSegment, ParamSegment, StaticSegment,
+    ParamSegment, StaticSegment,
 };
 use routes::{nav::*, stories::*, story::*, users::*};
 use std::time::Duration;
@@ -28,7 +28,9 @@ pub fn App() -> impl IntoView {
                 <FlatRoutes fallback=|| "Not found.">
                     <Route path=(StaticSegment("users"), ParamSegment("id")) view=User/>
                     <Route path=(StaticSegment("stories"), ParamSegment("id")) view=Story/>
-                    <Route path=OptionalParamSegment("stories") view=Stories/>
+                    <Route path=ParamSegment("stories") view=Stories/>
+                    // TODO allow optional params without duplication
+                    <Route path=StaticSegment("") view=Stories/>
                 </FlatRoutes>
             </main>
         </Router>

examples/hackernews/src/main.rs

@@ -56,7 +56,7 @@ async fn main() -> std::io::Result<()> {
                         </html>
                     }
             }})
-            .service(Files::new("/", site_root.as_ref()))
+            .service(Files::new("/", site_root))
         //.wrap(middleware::Compress::default())
     })
     .bind(&addr)?

examples/hackernews/src/routes/nav.rs

@@ -21,16 +21,10 @@ pub fn Nav() -> impl IntoView {
                 <A href="/job">
                     <strong>"Jobs"</strong>
                 </A>
-                <a
-                    class="github"
-                    href="http://github.com/leptos-rs/leptos"
-                    target="_blank"
-                    rel="noreferrer"
-                >
+                <a class="github" href="http://github.com/leptos-rs/leptos" target="_blank" rel="noreferrer">
                     "Built with Leptos"
                 </a>
             </nav>
         </header>
     }
-    .into_any()
 }

examples/hackernews/src/routes/stories.rs

@@ -50,42 +50,30 @@ pub fn Stories() -> impl IntoView {
         <div class="news-view">
             <div class="news-list-nav">
                 <span>
-                    {move || {
-                        if page() > 1 {
-                            Either::Left(
-                                view! {
-                                    <a
-                                        class="page-link"
-                                        href=move || {
-                                            format!("/{}?page={}", story_type(), page() - 1)
-                                        }
-                                        aria-label="Previous Page"
-                                    >
-                                        "< prev"
-                                    </a>
-                                },
-                            )
-                        } else {
-                            Either::Right(
-                                view! {
-                                    <span class="page-link disabled" aria-hidden="true">
-                                        "< prev"
-                                    </span>
-                                },
-                            )
-                        }
+                    {move || if page() > 1 {
+                        Either::Left(view! {
+                            <a class="page-link"
+                                href=move || format!("/{}?page={}", story_type(), page() - 1)
+                                aria-label="Previous Page"
+                            >
+                                "< prev"
+                            </a>
+                        })
+                    } else {
+                        Either::Right(view! {
+                            <span class="page-link disabled" aria-hidden="true">
+                                "< prev"
+                            </span>
+                        })
                     }}
-
                 </span>
                 <span>"page " {page}</span>
                 <Suspense>
-                    <span
-                        class="page-link"
+                    <span class="page-link"
                         class:disabled=hide_more_link
                         aria-hidden=hide_more_link
                     >
-                        <a
-                            href=move || format!("/{}?page={}", story_type(), page() + 1)
+                        <a href=move || format!("/{}?page={}", story_type(), page() + 1)
                             aria-label="Next Page"
                         >
                             "more >"
@@ -95,10 +83,14 @@ pub fn Stories() -> impl IntoView {
             </div>
             <main class="news-list">
                 <div>
-                    <Transition fallback=move || view! { <p>"Loading..."</p> } set_pending>
-                        <Show when=move || {
-                            stories.read().as_ref().map(Option::is_none).unwrap_or(false)
-                        }>> <p>"Error loading stories."</p></Show>
+                    <Transition
+                        fallback=move || view! { <p>"Loading..."</p> }
+                        set_pending
+                    >
+                        <Show when=move || stories.read().as_ref().map(Option::is_none).unwrap_or(false)>
+                        >
+                            <p>"Error loading stories."</p>
+                        </Show>
                         <ul>
                             <For
                                 each=move || stories.get().unwrap_or_default().unwrap_or_default()
@@ -113,78 +105,54 @@ pub fn Stories() -> impl IntoView {
             </main>
         </div>
     }
-    .into_any()
 }
 
 #[component]
 fn Story(story: api::Story) -> impl IntoView {
     view! {
-        <li class="news-item">
+         <li class="news-item">
             <span class="score">{story.points}</span>
             <span class="title">
                 {if !story.url.starts_with("item?id=") {
-                    Either::Left(
-                        view! {
-                            <span>
-                                <a href=story.url target="_blank" rel="noreferrer">
-                                    {story.title.clone()}
-                                </a>
-                                <span class="host">"(" {story.domain} ")"</span>
-                            </span>
-                        },
-                    )
+                    Either::Left(view! {
+                        <span>
+                            <a href=story.url target="_blank" rel="noreferrer">
+                                {story.title.clone()}
+                            </a>
+                            <span class="host">"("{story.domain}")"</span>
+                        </span>
+                    })
                 } else {
                     let title = story.title.clone();
                     Either::Right(view! { <A href=format!("/stories/{}", story.id)>{title}</A> })
                 }}
-
             </span>
-            <br/>
+            <br />
             <span class="meta">
                 {if story.story_type != "job" {
-                    Either::Left(
-                        view! {
-                            <span>
-                                {"by "}
-                                {story
-                                    .user
-                                    .map(|user| {
-                                        view! {
-                                            <A href=format!("/users/{user}")>{user.clone()}</A>
-                                        }
-                                    })} {format!(" {} | ", story.time_ago)}
-                                <A href=format!(
-                                    "/stories/{}",
-                                    story.id,
-                                )>
-                                    {if story.comments_count.unwrap_or_default() > 0 {
-                                        format!(
-                                            "{} comments",
-                                            story.comments_count.unwrap_or_default(),
-                                        )
-                                    } else {
-                                        "discuss".into()
-                                    }}
-
-                                </A>
-                            </span>
-                        },
-                    )
+                    Either::Left(view! {
+                        <span>
+                            {"by "}
+                            {story.user.map(|user| view ! {  <A href=format!("/users/{user}")>{user.clone()}</A>})}
+                            {format!(" {} | ", story.time_ago)}
+                            <A href=format!("/stories/{}", story.id)>
+                                {if story.comments_count.unwrap_or_default() > 0 {
+                                    format!("{} comments", story.comments_count.unwrap_or_default())
+                                } else {
+                                    "discuss".into()
+                                }}
+                            </A>
+                        </span>
+                    })
                 } else {
                     let title = story.title.clone();
                     Either::Right(view! { <A href=format!("/item/{}", story.id)>{title}</A> })
                 }}
-
             </span>
-            {(story.story_type != "link")
-                .then(|| {
-                    view! {
-                        " "
-                        <span class="label">{story.story_type}</span>
-                    }
-                })}
-
+            {(story.story_type != "link").then(|| view! {
+                " "
+                <span class="label">{story.story_type}</span>
+            })}
         </li>
     }
-    .into_any()
 }

examples/hackernews/src/routes/story.rs

@@ -28,21 +28,18 @@ pub fn Story() -> impl IntoView {
                     <Meta name="description" content=story.title.clone()/>
                     <div class="item-view">
                         <div class="item-view-header">
-                            <a href=story.url target="_blank">
-                                <h1>{story.title}</h1>
-                            </a>
-                            <span class="host">"(" {story.domain} ")"</span>
-                            {story
-                                .user
-                                .map(|user| {
-                                    view! {
-                                        <p class="meta">
-                                            {story.points} " points | by "
-                                            <A href=format!("/users/{user}")>{user.clone()}</A>
-                                            {format!(" {}", story.time_ago)}
-                                        </p>
-                                    }
-                                })}
+                        <a href=story.url target="_blank">
+                            <h1>{story.title}</h1>
+                        </a>
+                        <span class="host">
+                            "("{story.domain}")"
+                        </span>
+                        {story.user.map(|user| view! {  <p class="meta">
+                            {story.points}
+                            " points | by "
+                            <A href=format!("/users/{user}")>{user.clone()}</A>
+                            {format!(" {}", story.time_ago)}
+                        </p>})}
                         </div>
                         <div class="item-view-comments">
                             <p class="item-view-comments-header">
@@ -51,7 +48,6 @@ pub fn Story() -> impl IntoView {
                                 } else {
                                     "No comments yet.".into()
                                 }}
-
                             </p>
                             <ul class="comment-children">
                                 <For
@@ -59,7 +55,7 @@ pub fn Story() -> impl IntoView {
                                     key=|comment| comment.id
                                     let:comment
                                 >
-                                    <Comment comment/>
+                                    <Comment comment />
                                 </For>
                             </ul>
                         </div>
@@ -68,7 +64,6 @@ pub fn Story() -> impl IntoView {
             }
         }
     }))).build())
-    .into_any()
 }
 
 #[component]
@@ -77,65 +72,43 @@ pub fn Comment(comment: api::Comment) -> impl IntoView {
 
     view! {
         <li class="comment">
-            <div class="by">
-                <A href=format!(
-                    "/users/{}",
-                    comment.user.clone().unwrap_or_default(),
-                )>{comment.user.clone()}</A>
-                {format!(" {}", comment.time_ago)}
-            </div>
-            <div class="text" inner_html=comment.content></div>
-            {(!comment.comments.is_empty())
-                .then(|| {
-                    view! {
-                        <div>
-                            <div class="toggle" class:open=open>
-                                <a on:click=move |_| {
-                                    set_open.update(|n| *n = !*n)
-                                }>
-
-                                    {
-                                        let comments_len = comment.comments.len();
-                                        move || {
-                                            if open.get() {
-                                                "[-]".into()
-                                            } else {
-                                                format!(
-                                                    "[+] {}{} collapsed",
-                                                    comments_len,
-                                                    pluralize(comments_len),
-                                                )
-                                            }
-                                        }
-                                    }
-
-                                </a>
-                            </div>
-                            {move || {
-                                open
-                                    .get()
-                                    .then({
-                                        let comments = comment.comments.clone();
-                                        move || {
-                                            view! {
-                                                <ul class="comment-children">
-                                                    <For
-                                                        each=move || comments.clone()
-                                                        key=|comment| comment.id
-                                                        let:comment
-                                                    >
-                                                        <Comment comment/>
-                                                    </For>
-                                                </ul>
-                                            }
-                                        }
-                                    })
-                            }}
-
-                        </div>
-                    }
-                })}
-
+        <div class="by">
+            <A href=format!("/users/{}", comment.user.clone().unwrap_or_default())>{comment.user.clone()}</A>
+            {format!(" {}", comment.time_ago)}
+        </div>
+        <div class="text" inner_html=comment.content></div>
+        {(!comment.comments.is_empty()).then(|| {
+            view! {
+                <div>
+                    <div class="toggle" class:open=open>
+                        <a on:click=move |_| set_open.update(|n| *n = !*n)>
+                            {
+                                let comments_len = comment.comments.len();
+                                move || if open.get() {
+                                    "[-]".into()
+                                } else {
+                                    format!("[+] {}{} collapsed", comments_len, pluralize(comments_len))
+                                }
+                            }
+                        </a>
+                    </div>
+                    {move || open.get().then({
+                        let comments = comment.comments.clone();
+                        move || view! {
+                            <ul class="comment-children">
+                                <For
+                                    each=move || comments.clone()
+                                    key=|comment| comment.id
+                                    let:comment
+                                >
+                                    <Comment comment />
+                                </For>
+                            </ul>
+                        }
+                    })}
+                </div>
+            }
+        })}
         </li>
     }.into_any()
 }

examples/hackernews/src/routes/users.rs

@@ -18,48 +18,30 @@ pub fn User() -> impl IntoView {
     );
     view! {
         <div class="user-view">
-            <Suspense fallback=|| {
-                view! { "Loading..." }
-            }>
-                {move || Suspend::new(async move {
-                    match user.await.clone() {
-                        None => Either::Left(view! { <h1>"User not found."</h1> }),
-                        Some(user) => {
-                            Either::Right(
-                                view! {
-                                    <div>
-                                        <h1>"User: " {user.id.clone()}</h1>
-                                        <ul class="meta">
-                                            <li>
-                                                <span class="label">"Created: "</span>
-                                                {user.created}
-                                            </li>
-                                            <li>
-                                                <span class="label">"Karma: "</span>
-                                                {user.karma}
-                                            </li>
-                                            <li inner_html=user.about class="about"></li>
-                                        </ul>
-                                        <p class="links">
-                                            <a href=format!(
-                                                "https://news.ycombinator.com/submitted?id={}",
-                                                user.id,
-                                            )>"submissions"</a>
-                                            " | "
-                                            <a href=format!(
-                                                "https://news.ycombinator.com/threads?id={}",
-                                                user.id,
-                                            )>"comments"</a>
-                                        </p>
-                                    </div>
-                                },
-                            )
-                        }
-                    }
-                })}
-
+            <Suspense fallback=|| view! { "Loading..." }>
+                {move || Suspend::new(async move { match user.await.clone() {
+                    None => Either::Left(view! {  <h1>"User not found."</h1> }),
+                    Some(user) => Either::Right(view! {
+                        <div>
+                            <h1>"User: " {user.id.clone()}</h1>
+                            <ul class="meta">
+                                <li>
+                                    <span class="label">"Created: "</span> {user.created}
+                                </li>
+                                <li>
+                                <span class="label">"Karma: "</span> {user.karma}
+                                </li>
+                                <li inner_html={user.about} class="about"></li>
+                            </ul>
+                            <p class="links">
+                                <a href=format!("https://news.ycombinator.com/submitted?id={}", user.id)>"submissions"</a>
+                                " | "
+                                <a href=format!("https://news.ycombinator.com/threads?id={}", user.id)>"comments"</a>
+                            </p>
+                        </div>
+                    })
+                }})}
             </Suspense>
         </div>
     }
-    .into_any()
 }

examples/hackernews_axum/src/lib.rs

@@ -4,7 +4,7 @@ mod routes;
 use leptos_meta::{provide_meta_context, Link, Meta, MetaTags, Stylesheet};
 use leptos_router::{
     components::{FlatRoutes, Route, Router, RoutingProgress},
-    OptionalParamSegment, ParamSegment, StaticSegment,
+    ParamSegment, StaticSegment,
 };
 use routes::{nav::*, stories::*, story::*, users::*};
 use std::time::Duration;
@@ -46,7 +46,9 @@ pub fn App() -> impl IntoView {
                 <FlatRoutes fallback=|| "Not found.">
                     <Route path=(StaticSegment("users"), ParamSegment("id")) view=User/>
                     <Route path=(StaticSegment("stories"), ParamSegment("id")) view=Story/>
-                    <Route path=OptionalParamSegment("stories") view=Stories/>
+                    <Route path=ParamSegment("stories") view=Stories/>
+                    // TODO allow optional params without duplication
+                    <Route path=StaticSegment("") view=Stories/>
                 </FlatRoutes>
             </main>
         </Router>

examples/hackernews_islands_axum/src/lib.rs

@@ -4,7 +4,7 @@ mod routes;
 use leptos_meta::{provide_meta_context, Link, Meta, MetaTags, Stylesheet};
 use leptos_router::{
     components::{FlatRoutes, Route, Router},
-    OptionalParamSegment, ParamSegment, StaticSegment,
+    ParamSegment, StaticSegment,
 };
 use routes::{nav::*, stories::*, story::*, users::*};
 #[cfg(feature = "ssr")]
@@ -42,7 +42,9 @@ pub fn App() -> impl IntoView {
                 <FlatRoutes fallback=|| "Not found.">
                     <Route path=(StaticSegment("users"), ParamSegment("id")) view=User/>
                     <Route path=(StaticSegment("stories"), ParamSegment("id")) view=Story/>
-                    <Route path=OptionalParamSegment("stories") view=Stories/>
+                    <Route path=ParamSegment("stories") view=Stories/>
+                    // TODO allow optional params without duplication
+                    <Route path=StaticSegment("") view=Stories/>
                 </FlatRoutes>
             </main>
         </Router>

examples/hackernews_js_fetch/src/lib.rs

@@ -4,7 +4,7 @@ mod routes;
 use leptos_meta::{provide_meta_context, Link, Meta, MetaTags, Stylesheet};
 use leptos_router::{
     components::{FlatRoutes, Route, Router, RoutingProgress},
-    OptionalParamSegment, ParamSegment, StaticSegment,
+    ParamSegment, StaticSegment,
 };
 use routes::{nav::*, stories::*, story::*, users::*};
 use std::time::Duration;
@@ -46,7 +46,9 @@ pub fn App() -> impl IntoView {
                 <FlatRoutes fallback=|| "Not found.">
                     <Route path=(StaticSegment("users"), ParamSegment("id")) view=User/>
                     <Route path=(StaticSegment("stories"), ParamSegment("id")) view=Story/>
-                    <Route path=OptionalParamSegment("stories") view=Stories/>
+                    <Route path=ParamSegment("stories") view=Stories/>
+                    // TODO allow optional params without duplication
+                    <Route path=StaticSegment("") view=Stories/>
                 </FlatRoutes>
             </main>
         </Router>

examples/islands_router/Cargo.toml

@@ -17,7 +17,7 @@ leptos = { path = "../../leptos", features = [
 leptos_router = { path = "../../router" }
 server_fn = { path = "../../server_fn", features = ["serde-lite"] }
 leptos_axum = { path = "../../integrations/axum", features = [
-  "dont-use-islands-router",
+  "islands-router",
 ], optional = true }
 log = "0.4.22"
 serde = { version = "1.0", features = ["derive"] }

examples/islands_router/README.md

@@ -1,14 +1,19 @@
-# Work in Progress
+# Leptos Todo App Sqlite with Axum
 
-This example is something I wrote on a long layover in the Orlando airport in July. (It was really hot!)
+This example creates a basic todo app with an Axum backend that uses Leptos' server functions to call sqlx from the client and seamlessly run it on the server.
 
-It is the culmination of a couple years of thinking and working toward being able to do this, which you can see 
-described pretty well in the pinned roadmap issue (#1830) and its discussion of different modes of client-side
-routing when you use islands.
+## Getting Started
 
-This uses *only* server rendering, with no actual islands, but still maintains client-side state across page navigations.
-It does this by building on the fact that we now have a statically-typed view tree to do pretty smart updates with 
-new HTML from the client, with extremely minimal diffing.
+See the [Examples README](../README.md) for setup and run instructions.
 
-The demo itself works, but the feature that supports it is incomplete. A couple people have accidentally
-used it and broken their applications in ways they don't understand, so I've renamed the feature to `dont-use-islands-router`.
+## E2E Testing
+
+See the [E2E README](./e2e/README.md) for more information about the testing strategy.
+
+## Rendering
+
+See the [SSR Notes](../SSR_NOTES.md) for more information about Server Side Rendering.
+
+## Quick Start
+
+Run `cargo leptos watch` to run this example.

examples/js-framework-benchmark/tests/web.rs

@@ -1,5 +1,5 @@
 use js_framework_benchmark_leptos::*;
-use leptos::{prelude::*, task::tick};
+use leptos::{prelude::*, spawn::tick};
 use wasm_bindgen::JsCast;
 use wasm_bindgen_test::*;
 

examples/portal/src/main.rs

@@ -6,7 +6,7 @@ fn main() {
     _ = console_log::init_with_level(log::Level::Debug);
     console_error_panic_hook::set_once();
     let handle = mount_to(
-        document()
+        helpers::document()
             .get_element_by_id("app")
             .unwrap()
             .unchecked_into(),

examples/portal/tests/web.rs

@@ -3,7 +3,7 @@ use wasm_bindgen::JsCast;
 use wasm_bindgen_test::*;
 
 wasm_bindgen_test_configure!(run_in_browser);
-use leptos::task::tick;
+use leptos::spawn::tick;
 use leptos::{leptos_dom::helpers::document, mount::mount_to};
 use web_sys::HtmlButtonElement;
 

examples/router/index.html

@@ -3,7 +3,7 @@
 	<head>
 		<link data-trunk rel="rust" data-wasm-opt="z"/>
 		<link data-trunk rel="icon" type="image/ico" href="/public/favicon.ico"/>
-		<link data-trunk rel="css" href="style.css"/>
+        <link data-trunk rel="css" href="style.css"/>
 	</head>
 	<body></body>
 </html>

examples/router/src/lib.rs

@@ -5,14 +5,13 @@ use leptos::prelude::*;
 use leptos_router::{
     components::{
         Form, Outlet, ParentRoute, ProtectedRoute, Redirect, Route, Router,
-        Routes, RoutingProgress, A,
+        Routes, A,
     },
     hooks::{use_navigate, use_params, use_query_map},
     params::Params,
     MatchNestedRoutes,
 };
 use leptos_router_macro::path;
-use std::time::Duration;
 use tracing::info;
 
 #[derive(Copy, Clone, Debug, PartialEq, Eq)]
@@ -27,14 +26,9 @@ pub fn RouterExample() -> impl IntoView {
 
     // this signal will be ued to set whether we are allowed to access a protected route
     let (logged_in, set_logged_in) = signal(true);
-    let (is_routing, set_is_routing) = signal(false);
 
     view! {
-        <Router set_is_routing>
-            // shows a progress bar while async data are loading
-            <div class="routing-progress">
-                <RoutingProgress is_routing max_time=Duration::from_millis(250)/>
-            </div>
+        <Router>
             <nav>
                 // ordinary <a> elements can be used for client-side navigation
                 // using <A> has two effects:
@@ -50,7 +44,7 @@ pub fn RouterExample() -> impl IntoView {
                 }>{move || if logged_in.get() { "Log Out" } else { "Log In" }}</button>
             </nav>
             <main>
-                <Routes transition=true fallback=|| "This page could not be found.">
+                <Routes fallback=|| "This page could not be found.">
                     // paths can be created using the path!() macro, or provided as types like
                     // StaticSegment("about")
                     <Route path=path!("about") view=About/>
@@ -70,8 +64,8 @@ pub fn RouterExample() -> impl IntoView {
 
 // You can define other routes in their own component.
 // Routes implement the MatchNestedRoutes
-#[component(transparent)]
-pub fn ContactRoutes() -> impl MatchNestedRoutes + Clone {
+#[component]
+pub fn ContactRoutes() -> impl MatchNestedRoutes<Dom> + Clone {
     view! {
         <ParentRoute path=path!("") view=ContactList>
             <Route path=path!("/") view=|| "Select a contact."/>

examples/router/style.css

@@ -1,8 +1,3 @@
-.routing-progress {
-	width: 100%;
-	height: 20px;
-}
-
 a[aria-current] {
     font-weight: bold;
 }
@@ -17,8 +12,12 @@ a[aria-current] {
     padding: 1rem;
 }
 
-.contact {
-	view-transition-name: contact;
+.fadeIn {
+  animation: 0.5s fadeIn forwards;
+}
+
+.fadeOut {
+  animation: 0.5s fadeOut forwards;
 }
 
 @keyframes fadeIn {
@@ -41,44 +40,12 @@ a[aria-current] {
   }
 }
 
-.router-outlet-0 main {
-  view-transition-name: main;
+.slideIn {
+  animation: 0.25s slideIn forwards;
 }
 
-.router-back main {
-  view-transition-name: main-back;
-}
-
-.router-outlet-1 .contact-list {
-  view-transition-name: contact;
-}
-
-@media (prefers-reduced-motion: no-preference) {
-	::view-transition-old(contact) {
-	  animation: 0.5s fadeOut;
-	}
-
-	::view-transition-new(contact) {
-	  animation: 0.5s fadeIn;
-	}
-
-	::view-transition-old(main) {
-	  animation: 0.5s slideOut;
-	}
-
-	::view-transition-new(main) {
-	  animation: 0.5s slideIn;
-	}
-
-	::view-transition-old(main-back) {
-		color: red;
-		animation: 0.5s slideOutBack;
-	}
-
-	::view-transition-new(main-back) {
-		color: blue;
-		animation: 0.5s slideInBack;
-	}
+.slideOut {
+  animation: 0.25s slideOut forwards;
 }
 
 @keyframes slideIn {
@@ -99,6 +66,14 @@ a[aria-current] {
   }
 }
 
+.slideInBack {
+  animation: 0.25s slideInBack forwards;
+}
+
+.slideOutBack {
+  animation: 0.25s slideOutBack forwards;
+}
+
 @keyframes slideInBack {
   from {
     transform: translate(-100vw, 0);

examples/server_fns_axum/Cargo.toml

@@ -40,8 +40,6 @@ pin-project-lite = "0.2.14"
 dashmap = { version = "6.0", optional = true }
 once_cell = { version = "1.19", optional = true }
 async-broadcast = { version = "0.7.1", optional = true }
-bytecheck = "0.8.0"
-rkyv = { version = "0.8.8" }
 
 [features]
 hydrate = ["leptos/hydrate"]

examples/server_fns_axum/src/app.rs

@@ -1,6 +1,6 @@
 use futures::StreamExt;
 use http::Method;
-use leptos::{html::Input, prelude::*, task::spawn_local};
+use leptos::{html::Input, prelude::*, spawn::spawn_local};
 use serde::{de::DeserializeOwned, Deserialize, Serialize};
 use server_fn::{
     client::{browser::BrowserClient, Client},
@@ -417,6 +417,7 @@ pub fn FileUploadWithProgress() -> impl IntoView {
     /// This requires us to store some global state of all the uploads. In a real app, you probably
     /// shouldn't do exactly what I'm doing here in the demo. For example, this map just
     /// distinguishes between files by filename, not by user.
+
     #[cfg(feature = "ssr")]
     mod progress {
         use async_broadcast::{broadcast, Receiver, Sender};

examples/server_fns_axum/src/main.rs

@@ -4,8 +4,6 @@ use leptos::{config::get_configuration, logging};
 use leptos_axum::{generate_route_list, LeptosRoutes};
 use server_fns_axum::*;
 
-// cargo make cli: error: unneeded `return` statement
-#[allow(clippy::needless_return)]
 #[tokio::main]
 async fn main() {
     simple_logger::init_with_level(log::Level::Error)

examples/slots/src/lib.rs

@@ -10,7 +10,7 @@ struct Then {
 // the type with Option<...> and marking the option as #[prop(optional)].
 #[slot]
 struct ElseIf {
-    cond: Signal<bool>,
+    cond: MaybeSignal<bool>,
     children: ChildrenFn,
 }
 
@@ -22,7 +22,7 @@ struct Fallback {
 // Slots are added to components like any other prop.
 #[component]
 fn SlotIf(
-    cond: Signal<bool>,
+    cond: MaybeSignal<bool>,
     then: Then,
     #[prop(default=vec![])] else_if: Vec<ElseIf>,
     #[prop(optional)] fallback: Option<Fallback>,
@@ -43,9 +43,9 @@ fn SlotIf(
 #[component]
 pub fn App() -> impl IntoView {
     let (count, set_count) = signal(0);
-    let is_even = Signal::derive(move || count.get() % 2 == 0);
-    let is_div5 = Signal::derive(move || count.get() % 5 == 0);
-    let is_div7 = Signal::derive(move || count.get() % 7 == 0);
+    let is_even = MaybeSignal::derive(move || count.get() % 2 == 0);
+    let is_div5 = MaybeSignal::derive(move || count.get() % 5 == 0);
+    let is_div7 = MaybeSignal::derive(move || count.get() % 7 == 0);
 
     view! {
         <button on:click=move |_| set_count.update(|value| *value += 1)>"+1"</button>

examples/ssr_modes/src/main.rs

@@ -39,7 +39,7 @@ async fn main() -> std::io::Result<()> {
                         </html>
                     }
             }})
-            .service(Files::new("/", site_root.as_ref()))
+            .service(Files::new("/", site_root))
         //.wrap(middleware::Compress::default())
     })
     .bind(&addr)?

examples/ssr_modes_axum/src/main.rs

@@ -2,7 +2,6 @@
 #[tokio::main]
 async fn main() {
     use axum::Router;
-    use leptos::logging::log;
     use leptos::prelude::*;
     use leptos_axum::{generate_route_list, LeptosRoutes};
     use ssr_modes_axum::app::*;

examples/static_routing/src/main.rs

@@ -2,7 +2,6 @@
 #[tokio::main]
 async fn main() {
     use axum::Router;
-    use leptos::logging::log;
     use leptos::prelude::*;
     use leptos_axum::{generate_route_list_with_ssg, LeptosRoutes};
     use static_routing::app::*;

examples/stores/src/lib.rs

@@ -1,9 +1,9 @@
 use std::sync::atomic::{AtomicUsize, Ordering};
 
 use chrono::{Local, NaiveDate};
-use leptos::logging::warn;
 use leptos::prelude::*;
 use reactive_stores::{Field, Patch, Store};
+use reactive_stores_macro::{Patch, Store};
 use serde::{Deserialize, Serialize};
 
 // ID starts higher than 0 because we have a few starting todos by default
@@ -110,7 +110,11 @@ pub fn App() -> impl IntoView {
             // directly implements IntoIterator, so we can use it in <For/> and
             // it will manage reactivity for the store fields correctly
             <For
-                each=move || store.todos()
+                each=move || {
+                    leptos::logging::log!("RERUNNING FOR CALCULATION");
+                    store.todos()
+                }
+
                 key=|row| row.id().get()
                 let:todo
             >

examples/suspense_tests/Cargo.toml

@@ -10,7 +10,6 @@ crate-type = ["cdylib", "rlib"]
 actix-files = { version = "0.6.6", optional = true }
 actix-web = { version = "4.8", optional = true, features = ["macros"] }
 console_error_panic_hook = "0.1.7"
-js-sys = { version = "0.3.70", optional = true }
 leptos = { path = "../../leptos" }
 leptos_actix = { path = "../../integrations/actix", optional = true }
 leptos_router = { path = "../../router" }
@@ -20,10 +19,7 @@ serde = "1.0"
 tokio = { version = "1.39", features = ["time", "rt"], optional = true }
 
 [features]
-hydrate = [
-  "dep:js-sys",
-  "leptos/hydrate",
-]
+hydrate = ["leptos/hydrate"]
 ssr = [
   "dep:actix-files",
   "dep:actix-web",

examples/suspense_tests/e2e/features/check_instrumented.feature

@@ -1,94 +0,0 @@
-@check_instrumented
-Feature: Instrumented Counters showing the expected values
-
-    Scenario: I can fresh CSR instrumented counters
-        Given I see the app
-        When I access the instrumented counters via CSR
-        Then I see the following counters under section
-            | Suspend Calls      |   |
-            | item_listing       | 0 |
-            | item_overview      | 0 |
-            | item_inspect       | 0 |
-        And the following counters under section
-            | Server Calls (CSR) |   |
-            | list_items         | 0 |
-            | get_item           | 0 |
-            | inspect_item_root  | 0 |
-            | inspect_item_field | 0 |
-
-    Scenario: I should see counter going up after viewing Item Listing
-        Given I see the app
-        When I select the following links
-            | Instrumented |
-            | Item Listing |
-            | Counters     |
-        Then I see the following counters under section
-            | Suspend Calls      |   |
-            | item_listing       | 1 |
-            | item_overview      | 0 |
-            | item_inspect       | 0 |
-        And the following counters under section
-            | Server Calls (CSR) |   |
-            | list_items         | 1 |
-            | get_item           | 0 |
-            | inspect_item_root  | 0 |
-            | inspect_item_field | 0 |
-
-    # the reload has happened in Item Listing, it follows a suspend
-    # will be called as hydration happens.
-    Scenario: Refreshing Item Listing should have only suspend counters
-        Given I see the app
-        When I access the instrumented counters via SSR
-        And I select the component Item Listing
-        And I reload the page
-        And I select the component Counters
-        Then I see the following counters under section
-            | Suspend Calls      |   |
-            | item_listing       | 1 |
-            | item_overview      | 0 |
-            | item_inspect       | 0 |
-        And the following counters under section
-            | Server Calls (CSR) |   |
-            | list_items         | 0 |
-            | get_item           | 0 |
-            | inspect_item_root  | 0 |
-            | inspect_item_field | 0 |
-
-    Scenario: Reset CSR Counters work as expected.
-        Given I see the app
-        When I access the instrumented counters via SSR
-        And I select the component Item Listing
-        And I click on Reset CSR Counters
-        And I select the component Counters
-        Then I see the following counters under section
-            | Suspend Calls      |   |
-            | item_listing       | 0 |
-            | item_overview      | 0 |
-            | item_inspect       | 0 |
-        And the following counters under section
-            | Server Calls (CSR) |   |
-            | list_items         | 0 |
-            | get_item           | 0 |
-            | inspect_item_root  | 0 |
-            | inspect_item_field | 0 |
-
-    Scenario: Standard usage of the instruments traversing down
-        Given I see the app
-        When I select the following links
-            | Instrumented         |
-            | Item Listing         |
-            | Item 2               |
-            | Inspect path3        |
-            | Inspect path3/field1 |
-        And I access the instrumented counters via CSR
-        Then I see the following counters under section
-            | Suspend Calls      |   |
-            | item_listing       | 1 |
-            | item_overview      | 1 |
-            | item_inspect       | 2 |
-        And the following counters under section
-            | Server Calls (CSR) |   |
-            | list_items         | 1 |
-            | get_item           | 1 |
-            | inspect_item_root  | 1 |
-            | inspect_item_field | 1 |

examples/suspense_tests/e2e/features/check_instrumented_suspense_resource.feature

@@ -1,195 +0,0 @@
-@check_instrumented_suspense_resource
-Feature: Using instrumented counters for real
-    Check that the suspend/suspense and the underlying resources are
-    called with the expected number of times for CSR rendering.
-
-    Background:
-
-        Given I see the app
-        And I select the mode Instrumented
-
-    Scenario: Emulate steps 1 to 5 of issue #2961
-        Given I select the link Target 3##
-        And I refresh the page
-        When I select the following links
-            | Item Listing |
-            | Target 4##   |
-        And I go check the Counters
-        Then I see the following counters under section
-            | Suspend Calls      |   |
-            | item_listing       | 1 |
-            | item_overview      | 2 |
-            | item_inspect       | 0 |
-        And the following counters under section
-            | Server Calls (CSR) |   |
-            | list_items         | 0 |
-            | get_item           | 2 |
-            | inspect_item_root  | 0 |
-            | inspect_item_field | 0 |
-
-    Scenario: Emulate step 6 of issue #2961
-        Given I select the link Target 41#
-        And I refresh the page
-        When I select the following links
-            | Target 4##   |
-            | Target 42#   |
-        And I go check the Counters
-        Then I see the following counters under section
-            | Suspend Calls      |   |
-            | item_listing       | 0 |
-            | item_overview      | 1 |
-            | item_inspect       | 2 |
-        And the following counters under section
-            | Server Calls (CSR) |   |
-            | list_items         | 0 |
-            | get_item           | 1 |
-            | inspect_item_root  | 2 |
-            | inspect_item_field | 0 |
-
-    Scenario: Emulate step 7 of issue #2961
-        Given I select the link Target 42#
-        And I refresh the page
-        When I select the following links
-            | Target 4##   |
-            | Target 42#   |
-            | Target 41#   |
-        And I go check the Counters
-        Then I see the following counters under section
-            | Suspend Calls      |   |
-            | item_listing       | 0 |
-            | item_overview      | 1 |
-            | item_inspect       | 3 |
-        And the following counters under section
-            | Server Calls (CSR) |   |
-            | list_items         | 0 |
-            | get_item           | 1 |
-            | inspect_item_root  | 3 |
-            | inspect_item_field | 0 |
-
-    Scenario: Emulate step 8, "not trigger double fetch".
-        Given I select the link Target 3##
-        And I refresh the page
-        When I select the following links
-            | Item Listing |
-            | Target 4##   |
-            | Target 41#   |
-        And I go check the Counters
-        Then I see the following counters under section
-            | Suspend Calls      |   |
-            | item_listing       | 1 |
-            | item_overview      | 2 |
-            | item_inspect       | 1 |
-        And the following counters under section
-            | Server Calls (CSR) |   |
-            | list_items         | 0 |
-            | get_item           | 2 |
-            | inspect_item_root  | 1 |
-            | inspect_item_field | 0 |
-
-    Scenario: Like above, for the "double fetch" which shouldn't happen
-        Given I select the link Target 3##
-        And I refresh the page
-        When I select the following links
-            | Item Listing |
-            | Target 4##   |
-            | Target 41#   |
-            | Target 3##   |
-        And I go check the Counters
-        Then I see the following counters under section
-            | Suspend Calls      |   |
-            | item_listing       | 1 |
-            | item_overview      | 3 |
-            | item_inspect       | 1 |
-        And the following counters under section
-            | Server Calls (CSR) |   |
-            | list_items         | 0 |
-            | get_item           | 3 |
-            | inspect_item_root  | 1 |
-            | inspect_item_field | 0 |
-
-    Scenario: Like above, but using 4## instead
-        Given I select the link Target 3##
-        And I refresh the page
-        When I select the following links
-            | Item Listing |
-            | Target 4##   |
-            | Target 41#   |
-            | Target 4##   |
-        And I go check the Counters
-        Then I see the following counters under section
-            | Suspend Calls      |   |
-            | item_listing       | 1 |
-            | item_overview      | 3 |
-            | item_inspect       | 1 |
-        And the following counters under section
-            | Server Calls (CSR) |   |
-            | list_items         | 0 |
-            | get_item           | 2 |
-            | inspect_item_root  | 1 |
-            | inspect_item_field | 0 |
-
-    # Currently, get_item is invoked with `3` as the argument upon
-    # selection of `Item Listing` despite that `Item Listing` doesn't
-    # need `get_item` calls.  Seems like it may be due to the system
-    # still reacting to the unmounting of the component that needed
-    # view that generated the original `Item 3` (hydrated from SSR).
-    # Tests above may also have this type of behavior, but is somewhat
-    # masked because the direction of going down and then back up, but
-    # if this behavior changes for the better (avoiding this spurious
-    # resource fetch) then the above tests may need updating to reflect
-    # the corrected behavior.  Note the difference with the fully CSR
-    # scenario after this one
-    Scenario: Emulate part of step 8 of issue #2961
-        Given I select the link Target 3##
-        And I refresh the page
-        When I select the link Item Listing
-        And I go check the Counters
-        Then I see the following counters under section
-            | Server Calls (CSR) |   |
-            | list_items         | 0 |
-            | get_item           | 1 |
-            | inspect_item_root  | 0 |
-            | inspect_item_field | 0 |
-
-    # Instead of refreshing the page like above, CSR counters is reset
-    # instead to keep the starting counter conditions identical.
-    Scenario: Emulate above, instead of refresh page, reset csr counters
-        Given I select the link Target 3##
-        And I click on Reset CSR Counters
-        When I select the link Item Listing
-        And I go check the Counters
-        Then I see the following counters under section
-            | Server Calls (CSR) |   |
-            | list_items         | 0 |
-            | get_item           | 0 |
-            | inspect_item_root  | 0 |
-            | inspect_item_field | 0 |
-
-    # Again, the following two sets demostrates resources making stale
-    # and redundant requests when hydrated, and not do so when under
-    # CSR.
-    Scenario: Start with hydration from Target 41# and go up
-        Given I select the link Target 41#
-        And I refresh the page
-        When I select the link Target 4##
-        And I select the link Item Listing
-        And I go check the Counters
-        Then I see the following counters under section
-            | Server Calls (CSR) |   |
-            | list_items         | 0 |
-            | get_item           | 1 |
-            | inspect_item_root  | 1 |
-            | inspect_item_field | 0 |
-
-    Scenario: Start with hydration from Target 41# and go up
-        Given I select the link Target 41#
-        And I click on Reset CSR Counters
-        When I select the link Target 4##
-        And I select the link Item Listing
-        And I go check the Counters
-        Then I see the following counters under section
-            | Server Calls (CSR) |   |
-            | list_items         | 0 |
-            | get_item           | 0 |
-            | inspect_item_root  | 0 |
-            | inspect_item_field | 0 |

examples/suspense_tests/e2e/tests/fixtures/action.rs

@@ -37,19 +37,3 @@ pub async fn click_second_button(client: &Client) -> Result<()> {
 
     Ok(())
 }
-
-pub async fn click_reset_counters_button(client: &Client) -> Result<()> {
-    let reset_counter = find::reset_counter(client).await?;
-
-    reset_counter.click().await?;
-
-    Ok(())
-}
-
-pub async fn click_reset_csr_counters_button(client: &Client) -> Result<()> {
-    let reset_counter = find::reset_csr_counter(client).await?;
-
-    reset_counter.click().await?;
-
-    Ok(())
-}

examples/suspense_tests/e2e/tests/fixtures/check.rs

@@ -63,21 +63,3 @@ pub async fn second_count_is(client: &Client, expected: u32) -> Result<()> {
 
     Ok(())
 }
-
-pub async fn instrumented_counts(
-    client: &Client,
-    expected: &[(&str, u32)],
-) -> Result<()> {
-    let mut actual = Vec::<(&str, u32)>::new();
-
-    for (selector, _) in expected.iter() {
-        actual.push((
-            selector,
-            find::instrumented_count(client, selector).await?,
-        ))
-    }
-
-    assert_eq!(actual, expected);
-
-    Ok(())
-}

examples/suspense_tests/e2e/tests/fixtures/find.rs

@@ -77,43 +77,6 @@ pub async fn second_button(client: &Client) -> Result<Element> {
     Ok(counter_button)
 }
 
-pub async fn instrumented_count(
-    client: &Client,
-    selector: &str,
-) -> Result<u32> {
-    let element = client
-        .wait()
-        .for_element(Locator::Id(selector))
-        .await
-        .expect(format!("Element #{selector} not found.")
-            .as_str());
-    let text = element.text().await?;
-    let count = text.parse::<u32>()
-        .expect(format!("Element #{selector} does not contain a number.")
-            .as_str());
-    Ok(count)
-}
-
-pub async fn reset_counter(client: &Client) -> Result<Element> {
-    let reset_button = client
-        .wait()
-        .for_element(Locator::Id("reset-counters"))
-        .await
-        .expect("Reset counter input not found");
-
-    Ok(reset_button)
-}
-
-pub async fn reset_csr_counter(client: &Client) -> Result<Element> {
-    let reset_button = client
-        .wait()
-        .for_element(Locator::Id("reset-csr-counters"))
-        .await
-        .expect("Reset CSR counter input not found");
-
-    Ok(reset_button)
-}
-
 async fn component_message(client: &Client, id: &str) -> Result<String> {
     let element =
         client.wait().for_element(Locator::Id(id)).await.expect(

examples/suspense_tests/e2e/tests/fixtures/world/action_steps.rs

@@ -1,6 +1,6 @@
 use crate::fixtures::{action, world::AppWorld};
 use anyhow::{Ok, Result};
-use cucumber::{given, when, gherkin::Step};
+use cucumber::{given, when};
 
 #[given("I see the app")]
 #[when("I open the app")]
@@ -12,13 +12,19 @@ async fn i_open_the_app(world: &mut AppWorld) -> Result<()> {
 }
 
 #[given(regex = r"^I select the mode (.*)$")]
+async fn i_select_the_mode(world: &mut AppWorld, text: String) -> Result<()> {
+    let client = &world.client;
+    action::click_link(client, &text).await?;
+
+    Ok(())
+}
+
 #[given(regex = r"^I select the component (.*)$")]
 #[when(regex = "^I select the component (.*)$")]
-#[given(regex = "^I select the link (.*)$")]
-#[when(regex = "^I select the link (.*)$")]
-#[when(regex = "^I click on the link (.*)$")]
-#[when(regex = "^I go check the (.*)$")]
-async fn i_select_the_link(world: &mut AppWorld, text: String) -> Result<()> {
+async fn i_select_the_component(
+    world: &mut AppWorld,
+    text: String,
+) -> Result<()> {
     let client = &world.client;
     action::click_link(client, &text).await?;
 
@@ -53,69 +59,3 @@ async fn i_click_the_second_button_n_times(
 
     Ok(())
 }
-
-#[given(regex = "^I (refresh|reload) the (browser|page)$")]
-#[when(regex = "^I (refresh|reload) the (browser|page)$")]
-async fn i_refresh_the_browser(world: &mut AppWorld) -> Result<()> {
-    let client = &world.client;
-    client.refresh().await?;
-
-    Ok(())
-}
-
-#[when(expr = "I click on Reset Counters")]
-async fn i_click_on_reset_counters(world: &mut AppWorld) -> Result<()> {
-    let client = &world.client;
-    action::click_reset_counters_button(client).await?;
-
-    Ok(())
-}
-
-#[given(expr = "I click on Reset CSR Counters")]
-#[when(expr = "I click on Reset CSR Counters")]
-async fn i_click_on_reset_csr_counters(world: &mut AppWorld) -> Result<()> {
-    let client = &world.client;
-    action::click_reset_csr_counters_button(client).await?;
-
-    Ok(())
-}
-
-#[when(expr = "I access the instrumented counters via SSR")]
-async fn i_access_the_instrumented_counters_page_via_ssr(
-    world: &mut AppWorld,
-) -> Result<()> {
-    let client = &world.client;
-    action::click_link(client, "Instrumented").await?;
-    action::click_link(client, "Counters").await?;
-    client.refresh().await?;
-
-    Ok(())
-}
-
-#[when(expr = "I access the instrumented counters via CSR")]
-async fn i_access_the_instrumented_counters_page_via_csr(
-    world: &mut AppWorld,
-) -> Result<()> {
-    let client = &world.client;
-    action::click_link(client, "Instrumented").await?;
-    action::click_link(client, "Counters").await?;
-
-    Ok(())
-}
-
-#[given(expr = "I select the following links")]
-#[when(expr = "I select the following links")]
-async fn i_select_the_following_links(
-    world: &mut AppWorld,
-    step: &Step,
-) -> Result<()> {
-    let client = &world.client;
-
-    if let Some(table) = step.table.as_ref() {
-        for row in table.rows.iter() {
-            action::click_link(client, &row[0]).await?;
-        }
-    }
-
-    Ok(())
-}

examples/suspense_tests/e2e/tests/fixtures/world/check_steps.rs

@@ -1,6 +1,6 @@
 use crate::fixtures::{check, world::AppWorld};
 use anyhow::{Ok, Result};
-use cucumber::{then, gherkin::Step};
+use cucumber::then;
 
 #[then(regex = r"^I see the page title is (.*)$")]
 async fn i_see_the_page_title_is(
@@ -79,23 +79,3 @@ async fn i_see_the_second_count_is(
 
     Ok(())
 }
-
-#[then(expr = "I see the following counters under section")]
-#[then(expr = "the following counters under section")]
-async fn i_see_the_following_counters_under_section(
-    world: &mut AppWorld,
-    step: &Step,
-) -> Result<()> {
-    // FIXME ideally check the mode; for now leave it because effort
-    let client = &world.client;
-    if let Some(table) = step.table.as_ref() {
-        let expected = table.rows
-            .iter()
-            .skip(1)
-            .map(|row| (row[0].as_str(), row[1].parse::<u32>().unwrap()))
-            .collect::<Vec<_>>();
-        check::instrumented_counts(client, &expected).await?;
-    }
-
-    Ok(())
-}

examples/suspense_tests/src/app.rs

@@ -1,4 +1,3 @@
-use crate::instrumented::InstrumentedRoutes;
 use leptos::prelude::*;
 use leptos_router::{
     components::{Outlet, ParentRoute, Redirect, Route, Router, Routes, A},
@@ -42,7 +41,6 @@ pub fn App() -> impl IntoView {
                 <A href="/out-of-order">"Out-of-Order"</A>
                 <A href="/in-order">"In-Order"</A>
                 <A href="/async">"Async"</A>
-                <A href="/instrumented/">"Instrumented"</A>
             </nav>
             <main>
                 <Routes fallback=|| "Page not found.">
@@ -112,7 +110,6 @@ pub fn App() -> impl IntoView {
                         <Route path=StaticSegment("local") view=LocalResource/>
                         <Route path=StaticSegment("none") view=None/>
                     </ParentRoute>
-                    <InstrumentedRoutes/>
                 </Routes>
             </main>
         </Router>

examples/suspense_tests/src/instrumented.rs

@@ -1,667 +0,0 @@
-use leptos::prelude::*;
-use leptos_router::{
-    components::{ParentRoute, Route, A},
-    hooks::use_params,
-    nested_router::Outlet,
-    params::Params,
-    MatchNestedRoutes, ParamSegment, SsrMode, StaticSegment, WildcardSegment,
-};
-
-#[cfg(feature = "ssr")]
-pub(super) mod counter {
-    use std::{
-        collections::HashMap,
-        sync::{
-            atomic::{AtomicU32, Ordering},
-            LazyLock, Mutex,
-        },
-    };
-
-    #[derive(Default)]
-    pub struct Counter(AtomicU32);
-
-    impl Counter {
-        pub const fn new() -> Self {
-            Self(AtomicU32::new(0))
-        }
-
-        pub fn get(&self) -> u32 {
-            self.0.load(Ordering::SeqCst)
-        }
-
-        pub fn inc(&self) -> u32 {
-            self.0.fetch_add(1, Ordering::SeqCst)
-        }
-
-        pub fn reset(&self) {
-            self.0.store(0, Ordering::SeqCst);
-        }
-    }
-
-    #[derive(Default)]
-    pub struct Counters {
-        pub list_items: Counter,
-        pub get_item: Counter,
-        pub inspect_item_root: Counter,
-        pub inspect_item_field: Counter,
-    }
-
-    impl From<&mut Counters> for super::Counters {
-        fn from(counter: &mut Counters) -> Self {
-            Self {
-                get_item: counter.get_item.get(),
-                inspect_item_root: counter.inspect_item_root.get(),
-                inspect_item_field: counter.inspect_item_field.get(),
-                list_items: counter.list_items.get(),
-            }
-        }
-    }
-
-    impl Counters {
-        pub fn reset(&self) {
-            self.get_item.reset();
-            self.inspect_item_root.reset();
-            self.inspect_item_field.reset();
-            self.list_items.reset();
-        }
-    }
-
-    pub static COUNTERS: LazyLock<Mutex<HashMap<u64, Counters>>> =
-        LazyLock::new(|| Mutex::new(HashMap::new()));
-}
-
-#[derive(serde::Serialize, serde::Deserialize, Clone, Debug)]
-pub struct Item {
-    id: i64,
-    name: Option<String>,
-    field: Option<String>,
-}
-
-#[server]
-async fn list_items(ticket: u64) -> Result<Vec<i64>, ServerFnError> {
-    // emulate database query overhead
-    tokio::time::sleep(std::time::Duration::from_millis(25)).await;
-    (*counter::COUNTERS)
-        .lock()
-        .expect("somehow panicked elsewhere")
-        .entry(ticket)
-        .or_default()
-        .list_items
-        .inc();
-    Ok(vec![1, 2, 3, 4])
-}
-
-#[derive(serde::Serialize, serde::Deserialize, Clone, Debug)]
-pub struct GetItemResult(pub Item, pub Vec<String>);
-
-#[server]
-async fn get_item(
-    ticket: u64,
-    id: i64,
-) -> Result<GetItemResult, ServerFnError> {
-    // emulate database query overhead
-    tokio::time::sleep(std::time::Duration::from_millis(25)).await;
-    (*counter::COUNTERS)
-        .lock()
-        .expect("somehow panicked elsewhere")
-        .entry(ticket)
-        .or_default()
-        .get_item
-        .inc();
-    let name = None::<String>;
-    let field = None::<String>;
-    Ok(GetItemResult(
-        Item { id, name, field },
-        ["path1", "path2", "path3"]
-            .into_iter()
-            .map(str::to_string)
-            .collect::<Vec<_>>(),
-    ))
-}
-
-#[derive(serde::Serialize, serde::Deserialize, Clone, Debug)]
-pub struct InspectItemResult(pub Item, pub String, pub Vec<String>);
-
-#[server]
-async fn inspect_item(
-    ticket: u64,
-    id: i64,
-    path: String,
-) -> Result<InspectItemResult, ServerFnError> {
-    // emulate database query overhead
-    tokio::time::sleep(std::time::Duration::from_millis(25)).await;
-    let mut split = path.split('/');
-    let name = split.next().map(str::to_string);
-    let path = name
-        .clone()
-        .expect("name should have been defined at this point");
-    let field = split
-        .next()
-        .and_then(|s| (!s.is_empty()).then(|| s.to_string()));
-    if field.is_none() {
-        (*counter::COUNTERS)
-            .lock()
-            .expect("somehow panicked elsewhere")
-            .entry(ticket)
-            .or_default()
-            .inspect_item_root
-            .inc();
-    } else {
-        (*counter::COUNTERS)
-            .lock()
-            .expect("somehow panicked elsewhere")
-            .entry(ticket)
-            .or_default()
-            .inspect_item_field
-            .inc();
-    }
-    Ok(InspectItemResult(
-        Item { id, name, field },
-        path,
-        ["field1", "field2", "field3"]
-            .into_iter()
-            .map(str::to_string)
-            .collect::<Vec<_>>(),
-    ))
-}
-
-#[derive(serde::Serialize, serde::Deserialize, Clone, Debug)]
-pub struct Counters {
-    pub get_item: u32,
-    pub inspect_item_root: u32,
-    pub inspect_item_field: u32,
-    pub list_items: u32,
-}
-
-#[server]
-async fn get_counters(ticket: u64) -> Result<Counters, ServerFnError> {
-    Ok((*counter::COUNTERS)
-        .lock()
-        .expect("somehow panicked elsewhere")
-        .entry(ticket)
-        .or_default()
-        .into())
-}
-
-#[server(ResetCounters)]
-async fn reset_counters(ticket: u64) -> Result<(), ServerFnError> {
-    (*counter::COUNTERS)
-        .lock()
-        .expect("somehow panicked elsewhere")
-        .entry(ticket)
-        .or_default()
-        .reset();
-    // leptos::logging::log!("counters for ticket {ticket} have been reset");
-    Ok(())
-}
-
-#[derive(Clone, Default)]
-pub struct SuspenseCounters {
-    item_overview: u32,
-    item_inspect: u32,
-    item_listing: u32,
-}
-
-#[component]
-pub fn InstrumentedRoutes() -> impl MatchNestedRoutes + Clone {
-    // TODO should make this mode configurable via feature flag?
-    let ssr = SsrMode::Async;
-    view! {
-        <ParentRoute path=StaticSegment("instrumented") view=InstrumentedRoot ssr>
-            <Route path=StaticSegment("/") view=InstrumentedTop/>
-            <ParentRoute path=StaticSegment("item") view=ItemRoot>
-                <Route path=StaticSegment("/") view=ItemListing/>
-                <ParentRoute path=ParamSegment("id") view=ItemTop>
-                    <Route path=StaticSegment("/") view=ItemOverview/>
-                    <Route path=WildcardSegment("path") view=ItemInspect/>
-                </ParentRoute>
-            </ParentRoute>
-            <Route path=StaticSegment("counters") view=ShowCounters/>
-        </ParentRoute>
-    }
-    .into_inner()
-}
-
-#[derive(Copy, Clone)]
-pub struct Ticket(pub u64);
-
-#[derive(Copy, Clone)]
-pub struct CSRTicket(pub u64);
-
-#[cfg(feature = "ssr")]
-fn inst_ticket() -> u64 {
-    // SSR will always use 0 for the ticket
-    0
-}
-
-#[cfg(not(feature = "ssr"))]
-fn inst_ticket() -> u64 {
-    // CSR will use a random number for the ticket
-    (js_sys::Math::random() * ((u64::MAX - 1) as f64) + 1f64) as u64
-}
-
-#[component]
-fn InstrumentedRoot() -> impl IntoView {
-    let counters = RwSignal::new(SuspenseCounters::default());
-    provide_context(counters);
-    provide_field_nav_portlet_context();
-
-    // Generate a ID directly on this component.  Rather than relying on
-    // additional server functions, doing it this way emulates more
-    // standard workflows better and to avoid having to add another
-    // thing to instrument/interfere with the typical use case.
-    // Downside is that randomness has a chance to conflict.
-    //
-    // Furthermore, this approach **will** result in unintuitive
-    // behavior when it isn't accounted for - specifically, the reason
-    // for this design is that when SSR it will guarantee usage of `0`
-    // as the ticket, while CSR it will be of some other value as the
-    // version it uses will be random.  However, when trying to get back
-    // the counters associated with the ticket, rendering using SSR will
-    // always produce the SSR version and this quirk will need to be
-    // accounted for.
-    let ticket = inst_ticket();
-    // leptos::logging::log!(
-    //     "Ticket for this InstrumentedRoot instance: {ticket}"
-    // );
-    provide_context(Ticket(ticket));
-
-    let csr_ticket = RwSignal::<Option<CSRTicket>>::new(None);
-
-    let reset_counters = ServerAction::<ResetCounters>::new();
-
-    Effect::new(move |_| {
-        let ticket = expect_context::<Ticket>().0;
-        csr_ticket.set(Some(CSRTicket(ticket)));
-    });
-
-    view! {
-        <section id="instrumented">
-            <nav>
-                <a href="/">"Site Root"</a>
-                <A href="./" exact=true>"Instrumented Root"</A>
-                <A href="item/" strict_trailing_slash=true>"Item Listing"</A>
-                <A href="counters" strict_trailing_slash=true>"Counters"</A>
-            </nav>
-            <FieldNavPortlet/>
-            <Outlet/>
-            <Suspense>{
-                move || Suspend::new(async move {
-                    let clear_suspense_counters = move |_| {
-                        counters.update(|c| *c = SuspenseCounters::default());
-                    };
-                    csr_ticket.get().map(|ticket| {
-                        let ticket = ticket.0;
-                        view! {
-                            <ActionForm action=reset_counters>
-                                <input type="hidden" name="ticket" value=format!("{ticket}") />
-                                <input
-                                    id="reset-csr-counters"
-                                    type="submit"
-                                    value="Reset CSR Counters"
-                                    on:click=clear_suspense_counters/>
-                            </ActionForm>
-                        }
-                    })
-                })
-            }</Suspense>
-            <footer>
-                <nav>
-                    <A href="item/3/">"Target 3##"</A>
-                    <A href="item/4/">"Target 4##"</A>
-                    <A href="item/4/path1/">"Target 41#"</A>
-                    <A href="item/4/path2/">"Target 42#"</A>
-                    <A href="item/4/path2/field1">"Target 421"</A>
-                    <A href="item/1/path2/field3">"Target 123"</A>
-                </nav>
-            </footer>
-        </section>
-    }
-}
-
-#[component]
-fn InstrumentedTop() -> impl IntoView {
-    view! {
-        <h1>"Instrumented Tests"</h1>
-        <p>"These tests validates the number of invocations of server functions and suspenses per access."</p>
-        <ul>
-            // not using `A` because currently some bugs with artix
-            <li><a href="item/">"Item Listing"</a></li>
-            <li><a href="item/4/path1/">"Target 41#"</a></li>
-        </ul>
-    }
-}
-
-#[component]
-fn ItemRoot() -> impl IntoView {
-    let ticket = expect_context::<Ticket>().0;
-    provide_context(Resource::new_blocking(
-        move || (),
-        move |_| async move { list_items(ticket).await },
-    ));
-
-    view! {
-        <h2>"<ItemRoot/>"</h2>
-        <Outlet/>
-    }
-}
-
-#[component]
-fn ItemListing() -> impl IntoView {
-    let suspense_counters = expect_context::<RwSignal<SuspenseCounters>>();
-    let resource =
-        expect_context::<Resource<Result<Vec<i64>, ServerFnError>>>();
-    let item_listing = move || {
-        Suspend::new(async move {
-            let result = resource.await.map(|items| items
-            .into_iter()
-            .map(move |item|
-                // FIXME seems like relative link isn't working, it is currently
-                // adding an extra `/` in artix; manually construct `a` instead.
-                // <li><A href=format!("./{item}/")>"Item "{item}</A></li>
-                view! {
-                    <li><a href=format!("/instrumented/item/{item}/")>"Item "{item}</a></li>
-                }
-            )
-            .collect_view()
-        );
-            suspense_counters.update_untracked(|c| c.item_listing += 1);
-            result
-        })
-    };
-
-    view! {
-        <h3>"<ItemListing/>"</h3>
-        <ul>
-        <Suspense>
-            {item_listing}
-        </Suspense>
-        </ul>
-    }
-}
-
-#[derive(Params, PartialEq, Clone, Debug)]
-struct ItemTopParams {
-    id: Option<i64>,
-}
-
-#[component]
-fn ItemTop() -> impl IntoView {
-    let ticket = expect_context::<Ticket>().0;
-    let params = use_params::<ItemTopParams>();
-    // map result to an option as the focus isn't error rendering
-    provide_context(Resource::new_blocking(
-        move || params.get().map(|p| p.id),
-        move |id| async move {
-            match id {
-                Err(_) => None,
-                Ok(Some(id)) => get_item(ticket, id).await.ok(),
-                _ => None,
-            }
-        },
-    ));
-    view! {
-        <h4>"<ItemTop/>"</h4>
-        <Outlet/>
-    }
-}
-
-#[component]
-fn ItemOverview() -> impl IntoView {
-    let suspense_counters = expect_context::<RwSignal<SuspenseCounters>>();
-    let resource = expect_context::<Resource<Option<GetItemResult>>>();
-    let item_view = move || {
-        Suspend::new(async move {
-            let result = resource.await.map(|GetItemResult(item, names)| view! {
-            <p>{format!("Viewing {item:?}")}</p>
-            <ul>{
-                names.into_iter()
-                    .map(|name| {
-                        // FIXME seems like relative link isn't working, it is currently
-                        // adding an extra `/` in artix; manually construct `a` instead.
-                        // <li><A href=format!("./{name}/")>{format!("Inspect {name}")}</A></li>
-                        let id = item.id;
-                        view! {
-                            <li><a href=format!("/instrumented/item/{id}/{name}/")>
-                                "Inspect "{name.clone()}
-                            </a></li>
-                        }
-                    })
-                    .collect_view()
-            }</ul>
-        });
-            suspense_counters.update_untracked(|c| c.item_overview += 1);
-            result
-        })
-    };
-
-    view! {
-        <h5>"<ItemOverview/>"</h5>
-        <Suspense>
-            {item_view}
-        </Suspense>
-    }
-}
-
-#[derive(Params, PartialEq, Clone, Debug)]
-struct ItemInspectParams {
-    path: Option<String>,
-}
-
-#[component]
-fn ItemInspect() -> impl IntoView {
-    let ticket = expect_context::<Ticket>().0;
-    let suspense_counters = expect_context::<RwSignal<SuspenseCounters>>();
-    let params = use_params::<ItemInspectParams>();
-    let res_overview = expect_context::<Resource<Option<GetItemResult>>>();
-    let res_inspect = Resource::new_blocking(
-        move || params.get().map(|p| p.path),
-        move |p| async move {
-            // leptos::logging::log!("res_inspect: res_overview.await");
-            let overview = res_overview.await;
-            // leptos::logging::log!("res_inspect: resolved res_overview.await");
-            // let result =
-            match (overview, p) {
-                (Some(item), Ok(Some(path))) => {
-                    // leptos::logging::log!("res_inspect: inspect_item().await");
-                    inspect_item(ticket, item.0.id, path.clone()).await.ok()
-                }
-                _ => None,
-            }
-            // ;
-            // leptos::logging::log!("res_inspect: resolved inspect_item().await");
-            // result
-        },
-    );
-    on_cleanup(|| {
-        if let Some(c) = use_context::<WriteSignal<Option<FieldNavCtx>>>() {
-            c.set(None);
-        }
-    });
-    let inspect_view = move || {
-        // leptos::logging::log!("inspect_view closure invoked");
-        Suspend::new(async move {
-            // leptos::logging::log!("inspect_view Suspend::new() called");
-            let result = res_inspect.await.map(|InspectItemResult(item, name, fields)| {
-                // leptos::logging::log!("inspect_view res_inspect awaited");
-                let id = item.id;
-                expect_context::<WriteSignal<Option<FieldNavCtx>>>().set(Some(
-                    fields.iter()
-                        .map(|field| FieldNavItem {
-                            href: format!("/instrumented/item/{id}/{name}/{field}"),
-                            text: field.to_string(),
-                        })
-                        .collect::<Vec<_>>()
-                        .into()
-                ));
-                view! {
-                    <p>{format!("Inspecting {item:?}")}</p>
-                    <ul>{
-                        fields.iter()
-                            .map(|field| {
-                                // FIXME seems like relative link to root for a wildcard isn't
-                                // working as expected, so manually construct `a` instead.
-                                // let text = format!("Inspect {name}/{field}");
-                                // view! {
-                                //     <li><A href=format!("{field}")>{text}</A></li>
-                                // }
-                                view! {
-                                    <li><a href=format!("/instrumented/item/{id}/{name}/{field}")>{
-                                        format!("Inspect {name}/{field}")
-                                    }</a></li>
-                                }
-                            })
-                            .collect_view()
-                    }</ul>
-                }
-            });
-            suspense_counters.update_untracked(|c| c.item_inspect += 1);
-            // leptos::logging::log!(
-            //     "returning result, result.is_some() = {}, count = {}",
-            //     result.is_some(),
-            //     suspense_counters.get().item_inspect,
-            // );
-            result
-        })
-    };
-
-    view! {
-        <h5>"<ItemInspect/>"</h5>
-        <Suspense>
-            {inspect_view}
-        </Suspense>
-    }
-}
-
-#[component]
-fn ShowCounters() -> impl IntoView {
-    // There is _weirdness_ in this view.  The `Server Calls` counters
-    // will be acquired via the expected mode and be rendered as such.
-    //
-    // However, upon `Reset Counters`, the mode from which the reset
-    // was issued will result in the rendering be reflected as such, so
-    // if the intial state was SSR, resetting under CSR will result in
-    // the CSR counters be rendered after.  However for the intents and
-    // purpose for the testing only the CSR is cared for.
-    //
-    // At the end of the day, it is possible to have both these be
-    // separated out, but for the purpose of this test the focus is not
-    // on the SSR side of things (at least until further regression is
-    // discovered that affects SSR directly).
-    let ticket = expect_context::<Ticket>().0;
-    let suspense_counters = expect_context::<RwSignal<SuspenseCounters>>();
-    let reset_counters = ServerAction::<ResetCounters>::new();
-    let res_counter = Resource::new(
-        move || reset_counters.version().get(),
-        move |_| async move {
-            (
-                get_counters(ticket).await,
-                if ticket == 0 { "SSR" } else { "CSR" }.to_string(),
-                ticket,
-            )
-        },
-    );
-    let counter_view = move || {
-        Suspend::new(async move {
-            // ensure current mode and ticket are both updated
-            let (counters, mode, ticket) = res_counter.await;
-            counters.map(|counters| {
-                let clear_suspense_counters = move |_| {
-                    suspense_counters.update(|c| {
-                        // leptos::logging::log!("resetting suspense counters");
-                        *c = SuspenseCounters::default();
-                    });
-                };
-                view! {
-                    <h3 id="server-calls">"Server Calls ("{mode}")"</h3>
-                    <dl>
-                        <dt>"list_items"</dt>
-                        <dd id="list_items">{counters.list_items}</dd>
-                        <dt>"get_item"</dt>
-                        <dd id="get_item">{counters.get_item}</dd>
-                        <dt>"inspect_item_root"</dt>
-                        <dd id="inspect_item_root">{counters.inspect_item_root}</dd>
-                        <dt>"inspect_item_field"</dt>
-                        <dd id="inspect_item_field">{counters.inspect_item_field}</dd>
-                    </dl>
-                    <ActionForm action=reset_counters>
-                        <input type="hidden" name="ticket" value=format!("{ticket}") />
-                        <input
-                            id="reset-counters"
-                            type="submit"
-                            value="Reset Counters"
-                            on:click=clear_suspense_counters/>
-                    </ActionForm>
-                }
-            })
-        })
-    };
-
-    view! {
-        <h2>"Counters"</h2>
-
-        <h3 id="suspend-calls">"Suspend Calls"</h3>
-        {move || suspense_counters.with(|c| view! {
-            <dl>
-                <dt>"item_listing"</dt>
-                <dd id="item_listing">{c.item_listing}</dd>
-                <dt>"item_overview"</dt>
-                <dd id="item_overview">{c.item_overview}</dd>
-                <dt>"item_inspect"</dt>
-                <dd id="item_inspect">{c.item_inspect}</dd>
-            </dl>
-        })}
-
-        <Suspense>
-            {counter_view}
-        </Suspense>
-    }
-}
-
-#[derive(serde::Serialize, serde::Deserialize, Clone, Debug, PartialEq)]
-pub struct FieldNavItem {
-    pub href: String,
-    pub text: String,
-}
-
-#[derive(serde::Serialize, serde::Deserialize, Clone, Debug, PartialEq)]
-pub struct FieldNavCtx(pub Option<Vec<FieldNavItem>>);
-
-impl From<Vec<FieldNavItem>> for FieldNavCtx {
-    fn from(item: Vec<FieldNavItem>) -> Self {
-        Self(Some(item))
-    }
-}
-
-#[component]
-pub fn FieldNavPortlet() -> impl IntoView {
-    let ctx = expect_context::<ReadSignal<Option<FieldNavCtx>>>();
-    move || {
-        let ctx = ctx.get();
-        ctx.map(|ctx| {
-            view! {
-                <div id="FieldNavPortlet">
-                    <span>"FieldNavPortlet:"</span>
-                    <nav>{
-                        ctx.0.map(|ctx| {
-                            ctx.into_iter()
-                                .map(|FieldNavItem { href, text }| {
-                                    view! {
-                                        <A href=href>{text}</A>
-                                    }
-                                })
-                                .collect_view()
-                        })
-                    }</nav>
-                </div>
-            }
-        })
-    }
-}
-
-pub fn provide_field_nav_portlet_context() {
-    // wrapping the Ctx in an Option allows better ergonomics whenever it isn't needed
-    let (ctx, set_ctx) = signal(None::<FieldNavCtx>);
-    provide_context(ctx);
-    provide_context(set_ctx);
-}

examples/suspense_tests/src/lib.rs

@@ -1,5 +1,4 @@
 pub mod app;
-mod instrumented;
 
 #[cfg(feature = "hydrate")]
 #[wasm_bindgen::prelude::wasm_bindgen]

examples/suspense_tests/src/main.rs

@@ -41,7 +41,7 @@ async fn main() -> std::io::Result<()> {
                         </html>
                     }
             }})
-            .service(Files::new("/", site_root.as_ref()))
+            .service(Files::new("/", site_root))
     })
     .bind(addr)?
     .workers(1)

examples/tailwind_actix/end2end/tests/example.spec.ts

@@ -1,7 +1,7 @@
 import { test, expect } from "@playwright/test";
 
-test("homepage has title 'Leptos + Tailwindcss'", async ({ page }) => {
+test("should see the welcome message", async ({ page }) => {
   await page.goto("http://localhost:3000/");
 
-  await expect(page).toHaveTitle("Leptos + Tailwindcss");
+  await expect(page.locator("h2")).toHaveText("Welcome to Leptos with Tailwind");
 });

examples/tailwind_actix/src/app.rs

@@ -22,29 +22,24 @@ pub fn App() -> impl IntoView {
 
 #[component]
 fn Home() -> impl IntoView {
-    let (value, set_value) = signal(0);
+    let (count, set_count) = signal(0);
 
-    // thanks to https://tailwindcomponents.com/component/blue-buttons-example for the showcase layout
     view! {
-        <Title text="Leptos + Tailwindcss"/>
-        <main>
-            <div class="bg-gradient-to-tl from-blue-800 to-blue-500 text-white font-mono flex flex-col min-h-screen">
-                <div class="flex flex-row-reverse flex-wrap m-auto">
-                    <button on:click=move |_| set_value.update(|value| *value += 1) class="rounded px-3 py-2 m-1 border-b-4 border-l-2 shadow-lg bg-blue-700 border-blue-800 text-white">
-                        "+"
-                    </button>
-                    <button class="rounded px-3 py-2 m-1 border-b-4 border-l-2 shadow-lg bg-blue-800 border-blue-900 text-white">
-                        {value}
-                    </button>
-                    <button
-                        on:click=move |_| set_value.update(|value| *value -= 1)
-                        class="rounded px-3 py-2 m-1 border-b-4 border-l-2 shadow-lg bg-blue-700 border-blue-800 text-white"
-                        class:invisible=move || {value.get() < 1}
-                    >
-                        "-"
-                    </button>
-                </div>
-            </div>
+        <main class="my-0 mx-auto max-w-3xl text-center">
+            <h2 class="p-6 text-4xl">"Welcome to Leptos with Tailwind"</h2>
+            <p class="px-10 pb-10 text-left">"Tailwind will scan your Rust files for Tailwind class names and compile them into a CSS file."</p>
+            <button
+                class="bg-amber-600 hover:bg-sky-700 px-5 py-3 text-white rounded-lg"
+                on:click=move |_| set_count.update(|count| *count += 1)
+            >
+                "Something's here | "
+                {move || if count.get() == 0 {
+                    "Click me!".to_string()
+                } else {
+                    count.get().to_string()
+                }}
+                " | Some more text"
+            </button>
         </main>
     }
 }

examples/tailwind_actix/src/main.rs

@@ -40,7 +40,7 @@ async fn main() -> std::io::Result<()> {
                         </html>
                     }
             }})
-            .service(Files::new("/", site_root.as_ref()))
+            .service(Files::new("/", site_root))
             .wrap(middleware::Compress::default())
     })
     .bind(&addr)?

examples/tailwind_actix/tailwind.config.js

@@ -1,10 +1,7 @@
 /** @type {import('tailwindcss').Config} */
 module.exports = {
-  content: {
+  content: { 
     files: ["*.html", "./src/**/*.rs"],
-    transform: {
-      rs: (content) => content.replace(/(?:^|\s)class:/g, ' '),
-    },
   },
   theme: {
     extend: {},

examples/tailwind_axum/end2end/tests/example.spec.ts

@@ -1,7 +1,9 @@
 import { test, expect } from "@playwright/test";
 
-test("homepage has title 'Leptos + Tailwindcss'", async ({ page }) => {
+test("homepage has title and links to intro page", async ({ page }) => {
   await page.goto("http://localhost:3000/");
 
-  await expect(page).toHaveTitle("Leptos + Tailwindcss");
+  await expect(page).toHaveTitle("Welcome to Leptos");
+
+  await expect(page.locator("h1")).toHaveText("Welcome to Leptos!");
 });

examples/tailwind_axum/src/app.rs

@@ -54,11 +54,7 @@ fn Home() -> impl IntoView {
                     <button class="rounded px-3 py-2 m-1 border-b-4 border-l-2 shadow-lg bg-blue-800 border-blue-900 text-white">
                         {value}
                     </button>
-                    <button
-                        on:click=move |_| set_value.update(|value| *value -= 1)
-                        class="rounded px-3 py-2 m-1 border-b-4 border-l-2 shadow-lg bg-blue-700 border-blue-800 text-white"
-                        class:invisible=move || {value.get() < 1}
-                    >
+                    <button on:click=move |_| set_value.update(|value| *value -= 1) class="rounded px-3 py-2 m-1 border-b-4 border-l-2 shadow-lg bg-blue-700 border-blue-800 text-white">
                         "-"
                     </button>
                 </div>

examples/tailwind_axum/tailwind.config.js

@@ -1,13 +1,9 @@
 /** @type {import('tailwindcss').Config} */
 module.exports = {
-  content: {
-    files: ["*.html", "./src/**/*.rs"],
-    transform: {
-      rs: (content) => content.replace(/(?:^|\s)class:/g, ' '),
-    },
-  },
+  content: ["*.html", "./src/**/*.rs",],
   theme: {
     extend: {},
   },
   plugins: [],
 }
+

examples/tailwind_csr/end2end/tests/example.spec.ts

@@ -1,7 +1,9 @@
 import { test, expect } from "@playwright/test";
 
-test("homepage has title 'Leptos + Tailwindcss'", async ({ page }) => {
+test("homepage has title and links to intro page", async ({ page }) => {
   await page.goto("http://localhost:8080/");
 
-  await expect(page).toHaveTitle("Leptos + Tailwindcss");
+  await expect(page).toHaveTitle("Leptos • Counter with Tailwind");
+
+  await expect(page.locator("h2")).toHaveText("Welcome to Leptos with Tailwind");
 });

examples/tailwind_csr/src/app.rs

@@ -22,29 +22,24 @@ pub fn App() -> impl IntoView {
 
 #[component]
 fn Home() -> impl IntoView {
-    let (value, set_value) = signal(0);
+    let (count, set_count) = signal(0);
 
-    // thanks to https://tailwindcomponents.com/component/blue-buttons-example for the showcase layout
     view! {
-        <Title text="Leptos + Tailwindcss"/>
-        <main>
-            <div class="bg-gradient-to-tl from-blue-800 to-blue-500 text-white font-mono flex flex-col min-h-screen">
-                <div class="flex flex-row-reverse flex-wrap m-auto">
-                    <button on:click=move |_| set_value.update(|value| *value += 1) class="rounded px-3 py-2 m-1 border-b-4 border-l-2 shadow-lg bg-blue-700 border-blue-800 text-white">
-                        "+"
-                    </button>
-                    <button class="rounded px-3 py-2 m-1 border-b-4 border-l-2 shadow-lg bg-blue-800 border-blue-900 text-white">
-                        {value}
-                    </button>
-                    <button
-                        on:click=move |_| set_value.update(|value| *value -= 1)
-                        class="rounded px-3 py-2 m-1 border-b-4 border-l-2 shadow-lg bg-blue-700 border-blue-800 text-white"
-                        class:invisible=move || {value.get() < 1}
-                    >
-                        "-"
-                    </button>
-                </div>
-            </div>
-        </main>
+        <div class="my-0 mx-auto max-w-3xl text-center">
+            <h2 class="p-6 text-4xl">"Welcome to Leptos with Tailwind"</h2>
+            <p class="px-10 pb-10 text-left">"Tailwind will scan your Rust files for Tailwind class names and compile them into a CSS file."</p>
+            <button
+                class="bg-amber-600 hover:bg-sky-700 px-5 py-3 text-white rounded-lg"
+                on:click=move |_| set_count.update(|count| *count += 1)
+            >
+                "Something's here | "
+                {move || if count.get() == 0 {
+                    "Click me!".to_string()
+                } else {
+                    count.get().to_string()
+                }}
+                " | Some more text"
+            </button>
+        </div>
     }
 }

examples/tailwind_csr/tailwind.config.js

@@ -1,10 +1,7 @@
 /** @type {import('tailwindcss').Config} */
 module.exports = {
-  content: {
+  content: { 
     files: ["*.html", "./src/**/*.rs"],
-    transform: {
-      rs: (content) => content.replace(/(?:^|\s)class:/g, ' '),
-    },
   },
   theme: {
     extend: {},

examples/timer/src/lib.rs

@@ -38,7 +38,7 @@ pub fn TimerDemo() -> impl IntoView {
 pub fn use_interval<T, F>(interval_millis: T, f: F)
 where
     F: Fn() + Clone + 'static,
-    T: Into<Signal<u64>> + 'static,
+    T: Into<MaybeSignal<u64>> + 'static,
 {
     let interval_millis = interval_millis.into();
     Effect::new(move |prev_handle: Option<IntervalHandle>| {

examples/todo_app_sqlite/src/main.rs

@@ -59,7 +59,7 @@ async fn main() -> std::io::Result<()> {
                         </html>
                     }
             }})
-            .service(Files::new("/", site_root.as_ref()))
+            .service(Files::new("/", site_root))
         //.wrap(middleware::Compress::default())
     })
     .bind(&addr)?

examples/todomvc/src/lib.rs

@@ -319,7 +319,10 @@ pub fn Todo(todo: Todo) -> impl IntoView {
                     node_ref=todo_input
                     class="toggle"
                     type="checkbox"
-                    bind:checked=todo.completed
+                    prop:checked=move || todo.completed.get()
+                    on:input:target=move |ev| {
+                        todo.completed.set(ev.target().checked());
+                    }
                 />
 
                 <label on:dblclick=move |_| {

flake.lock

@@ -5,11 +5,29 @@
         "systems": "systems"
       },
       "locked": {
-        "lastModified": 1726560853,
-        "narHash": "sha256-X6rJYSESBVr3hBoH0WbKE5KvhPU5bloyZ2L4K60/fPQ=",
+        "lastModified": 1701680307,
+        "narHash": "sha256-kAuep2h5ajznlPMD9rnQyffWG8EM/C73lejGofXvdM8=",
         "owner": "numtide",
         "repo": "flake-utils",
-        "rev": "c1dfcf08411b08f6b8615f7d8971a2bfa81d5e8a",
+        "rev": "4022d587cbbfd70fe950c1e2083a02621806a725",
+        "type": "github"
+      },
+      "original": {
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "type": "github"
+      }
+    },
+    "flake-utils_2": {
+      "inputs": {
+        "systems": "systems_2"
+      },
+      "locked": {
+        "lastModified": 1681202837,
+        "narHash": "sha256-H+Rh19JDwRtpVPAWp64F+rlEtxUWBAQW28eAi3SRSzg=",
+        "owner": "numtide",
+        "repo": "flake-utils",
+        "rev": "cfacdce06f30d2b68473a46042957675eebb3401",
         "type": "github"
       },
       "original": {
@@ -20,11 +38,11 @@
     },
     "nixpkgs": {
       "locked": {
-        "lastModified": 1727634051,
-        "narHash": "sha256-S5kVU7U82LfpEukbn/ihcyNt2+EvG7Z5unsKW9H/yFA=",
+        "lastModified": 1703961334,
+        "narHash": "sha256-M1mV/Cq+pgjk0rt6VxoyyD+O8cOUiai8t9Q6Yyq4noY=",
         "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "06cf0e1da4208d3766d898b7fdab6513366d45b9",
+        "rev": "b0d36bd0a420ecee3bc916c91886caca87c894e9",
         "type": "github"
       },
       "original": {
@@ -36,11 +54,11 @@
     },
     "nixpkgs_2": {
       "locked": {
-        "lastModified": 1718428119,
-        "narHash": "sha256-WdWDpNaq6u1IPtxtYHHWpl5BmabtpmLnMAx0RdJ/vo8=",
+        "lastModified": 1681358109,
+        "narHash": "sha256-eKyxW4OohHQx9Urxi7TQlFBTDWII+F+x2hklDOQPB50=",
         "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "e6cea36f83499eb4e9cd184c8a8e823296b50ad5",
+        "rev": "96ba1c52e54e74c3197f4d43026b3f3d92e83ff9",
         "type": "github"
       },
       "original": {
@@ -59,14 +77,15 @@
     },
     "rust-overlay": {
       "inputs": {
+        "flake-utils": "flake-utils_2",
         "nixpkgs": "nixpkgs_2"
       },
       "locked": {
-        "lastModified": 1727749966,
-        "narHash": "sha256-DUS8ehzqB1DQzfZ4bRXVSollJhu+y7cvh1DJ9mbWebE=",
+        "lastModified": 1704075545,
+        "narHash": "sha256-L3zgOuVKhPjKsVLc3yTm2YJ6+BATyZBury7wnhyc8QU=",
         "owner": "oxalica",
         "repo": "rust-overlay",
-        "rev": "00decf1b4f9886d25030b9ee4aed7bfddccb5f66",
+        "rev": "a0df72e106322b67e9c6e591fe870380bd0da0d5",
         "type": "github"
       },
       "original": {
@@ -89,6 +108,21 @@
         "repo": "default",
         "type": "github"
       }
+    },
+    "systems_2": {
+      "locked": {
+        "lastModified": 1681028828,
+        "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=",
+        "owner": "nix-systems",
+        "repo": "default",
+        "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nix-systems",
+        "repo": "default",
+        "type": "github"
+      }
     }
   },
   "root": "root",

hydration_context/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "hydration_context"
-version = "0.2.0-rc1"
+version = "0.2.0-beta6"
 authors = ["Greg Johnston"]
 license = "MIT"
 readme = "../README.md"

hydration_context/src/lib.rs

@@ -44,18 +44,6 @@ pub type PinnedStream<T> = Pin<Box<dyn Stream<Item = T> + Send + Sync>>;
 /// from the server to the client.
 pub struct SerializedDataId(usize);
 
-impl SerializedDataId {
-    /// Create a new instance of [`SerializedDataId`].
-    pub fn new(id: usize) -> Self {
-        SerializedDataId(id)
-    }
-
-    /// Consume into the inner usize identifier.
-    pub fn into_inner(self) -> usize {
-        self.0
-    }
-}
-
 impl From<SerializedDataId> for ErrorId {
     fn from(value: SerializedDataId) -> Self {
         value.0.into()

hydration_context/src/ssr.rs

@@ -58,27 +58,6 @@ impl SsrSharedContext {
             ..Default::default()
         }
     }
-
-    /// Consume the data buffers, awaiting all async resources,
-    /// returning both sync and async buffers.
-    /// Useful to implement custom hydration contexts.
-    ///
-    /// WARNING: this will clear the internal buffers, it should only be called once.
-    /// A second call would return an empty `vec![]`.
-    pub async fn consume_buffers(&self) -> Vec<(SerializedDataId, String)> {
-        let sync_data = mem::take(&mut *self.sync_buf.write().or_poisoned());
-        let async_data = mem::take(&mut *self.async_buf.write().or_poisoned());
-
-        let mut all_data = Vec::new();
-        for resolved in sync_data {
-            all_data.push((resolved.0, resolved.1));
-        }
-        for (id, fut) in async_data {
-            let data = fut.await;
-            all_data.push((id, data));
-        }
-        all_data
-    }
 }
 
 impl Debug for SsrSharedContext {

integrations/actix/Cargo.toml

@@ -33,7 +33,7 @@ once_cell = "1"
 rustdoc-args = ["--generate-link-to-definition"]
 
 [features]
-dont-use-islands-router = []
+islands-router = []
 tracing = ["dep:tracing"]
 
 [package.metadata.cargo-all-features]

integrations/actix/src/lib.rs

@@ -24,7 +24,7 @@ use leptos::{
     config::LeptosOptions,
     context::{provide_context, use_context},
     prelude::expect_context,
-    reactive::{computed::ScopedFuture, owner::Owner},
+    reactive_graph::{computed::ScopedFuture, owner::Owner},
     IntoView,
 };
 use leptos_integration_utils::{
@@ -35,7 +35,7 @@ use leptos_router::{
     components::provide_server_redirect,
     location::RequestUrl,
     static_routes::{RegenerationFn, ResolvedStaticPath},
-    ExpandOptionals, Method, PathSegment, RouteList, RouteListing, SsrMode,
+    Method, PathSegment, RouteList, RouteListing, SsrMode,
 };
 use once_cell::sync::Lazy;
 use parking_lot::RwLock;
@@ -44,7 +44,6 @@ use server_fn::{
     redirect::REDIRECT_HEADER, request::actix::ActixRequest, ServerFnError,
 };
 use std::{
-    collections::HashSet,
     fmt::{Debug, Display},
     future::Future,
     ops::{Deref, DerefMut},
@@ -750,7 +749,7 @@ where
     IV: IntoView + 'static,
 {
     Box::pin(async move {
-        let app = if cfg!(feature = "dont-use-islands-router") {
+        let app = if cfg!(feature = "islands-router") {
             app.to_html_stream_in_order_branching()
         } else {
             app.to_html_stream_in_order()
@@ -901,7 +900,7 @@ trait ActixPath {
     fn to_actix_path(&self) -> String;
 }
 
-impl ActixPath for Vec<PathSegment> {
+impl ActixPath for &[PathSegment] {
     fn to_actix_path(&self) -> String {
         let mut path = String::new();
         for segment in self.iter() {
@@ -923,14 +922,6 @@ impl ActixPath for Vec<PathSegment> {
                     path.push_str(":.*}");
                 }
                 PathSegment::Unit => {}
-                PathSegment::OptionalParam(_) => {
-                    #[cfg(feature = "tracing")]
-                    tracing::error!(
-                        "to_axum_path should only be called on expanded \
-                         paths, which do not have OptionalParam any longer"
-                    );
-                    Default::default()
-                }
             }
         }
         path
@@ -944,38 +935,25 @@ pub struct ActixRouteListing {
     mode: SsrMode,
     methods: Vec<leptos_router::Method>,
     regenerate: Vec<RegenerationFn>,
-    exclude: bool,
 }
 
-trait IntoRouteListing: Sized {
-    fn into_route_listing(self) -> Vec<ActixRouteListing>;
-}
-
-impl IntoRouteListing for RouteListing {
-    fn into_route_listing(self) -> Vec<ActixRouteListing> {
-        self.path()
-            .to_vec()
-            .expand_optionals()
-            .into_iter()
-            .map(|path| {
-                let path = path.to_actix_path();
-                let path = if path.is_empty() {
-                    "/".to_string()
-                } else {
-                    path
-                };
-                let mode = self.mode();
-                let methods = self.methods().collect();
-                let regenerate = self.regenerate().into();
-                ActixRouteListing {
-                    path,
-                    mode: mode.clone(),
-                    methods,
-                    regenerate,
-                    exclude: false,
-                }
-            })
-            .collect()
+impl From<RouteListing> for ActixRouteListing {
+    fn from(value: RouteListing) -> Self {
+        let path = value.path().to_actix_path();
+        let path = if path.is_empty() {
+            "/".to_string()
+        } else {
+            path
+        };
+        let mode = value.mode();
+        let methods = value.methods().collect();
+        let regenerate = value.regenerate().into();
+        Self {
+            path,
+            mode: mode.clone(),
+            methods,
+            regenerate,
+        }
     }
 }
 
@@ -992,7 +970,6 @@ impl ActixRouteListing {
             mode,
             methods: methods.into_iter().collect(),
             regenerate: regenerate.into(),
-            exclude: false,
         }
     }
 
@@ -1050,37 +1027,27 @@ where
     let mut routes = routes
         .into_inner()
         .into_iter()
-        .flat_map(IntoRouteListing::into_route_listing)
+        .map(ActixRouteListing::from)
         .collect::<Vec<_>>();
 
-    let routes = if routes.is_empty() {
-        vec![ActixRouteListing::new(
-            "/".to_string(),
-            Default::default(),
-            [leptos_router::Method::Get],
-            vec![],
-        )]
-    } else {
-        // Routes to exclude from auto generation
-        if let Some(excluded_routes) = &excluded_routes {
-            routes.retain(|p| !excluded_routes.iter().any(|e| e == p.path()))
-        }
-        routes
-    };
-
-    let excluded =
-        excluded_routes
-            .into_iter()
-            .flatten()
-            .map(|path| ActixRouteListing {
-                path,
-                mode: Default::default(),
-                methods: Vec::new(),
-                regenerate: Vec::new(),
-                exclude: true,
-            });
-
-    (routes.into_iter().chain(excluded).collect(), generator)
+    (
+        if routes.is_empty() {
+            vec![ActixRouteListing::new(
+                "/".to_string(),
+                Default::default(),
+                [leptos_router::Method::Get],
+                vec![],
+            )]
+        } else {
+            // Routes to exclude from auto generation
+            if let Some(excluded_routes) = excluded_routes {
+                routes
+                    .retain(|p| !excluded_routes.iter().any(|e| e == p.path()))
+            }
+            routes
+        },
+        generator,
+    )
 }
 
 /// Allows generating any prerendered routes.
@@ -1386,24 +1353,15 @@ where
     {
         let mut router = self;
 
-        let excluded = paths
-            .iter()
-            .filter(|&p| p.exclude)
-            .map(|p| p.path.as_str())
-            .collect::<HashSet<_>>();
-
         // register server functions first to allow for wildcard route in Leptos's Router
         for (path, _) in server_fn::actix::server_fn_paths() {
-            if !excluded.contains(path) {
-                let additional_context = additional_context.clone();
-                let handler =
-                    handle_server_fns_with_context(additional_context);
-                router = router.route(path, handler);
-            }
+            let additional_context = additional_context.clone();
+            let handler = handle_server_fns_with_context(additional_context);
+            router = router.route(path, handler);
         }
 
         // register routes defined in Leptos's Router
-        for listing in paths.iter().filter(|p| !p.exclude) {
+        for listing in paths.iter() {
             let path = listing.path();
             let mode = listing.mode();
 
@@ -1423,41 +1381,39 @@ where
                         ),
                     )
                 } else {
-                    router
-                        .route(path, web::head().to(HttpResponse::Ok))
-                        .route(
-                            path,
-                            match mode {
-                                SsrMode::OutOfOrder => {
-                                    render_app_to_stream_with_context(
-                                        additional_context_and_method.clone(),
-                                        app_fn.clone(),
-                                        method,
-                                    )
-                                }
-                                SsrMode::PartiallyBlocked => {
-                                    render_app_to_stream_with_context_and_replace_blocks(
-                                        additional_context_and_method.clone(),
-                                        app_fn.clone(),
-                                        method,
-                                        true,
-                                    )
-                                }
-                                SsrMode::InOrder => {
-                                    render_app_to_stream_in_order_with_context(
-                                        additional_context_and_method.clone(),
-                                        app_fn.clone(),
-                                        method,
-                                    )
-                                }
-                                SsrMode::Async => render_app_async_with_context(
-                                    additional_context_and_method.clone(),
-                                    app_fn.clone(),
-                                    method,
-                                ),
-                                _ => unreachable!()
-                            },
-                        )
+                    router.route(
+                    path,
+                    match mode {
+                        SsrMode::OutOfOrder => {
+                            render_app_to_stream_with_context(
+                                additional_context_and_method.clone(),
+                                app_fn.clone(),
+                                method,
+                            )
+                        }
+                        SsrMode::PartiallyBlocked => {
+                            render_app_to_stream_with_context_and_replace_blocks(
+                                additional_context_and_method.clone(),
+                                app_fn.clone(),
+                                method,
+                                true,
+                            )
+                        }
+                        SsrMode::InOrder => {
+                            render_app_to_stream_in_order_with_context(
+                                additional_context_and_method.clone(),
+                                app_fn.clone(),
+                                method,
+                            )
+                        }
+                        SsrMode::Async => render_app_async_with_context(
+                            additional_context_and_method.clone(),
+                            app_fn.clone(),
+                            method,
+                        ),
+                        _ => unreachable!()
+                    },
+                )
                 };
             }
         }
@@ -1499,24 +1455,15 @@ impl LeptosRoutes for &mut ServiceConfig {
     {
         let mut router = self;
 
-        let excluded = paths
-            .iter()
-            .filter(|&p| p.exclude)
-            .map(|p| p.path.as_str())
-            .collect::<HashSet<_>>();
-
         // register server functions first to allow for wildcard route in Leptos's Router
         for (path, _) in server_fn::actix::server_fn_paths() {
-            if !excluded.contains(path) {
-                let additional_context = additional_context.clone();
-                let handler =
-                    handle_server_fns_with_context(additional_context);
-                router = router.route(path, handler);
-            }
+            let additional_context = additional_context.clone();
+            let handler = handle_server_fns_with_context(additional_context);
+            router = router.route(path, handler);
         }
 
         // register routes defined in Leptos's Router
-        for listing in paths.iter().filter(|p| !p.exclude) {
+        for listing in paths.iter() {
             let path = listing.path();
             let mode = listing.mode();
 
@@ -1605,10 +1552,7 @@ where
         ServerFnError::new("HttpRequest should have been provided via context")
     })?;
 
-    SendWrapper::new(async move {
-        T::extract(&req)
-            .await
-            .map_err(|e| ServerFnError::ServerError(e.to_string()))
-    })
-    .await
+    T::extract(&req)
+        .await
+        .map_err(|e| ServerFnError::ServerError(e.to_string()))
 }

integrations/axum/Cargo.toml

@@ -16,6 +16,8 @@ axum = { version = "0.7.5", default-features = false, features = [
 ] }
 dashmap = "6"
 futures = "0.3.30"
+http = "1.1"
+http-body-util = "0.1.2"
 leptos = { workspace = true, features = ["nonce", "ssr"] }
 server_fn = { workspace = true, features = ["axum-no-default"] }
 leptos_macro = { workspace = true, features = ["axum"] }
@@ -24,8 +26,9 @@ leptos_router = { workspace = true, features = ["ssr"] }
 leptos_integration_utils = { workspace = true }
 once_cell = "1"
 parking_lot = "0.12.3"
+serde_json = "1.0"
 tokio = { version = "1.39", default-features = false }
-tower = { version = "0.4.13", features = ["util"] }
+tower = "0.4.13"
 tower-http = "0.5.2"
 tracing = { version = "0.1.40", optional = true }
 
@@ -36,7 +39,7 @@ tokio = { version = "1.39", features = ["net", "rt-multi-thread"] }
 [features]
 wasm = []
 default = ["tokio/fs", "tokio/sync", "tower-http/fs", "tower/util"]
-dont-use-islands-router = []
+islands-router = []
 tracing = ["dep:tracing"]
 
 [package.metadata.docs.rs]

integrations/axum/src/lib.rs

@@ -53,7 +53,7 @@ use leptos::{
     config::LeptosOptions,
     context::{provide_context, use_context},
     prelude::*,
-    reactive::{computed::ScopedFuture, owner::Owner},
+    reactive_graph::{computed::ScopedFuture, owner::Owner},
     IntoView,
 };
 use leptos_integration_utils::{
@@ -66,7 +66,7 @@ use leptos_router::{
     components::provide_server_redirect,
     location::RequestUrl,
     static_routes::{RegenerationFn, StaticParamsMap},
-    ExpandOptionals, PathSegment, RouteList, RouteListing, SsrMode,
+    PathSegment, RouteList, RouteListing, SsrMode,
 };
 #[cfg(feature = "default")]
 use once_cell::sync::Lazy;
@@ -74,9 +74,9 @@ use parking_lot::RwLock;
 use server_fn::{redirect::REDIRECT_HEADER, ServerFnError};
 #[cfg(feature = "default")]
 use std::path::Path;
-use std::{collections::HashSet, fmt::Debug, io, pin::Pin, sync::Arc};
+use std::{fmt::Debug, io, pin::Pin, sync::Arc};
 #[cfg(feature = "default")]
-use tower::util::ServiceExt;
+use tower::ServiceExt;
 #[cfg(feature = "default")]
 use tower_http::services::ServeDir;
 // use tracing::Instrument; // TODO check tracing span -- was this used in 0.6 for a missing link?
@@ -606,9 +606,9 @@ where
 /// use axum::{
 ///     body::Body,
 ///     extract::Path,
-///     http::Request,
 ///     response::{IntoResponse, Response},
 /// };
+/// use http::Request;
 /// use leptos::{config::LeptosOptions, context::provide_context, prelude::*};
 ///
 /// async fn custom_handler(
@@ -784,7 +784,7 @@ where
     _ = replace_blocks; // TODO
     handle_response(additional_context, app_fn, |app, chunks| {
         Box::pin(async move {
-            let app = if cfg!(feature = "dont-use-islands-router") {
+            let app = if cfg!(feature = "islands-router") {
                 app.to_html_stream_out_of_order_branching()
             } else {
                 app.to_html_stream_out_of_order()
@@ -806,9 +806,9 @@ where
 /// use axum::{
 ///     body::Body,
 ///     extract::Path,
-///     http::Request,
 ///     response::{IntoResponse, Response},
 /// };
+/// use http::Request;
 /// use leptos::context::provide_context;
 ///
 /// async fn custom_handler(
@@ -849,7 +849,7 @@ where
     IV: IntoView + 'static,
 {
     handle_response(additional_context, app_fn, |app, chunks| {
-        let app = if cfg!(feature = "dont-use-islands-router") {
+        let app = if cfg!(feature = "islands-router") {
             app.to_html_stream_in_order_branching()
         } else {
             app.to_html_stream_in_order()
@@ -1025,9 +1025,9 @@ where
 /// use axum::{
 ///     body::Body,
 ///     extract::Path,
-///     http::Request,
 ///     response::{IntoResponse, Response},
 /// };
+/// use http::Request;
 /// use leptos::context::provide_context;
 ///
 /// async fn custom_handler(
@@ -1069,7 +1069,7 @@ where
 {
     handle_response(additional_context, app_fn, |app, chunks| {
         Box::pin(async move {
-            let app = if cfg!(feature = "dont-use-islands-router") {
+            let app = if cfg!(feature = "islands-router") {
                 app.to_html_stream_in_order_branching()
             } else {
                 app.to_html_stream_in_order()
@@ -1093,9 +1093,9 @@ where
 /// use axum::{
 ///     body::Body,
 ///     extract::Path,
-///     http::Request,
 ///     response::{IntoResponse, Response},
 /// };
+/// use http::Request;
 /// use leptos::context::provide_context;
 ///
 /// async fn custom_handler(
@@ -1146,7 +1146,7 @@ where
     IV: IntoView + 'static,
 {
     Box::pin(async move {
-        let app = if cfg!(feature = "dont-use-islands-router") {
+        let app = if cfg!(feature = "islands-router") {
             app.to_html_stream_in_order_branching()
         } else {
             app.to_html_stream_in_order()
@@ -1263,38 +1263,25 @@ pub struct AxumRouteListing {
     methods: Vec<leptos_router::Method>,
     #[allow(unused)]
     regenerate: Vec<RegenerationFn>,
-    exclude: bool,
 }
 
-trait IntoRouteListing: Sized {
-    fn into_route_listing(self) -> Vec<AxumRouteListing>;
-}
-
-impl IntoRouteListing for RouteListing {
-    fn into_route_listing(self) -> Vec<AxumRouteListing> {
-        self.path()
-            .to_vec()
-            .expand_optionals()
-            .into_iter()
-            .map(|path| {
-                let path = path.to_axum_path();
-                let path = if path.is_empty() {
-                    "/".to_string()
-                } else {
-                    path
-                };
-                let mode = self.mode();
-                let methods = self.methods().collect();
-                let regenerate = self.regenerate().into();
-                AxumRouteListing {
-                    path,
-                    mode: mode.clone(),
-                    methods,
-                    regenerate,
-                    exclude: false,
-                }
-            })
-            .collect()
+impl From<RouteListing> for AxumRouteListing {
+    fn from(value: RouteListing) -> Self {
+        let path = value.path().to_axum_path();
+        let path = if path.is_empty() {
+            "/".to_string()
+        } else {
+            path
+        };
+        let mode = value.mode();
+        let methods = value.methods().collect();
+        let regenerate = value.regenerate().into();
+        Self {
+            path,
+            mode: mode.clone(),
+            methods,
+            regenerate,
+        }
     }
 }
 
@@ -1311,7 +1298,6 @@ impl AxumRouteListing {
             mode,
             methods: methods.into_iter().collect(),
             regenerate: regenerate.into(),
-            exclude: false,
         }
     }
 
@@ -1356,7 +1342,8 @@ where
         .with(|| {
             // stub out a path for now
             provide_context(RequestUrl::new(""));
-            let (mock_parts, _) = Request::new(Body::from("")).into_parts();
+            let (mock_parts, _) =
+                http::Request::new(Body::from("")).into_parts();
             let (mock_meta, _) = ServerMetaContext::new();
             provide_contexts("", &mock_meta, mock_parts, Default::default());
             additional_context();
@@ -1374,36 +1361,27 @@ where
     let mut routes = routes
         .into_inner()
         .into_iter()
-        .flat_map(IntoRouteListing::into_route_listing)
+        .map(AxumRouteListing::from)
         .collect::<Vec<_>>();
 
-    let routes = if routes.is_empty() {
-        vec![AxumRouteListing::new(
-            "/".to_string(),
-            Default::default(),
-            [leptos_router::Method::Get],
-            vec![],
-        )]
-    } else {
-        // Routes to exclude from auto generation
-        if let Some(excluded_routes) = &excluded_routes {
-            routes.retain(|p| !excluded_routes.iter().any(|e| e == p.path()))
-        }
-        routes
-    };
-    let excluded =
-        excluded_routes
-            .into_iter()
-            .flatten()
-            .map(|path| AxumRouteListing {
-                path,
-                mode: Default::default(),
-                methods: Vec::new(),
-                regenerate: Vec::new(),
-                exclude: true,
-            });
-
-    (routes.into_iter().chain(excluded).collect(), generator)
+    (
+        if routes.is_empty() {
+            vec![AxumRouteListing::new(
+                "/".to_string(),
+                Default::default(),
+                [leptos_router::Method::Get],
+                vec![],
+            )]
+        } else {
+            // Routes to exclude from auto generation
+            if let Some(excluded_routes) = excluded_routes {
+                routes
+                    .retain(|p| !excluded_routes.iter().any(|e| e == p.path()))
+            }
+            routes
+        },
+        generator,
+    )
 }
 
 /// Allows generating any prerendered routes.
@@ -1424,8 +1402,8 @@ impl StaticRouteGenerator {
             let add_context = additional_context.clone();
             move || {
                 let full_path = format!("http://leptos.dev{path}");
-                let mock_req = Request::builder()
-                    .method(Method::GET)
+                let mock_req = http::Request::builder()
+                    .method(http::Method::GET)
                     .header("Accept", "text/html")
                     .body(Body::empty())
                     .unwrap();
@@ -1517,12 +1495,10 @@ impl StaticRouteGenerator {
             _ = routes;
             _ = app_fn;
             _ = additional_context;
-            Self(Box::new(|_| {
-                panic!(
-                    "Static routes are not currently supported on WASM32 \
-                     server targets."
-                );
-            }))
+            panic!(
+                "Static routes are not currently supported on WASM32 server \
+                 targets."
+            );
         }
     }
 
@@ -1716,7 +1692,7 @@ trait AxumPath {
     fn to_axum_path(&self) -> String;
 }
 
-impl AxumPath for Vec<PathSegment> {
+impl AxumPath for &[PathSegment] {
     fn to_axum_path(&self) -> String {
         let mut path = String::new();
         for segment in self.iter() {
@@ -1736,14 +1712,6 @@ impl AxumPath for Vec<PathSegment> {
                     path.push_str(s);
                 }
                 PathSegment::Unit => {}
-                PathSegment::OptionalParam(_) => {
-                    #[cfg(feature = "tracing")]
-                    tracing::error!(
-                        "to_axum_path should only be called on expanded \
-                         paths, which do not have OptionalParam any longer"
-                    );
-                    Default::default()
-                }
             }
         }
         path
@@ -1799,41 +1767,32 @@ where
 
         let mut router = self;
 
-        let excluded = paths
-            .iter()
-            .filter(|&p| p.exclude)
-            .map(|p| p.path.as_str())
-            .collect::<HashSet<_>>();
-
         // register server functions
         for (path, method) in server_fn::axum::server_fn_paths() {
             let cx_with_state = cx_with_state.clone();
             let handler = move |req: Request<Body>| async move {
                 handle_server_fns_with_context(cx_with_state, req).await
             };
-
-            if !excluded.contains(path) {
-                router = router.route(
-                    path,
-                    match method {
-                        Method::GET => get(handler),
-                        Method::POST => post(handler),
-                        Method::PUT => put(handler),
-                        Method::DELETE => delete(handler),
-                        Method::PATCH => patch(handler),
-                        _ => {
-                            panic!(
-                                "Unsupported server function HTTP method: \
-                                 {method:?}"
-                            );
-                        }
-                    },
-                );
-            }
+            router = router.route(
+                path,
+                match method {
+                    Method::GET => get(handler),
+                    Method::POST => post(handler),
+                    Method::PUT => put(handler),
+                    Method::DELETE => delete(handler),
+                    Method::PATCH => patch(handler),
+                    _ => {
+                        panic!(
+                            "Unsupported server function HTTP method: \
+                             {method:?}"
+                        );
+                    }
+                },
+            );
         }
 
         // register router paths
-        for listing in paths.iter().filter(|p| !p.exclude) {
+        for listing in paths.iter() {
             let path = listing.path();
 
             for method in listing.methods() {
@@ -1942,7 +1901,7 @@ where
         T: 'static,
     {
         let mut router = self;
-        for listing in paths.iter().filter(|p| !p.exclude) {
+        for listing in paths.iter() {
             for method in listing.methods() {
                 router = router.route(
                     listing.path(),
@@ -1974,7 +1933,7 @@ where
 ///
 /// #[server]
 /// pub async fn request_method() -> Result<String, ServerFnError> {
-///     use axum::http::Method;
+///     use http::Method;
 ///     use leptos_axum::extract;
 ///
 ///     // you can extract anything that a regular Axum extractor can extract
@@ -2033,7 +1992,7 @@ where
     move |uri: Uri, State(options): State<S>, req: Request<Body>| {
         Box::pin(async move {
             let options = LeptosOptions::from_ref(&options);
-            let res = get_static_file(uri, &options.site_root, req.headers());
+            let res = get_static_file(uri, &options.site_root);
             let res = res.await.unwrap();
 
             if res.status() == StatusCode::OK {
@@ -2067,26 +2026,14 @@ where
 async fn get_static_file(
     uri: Uri,
     root: &str,
-    headers: &HeaderMap<HeaderValue>,
 ) -> Result<Response<Body>, (StatusCode, String)> {
-    use axum::http::header::ACCEPT_ENCODING;
-
-    let req = Request::builder().uri(uri);
-
-    let req = match headers.get(ACCEPT_ENCODING) {
-        Some(value) => req.header(ACCEPT_ENCODING, value),
-        None => req,
-    };
-
-    let req = req.body(Body::empty()).unwrap();
+    let req = Request::builder()
+        .uri(uri.clone())
+        .body(Body::empty())
+        .unwrap();
     // `ServeDir` implements `tower::Service` so we can call it with `tower::ServiceExt::oneshot`
     // This path is relative to the cargo root
-    match ServeDir::new(root)
-        .precompressed_gzip()
-        .precompressed_br()
-        .oneshot(req)
-        .await
-    {
+    match ServeDir::new(root).oneshot(req).await {
         Ok(res) => Ok(res.into_response()),
         Err(err) => Err((
             StatusCode::INTERNAL_SERVER_ERROR,

integrations/utils/src/lib.rs

@@ -2,7 +2,7 @@ use futures::{stream::once, Stream, StreamExt};
 use hydration_context::{SharedContext, SsrSharedContext};
 use leptos::{
     nonce::use_nonce,
-    reactive::owner::{Owner, Sandboxed},
+    reactive_graph::owner::{Owner, Sandboxed},
     IntoView,
 };
 use leptos_config::LeptosOptions;

leptos/Cargo.toml

@@ -28,7 +28,7 @@ paste = "1.0"
 rand = { version = "0.8.5", optional = true }
 reactive_graph = { workspace = true, features = ["serde"] }
 rustc-hash = "2.0"
-tachys = { workspace = true, features = ["reactive_graph", "reactive_stores", "oco"] }
+tachys = { workspace = true, features = ["reactive_graph", "oco"] }
 thiserror = "1.0"
 tracing = { version = "0.1.40", optional = true }
 typed-builder = "0.19.1"
@@ -45,7 +45,7 @@ web-sys = { version = "0.3.70", features = [
   "ShadowRootInit",
   "ShadowRootMode",
 ] }
-wasm-bindgen = "0.2.95"
+wasm-bindgen = "0.2.93"
 serde_qs = "0.13.0"
 slotmap = "1.0"
 futures = "0.3.30"

leptos/src/additional_attributes.rs

@@ -0,0 +1,59 @@
+#![allow(deprecated)]
+
+use crate::TextProp;
+use std::rc::Rc;
+
+/// A collection of additional HTML attributes to be applied to an element,
+/// each of which may or may not be reactive.
+#[derive(Clone)]
+#[repr(transparent)]
+#[deprecated = "Most uses of `AdditionalAttributes` can be replaced with `#[prop(attrs)]` \
+and the `attr:` syntax. If you have a use case that still requires `AdditionalAttributes`, please \
+open a GitHub issue here and share it: https://github.com/leptos-rs/leptos"]
+pub struct AdditionalAttributes(pub(crate) Rc<[(String, TextProp)]>);
+
+impl<I, T, U> From<I> for AdditionalAttributes
+where
+    I: IntoIterator<Item = (T, U)>,
+    T: Into<String>,
+    U: Into<TextProp>,
+{
+    fn from(value: I) -> Self {
+        Self(
+            value
+                .into_iter()
+                .map(|(k, v)| (k.into(), v.into()))
+                .collect(),
+        )
+    }
+}
+
+impl Default for AdditionalAttributes {
+    fn default() -> Self {
+        Self([].into_iter().collect())
+    }
+}
+
+/// Iterator over additional HTML attributes.
+#[repr(transparent)]
+pub struct AdditionalAttributesIter<'a>(
+    std::slice::Iter<'a, (String, TextProp)>,
+);
+
+impl<'a> Iterator for AdditionalAttributesIter<'a> {
+    type Item = &'a (String, TextProp);
+
+    #[inline(always)]
+    fn next(&mut self) -> Option<Self::Item> {
+        self.0.next()
+    }
+}
+
+impl<'a> IntoIterator for &'a AdditionalAttributes {
+    type Item = &'a (String, TextProp);
+    type IntoIter = AdditionalAttributesIter<'a>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        AdditionalAttributesIter(self.0.iter())
+    }
+}

leptos/src/animated_show.rs

@@ -1,15 +1,12 @@
-use crate::{children::ChildrenFn, component, control_flow::Show, IntoView};
+use crate::{ChildrenFn, Show};
 use core::time::Duration;
-use leptos_dom::helpers::TimeoutHandle;
+use leptos::component;
+use leptos_dom::{helpers::TimeoutHandle, IntoView};
 use leptos_macro::view;
-use reactive_graph::{
-    effect::RenderEffect,
-    owner::{on_cleanup, StoredValue},
-    signal::RwSignal,
-    traits::{Get, GetUntracked, GetValue, Set, SetValue},
-    wrappers::read::Signal,
+use leptos_reactive::{
+    create_render_effect, on_cleanup, signal_prelude::*, store_value,
+    StoredValue,
 };
-use tachys::prelude::*;
 
 /// A component that will show its children when the `when` condition is `true`.
 /// Additionally, you need to specify a `hide_delay`. If the `when` condition changes to `false`,
@@ -19,10 +16,10 @@ use tachys::prelude::*;
 ///
 /// ```rust
 /// # use core::time::Duration;
-/// # use leptos::prelude::*;
+/// # use leptos::*;
 /// # #[component]
 /// # pub fn App() -> impl IntoView {
-/// let show = RwSignal::new(false);
+/// let show = create_rw_signal(false);
 ///
 /// view! {
 ///     <div
@@ -53,7 +50,7 @@ pub fn AnimatedShow(
     children: ChildrenFn,
     /// If the component should show or not
     #[prop(into)]
-    when: Signal<bool>,
+    when: MaybeSignal<bool>,
     /// Optional CSS class to apply if `when == true`
     #[prop(optional)]
     show_class: &'static str,
@@ -63,15 +60,15 @@ pub fn AnimatedShow(
     /// The timeout after which the component will be unmounted if `when == false`
     hide_delay: Duration,
 ) -> impl IntoView {
-    let handle: StoredValue<Option<TimeoutHandle>> = StoredValue::new(None);
-    let cls = RwSignal::new(if when.get_untracked() {
+    let handle: StoredValue<Option<TimeoutHandle>> = store_value(None);
+    let cls = create_rw_signal(if when.get_untracked() {
         show_class
     } else {
         hide_class
     });
-    let show = RwSignal::new(when.get_untracked());
+    let show = create_rw_signal(when.get_untracked());
 
-    let eff = RenderEffect::new(move |_| {
+    create_render_effect(move |_| {
         if when.get() {
             // clear any possibly active timer
             if let Some(h) = handle.get_value() {
@@ -96,7 +93,6 @@ pub fn AnimatedShow(
         if let Some(Some(h)) = handle.try_get_value() {
             h.clear();
         }
-        drop(eff);
     });
 
     view! {

leptos/src/await_.rs

@@ -1,8 +1,10 @@
-use crate::{prelude::Suspend, suspense_component::Suspense, IntoView};
+use crate::Suspense;
+use leptos_dom::IntoView;
 use leptos_macro::{component, view};
-use leptos_server::ArcOnceResource;
-use reactive_graph::prelude::ReadUntracked;
-use serde::{de::DeserializeOwned, Serialize};
+use leptos_reactive::{
+    create_blocking_resource, create_local_resource, create_resource,
+    store_value, Serializable,
+};
 
 #[component]
 /// Allows you to inline the data loading for an `async` block or
@@ -13,8 +15,11 @@ use serde::{de::DeserializeOwned, Serialize};
 /// Adding `let:{variable name}` to the props makes the data available in the children
 /// that variable name, when resolved.
 /// ```
-/// # use leptos::prelude::*;
+/// # use leptos_reactive::*;
+/// # use leptos_macro::*;
+/// # use leptos_dom::*; use leptos::*;
 /// # if false {
+/// # let runtime = create_runtime();
 /// async fn fetch_monkeys(monkey: i32) -> i32 {
 ///     // do some expensive work
 ///     3
@@ -22,23 +27,29 @@ use serde::{de::DeserializeOwned, Serialize};
 ///
 /// view! {
 ///     <Await
-///         future=fetch_monkeys(3)
+///         future=|| fetch_monkeys(3)
 ///         let:data
 ///     >
 ///         <p>{*data} " little monkeys, jumping on the bed."</p>
 ///     </Await>
 /// }
 /// # ;
+/// # runtime.dispose();
 /// # }
 /// ```
-pub fn Await<T, Fut, Chil, V>(
-    /// A [`Future`](std::future::Future) that will the component will `.await`
-    /// before rendering.
-    future: Fut,
-    /// If `true`, the component will create a blocking resource, preventing
+pub fn Await<T, Fut, FF, VF, V>(
+    /// A function that returns the [`Future`](std::future::Future) that
+    /// will the component will `.await` before rendering.
+    future: FF,
+    /// If `true`, the component will use [`create_blocking_resource`], preventing
     /// the HTML stream from returning anything before `future` has resolved.
     #[prop(optional)]
     blocking: bool,
+    /// If `true`, the component will use [`create_local_resource`], this will
+    /// always run on the local system and therefore its result type does not
+    /// need to be `Serializable`.
+    #[prop(optional)]
+    local: bool,
     /// A function that takes a reference to the resolved data from the `future`
     /// renders a view.
     ///
@@ -47,58 +58,65 @@ pub fn Await<T, Fut, Chil, V>(
     /// `let:` syntax to specify the name for the data variable.
     ///
     /// ```rust
-    /// # use leptos::prelude::*;
+    /// # use leptos::*;
     /// # if false {
+    /// # let runtime = create_runtime();
     /// # async fn fetch_monkeys(monkey: i32) -> i32 {
     /// #    3
     /// # }
     /// view! {
     ///     <Await
-    ///         future=fetch_monkeys(3)
+    ///         future=|| fetch_monkeys(3)
     ///         let:data
     ///     >
     ///         <p>{*data} " little monkeys, jumping on the bed."</p>
     ///     </Await>
     /// }
     /// # ;
+    /// # runtime.dispose();
     /// # }
     /// ```
     /// is the same as
     ///  ```rust
-    /// # use leptos::prelude::*;
+    /// # use leptos::*;
     /// # if false {
+    /// # let runtime = create_runtime();
     /// # async fn fetch_monkeys(monkey: i32) -> i32 {
     /// #    3
     /// # }
     /// view! {
     ///     <Await
-    ///         future=fetch_monkeys(3)
+    ///         future=|| fetch_monkeys(3)
     ///         children=|data| view! {
     ///           <p>{*data} " little monkeys, jumping on the bed."</p>
     ///         }
     ///     />
     /// }
     /// # ;
+    /// # runtime.dispose();
     /// # }
     /// ```
-    children: Chil,
+    children: VF,
 ) -> impl IntoView
 where
-    T: Send + Sync + Serialize + DeserializeOwned + 'static,
-    Fut: std::future::Future<Output = T> + Send + 'static,
-    Chil: FnOnce(&T) -> V + Send + 'static,
-    V: IntoView + 'static,
+    Fut: std::future::Future<Output = T> + 'static,
+    FF: Fn() -> Fut + 'static,
+    V: IntoView,
+    VF: Fn(&T) -> V + 'static,
+    T: Serializable + 'static,
 {
-    let res = ArcOnceResource::<T>::new_with_options(future, blocking);
-    let ready = res.ready();
+    let res = if blocking {
+        create_blocking_resource(|| (), move |_| future())
+    } else if local {
+        create_local_resource(|| (), move |_| future())
+    } else {
+        create_resource(|| (), move |_| future())
+    };
+    let view = store_value(children);
 
     view! {
         <Suspense fallback=|| ()>
-            {Suspend::new(async move {
-                ready.await;
-                children(res.read_untracked().as_ref().unwrap())
-            })}
-
+            {move || res.map(|data| view.with_value(|view| view(data)))}
         </Suspense>
     }
 }

leptos/src/callback.rs

@@ -41,10 +41,7 @@
 //!
 //! Use `SyncCallback` if the function is not `Sync` and `Send`.
 
-use reactive_graph::{
-    owner::{LocalStorage, StoredValue},
-    traits::WithValue,
-};
+use reactive_graph::owner::{LocalStorage, StoredValue};
 use std::{fmt, rc::Rc, sync::Arc};
 
 /// A wrapper trait for calling callbacks.

leptos/src/children.rs

@@ -3,10 +3,13 @@ use std::{
     fmt::{self, Debug},
     sync::Arc,
 };
-use tachys::view::{
-    any_view::{AnyView, IntoAny},
-    fragment::{Fragment, IntoFragment},
-    RenderHtml,
+use tachys::{
+    renderer::dom::Dom,
+    view::{
+        any_view::{AnyView, IntoAny},
+        fragment::{Fragment, IntoFragment},
+        RenderHtml,
+    },
 };
 
 /// The most common type for the `children` property on components,
@@ -14,31 +17,31 @@ use tachys::view::{
 ///
 /// This does not support iterating over individual nodes within the children.
 /// To iterate over children, use [`ChildrenFragment`].
-pub type Children = Box<dyn FnOnce() -> AnyView + Send>;
+pub type Children = Box<dyn FnOnce() -> AnyView<Dom> + Send>;
 
 /// A type for the `children` property on components that can be called only once,
 /// and provides a collection of all the children passed to this component.
-pub type ChildrenFragment = Box<dyn FnOnce() -> Fragment + Send>;
+pub type ChildrenFragment = Box<dyn FnOnce() -> Fragment<Dom> + Send>;
 
 /// A type for the `children` property on components that can be called
 /// more than once.
-pub type ChildrenFn = Arc<dyn Fn() -> AnyView + Send + Sync>;
+pub type ChildrenFn = Arc<dyn Fn() -> AnyView<Dom> + Send + Sync>;
 
 /// A type for the `children` property on components that can be called more than once,
 /// and provides a collection of all the children passed to this component.
-pub type ChildrenFragmentFn = Arc<dyn Fn() -> Fragment + Send>;
+pub type ChildrenFragmentFn = Arc<dyn Fn() -> Fragment<Dom> + Send>;
 
 /// A type for the `children` property on components that can be called
 /// more than once, but may mutate the children.
-pub type ChildrenFnMut = Box<dyn FnMut() -> AnyView + Send>;
+pub type ChildrenFnMut = Box<dyn FnMut() -> AnyView<Dom> + Send>;
 
 /// A type for the `children` property on components that can be called more than once,
 /// but may mutate the children, and provides a collection of all the children
 /// passed to this component.
-pub type ChildrenFragmentMut = Box<dyn FnMut() -> Fragment + Send>;
+pub type ChildrenFragmentMut = Box<dyn FnMut() -> Fragment<Dom> + Send>;
 
 // This is to still support components that accept `Box<dyn Fn() -> AnyView>` as a children.
-type BoxedChildrenFn = Box<dyn Fn() -> AnyView + Send>;
+type BoxedChildrenFn = Box<dyn Fn() -> AnyView<Dom> + Send>;
 
 /// This trait can be used when constructing a component that takes children without needing
 /// to know exactly what children type the component expects. This is used internally by the
@@ -94,7 +97,7 @@ pub trait ToChildren<F> {
 impl<F, C> ToChildren<F> for Children
 where
     F: FnOnce() -> C + Send + 'static,
-    C: RenderHtml + Send + 'static,
+    C: RenderHtml<Dom> + Send + 'static,
 {
     #[inline]
     fn to_children(f: F) -> Self {
@@ -105,7 +108,7 @@ where
 impl<F, C> ToChildren<F> for ChildrenFn
 where
     F: Fn() -> C + Send + Sync + 'static,
-    C: RenderHtml + Send + 'static,
+    C: RenderHtml<Dom> + Send + 'static,
 {
     #[inline]
     fn to_children(f: F) -> Self {
@@ -116,7 +119,7 @@ where
 impl<F, C> ToChildren<F> for ChildrenFnMut
 where
     F: Fn() -> C + Send + 'static,
-    C: RenderHtml + Send + 'static,
+    C: RenderHtml<Dom> + Send + 'static,
 {
     #[inline]
     fn to_children(f: F) -> Self {
@@ -127,7 +130,7 @@ where
 impl<F, C> ToChildren<F> for BoxedChildrenFn
 where
     F: Fn() -> C + Send + 'static,
-    C: RenderHtml + Send + 'static,
+    C: RenderHtml<Dom> + Send + 'static,
 {
     #[inline]
     fn to_children(f: F) -> Self {
@@ -138,7 +141,7 @@ where
 impl<F, C> ToChildren<F> for ChildrenFragment
 where
     F: FnOnce() -> C + Send + 'static,
-    C: IntoFragment,
+    C: IntoFragment<Dom>,
 {
     #[inline]
     fn to_children(f: F) -> Self {
@@ -149,7 +152,7 @@ where
 impl<F, C> ToChildren<F> for ChildrenFragmentFn
 where
     F: Fn() -> C + Send + 'static,
-    C: IntoFragment,
+    C: IntoFragment<Dom>,
 {
     #[inline]
     fn to_children(f: F) -> Self {
@@ -160,7 +163,7 @@ where
 impl<F, C> ToChildren<F> for ChildrenFragmentMut
 where
     F: FnMut() -> C + Send + 'static,
-    C: IntoFragment,
+    C: IntoFragment<Dom>,
 {
     #[inline]
     fn to_children(mut f: F) -> Self {
@@ -171,7 +174,7 @@ where
 /// New-type wrapper for a function that returns a view with `From` and `Default` traits implemented
 /// to enable optional props in for example `<Show>` and `<Suspense>`.
 #[derive(Clone)]
-pub struct ViewFn(Arc<dyn Fn() -> AnyView + Send + Sync + 'static>);
+pub struct ViewFn(Arc<dyn Fn() -> AnyView<Dom> + Send + Sync + 'static>);
 
 impl Default for ViewFn {
     fn default() -> Self {
@@ -182,7 +185,7 @@ impl Default for ViewFn {
 impl<F, C> From<F> for ViewFn
 where
     F: Fn() -> C + Send + Sync + 'static,
-    C: RenderHtml + Send + 'static,
+    C: RenderHtml<Dom> + Send + 'static,
 {
     fn from(value: F) -> Self {
         Self(Arc::new(move || value().into_any()))
@@ -191,14 +194,14 @@ where
 
 impl ViewFn {
     /// Execute the wrapped function
-    pub fn run(&self) -> AnyView {
+    pub fn run(&self) -> AnyView<Dom> {
         (self.0)()
     }
 }
 
 /// New-type wrapper for a function, which will only be called once and returns a view with `From` and
 /// `Default` traits implemented to enable optional props in for example `<Show>` and `<Suspense>`.
-pub struct ViewFnOnce(Box<dyn FnOnce() -> AnyView + Send + 'static>);
+pub struct ViewFnOnce(Box<dyn FnOnce() -> AnyView<Dom> + Send + 'static>);
 
 impl Default for ViewFnOnce {
     fn default() -> Self {
@@ -209,7 +212,7 @@ impl Default for ViewFnOnce {
 impl<F, C> From<F> for ViewFnOnce
 where
     F: FnOnce() -> C + Send + 'static,
-    C: RenderHtml + Send + 'static,
+    C: RenderHtml<Dom> + Send + 'static,
 {
     fn from(value: F) -> Self {
         Self(Box::new(move || value().into_any()))
@@ -218,7 +221,7 @@ where
 
 impl ViewFnOnce {
     /// Execute the wrapped function
-    pub fn run(self) -> AnyView {
+    pub fn run(self) -> AnyView<Dom> {
         (self.0)()
     }
 }

leptos/src/error_boundary.rs

@@ -9,11 +9,12 @@ use reactive_graph::{
     traits::{Get, Update, With, WithUntracked},
 };
 use rustc_hash::FxHashMap;
-use std::{fmt::Debug, sync::Arc};
+use std::{fmt::Debug, marker::PhantomData, sync::Arc};
 use tachys::{
     html::attribute::Attribute,
     hydration::Cursor,
     reactive_graph::OwnedView,
+    renderer::Renderer,
     ssr::StreamBuilder,
     view::{
         add_attr::AddAnyAttr, Mountable, Position, PositionState, Render,
@@ -111,18 +112,20 @@ where
             children,
             errors,
             fallback,
+            rndr: PhantomData,
         },
         owner,
     )
 }
 
-struct ErrorBoundaryView<Chil, FalFn> {
+struct ErrorBoundaryView<Chil, FalFn, Rndr> {
     hook: Arc<dyn ErrorHook>,
     boundary_id: SerializedDataId,
     errors_empty: ArcMemo<bool>,
     children: Chil,
     fallback: FalFn,
     errors: ArcRwSignal<Errors>,
+    rndr: PhantomData<Rndr>,
 }
 
 struct ErrorBoundaryViewState<Chil, Fal> {
@@ -131,10 +134,11 @@ struct ErrorBoundaryViewState<Chil, Fal> {
     fallback: Option<Fal>,
 }
 
-impl<Chil, Fal> Mountable for ErrorBoundaryViewState<Chil, Fal>
+impl<Chil, Fal, Rndr> Mountable<Rndr> for ErrorBoundaryViewState<Chil, Fal>
 where
-    Chil: Mountable,
-    Fal: Mountable,
+    Chil: Mountable<Rndr>,
+    Fal: Mountable<Rndr>,
+    Rndr: Renderer,
 {
     fn unmount(&mut self) {
         if let Some(fallback) = &mut self.fallback {
@@ -144,11 +148,7 @@ where
         }
     }
 
-    fn mount(
-        &mut self,
-        parent: &tachys::renderer::types::Element,
-        marker: Option<&tachys::renderer::types::Node>,
-    ) {
+    fn mount(&mut self, parent: &Rndr::Element, marker: Option<&Rndr::Node>) {
         if let Some(fallback) = &mut self.fallback {
             fallback.mount(parent, marker);
         } else {
@@ -156,7 +156,7 @@ where
         }
     }
 
-    fn insert_before_this(&self, child: &mut dyn Mountable) -> bool {
+    fn insert_before_this(&self, child: &mut dyn Mountable<Rndr>) -> bool {
         if let Some(fallback) = &self.fallback {
             fallback.insert_before_this(child)
         } else {
@@ -165,11 +165,13 @@ where
     }
 }
 
-impl<Chil, FalFn, Fal> Render for ErrorBoundaryView<Chil, FalFn>
+impl<Chil, FalFn, Fal, Rndr> Render<Rndr>
+    for ErrorBoundaryView<Chil, FalFn, Rndr>
 where
-    Chil: Render + 'static,
+    Chil: Render<Rndr> + 'static,
     FalFn: FnMut(ArcRwSignal<Errors>) -> Fal + Send + 'static,
-    Fal: Render + 'static,
+    Fal: Render<Rndr> + 'static,
+    Rndr: Renderer,
 {
     type State = RenderEffect<ErrorBoundaryViewState<Chil::State, Fal::State>>;
 
@@ -226,21 +228,26 @@ where
     }
 }
 
-impl<Chil, FalFn, Fal> AddAnyAttr for ErrorBoundaryView<Chil, FalFn>
+impl<Chil, FalFn, Fal, Rndr> AddAnyAttr<Rndr>
+    for ErrorBoundaryView<Chil, FalFn, Rndr>
 where
-    Chil: RenderHtml + 'static,
+    Chil: RenderHtml<Rndr> + 'static,
     FalFn: FnMut(ArcRwSignal<Errors>) -> Fal + Send + 'static,
-    Fal: RenderHtml + Send + 'static,
+    Fal: RenderHtml<Rndr> + Send + 'static,
+    Rndr: Renderer,
 {
-    type Output<SomeNewAttr: Attribute> =
-        ErrorBoundaryView<Chil::Output<SomeNewAttr::CloneableOwned>, FalFn>;
+    type Output<SomeNewAttr: Attribute<Rndr>> = ErrorBoundaryView<
+        Chil::Output<SomeNewAttr::CloneableOwned>,
+        FalFn,
+        Rndr,
+    >;
 
-    fn add_any_attr<NewAttr: Attribute>(
+    fn add_any_attr<NewAttr: Attribute<Rndr>>(
         self,
         attr: NewAttr,
     ) -> Self::Output<NewAttr>
     where
-        Self::Output<NewAttr>: RenderHtml,
+        Self::Output<NewAttr>: RenderHtml<Rndr>,
     {
         let ErrorBoundaryView {
             hook,
@@ -249,6 +256,7 @@ where
             children,
             fallback,
             errors,
+            rndr,
         } = self;
         ErrorBoundaryView {
             hook,
@@ -257,17 +265,20 @@ where
             children: children.add_any_attr(attr.into_cloneable_owned()),
             fallback,
             errors,
+            rndr,
         }
     }
 }
 
-impl<Chil, FalFn, Fal> RenderHtml for ErrorBoundaryView<Chil, FalFn>
+impl<Chil, FalFn, Fal, Rndr> RenderHtml<Rndr>
+    for ErrorBoundaryView<Chil, FalFn, Rndr>
 where
-    Chil: RenderHtml + Send + 'static,
+    Chil: RenderHtml<Rndr> + Send + 'static,
     FalFn: FnMut(ArcRwSignal<Errors>) -> Fal + Send + 'static,
-    Fal: RenderHtml + Send + 'static,
+    Fal: RenderHtml<Rndr> + Send + 'static,
+    Rndr: Renderer,
 {
-    type AsyncOutput = ErrorBoundaryView<Chil::AsyncOutput, FalFn>;
+    type AsyncOutput = ErrorBoundaryView<Chil::AsyncOutput, FalFn, Rndr>;
 
     const MIN_LENGTH: usize = Chil::MIN_LENGTH;
 
@@ -292,6 +303,7 @@ where
             children: children.resolve().await,
             fallback,
             errors,
+            rndr: PhantomData,
         }
     }
 
@@ -365,7 +377,7 @@ where
 
     fn hydrate<const FROM_SERVER: bool>(
         mut self,
-        cursor: &Cursor,
+        cursor: &Cursor<Rndr>,
         position: &PositionState,
     ) -> Self::State {
         let mut children = Some(self.children);

leptos/src/for_loop.rs

@@ -157,7 +157,7 @@ where
     };
     move || keyed(each(), key.clone(), children.clone())
 }
-/*
+
 #[cfg(test)]
 mod tests {
     use crate::prelude::*;
@@ -168,7 +168,7 @@ mod tests {
     fn creates_list() {
         Owner::new().with(|| {
             let values = RwSignal::new(vec![1, 2, 3, 4, 5]);
-            let list: View<HtmlElement<_, _, _>> = view! {
+            let list: View<HtmlElement<_, _, _, Dom>> = view! {
                 <ol>
                     <For each=move || values.get() key=|i| *i let:i>
                         <li>{i}</li>
@@ -187,7 +187,7 @@ mod tests {
     fn creates_list_enumerate() {
         Owner::new().with(|| {
             let values = RwSignal::new(vec![1, 2, 3, 4, 5]);
-            let list: View<HtmlElement<_, _, _>> = view! {
+            let list: View<HtmlElement<_, _, _, Dom>> = view! {
                 <ol>
                     <ForEnumerate each=move || values.get() key=|i| *i let(index, i)>
                         <li>{move || index.get()}"-"{i}</li>
@@ -200,7 +200,7 @@ mod tests {
                 <!>-<!>4</li><li>4<!>-<!>5</li><!></ol>"
             );
 
-            let list: View<HtmlElement<_, _, _>> = view! {
+            let list: View<HtmlElement<_, _, _, Dom>> = view! {
                 <ol>
                     <ForEnumerate each=move || values.get() key=|i| *i let(index, i)>
                         <li>{move || index.get()}"-"{i}</li>
@@ -216,4 +216,3 @@ mod tests {
         });
     }
 }
- */

leptos/src/hydration/hydration_script.js

@@ -1,8 +1,8 @@
 (function (root, pkg_path, output_name, wasm_output_name) {
 	import(`${root}/${pkg_path}/${output_name}.js`)
 		.then(mod => {
-			mod.default(`${root}/${pkg_path}/${wasm_output_name}.wasm`).then(() => {
+			mod.default(`/${pkg_path}/${wasm_output_name}.wasm`).then(() => {
 				mod.hydrate();
 			});
 		})
-})
+})

leptos/src/hydration/island_script.js

@@ -38,7 +38,7 @@
 		if (islandFn) {
 			islandFn(el);
 		} else {
-			console.warn(`Could not find WASM function for the island ${id}.`);
+			console.warn(`Could not find WASM function for the island ${l}.`);
 		}
 	}
 	function hydrateIslands(entry, mod) {

leptos/src/hydration/mod.rs

@@ -50,7 +50,7 @@ pub fn HydrationScripts(
                 path.parent().map(|p| p.to_path_buf()).unwrap_or_default()
             })
             .unwrap_or_default()
-            .join(options.hash_file.as_ref());
+            .join(&options.hash_file);
         if hash_path.exists() {
             let hashes = std::fs::read_to_string(&hash_path)
                 .expect("failed to read hash file");

leptos/src/into_view.rs

@@ -2,6 +2,7 @@ use std::borrow::Cow;
 use tachys::{
     html::attribute::Attribute,
     hydration::Cursor,
+    renderer::{dom::Dom, Renderer},
     ssr::StreamBuilder,
     view::{
         add_attr::AddAnyAttr, Position, PositionState, Render, RenderHtml,
@@ -49,14 +50,14 @@ impl<T> View<T> {
 
 pub trait IntoView
 where
-    Self: Sized + Render + RenderHtml + Send,
+    Self: Sized + Render<Dom> + RenderHtml<Dom> + Send,
 {
     fn into_view(self) -> View<Self>;
 }
 
 impl<T> IntoView for T
 where
-    T: Sized + Render + RenderHtml + Send, //+ AddAnyAttr,
+    T: Sized + Render<Dom> + RenderHtml<Dom> + Send, //+ AddAnyAttr<Dom>,
 {
     fn into_view(self) -> View<Self> {
         View {
@@ -67,7 +68,7 @@ where
     }
 }
 
-impl<T: Render> Render for View<T> {
+impl<T: Render<Rndr>, Rndr: Renderer> Render<Rndr> for View<T> {
     type State = T::State;
 
     fn build(self) -> Self::State {
@@ -79,10 +80,10 @@ impl<T: Render> Render for View<T> {
     }
 }
 
-impl<T: RenderHtml> RenderHtml for View<T> {
+impl<T: RenderHtml<Rndr>, Rndr: Renderer> RenderHtml<Rndr> for View<T> {
     type AsyncOutput = T::AsyncOutput;
 
-    const MIN_LENGTH: usize = <T as RenderHtml>::MIN_LENGTH;
+    const MIN_LENGTH: usize = <T as RenderHtml<Rndr>>::MIN_LENGTH;
 
     async fn resolve(self) -> Self::AsyncOutput {
         self.inner.resolve().await
@@ -146,7 +147,7 @@ impl<T: RenderHtml> RenderHtml for View<T> {
 
     fn hydrate<const FROM_SERVER: bool>(
         self,
-        cursor: &Cursor,
+        cursor: &Cursor<Rndr>,
         position: &PositionState,
     ) -> Self::State {
         self.inner.hydrate::<FROM_SERVER>(cursor, position)
@@ -165,15 +166,18 @@ impl<T: ToTemplate> ToTemplate for View<T> {
     }
 }
 
-impl<T: AddAnyAttr> AddAnyAttr for View<T> {
-    type Output<SomeNewAttr: Attribute> = View<T::Output<SomeNewAttr>>;
+impl<T: AddAnyAttr<Rndr>, Rndr> AddAnyAttr<Rndr> for View<T>
+where
+    Rndr: Renderer,
+{
+    type Output<SomeNewAttr: Attribute<Rndr>> = View<T::Output<SomeNewAttr>>;
 
-    fn add_any_attr<NewAttr: Attribute>(
+    fn add_any_attr<NewAttr: Attribute<Rndr>>(
         self,
         attr: NewAttr,
     ) -> Self::Output<NewAttr>
     where
-        Self::Output<NewAttr>: RenderHtml,
+        Self::Output<NewAttr>: RenderHtml<Rndr>,
     {
         let View {
             inner,

leptos/src/lib.rs

@@ -163,20 +163,19 @@ pub mod prelude {
             form::*, hydration::*, into_view::*, mount::*, suspense::*,
         };
         pub use leptos_config::*;
-        pub use leptos_dom::helpers::*;
+        pub use leptos_dom::{helpers::*, *};
         pub use leptos_macro::*;
         pub use leptos_server::*;
         pub use oco_ref::*;
         pub use reactive_graph::{
-            actions::*, computed::*, effect::*, graph::untrack, owner::*,
-            signal::*, wrappers::read::*,
+            actions::*, computed::*, effect::*, owner::*, signal::*, untrack,
+            wrappers::read::*,
         };
         pub use server_fn::{self, ServerFnError};
         pub use tachys::{
-            reactive_graph::{bind::BindAttribute, node_ref::*, Suspend},
-            view::{
-                any_view::AnyView, fragment::Fragment, template::ViewTemplate,
-            },
+            self,
+            reactive_graph::{node_ref::*, Suspend},
+            view::template::ViewTemplate,
         };
     }
     pub use export_types::*;
@@ -202,12 +201,10 @@ pub mod error {
     pub use throw_error::*;
 }
 
-/// Control-flow components like `<Show>`, `<For>`, and `<Await>`.
+/// Control-flow components like `<Show>` and `<For>`.
 pub mod control_flow {
-    pub use crate::{animated_show::*, await_::*, for_loop::*, show::*};
+    pub use crate::{for_loop::*, show::*};
 }
-mod animated_show;
-mod await_;
 mod for_loop;
 mod show;
 
@@ -233,7 +230,6 @@ mod suspense_component;
 pub mod text_prop;
 mod transition;
 pub use leptos_macro::*;
-#[doc(inline)]
 pub use server_fn;
 #[doc(hidden)]
 pub use typed_builder;
@@ -241,22 +237,16 @@ pub use typed_builder;
 pub use typed_builder_macro;
 mod into_view;
 pub use into_view::IntoView;
-#[doc(inline)]
 pub use leptos_dom;
 mod provider;
-#[doc(inline)]
 pub use tachys;
 /// Tools to mount an application to the DOM, or to hydrate it from server-rendered HTML.
 pub mod mount;
-#[doc(inline)]
 pub use leptos_config as config;
-#[doc(inline)]
 pub use oco_ref as oco;
 mod from_form_data;
-#[doc(inline)]
 pub use either_of as either;
-#[doc(inline)]
-pub use reactive_graph as reactive;
+pub use reactive_graph;
 
 /// Provide and access data along the reactive graph, sharing data without directly passing arguments.
 pub mod context {
@@ -264,22 +254,17 @@ pub mod context {
     pub use reactive_graph::owner::{provide_context, use_context};
 }
 
-#[doc(inline)]
 pub use leptos_server as server;
 /// HTML attribute types.
-#[doc(inline)]
 pub use tachys::html::attribute as attr;
 /// HTML element types.
-#[doc(inline)]
 pub use tachys::html::element as html;
 /// HTML event types.
 #[doc(no_inline)]
 pub use tachys::html::event as ev;
 /// MathML element types.
-#[doc(inline)]
 pub use tachys::mathml as math;
 /// SVG element types.
-#[doc(inline)]
 pub use tachys::svg;
 
 /// Utilities for simple isomorphic logging to the console or terminal.
@@ -287,7 +272,7 @@ pub mod logging {
     pub use leptos_dom::{debug_warn, error, log, warn};
 }
 
-pub mod task {
+pub mod spawn {
     pub use any_spawner::Executor;
     use std::future::Future;
 
@@ -305,14 +290,9 @@ pub mod task {
         Executor::spawn_local(fut)
     }
 
-    /// Waits until the next "tick" of the current async executor.
     pub async fn tick() {
         Executor::tick().await
     }
-
-    pub use reactive_graph::{
-        spawn_local_scoped, spawn_local_scoped_with_cancellation,
-    };
 }
 
 // these reexports are used in islands
@@ -329,3 +309,234 @@ pub use tracing;
 pub use wasm_bindgen;
 #[doc(hidden)]
 pub use web_sys;
+
+/*mod additional_attributes;
+pub use additional_attributes::*;
+mod await_;
+pub use await_::*;
+pub use leptos_config::{self, get_configuration, LeptosOptions};
+#[cfg(not(all(
+    target_arch = "wasm32",
+    any(feature = "csr", feature = "hydrate")
+)))]
+/// Utilities for server-side rendering HTML.
+pub mod ssr {
+    pub use leptos_dom::{ssr::*, ssr_in_order::*};
+}
+pub use leptos_dom::{
+    self, create_node_ref, document, ev,
+    helpers::{
+        event_target, event_target_checked, event_target_value,
+        request_animation_frame, request_animation_frame_with_handle,
+        request_idle_callback, request_idle_callback_with_handle, set_interval,
+        set_interval_with_handle, set_timeout, set_timeout_with_handle,
+        window_event_listener, window_event_listener_untyped,
+    },
+    html,
+    html::Binding,
+    math, mount_to, mount_to_body, nonce, svg, window, Attribute, Class,
+    CollectView, Errors, EventHandlerFn, Fragment, HtmlElement, IntoAttribute,
+    IntoClass, IntoProperty, IntoStyle, IntoView, NodeRef, Property, View,
+};
+
+/// Types to make it easier to handle errors in your application.
+pub mod error {
+    pub use server_fn::error::{Error, Result};
+}
+#[cfg(all(target_arch = "wasm32", feature = "template_macro"))]
+pub use leptos_macro::template;
+#[cfg(not(all(target_arch = "wasm32", feature = "template_macro")))]
+pub use leptos_macro::view as template;
+pub use leptos_macro::{component, island, slice, slot, view, Params};
+cfg_if::cfg_if!(
+    if #[cfg(feature="spin")] {
+        pub use leptos_spin_macro::server;
+    } else {
+        pub use leptos_macro::server;
+    }
+);
+pub use leptos_reactive::*;
+pub use leptos_server::{
+    self, create_action, create_multi_action, create_server_action,
+    create_server_multi_action, Action, MultiAction, ServerFnError,
+    ServerFnErrorErr,
+};
+pub use server_fn::{self, ServerFn as _};
+mod error_boundary;
+pub use error_boundary::*;
+mod animated_show;
+mod for_loop;
+mod provider;
+mod show;
+pub use animated_show::*;
+pub use for_loop::*;
+pub use provider::*;
+#[cfg(feature = "experimental-islands")]
+pub use serde;
+#[cfg(feature = "experimental-islands")]
+pub use serde_json;
+pub use show::*;
+//pub use suspense_component::*;
+mod suspense_component;
+//mod transition;
+#[cfg(feature = "tracing")]
+#[doc(hidden)]
+pub use tracing;
+pub use transition::*;
+#[doc(hidden)]
+pub use typed_builder;
+#[doc(hidden)]
+pub use typed_builder::Optional;
+#[doc(hidden)]
+pub use typed_builder_macro;
+#[doc(hidden)]
+#[cfg(any(
+    feature = "csr",
+    feature = "hydrate",
+    feature = "template_macro"
+))]
+pub use wasm_bindgen; // used in islands
+#[doc(hidden)]
+#[cfg(any(
+    feature = "csr",
+    feature = "hydrate",
+    feature = "template_macro"
+))]
+pub use web_sys; // used in islands
+
+mod children;
+mod portal;
+mod view_fn;
+pub use children::*;
+pub use portal::*;
+pub use view_fn::*;
+
+extern crate self as leptos;
+
+/// A type for taking anything that implements [`IntoAttribute`].
+///
+/// ```rust
+/// use leptos::*;
+///
+/// #[component]
+/// pub fn MyHeading(
+///     text: String,
+///     #[prop(optional, into)] class: Option<AttributeValue>,
+/// ) -> impl IntoView {
+///     view! {
+///       <h1 class=class>{text}</h1>
+///     }
+/// }
+/// ```
+pub type AttributeValue = Box<dyn IntoAttribute>;
+
+#[doc(hidden)]
+pub trait Component<P> {}
+
+#[doc(hidden)]
+pub trait Props {
+    type Builder;
+    fn builder() -> Self::Builder;
+}
+
+#[doc(hidden)]
+pub trait DynAttrs {
+    fn dyn_attrs(self, _args: Vec<(&'static str, Attribute)>) -> Self
+    where
+        Self: Sized,
+    {
+        self
+    }
+}
+
+impl DynAttrs for () {}
+
+#[doc(hidden)]
+pub trait DynBindings {
+    fn dyn_bindings<B: Into<Binding>>(
+        self,
+        _args: impl IntoIterator<Item = B>,
+    ) -> Self
+    where
+        Self: Sized,
+    {
+        self
+    }
+}
+
+impl DynBindings for () {}
+
+#[doc(hidden)]
+pub trait PropsOrNoPropsBuilder {
+    type Builder;
+    fn builder_or_not() -> Self::Builder;
+}
+
+#[doc(hidden)]
+#[derive(Copy, Clone, Debug, Default)]
+pub struct EmptyPropsBuilder {}
+
+impl EmptyPropsBuilder {
+    pub fn build(self) {}
+}
+
+impl<P: Props> PropsOrNoPropsBuilder for P {
+    type Builder = <P as Props>::Builder;
+    fn builder_or_not() -> Self::Builder {
+        Self::builder()
+    }
+}
+
+impl PropsOrNoPropsBuilder for EmptyPropsBuilder {
+    type Builder = EmptyPropsBuilder;
+    fn builder_or_not() -> Self::Builder {
+        EmptyPropsBuilder {}
+    }
+}
+
+impl<F, R> Component<EmptyPropsBuilder> for F where F: FnOnce() -> R {}
+
+impl<P, F, R> Component<P> for F
+where
+    F: FnOnce(P) -> R,
+    P: Props,
+{
+}
+
+#[doc(hidden)]
+pub fn component_props_builder<P: PropsOrNoPropsBuilder>(
+    _f: &impl Component<P>,
+) -> <P as PropsOrNoPropsBuilder>::Builder {
+    <P as PropsOrNoPropsBuilder>::builder_or_not()
+}
+
+#[doc(hidden)]
+pub fn component_view<P>(f: impl ComponentConstructor<P>, props: P) -> View {
+    f.construct(props)
+}
+
+#[doc(hidden)]
+pub trait ComponentConstructor<P> {
+    fn construct(self, props: P) -> View;
+}
+
+impl<Func, V> ComponentConstructor<()> for Func
+where
+    Func: FnOnce() -> V,
+    V: IntoView,
+{
+    fn construct(self, (): ()) -> View {
+        (self)().into_view()
+    }
+}
+
+impl<Func, V, P> ComponentConstructor<P> for Func
+where
+    Func: FnOnce(P) -> V,
+    V: IntoView,
+    P: PropsOrNoPropsBuilder,
+{
+    fn construct(self, props: P) -> View {
+        (self)(props).into_view()
+    }
+}*/

leptos/src/mount.rs

@@ -5,8 +5,10 @@ use any_spawner::Executor;
 use reactive_graph::owner::Owner;
 #[cfg(debug_assertions)]
 use std::cell::Cell;
+use std::marker::PhantomData;
 use tachys::{
     dom::body,
+    renderer::{dom::Dom, Renderer},
     view::{Mountable, Render},
 };
 #[cfg(feature = "hydrate")]
@@ -36,7 +38,10 @@ thread_local! {
 
 #[cfg(feature = "hydrate")]
 /// Runs the provided closure and mounts the result to the provided element.
-pub fn hydrate_from<F, N>(parent: HtmlElement, f: F) -> UnmountHandle<N::State>
+pub fn hydrate_from<F, N>(
+    parent: HtmlElement,
+    f: F,
+) -> UnmountHandle<N::State, Dom>
 where
     F: FnOnce() -> N + 'static,
     N: IntoView,
@@ -80,7 +85,11 @@ where
 
     // returns a handle that owns the owner
     // when this is dropped, it will clean up the reactive system and unmount the view
-    UnmountHandle { owner, mountable }
+    UnmountHandle {
+        owner,
+        mountable,
+        rndr: PhantomData,
+    }
 }
 
 /// Runs the provided closure and mounts the result to the `<body>`.
@@ -94,7 +103,7 @@ where
 }
 
 /// Runs the provided closure and mounts the result to the provided element.
-pub fn mount_to<F, N>(parent: HtmlElement, f: F) -> UnmountHandle<N::State>
+pub fn mount_to<F, N>(parent: HtmlElement, f: F) -> UnmountHandle<N::State, Dom>
 where
     F: FnOnce() -> N + 'static,
     N: IntoView,
@@ -131,17 +140,22 @@ where
 
     // returns a handle that owns the owner
     // when this is dropped, it will clean up the reactive system and unmount the view
-    UnmountHandle { owner, mountable }
+    UnmountHandle {
+        owner,
+        mountable,
+        rndr: PhantomData,
+    }
 }
 
 /// Runs the provided closure and mounts the result to the provided element.
-pub fn mount_to_renderer<F, N>(
-    parent: &tachys::renderer::types::Element,
+pub fn mount_to_renderer<F, N, R>(
+    parent: &R::Element,
     f: F,
-) -> UnmountHandle<N::State>
+) -> UnmountHandle<N::State, R>
 where
     F: FnOnce() -> N + 'static,
-    N: Render,
+    N: Render<R>,
+    R: Renderer,
 {
     // use wasm-bindgen-futures to drive the reactive system
     // we ignore the return value because an Err here just means the wasm-bindgen executor is
@@ -159,7 +173,11 @@ where
 
     // returns a handle that owns the owner
     // when this is dropped, it will clean up the reactive system and unmount the view
-    UnmountHandle { owner, mountable }
+    UnmountHandle {
+        owner,
+        mountable,
+        rndr: PhantomData,
+    }
 }
 
 /// Hydrates any islands that are currently present on the page.
@@ -193,18 +211,21 @@ pub fn hydrate_islands() {
               reactive system. You should either call `.forget()` to keep the \
               view permanently mounted, or store the `UnmountHandle` somewhere \
               and drop it when you'd like to unmount the view."]
-pub struct UnmountHandle<M>
+pub struct UnmountHandle<M, R>
 where
-    M: Mountable,
+    M: Mountable<R>,
+    R: Renderer,
 {
     #[allow(dead_code)]
     owner: Owner,
     mountable: M,
+    rndr: PhantomData<R>,
 }
 
-impl<M> UnmountHandle<M>
+impl<M, R> UnmountHandle<M, R>
 where
-    M: Mountable,
+    M: Mountable<R>,
+    R: Renderer,
 {
     /// Leaks the handle, preventing the reactive system from being cleaned up and the view from
     /// being unmounted. This should always be called when [`mount_to`] is used for the root of an
@@ -214,9 +235,10 @@ where
     }
 }
 
-impl<M> Drop for UnmountHandle<M>
+impl<M, R> Drop for UnmountHandle<M, R>
 where
-    M: Mountable,
+    M: Mountable<R>,
+    R: Renderer,
 {
     fn drop(&mut self) {
         self.mountable.unmount();

leptos/src/nonce.rs

@@ -6,7 +6,7 @@ use base64::{
 };
 use rand::{thread_rng, RngCore};
 use std::{fmt::Display, ops::Deref, sync::Arc};
-use tachys::html::attribute::AttributeValue;
+use tachys::{html::attribute::AttributeValue, renderer::Renderer};
 
 /// A cryptographic nonce ("number used once") which can be
 /// used by Content Security Policy to determine whether or not a given
@@ -65,9 +65,12 @@ impl Display for Nonce {
     }
 }
 
-impl AttributeValue for Nonce {
+impl<R> AttributeValue<R> for Nonce
+where
+    R: Renderer,
+{
     type AsyncOutput = Self;
-    type State = <Arc<str> as AttributeValue>::State;
+    type State = <Arc<str> as AttributeValue<R>>::State;
     type Cloneable = Self;
     type CloneableOwned = Self;
 
@@ -76,7 +79,7 @@ impl AttributeValue for Nonce {
     }
 
     fn to_html(self, key: &str, buf: &mut String) {
-        <Arc<str> as AttributeValue>::to_html(self.0, key, buf)
+        <Arc<str> as AttributeValue<R>>::to_html(self.0, key, buf)
     }
 
     fn to_template(_key: &str, _buf: &mut String) {}
@@ -84,21 +87,17 @@ impl AttributeValue for Nonce {
     fn hydrate<const FROM_SERVER: bool>(
         self,
         key: &str,
-        el: &tachys::renderer::types::Element,
+        el: &<R as Renderer>::Element,
     ) -> Self::State {
-        <Arc<str> as AttributeValue>::hydrate::<FROM_SERVER>(self.0, key, el)
+        <Arc<str> as AttributeValue<R>>::hydrate::<FROM_SERVER>(self.0, key, el)
     }
 
-    fn build(
-        self,
-        el: &tachys::renderer::types::Element,
-        key: &str,
-    ) -> Self::State {
-        <Arc<str> as AttributeValue>::build(self.0, el, key)
+    fn build(self, el: &<R as Renderer>::Element, key: &str) -> Self::State {
+        <Arc<str> as AttributeValue<R>>::build(self.0, el, key)
     }
 
     fn rebuild(self, key: &str, state: &mut Self::State) {
-        <Arc<str> as AttributeValue>::rebuild(self.0, key, state)
+        <Arc<str> as AttributeValue<R>>::rebuild(self.0, key, state)
     }
 
     fn into_cloneable(self) -> Self::Cloneable {

leptos/src/portal.rs

@@ -1,7 +1,7 @@
 use crate::{children::TypedChildrenFn, mount, IntoView};
 use leptos_dom::helpers::document;
 use leptos_macro::component;
-use reactive_graph::{effect::Effect, graph::untrack, owner::Owner};
+use reactive_graph::{effect::Effect, owner::Owner, untrack};
 use std::sync::Arc;
 
 /// Renders components somewhere else in the DOM.

leptos/src/provider.rs

@@ -35,7 +35,7 @@ pub fn Provider<T, Chil>(
 ) -> impl IntoView
 where
     T: Send + Sync + 'static,
-    Chil: IntoView + 'static,
+    Chil: IntoView,
 {
     let owner = Owner::current()
         .expect("no current reactive Owner found")

leptos/src/suspense_component.rs

@@ -21,6 +21,7 @@ use tachys::{
     html::attribute::Attribute,
     hydration::Cursor,
     reactive_graph::{OwnedView, OwnedViewState},
+    renderer::Renderer,
     ssr::StreamBuilder,
     view::{
         add_attr::AddAnyAttr,
@@ -134,14 +135,15 @@ pub(crate) struct SuspenseBoundary<const TRANSITION: bool, Fal, Chil> {
     pub children: Chil,
 }
 
-impl<const TRANSITION: bool, Fal, Chil> Render
+impl<const TRANSITION: bool, Fal, Chil, Rndr> Render<Rndr>
     for SuspenseBoundary<TRANSITION, Fal, Chil>
 where
-    Fal: Render + Send + 'static,
-    Chil: Render + Send + 'static,
+    Fal: Render<Rndr> + Send + 'static,
+    Chil: Render<Rndr> + Send + 'static,
+    Rndr: Renderer + 'static,
 {
     type State = RenderEffect<
-        OwnedViewState<EitherKeepAliveState<Chil::State, Fal::State>>,
+        OwnedViewState<EitherKeepAliveState<Chil::State, Fal::State>, Rndr>,
     >;
 
     fn build(self) -> Self::State {
@@ -185,24 +187,25 @@ where
     }
 }
 
-impl<const TRANSITION: bool, Fal, Chil> AddAnyAttr
+impl<const TRANSITION: bool, Fal, Chil, Rndr> AddAnyAttr<Rndr>
     for SuspenseBoundary<TRANSITION, Fal, Chil>
 where
-    Fal: RenderHtml + Send + 'static,
-    Chil: RenderHtml + Send + 'static,
+    Fal: RenderHtml<Rndr> + Send + 'static,
+    Chil: RenderHtml<Rndr> + Send + 'static,
+    Rndr: Renderer + 'static,
 {
-    type Output<SomeNewAttr: Attribute> = SuspenseBoundary<
+    type Output<SomeNewAttr: Attribute<Rndr>> = SuspenseBoundary<
         TRANSITION,
         Fal,
         Chil::Output<SomeNewAttr::CloneableOwned>,
     >;
 
-    fn add_any_attr<NewAttr: Attribute>(
+    fn add_any_attr<NewAttr: Attribute<Rndr>>(
         self,
         attr: NewAttr,
     ) -> Self::Output<NewAttr>
     where
-        Self::Output<NewAttr>: RenderHtml,
+        Self::Output<NewAttr>: RenderHtml<Rndr>,
     {
         let attr = attr.into_cloneable_owned();
         let SuspenseBoundary {
@@ -220,11 +223,12 @@ where
     }
 }
 
-impl<const TRANSITION: bool, Fal, Chil> RenderHtml
+impl<const TRANSITION: bool, Fal, Chil, Rndr> RenderHtml<Rndr>
     for SuspenseBoundary<TRANSITION, Fal, Chil>
 where
-    Fal: RenderHtml + Send + 'static,
-    Chil: RenderHtml + Send + 'static,
+    Fal: RenderHtml<Rndr> + Send + 'static,
+    Chil: RenderHtml<Rndr> + Send + 'static,
+    Rndr: Renderer + 'static,
 {
     // i.e., if this is the child of another Suspense during SSR, don't wait for it: it will handle
     // itself
@@ -401,7 +405,7 @@ where
 
     fn hydrate<const FROM_SERVER: bool>(
         self,
-        cursor: &Cursor,
+        cursor: &Cursor<Rndr>,
         position: &PositionState,
     ) -> Self::State {
         let cursor = cursor.to_owned();
@@ -451,9 +455,10 @@ impl<T> Unsuspend<T> {
     }
 }
 
-impl<T> Render for Unsuspend<T>
+impl<T, Rndr> Render<Rndr> for Unsuspend<T>
 where
-    T: Render,
+    T: Render<Rndr>,
+    Rndr: Renderer,
 {
     type State = T::State;
 
@@ -466,28 +471,30 @@ where
     }
 }
 
-impl<T> AddAnyAttr for Unsuspend<T>
+impl<T, Rndr> AddAnyAttr<Rndr> for Unsuspend<T>
 where
-    T: AddAnyAttr + 'static,
+    T: AddAnyAttr<Rndr> + 'static,
+    Rndr: Renderer,
 {
-    type Output<SomeNewAttr: Attribute> =
+    type Output<SomeNewAttr: Attribute<Rndr>> =
         Unsuspend<T::Output<SomeNewAttr::CloneableOwned>>;
 
-    fn add_any_attr<NewAttr: Attribute>(
+    fn add_any_attr<NewAttr: Attribute<Rndr>>(
         self,
         attr: NewAttr,
     ) -> Self::Output<NewAttr>
     where
-        Self::Output<NewAttr>: RenderHtml,
+        Self::Output<NewAttr>: RenderHtml<Rndr>,
     {
         let attr = attr.into_cloneable_owned();
         Unsuspend::new(move || (self.0)().add_any_attr(attr))
     }
 }
 
-impl<T> RenderHtml for Unsuspend<T>
+impl<T, Rndr> RenderHtml<Rndr> for Unsuspend<T>
 where
-    T: RenderHtml + 'static,
+    T: RenderHtml<Rndr> + 'static,
+    Rndr: Renderer,
 {
     type AsyncOutput = Self;
 
@@ -528,7 +535,7 @@ where
 
     fn hydrate<const FROM_SERVER: bool>(
         self,
-        cursor: &Cursor,
+        cursor: &Cursor<Rndr>,
         position: &PositionState,
     ) -> Self::State {
         (self.0)().hydrate::<FROM_SERVER>(cursor, position)

leptos/src/view_fn.rs

@@ -0,0 +1,30 @@
+use leptos_dom::{IntoView, View};
+use std::rc::Rc;
+
+/// New-type wrapper for the a function that returns a view with `From` and `Default` traits implemented
+/// to enable optional props in for example `<Show>` and `<Suspense>`.
+#[derive(Clone)]
+pub struct ViewFn(Rc<dyn Fn() -> View>);
+
+impl Default for ViewFn {
+    fn default() -> Self {
+        Self(Rc::new(|| ().into_view()))
+    }
+}
+
+impl<F, IV> From<F> for ViewFn
+where
+    F: Fn() -> IV + 'static,
+    IV: IntoView,
+{
+    fn from(value: F) -> Self {
+        Self(Rc::new(move || value().into_view()))
+    }
+}
+
+impl ViewFn {
+    /// Execute the wrapped function
+    pub fn run(&self) -> View {
+        (self.0)()
+    }
+}

leptos/tests/ssr.rs

@@ -1,13 +1,11 @@
-#[cfg(feature = "ssr")]
 use leptos::html::HtmlElement;
 
-#[cfg(feature = "ssr")]
 #[test]
 fn simple_ssr_test() {
     use leptos::prelude::*;
 
     let (value, set_value) = signal(0);
-    let rendered: View<HtmlElement<_, _, _>> = view! {
+    let rendered: View<HtmlElement<_, _, _, Dom>> = view! {
         <div>
             <button on:click=move |_| set_value.update(|value| *value -= 1)>"-1"</button>
             <span>"Value: " {move || value.get().to_string()} "!"</span>
@@ -22,7 +20,6 @@ fn simple_ssr_test() {
     );
 }
 
-#[cfg(feature = "ssr")]
 #[test]
 fn ssr_test_with_components() {
     use leptos::prelude::*;
@@ -39,7 +36,7 @@ fn ssr_test_with_components() {
         }
     }
 
-    let rendered: View<HtmlElement<_, _, _>> = view! {
+    let rendered: View<HtmlElement<_, _, _, Dom>> = view! {
         <div class="counters">
             <Counter initial_value=1/>
             <Counter initial_value=2/>
@@ -54,7 +51,6 @@ fn ssr_test_with_components() {
     );
 }
 
-#[cfg(feature = "ssr")]
 #[test]
 fn ssr_test_with_snake_case_components() {
     use leptos::prelude::*;
@@ -70,7 +66,7 @@ fn ssr_test_with_snake_case_components() {
             </div>
         }
     }
-    let rendered: View<HtmlElement<_, _, _>> = view! {
+    let rendered: View<HtmlElement<_, _, _, Dom>> = view! {
         <div class="counters">
             <SnakeCaseCounter initial_value=1/>
             <SnakeCaseCounter initial_value=2/>
@@ -85,13 +81,12 @@ fn ssr_test_with_snake_case_components() {
     );
 }
 
-#[cfg(feature = "ssr")]
 #[test]
 fn test_classes() {
     use leptos::prelude::*;
 
     let (value, _set_value) = signal(5);
-    let rendered: View<HtmlElement<_, _, _>> = view! {
+    let rendered: View<HtmlElement<_, _, _, Dom>> = view! {
         <div
             class="my big"
             class:a=move || { value.get() > 10 }
@@ -103,14 +98,13 @@ fn test_classes() {
     assert_eq!(rendered.to_html(), "<div class=\"my big  red car\"></div>");
 }
 
-#[cfg(feature = "ssr")]
 #[test]
 fn ssr_with_styles() {
     use leptos::prelude::*;
 
     let (_, set_value) = signal(0);
     let styles = "myclass";
-    let rendered: View<HtmlElement<_, _, _>> = view! { class=styles,
+    let rendered: View<HtmlElement<_, _, _, Dom>> = view! { class=styles,
         <div>
             <button class="btn" on:click=move |_| set_value.update(|value| *value -= 1)>
                 "-1"
@@ -125,13 +119,12 @@ fn ssr_with_styles() {
     );
 }
 
-#[cfg(feature = "ssr")]
 #[test]
 fn ssr_option() {
     use leptos::prelude::*;
 
     let (_, _) = signal(0);
-    let rendered: View<HtmlElement<_, _, _>> = view! { <option></option> };
+    let rendered: View<HtmlElement<_, _, _, Dom>> = view! { <option></option> };
 
     assert_eq!(rendered.to_html(), "<option></option>");
 }