remove unnecessary Props imports

* tests: add Criterion benchmarking and move reactive benchmarks into `leptos_reactive`
* tests: updated SSR benchmarks

.github/workflows/check-stable.yml

@@ -42,4 +42,4 @@ jobs:
       - uses: Swatinem/rust-cache@v2
 
       - name: Run cargo check on all examples
-        run: cargo make check-stable
+        run: cargo make --profile=github-actions check-stable

.github/workflows/check.yml

@@ -42,4 +42,4 @@ jobs:
       - uses: Swatinem/rust-cache@v2
 
       - name: Run cargo check on all libraries
-        run: cargo make check
+        run: cargo make --profile=github-actions check

.github/workflows/publish-book.yml

@@ -0,0 +1,37 @@
+name: Deploy book
+on:
+  push:
+    paths: ['docs/book/**']
+    branches:
+      - main
+
+jobs:
+  deploy:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write  # To push a branch 
+      pull-requests: write  # To create a PR from that branch
+    steps:
+    - uses: actions/checkout@v3
+      with:
+        fetch-depth: 0
+    - name: Install mdbook
+      run: |
+        mkdir mdbook
+        curl -sSL https://github.com/rust-lang/mdBook/releases/download/v0.4.27/mdbook-v0.4.27-x86_64-unknown-linux-gnu.tar.gz | tar -xz --directory=./mdbook
+        echo `pwd`/mdbook >> $GITHUB_PATH
+    - name: Deploy GitHub Pages
+      run: |
+        cd docs/book
+        mdbook build
+        git worktree add gh-pages
+        git config user.name "Deploy book from CI"
+        git config user.email ""
+        cd gh-pages
+        # Delete the ref to avoid keeping history.
+        git update-ref -d refs/heads/gh-pages
+        rm -rf *
+        mv ../book/* .
+        git add .
+        git commit -m "Deploy book $GITHUB_SHA to gh-pages"
+        git push --force --set-upstream origin gh-pages

.github/workflows/test.yml

@@ -42,4 +42,4 @@ jobs:
       - uses: Swatinem/rust-cache@v2
 
       - name: Run tests with all features
-        run: cargo make test
+        run: cargo make --profile=github-actions test

Cargo.toml

@@ -39,7 +39,7 @@ server_fn_macro = { path = "./server_fn_macro", default-features = false, versio
 server_fn_macro_default = { path = "./server_fn/server_fn_macro_default", default-features = false, version = "0.2.5" }
 leptos_config = { path = "./leptos_config", default-features = false, version = "0.2.5" }
 leptos_router = { path = "./router", version = "0.2.5" }
-leptos_meta = { path = "./meta", default-feature = false, version = "0.2.5" }
+leptos_meta = { path = "./meta", default-features = false, version = "0.2.5" }
 leptos_integration_utils = { path = "./integrations/utils", version = "0.2.5" }
 
 [profile.release]

Makefile.toml

@@ -74,3 +74,9 @@ dependencies = ["test-all"]
 command = "cargo"
 args = ["+nightly", "test-all-features"]
 install_crate = "cargo-all-features"
+
+[env]
+RUSTFLAGS=""
+
+[env.github-actions]
+RUSTFLAGS="-D warnings"

README.md

@@ -24,8 +24,7 @@ pub fn SimpleCounter(cx: Scope, initial_value: i32) -> impl IntoView {
     let increment = move |_| set_value.update(|value| *value += 1);
 
     // create user interfaces with the declarative `view!` macro
-    view! {
-        cx,
+    view! { cx,
         <div>
             <button on:click=clear>"Clear"</button>
             <button on:click=decrement>"-1"</button>
@@ -48,21 +47,21 @@ Leptos is a full-stack, isomorphic Rust web framework leveraging fine-grained re
 
 ## What does that mean?
 
-- **Full-stack**: Leptos can be used to build apps that run in the browser (_client-side rendering_), on the server (_server-side rendering_), or by rendering HTML on the server and then adding interactivity in the browser (_hydration_). This includes support for _HTTP streaming_ of both data (`Resource`s) and HTML (out-of-order streaming of `<Suspense/>` components.)
-- **Isomorphic**: Leptos provides primitives to write isomorphic server functions, i.e., functions that can be called with the “same shape” on the client or server, but only run on the server. This means you can write your server-only logic (database requests, authentication etc.) alongside the client-side components that will consume it, and call server functions as if they were running in the browser.
-- **Web**: Leptos is built on the Web platform and Web standards. The router is designed to use Web fundamentals (like links and forms) and build on top of them rather than trying to replace them.
+- **Full-stack**: Leptos can be used to build apps that run in the browser (client-side rendering), on the server (server-side rendering), or by rendering HTML on the server and then adding interactivity in the browser (server-side rendering with hydration). This includes support for HTTP streaming of both data ([`Resource`s](https://docs.rs/leptos/latest/leptos/struct.Resource.html)) and HTML (out-of-order or in-order streaming of [`<Suspense/>`](https://docs.rs/leptos/latest/leptos/fn.Suspense.html) components.)
+- **Isomorphic**: Leptos provides primitives to write isomorphic [server functions](https://docs.rs/leptos_server/0.2.5/leptos_server/index.html), i.e., functions that can be called with the “same shape” on the client or server, but only run on the server. This means you can write your server-only logic (database requests, authentication etc.) alongside the client-side components that will consume it, and call server functions as if they were running in the browser, without needing to create and maintain a separate REST or other API.
+- **Web**: Leptos is built on the Web platform and Web standards. The [router](https://docs.rs/leptos_router/latest/leptos_router/) is designed to use Web fundamentals (like links and forms) and build on top of them rather than trying to replace them.
 - **Framework**: Leptos provides most of what you need to build a modern web app: a reactive system, templating library, and a router that works on both the server and client side.
-- **Fine-grained reactivity**: The entire framework is built from reactive primitives. This allows for extremely performant code with minimal overhead: when a reactive signal’s value changes, it can update a single text node, toggle a single class, or remove an element from the DOM without any other code running. (_So, no virtual DOM!_)
+- **Fine-grained reactivity**: The entire framework is built from reactive primitives. This allows for extremely performant code with minimal overhead: when a reactive signal’s value changes, it can update a single text node, toggle a single class, or remove an element from the DOM without any other code running. (So, no virtual DOM overhead!)
 - **Declarative**: Tell Leptos how you want the page to look, and let the framework tell the browser how to do it.
 
 ## Learn more
 
 Here are some resources for learning more about Leptos:
 
+- [Book](https://leptos-rs.github.io/leptos/) (work in progress)
 - [Examples](https://github.com/leptos-rs/leptos/tree/main/examples)
 - [API Documentation](https://docs.rs/leptos/latest/leptos/)
 - [Common Bugs](https://github.com/leptos-rs/leptos/tree/main/docs/COMMON_BUGS.md) (and how to fix them!)
-- Leptos Guide (in progress)
 
 ## `nightly` Note
 
@@ -86,7 +85,7 @@ If you’re on `stable`, note the following:
 
 ## `cargo-leptos`
 
-[`cargo-leptos`](https://github.com/leptos-rs/cargo-leptos) is a build tool that's designed to make it easy to build apps that run on both the client and the server, with seamless integration. The best way to get started with a real Leptos project right now is to use `cargo-leptos` and our [starter template](https://github.com/leptos-rs/start).
+[`cargo-leptos`](https://github.com/leptos-rs/cargo-leptos) is a build tool that's designed to make it easy to build apps that run on both the client and the server, with seamless integration. The best way to get started with a real Leptos project right now is to use `cargo-leptos` and our starter templates for [Actix](https://github.com/leptos-rs/start) or [Axum](https://github.com/leptos-rs/start-axum).
 
 ```bash
 cargo install cargo-leptos
@@ -95,13 +94,13 @@ cd [your project name]
 cargo leptos watch
 ```
 
-Open browser on [http://localhost:3000/](http://localhost:3000/)
+Open browser to [http://localhost:3000/](http://localhost:3000/).
 
 ## FAQs
 
 ### What’s up with the name?
 
-*Leptos* (λεπτός) is an ancient Greek word meaning “thin, light, refine, fine-grained.” To me, a classicist and not a dog owner, it evokes the lightweight reactive system that powers the framework. I've since learned the same word is at the root of the medical term “leptospirosis,” a blood infection that affects humans and animals... My bad. No dogs were harmed in the creation of this framework.
+_Leptos_ (λεπτός) is an ancient Greek word meaning “thin, light, refine, fine-grained.” To me, a classicist and not a dog owner, it evokes the lightweight reactive system that powers the framework. I've since learned the same word is at the root of the medical term “leptospirosis,” a blood infection that affects humans and animals... My bad. No dogs were harmed in the creation of this framework.
 
 ### Is it production ready?
 
@@ -109,7 +108,7 @@ People usually mean one of three things by this question.
 
 1. **Are the APIs stable?** i.e., will I have to rewrite my whole app from Leptos 0.1 to 0.2 to 0.3 to 0.4, or can I write it now and benefit from new features and updates as new versions come?
 
-With 0.1 the APIs are basically settled. We’re adding new features, but we’re very happy with where the type system and patterns have landed. I would not expect major breaking changes to your code to adapt to, for example, a 0.2.0 release.
+The APIs are basically settled. We’re adding new features, but we’re very happy with where the type system and patterns have landed. I would not expect major breaking changes to your code to adapt to future releases. The sorts of breaking changes that we discuss are things like “Oh yeah, that function should probably take `cx` as its argument...” not major changes to the way you write your application.
 
 2. **Are there bugs?**
 
@@ -119,7 +118,7 @@ Yes, I’m sure there are. You can see from the state of our issue tracker over
 
 This may be the big one: “production ready” implies a certain orientation to a library: that you can basically use it, without any special knowledge of its internals or ability to contribute. Everyone has this at some level in their stack: for example I (@gbj) don’t have the capacity or knowledge to contribute to something like `wasm-bindgen` at this point: I simply rely on it to work.
 
-There are several people in this community using Leptos right now for internal apps at work, who have also become significant contributors. I think this is the right level of production use for now. There may be missing features that you need, and you may end up building them! But for internal apps, if you’re willing to build and contribute missing pieces along the way, the framework is definitely usable right now.
+There are several people in the community using Leptos right now for internal apps at work, who have also become significant contributors. I think this is the right level of production use for now. There may be missing features that you need, and you may end up building them! But for internal apps, if you’re willing to build and contribute missing pieces along the way, the framework is definitely usable right now.
 
 ### Can I use this for native GUI?
 
@@ -137,8 +136,8 @@ I've put together a [very simple GTK example](https://github.com/leptos-rs/lepto
 On the surface level, these libraries may seem similar. Yew is, of course, the most mature Rust library for web UI development and has a huge ecosystem. Dioxus is similar in many ways, being heavily inspired by React. Here are some conceptual differences between Leptos and these frameworks:
 
 - **VDOM vs. fine-grained:** Yew is built on the virtual DOM (VDOM) model: state changes cause components to re-render, generating a new virtual DOM tree. Yew diffs this against the previous VDOM, and applies those patches to the actual DOM. Component functions rerun whenever state changes. Leptos takes an entirely different approach. Components run once, creating (and returning) actual DOM nodes and setting up a reactive system to update those DOM nodes.
-- **Performance:** This has huge performance implications: Leptos is simply _much_ faster at both creating and updating the UI than Yew is.
-- **Mental model:** Adopting fine-grained reactivity also tends to simplify the mental model. There are no surprising component re-renders because there are no re-renders. Your app can be divided into components based on what makes sense for your app, because they have no performance implications.
+- **Performance:** This has huge performance implications: Leptos is simply much faster at both creating and updating the UI than Yew is. (Dioxus has made huge advances in performance with its recent 0.3 release, and is now roughly on par with Leptos.)
+- **Mental model:** Adopting fine-grained reactivity also tends to simplify the mental model. There are no surprising component re-renders because there are no re-renders. You can call functions, create timeouts, etc. within the body of your component functions because they won’t be re-run. You don’t need to think about manual dependency tracking for effects; fine-grained reactivity tracks dependencies automatically.
 
 ### How is this different from Sycamore?
 
@@ -146,9 +145,9 @@ Conceptually, these two frameworks are very similar: because both are built on f
 
 There are some practical differences that make a significant difference:
 
-- **Maturity:** Sycamore is obviously a much more mature and stable library with a larger ecosystem.
 - **Templating:** Leptos uses a JSX-like template format (built on [syn-rsx](https://github.com/stoically/syn-rsx)) for its `view` macro. Sycamore offers the choice of its own templating DSL or a builder syntax.
-- **Read-write segregation:** Leptos, like Solid, encourages read-write segregation between signal getters and setters, so you end up accessing signals with tuples like `let (count, set_count) = create_signal(cx, 0);` _(If you prefer or if it's more convenient for your API, you can use `create_rw_signal` to give a unified read/write signal.)_
+- **Server integration:** Leptos provides primitives that encourage HTML streaming and allow for easy async integration and RPC calls, even without WASM enabled, making it easy to opt into integrations between your frontend and backend code without pushing you toward any particular metaframework patterns.
+- **Read-write segregation:** Leptos, like Solid, encourages read-write segregation between signal getters and setters, so you end up accessing signals with tuples like `let (count, set_count) = create_signal(cx, 0);` _(If you prefer or if it's more convenient for your API, you can use [`create_rw_signal`](https://docs.rs/leptos/latest/leptos/fn.create_rw_signal.html) to give a unified read/write signal.)_
 - **Signals are functions:** In Leptos, you can call a signal to access it rather than calling a specific method (so, `count()` instead of `count.get()`) This creates a more consistent mental model: accessing a reactive value is always a matter of calling a function. For example:
 
   ```rust

benchmarks/Cargo.toml

@@ -17,15 +17,11 @@ lazy_static = "1"
 log = "0.4"
 strum = "0.24"
 strum_macros = "0.24"
-serde = { version = "1", features = ["derive", "rc"]}
+serde = { version = "1", features = ["derive", "rc"] }
 serde_json = "1"
 tera = "1"
+reactive-signals = "0.1.0-alpha.4"
 
 [dependencies.web-sys]
 version = "0.3"
-features = [
-	"Window",
-	"Document",
-	"HtmlElement",
-	"HtmlInputElement"
-]
+features = ["Window", "Document", "HtmlElement", "HtmlInputElement"]

benchmarks/src/lib.rs

@@ -2,6 +2,6 @@
 
 extern crate test;
 
-mod reactive;
+//åmod reactive;
 //mod ssr;
-//mod todomvc;
+mod todomvc;

benchmarks/src/reactive.rs

@@ -162,6 +162,77 @@ fn leptos_scope_creation_and_disposal(b: &mut Bencher) {
     runtime.dispose();
 }
 
+#[bench]
+fn rs_deep_update(b: &mut Bencher) {
+    use reactive_signals::{Scope, Signal, signal, runtimes::ClientRuntime, types::Func};
+
+    let sc = ClientRuntime::new_root_scope();
+    b.iter(|| {
+        let signal = signal!(sc, 0);
+        let mut memos = Vec::<Signal<Func<i32>, ClientRuntime>>::new();
+        for i in 0..1000usize {
+            let prev = memos.get(i.saturating_sub(1)).copied();
+            if let Some(prev) = prev {
+                memos.push(signal!(sc, move || prev.get() + 1))
+            } else {
+                memos.push(signal!(sc, move || signal.get() + 1))
+            }
+        }
+        signal.set(1);
+        assert_eq!(memos[999].get(), 1001);
+    });
+}
+
+#[bench]
+fn rs_fanning_out(b: &mut Bencher) {
+    use reactive_signals::{Scope, Signal, signal, runtimes::ClientRuntime, types::Func};
+    let cx = ClientRuntime::new_root_scope();
+
+    b.iter(|| {
+        let sig = signal!(cx, 0);
+        let memos = (0..1000)
+            .map(|_| signal!(cx, move || sig.get()))
+            .collect::<Vec<_>>();
+        assert_eq!(memos.iter().map(|m| m.get()).sum::<i32>(), 0);
+        sig.set(1);
+        assert_eq!(memos.iter().map(|m| m.get()).sum::<i32>(), 1000);
+    });
+}
+
+#[bench]
+fn rs_narrowing_update(b: &mut Bencher) {
+    use reactive_signals::{Scope, Signal, signal, runtimes::ClientRuntime, types::Func};
+    let cx = ClientRuntime::new_root_scope();
+
+    b.iter(|| {
+        let acc = Rc::new(Cell::new(0));
+        let sigs =
+            (0..1000).map(|n| signal!(cx, n)).collect::<Vec<_>>();
+        let memo = signal!(cx, {
+            let sigs = sigs.clone();
+            move || {
+                sigs.iter().map(|r| r.get()).sum::<i32>()
+            }
+        });
+        assert_eq!(memo.get(), 499500);
+        signal!(cx, {
+            let acc = Rc::clone(&acc);
+            move || {
+                acc.set(memo.get());
+            }
+        });
+
+        assert_eq!(acc.get(), 499500);
+
+        sigs[1].update(|n| *n += 1);
+        sigs[10].update(|n| *n += 1);
+        sigs[100].update(|n| *n += 1);
+
+        assert_eq!(acc.get(), 499503);
+        assert_eq!(memo.get(), 499503);
+    });
+}
+
 #[bench]
 fn l021_deep_creation(b: &mut Bencher) {
     use l021::*;

benchmarks/src/ssr.rs

@@ -4,7 +4,7 @@ use test::Bencher;
 fn leptos_ssr_bench(b: &mut Bencher) {
     b.iter(|| {
 		use leptos::*;
-		HydrationCtx::reset_id();
+		leptos_dom::HydrationCtx::reset_id();
 		_ = create_scope(create_runtime(), |cx| {
 			#[component]
 			fn Counter(cx: Scope, initial: i32) -> impl IntoView {
@@ -32,7 +32,8 @@ fn leptos_ssr_bench(b: &mut Bencher) {
 
 			assert_eq!(
 				rendered,
-				"<main id=\"_0-1\"><h1 id=\"_0-2\">Welcome to our benchmark page.</h1><p id=\"_0-3\">Here's some introductory text.</p><div id=\"_0-3-1\"><button id=\"_0-3-2\">-1</button><span id=\"_0-3-3\">Value: <!>1<!--hk=_0-3-4-->!</span><button id=\"_0-3-5\">+1</button></div><!--hk=_0-3-0--><div id=\"_0-3-5-1\"><button id=\"_0-3-5-2\">-1</button><span id=\"_0-3-5-3\">Value: <!>2<!--hk=_0-3-5-4-->!</span><button id=\"_0-3-5-5\">+1</button></div><!--hk=_0-3-5-0--><div id=\"_0-3-5-5-1\"><button id=\"_0-3-5-5-2\">-1</button><span id=\"_0-3-5-5-3\">Value: <!>3<!--hk=_0-3-5-5-4-->!</span><button id=\"_0-3-5-5-5\">+1</button></div><!--hk=_0-3-5-5-0--></main>"			);
+				"<main id=\"_0-1\"><h1 id=\"_0-2\">Welcome to our benchmark page.</h1><p id=\"_0-3\">Here&#x27;s some introductory text.</p><div id=\"_0-3-1\"><button id=\"_0-3-2\">-1</button><span id=\"_0-3-3\">Value: <!>1<!--hk=_0-3-4-->!</span><button id=\"_0-3-5\">+1</button></div><!--hk=_0-3-0--><div id=\"_0-3-5-1\"><button id=\"_0-3-5-2\">-1</button><span id=\"_0-3-5-3\">Value: <!>2<!--hk=_0-3-5-4-->!</span><button id=\"_0-3-5-5\">+1</button></div><!--hk=_0-3-5-0--><div id=\"_0-3-5-5-1\"><button id=\"_0-3-5-5-2\">-1</button><span id=\"_0-3-5-5-3\">Value: <!>3<!--hk=_0-3-5-5-4-->!</span><button id=\"_0-3-5-5-5\">+1</button></div><!--hk=_0-3-5-5-0--></main>"
+			);
 		});
 	});
 }

benchmarks/src/todomvc/leptos.rs

@@ -1,6 +1,7 @@
 pub use leptos::*;
 use miniserde::*;
 use web_sys::HtmlInputElement;
+use wasm_bindgen::JsCast;
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Todos(pub Vec<Todo>);
@@ -110,10 +111,6 @@ pub fn TodoMVC(cx: Scope, todos: Todos) -> impl IntoView {
     provide_context(cx, set_todos);
 
     let (mode, set_mode) = create_signal(cx, Mode::All);
-    window_event_listener("hashchange", move |_| {
-        let new_mode = location_hash().map(|hash| route(&hash)).unwrap_or_default();
-        set_mode(new_mode);
-    });
 
     let add_todo = move |ev: web_sys::KeyboardEvent| {
         let target = event_target::<HtmlInputElement>(&ev);
@@ -167,57 +164,79 @@ pub fn TodoMVC(cx: Scope, todos: Todos) -> impl IntoView {
     });
 
     view! { cx,
-      <main>
-          <section class="todoapp">
-              <header class="header">
-                  <h1>"todos"</h1>
-                  <input class="new-todo" placeholder="What needs to be done?" autofocus="" on:keydown=add_todo />
-              </header>
-              <section class="main" class:hidden={move || todos.with(|t| t.is_empty())}>
-                  <input id="toggle-all" class="toggle-all" type="checkbox"
-                      prop:checked={move || todos.with(|t| t.remaining() > 0)}
-                      on:input=move |_| set_todos.update(|t| t.toggle_all())
-                  />
-                  <label for="toggle-all">"Mark all as complete"</label>
-                  <ul class="todo-list">
-                      <For
-                        each=filtered_todos
-                        key=|todo| todo.id
-                        view=move |todo: Todo| view! { cx,  <Todo todo=todo.clone() /> }
-                      />
-                  </ul>
-              </section>
-              <footer class="footer" class:hidden={move || todos.with(|t| t.is_empty())}>
-                  <span class="todo-count">
-                      <strong>{move || todos.with(|t| t.remaining().to_string())}</strong>
-                      {move || if todos.with(|t| t.remaining()) == 1 {
-                          " item"
-                      } else {
-                          " items"
-                      }}
-                      " left"
-                  </span>
-                  <ul class="filters">
-                      <li><a href="#/" class="selected" class:selected={move || mode() == Mode::All}>"All"</a></li>
-                      <li><a href="#/active" class:selected={move || mode() == Mode::Active}>"Active"</a></li>
-                      <li><a href="#/completed" class:selected={move || mode() == Mode::Completed}>"Completed"</a></li>
-                  </ul>
-                  <button
-                      class="clear-completed hidden"
-                      class:hidden={move || todos.with(|t| t.completed() == 0)}
-                      on:click=move |_| set_todos.update(|t| t.clear_completed())
-                  >
-                      "Clear completed"
-                  </button>
-              </footer>
-          </section>
-          <footer class="info">
-              <p>"Double-click to edit a todo"</p>
-              <p>"Created by "<a href="http://todomvc.com">"Greg Johnston"</a></p>
-              <p>"Part of "<a href="http://todomvc.com">"TodoMVC"</a></p>
-          </footer>
-      </main>
-  }.into_view(cx)
+        <main>
+            <section class="todoapp">
+                <header class="header">
+                    <h1>"todos"</h1>
+                    <input
+                        class="new-todo"
+                        placeholder="What needs to be done?"
+                        autofocus=""
+                        on:keydown=add_todo
+                    />
+                </header>
+                <section class="main" class:hidden=move || todos.with(|t| t.is_empty())>
+                    <input
+                        id="toggle-all"
+                        class="toggle-all"
+                        type="checkbox"
+                        prop:checked=move || todos.with(|t| t.remaining() > 0)
+                        on:input=move |_| set_todos.update(|t| t.toggle_all())
+                    />
+                    <label for="toggle-all">"Mark all as complete"</label>
+                    <ul class="todo-list">
+                        <For
+                            each=filtered_todos
+                            key=|todo| todo.id
+                            view=move |cx, todo: Todo| {
+                                view! { cx, <Todo todo=todo.clone()/> }
+                            }
+                        />
+                    </ul>
+                </section>
+                <footer class="footer" class:hidden=move || todos.with(|t| t.is_empty())>
+                    <span class="todo-count">
+                        <strong>{move || todos.with(|t| t.remaining().to_string())}</strong>
+                        {move || if todos.with(|t| t.remaining()) == 1 { " item" } else { " items" }}
+                        " left"
+                    </span>
+                    <ul class="filters">
+                        <li>
+                            <a
+                                href="#/"
+                                class="selected"
+                                class:selected=move || mode() == Mode::All
+                            >
+                                "All"
+                            </a>
+                        </li>
+                        <li>
+                            <a href="#/active" class:selected=move || mode() == Mode::Active>
+                                "Active"
+                            </a>
+                        </li>
+                        <li>
+                            <a href="#/completed" class:selected=move || mode() == Mode::Completed>
+                                "Completed"
+                            </a>
+                        </li>
+                    </ul>
+                    <button
+                        class="clear-completed hidden"
+                        class:hidden=move || todos.with(|t| t.completed() == 0)
+                        on:click=move |_| set_todos.update(|t| t.clear_completed())
+                    >
+                        "Clear completed"
+                    </button>
+                </footer>
+            </section>
+            <footer class="info">
+                <p>"Double-click to edit a todo"</p>
+                <p>"Created by " <a href="http://todomvc.com">"Greg Johnston"</a></p>
+                <p>"Part of " <a href="http://todomvc.com">"TodoMVC"</a></p>
+            </footer>
+        </main>
+    }.into_view(cx)
 }
 
 #[component]
@@ -237,41 +256,36 @@ pub fn Todo(cx: Scope, todo: Todo) -> impl IntoView {
     };
 
     view! { cx,
-        <li
-            class="todo"
-            class:editing={editing}
-            class:completed={move || (todo.completed)()}
-            //_ref=input
-        >
+        <li class="todo" class:editing=editing class:completed=move || (todo.completed)()>
             <div class="view">
-                <input
-                    class="toggle"
-                    type="checkbox"
-                    prop:checked={move || (todo.completed)()}
-
-                />
-                <label on:dblclick=move |_| set_editing(true)>
-                    {move || todo.title.get()}
-                </label>
-                <button class="destroy" on:click=move |_| set_todos.update(|t| t.remove(todo.id))/>
+                <input class="toggle" type="checkbox" prop:checked=move || (todo.completed)()/>
+                <label on:dblclick=move |_| set_editing(true)>{move || todo.title.get()}</label>
+                <button
+                    class="destroy"
+                    on:click=move |_| set_todos.update(|t| t.remove(todo.id))
+                ></button>
             </div>
-            {move || editing().then(|| view! { cx,
-                <input
-                    class="edit"
-                    class:hidden={move || !(editing)()}
-                    prop:value={move || todo.title.get()}
-                    on:focusout=move |ev| save(&event_target_value(&ev))
-                    on:keyup={move |ev| {
-                        let key_code = ev.unchecked_ref::<web_sys::KeyboardEvent>().key_code();
-                        if key_code == ENTER_KEY {
-                            save(&event_target_value(&ev));
-                        } else if key_code == ESCAPE_KEY {
-                            set_editing(false);
+            {move || {
+                editing()
+                    .then(|| {
+                        view! { cx,
+                            <input
+                                class="edit"
+                                class:hidden=move || !(editing)()
+                                prop:value=move || todo.title.get()
+                                on:focusout=move |ev| save(&event_target_value(&ev))
+                                on:keyup=move |ev| {
+                                    let key_code = ev.unchecked_ref::<web_sys::KeyboardEvent>().key_code();
+                                    if key_code == ENTER_KEY {
+                                        save(&event_target_value(&ev));
+                                    } else if key_code == ESCAPE_KEY {
+                                        set_editing(false);
+                                    }
+                                }
+                            />
                         }
-                    }}
-                />
-            })
-        }
+                    })
+            }}
         </li>
     }
 }

benchmarks/src/todomvc/mod.rs

@@ -7,19 +7,15 @@ mod yew;
 
 #[bench]
 fn leptos_todomvc_ssr(b: &mut Bencher) {
+    use ::leptos::*;
+    let runtime = create_runtime();
     b.iter(|| {
         use crate::todomvc::leptos::*;
 
-        _ = create_scope(create_runtime(), |cx| {
-            let rendered = view! {
-                cx,
-                <TodoMVC todos=Todos::new(cx)/>
-            }
-            .into_view(cx)
-            .render_to_string(cx);
-
-            assert!(rendered.len() > 1);
+        let html = ::leptos::ssr::render_to_string(|cx| {
+            view! { cx, <TodoMVC todos=Todos::new(cx)/> }
         });
+        assert!(html.len() > 1);
     });
 }
 
@@ -57,21 +53,20 @@ fn yew_todomvc_ssr(b: &mut Bencher) {
         });
     });
 }
-/*
+
 #[bench]
 fn leptos_todomvc_ssr_with_1000(b: &mut Bencher) {
     b.iter(|| {
         use self::leptos::*;
         use ::leptos::*;
 
-        _ = create_scope(create_runtime(), |cx| {
-            let rendered = view! {
+        let html = ::leptos::ssr::render_to_string(|cx| {
+            view! {
                 cx,
                 <TodoMVC todos=Todos::new_with_1000(cx)/>
-            }.into_view(cx).render_to_string(cx);
-
-            assert!(rendered.len() > 1);
+            }
         });
+        assert!(html.len() > 1);
     });
 }
 
@@ -108,5 +103,4 @@ fn yew_todomvc_ssr_with_1000(b: &mut Bencher) {
             assert!(rendered.len() > 1);
         });
     });
-}
- */
+}

benchmarks/src/todomvc/tera.rs

@@ -174,4 +174,4 @@ fn tera_todomvc_1000(b: &mut Bencher) {
 
         let _ = TERA.render("template.html", &ctx).unwrap();
     });
-}
+}

docs/book/src/14_create_effect.md

@@ -107,4 +107,6 @@ create_effect(cx, move |prev_value| {
 
 Every time `count` is updated, this effect wil rerun. This is what allows reactive, fine-grained updates to the DOM.
 
-<iframe src="https://codesandbox.io/p/sandbox/serene-thompson-40974n?file=%2Fsrc%2Fmain.rs&selection=%5B%7B%22endColumn%22%3A1%2C%22endLineNumber%22%3A2%2C%22startColumn%22%3A1%2C%22startLineNumber%22%3A2%7D%5D" width="100%" height="1000px"></iframe>
+[Click to open CodeSandbox.](https://codesandbox.io/p/sandbox/serene-thompson-40974n?file=%2Fsrc%2Fmain.rs&selection=%5B%7B%22endColumn%22%3A1%2C%22endLineNumber%22%3A2%2C%22startColumn%22%3A1%2C%22startLineNumber%22%3A2%7D%5D)
+
+<iframe src="https://codesandbox.io/p/sandbox/serene-thompson-40974n?file=%2Fsrc%2Fmain.rs&selection=%5B%7B%22endColumn%22%3A1%2C%22endLineNumber%22%3A2%2C%22startColumn%22%3A1%2C%22startLineNumber%22%3A2%7D%5D" width="100%" height="1000px" style="max-height: 100vh"></iframe>

docs/book/src/15_global_state.md

@@ -169,4 +169,6 @@ somewhere else that only takes `state.name`, clicking the button won’t cause
 that other slice to update. This allows you to combine the benefits of a top-down
 data flow and of fine-grained reactive updates.
 
-<iframe src="https://codesandbox.io/p/sandbox/1-basic-component-forked-8bte19?selection=%5B%7B%22endColumn%22%3A1%2C%22endLineNumber%22%3A2%2C%22startColumn%22%3A1%2C%22startLineNumber%22%3A2%7D%5D&file=%2Fsrc%2Fmain.rs" width="100%" height="1000px">
+[Click to open CodeSandbox.](https://codesandbox.io/p/sandbox/1-basic-component-forked-8bte19?selection=%5B%7B%22endColumn%22%3A1%2C%22endLineNumber%22%3A2%2C%22startColumn%22%3A1%2C%22startLineNumber%22%3A2%7D%5D&file=%2Fsrc%2Fmain.rs)
+
+<iframe src="https://codesandbox.io/p/sandbox/1-basic-component-forked-8bte19?selection=%5B%7B%22endColumn%22%3A1%2C%22endLineNumber%22%3A2%2C%22startColumn%22%3A1%2C%22startLineNumber%22%3A2%7D%5D&file=%2Fsrc%2Fmain.rs" width="100%" height="1000px" style="max-height: 100vh">

docs/book/src/SUMMARY.md

@@ -26,7 +26,7 @@
   - [Nested Routing](./router/17_nested_routing.md)
   - [Params and Queries](./router/18_params_and_queries.md)
   - [`<A/>`](./router/19_a.md)
-  - [`<Form/>`]()
+  - [`<Form/>`](./router/20_form.md)
 - [Interlude: Styling — CSS, Tailwind, Style.rs, and more]()
 - [Metadata]()
 - [SSR]()

docs/book/src/async/10_resources.md

@@ -50,4 +50,6 @@ view! { cx,
 
 Resources also provide a `refetch()` method that allows you to manually reload the data (for example, in response to a button click) and a `loading()` method that returns a `ReadSignal<bool>` indicating whether the resource is currently loading or not.
 
-<iframe src="https://codesandbox.io/p/sandbox/10-async-resources-4z0qt3?file=%2Fsrc%2Fmain.rs&selection=%5B%7B%22endColumn%22%3A1%2C%22endLineNumber%22%3A3%2C%22startColumn%22%3A1%2C%22startLineNumber%22%3A3%7D%5D" width="100%" height="1000px"></iframe>
+[Click to open CodeSandbox.](https://codesandbox.io/p/sandbox/10-async-resources-4z0qt3?file=%2Fsrc%2Fmain.rs&selection=%5B%7B%22endColumn%22%3A1%2C%22endLineNumber%22%3A3%2C%22startColumn%22%3A1%2C%22startLineNumber%22%3A3%7D%5D)
+
+<iframe src="https://codesandbox.io/p/sandbox/10-async-resources-4z0qt3?file=%2Fsrc%2Fmain.rs&selection=%5B%7B%22endColumn%22%3A1%2C%22endLineNumber%22%3A3%2C%22startColumn%22%3A1%2C%22startLineNumber%22%3A3%7D%5D" width="100%" height="1000px" style="max-height: 100vh"></iframe>

docs/book/src/async/11_suspense.md

@@ -69,4 +69,6 @@ Every time one of the resources is reloading, the `"Loading..."` fallback will s
 
 This inversion of the flow of control makes it easier to add or remove individual resources, as you don’t need to handle the matching yourself. It also unlocks some massive performance improvements during server-side rendering, which we’ll talk about during a later chapter.
 
-<iframe src="https://codesandbox.io/p/sandbox/11-suspense-907niv?file=%2Fsrc%2Fmain.rs" width="100%" height="1000px"></iframe>
+[Click to open CodeSandbox.](https://codesandbox.io/p/sandbox/11-suspense-907niv?file=%2Fsrc%2Fmain.rs)
+
+<iframe src="https://codesandbox.io/p/sandbox/11-suspense-907niv?file=%2Fsrc%2Fmain.rs" width="100%" height="1000px" style="max-height: 100vh"></iframe>

docs/book/src/async/12_transition.md

@@ -6,4 +6,6 @@ You’ll notice in the `<Suspense/>` example that if you keep reloading the data
 
 This example shows how you can create a simple tabbed contact list with `<Transition/>`. When you select a new tab, it continues showing the current contact until the new data loads. This can be a much better user experience than constantly falling back to a loading message.
 
-<iframe src="https://codesandbox.io/p/sandbox/12-transition-sn38sd?selection=%5B%7B%22endColumn%22%3A15%2C%22endLineNumber%22%3A2%2C%22startColumn%22%3A15%2C%22startLineNumber%22%3A2%7D%5D&file=%2Fsrc%2Fmain.rs" width="100%" height="1000px"></iframe>
+[Click to open CodeSandbox.](https://codesandbox.io/p/sandbox/12-transition-sn38sd?selection=%5B%7B%22endColumn%22%3A15%2C%22endLineNumber%22%3A2%2C%22startColumn%22%3A15%2C%22startLineNumber%22%3A2%7D%5D&file=%2Fsrc%2Fmain.rs)
+
+<iframe src="https://codesandbox.io/p/sandbox/12-transition-sn38sd?selection=%5B%7B%22endColumn%22%3A15%2C%22endLineNumber%22%3A2%2C%22startColumn%22%3A15%2C%22startLineNumber%22%3A2%7D%5D&file=%2Fsrc%2Fmain.rs" width="100%" height="1000px" style="max-height: 100vh"></iframe>

docs/book/src/async/13_actions.md

@@ -91,4 +91,6 @@ view! { cx,
 
 Now, there’s a chance this all seems a little over-complicated, or maybe too restricted. I wanted to include actions here, alongside resources, as the missing piece of the puzzle. In a real Leptos app, you’ll actually most often use actions alongside server functions, [`create_server_action`](https://docs.rs/leptos/latest/leptos/fn.create_server_action.html), and the [`<ActionForm/>`](https://docs.rs/leptos_router/latest/leptos_router/fn.ActionForm.html) component to create really powerful progressively-enhanced forms. So if this primitive seems useless to you... Don’t worry! Maybe it will make sense later. (Or check out our [`todo_app_sqlite`](https://github.com/leptos-rs/leptos/blob/main/examples/todo_app_sqlite/src/todo.rs) example now.)
 
-<iframe src="https://codesandbox.io/p/sandbox/10-async-resources-forked-hgpfp0?selection=%5B%7B%22endColumn%22%3A1%2C%22endLineNumber%22%3A4%2C%22startColumn%22%3A1%2C%22startLineNumber%22%3A4%7D%5D&file=%2Fsrc%2Fmain.rs" width="100%" height="1000px"></iframe>
+[Click to open CodeSandbox.](https://codesandbox.io/p/sandbox/10-async-resources-forked-hgpfp0?selection=%5B%7B%22endColumn%22%3A1%2C%22endLineNumber%22%3A4%2C%22startColumn%22%3A1%2C%22startLineNumber%22%3A4%7D%5D&file=%2Fsrc%2Fmain.rs)
+
+<iframe src="https://codesandbox.io/p/sandbox/10-async-resources-forked-hgpfp0?selection=%5B%7B%22endColumn%22%3A1%2C%22endLineNumber%22%3A4%2C%22startColumn%22%3A1%2C%22startLineNumber%22%3A4%7D%5D&file=%2Fsrc%2Fmain.rs" width="100%" height="1000px" style="max-height: 100vh"></iframe>

docs/book/src/router/17_nested_routing.md

@@ -167,4 +167,6 @@ In fact, in this case, we don’t even need to rerender the `<Contact/>` compone
 
 > This sandbox includes a couple features (like nested routing) discussed in this section and the previous one, and a couple we’ll cover in the rest of this chapter. The router is such an integrated system that it makes sense to provide a single example, so don’t be surprised if there’s anything you don’t understand.
 
-<iframe src="https://codesandbox.io/p/sandbox/16-router-fy4tjv?file=%2Fsrc%2Fmain.rs&selection=%5B%7B%22endColumn%22%3A1%2C%22endLineNumber%22%3A3%2C%22startColumn%22%3A1%2C%22startLineNumber%22%3A3%7D%5D" width="100%" height="1000px"></iframe>
+[Click to open CodeSandbox.](https://codesandbox.io/p/sandbox/16-router-fy4tjv?file=%2Fsrc%2Fmain.rs&selection=%5B%7B%22endColumn%22%3A1%2C%22endLineNumber%22%3A3%2C%22startColumn%22%3A1%2C%22startLineNumber%22%3A3%7D%5D)
+
+<iframe src="https://codesandbox.io/p/sandbox/16-router-fy4tjv?file=%2Fsrc%2Fmain.rs&selection=%5B%7B%22endColumn%22%3A1%2C%22endLineNumber%22%3A3%2C%22startColumn%22%3A1%2C%22startLineNumber%22%3A3%7D%5D" width="100%" height="1000px" style="max-height: 100vh"></iframe>

docs/book/src/router/18_params_and_queries.md

@@ -74,4 +74,6 @@ This can get a little messy: deriving a signal that wraps an `Option<_>` or `Res
 
 > This is the same example from the previous section. The router is such an integrated system that it makes sense to provide a single example highlighting multiple features, even if we haven’t explain them all yet.
 
-<iframe src="https://codesandbox.io/p/sandbox/16-router-fy4tjv?file=%2Fsrc%2Fmain.rs&selection=%5B%7B%22endColumn%22%3A1%2C%22endLineNumber%22%3A3%2C%22startColumn%22%3A1%2C%22startLineNumber%22%3A3%7D%5D" width="100%" height="1000px"></iframe>
+[Click to open CodeSandbox.](https://codesandbox.io/p/sandbox/16-router-fy4tjv?file=%2Fsrc%2Fmain.rs&selection=%5B%7B%22endColumn%22%3A1%2C%22endLineNumber%22%3A3%2C%22startColumn%22%3A1%2C%22startLineNumber%22%3A3%7D%5D)
+
+<iframe src="https://codesandbox.io/p/sandbox/16-router-fy4tjv?file=%2Fsrc%2Fmain.rs&selection=%5B%7B%22endColumn%22%3A1%2C%22endLineNumber%22%3A3%2C%22startColumn%22%3A1%2C%22startLineNumber%22%3A3%7D%5D" width="100%" height="1000px" style="max-height: 100vh"></iframe>

docs/book/src/router/19_a.md

@@ -18,4 +18,6 @@ The router also provides an [`<A>`](https://docs.rs/leptos_router/latest/leptos_
 
 > Once again, this is the same example. Check out the relative `<A/>` components, and take a look at the CSS in `index.html` to see the ARIA-based styling.
 
-<iframe src="https://codesandbox.io/p/sandbox/16-router-fy4tjv?file=%2Fsrc%2Fmain.rs&selection=%5B%7B%22endColumn%22%3A1%2C%22endLineNumber%22%3A3%2C%22startColumn%22%3A1%2C%22startLineNumber%22%3A3%7D%5D" width="100%" height="1000px"></iframe>
+[Click to open CodeSandbox.](https://codesandbox.io/p/sandbox/16-router-fy4tjv?file=%2Fsrc%2Fmain.rs&selection=%5B%7B%22endColumn%22%3A1%2C%22endLineNumber%22%3A3%2C%22startColumn%22%3A1%2C%22startLineNumber%22%3A3%7D%5D)
+
+<iframe src="https://codesandbox.io/p/sandbox/16-router-fy4tjv?file=%2Fsrc%2Fmain.rs&selection=%5B%7B%22endColumn%22%3A1%2C%22endLineNumber%22%3A3%2C%22startColumn%22%3A1%2C%22startLineNumber%22%3A3%7D%5D" width="100%" height="1000px" style="max-height: 100vh"></iframe>

docs/book/src/router/20_form.md

@@ -0,0 +1,69 @@
+# The `<Form/>` Component
+
+Links and forms sometimes seem completely unrelated. But in fact, they work in very similar ways.
+
+In plain HTML, there are three ways to navigate to another page:
+
+1. An `<a>` element that links to another page. Navigates to the URL in its `href` attribute with the `GET` HTTP method.
+2. A `<form method="GET">`. Navigates to the URL in its `action` attribute with the `GET` HTTP method and the form data from its inputs encoded in the URL query string.
+3. A `<form method="POST">`. Navigates to the URL in its `action` attribute with the `POST` HTTP method and the form data from its inputs encoded in the body of the request.
+
+Since we have a client-side router, we can do client-side link navigations without reloading the page, i.e., without a full round-trip to the server and back. It makes sense that we can do client-side form navigations in the same way.
+
+The router provides a [`<Form>`](https://docs.rs/leptos_router/latest/leptos_router/fn.Form.html) component, which works like the HTML `<form>` element, but uses client-side navigations instead of full page reloads. `<Form/>` works with both `GET` and `POST` requests. With `method="GET"`, it will navigate to the URL encoded in the form data. With `method="POST"` it will make a `POST` request and handle the server’s response.
+
+`<Form/>` provides the basis for some components like `<ActionForm/>` and `<MultiActionForm/>` that we’ll see in later chapters. But it also enables some powerful patterns of its own.
+
+For example, imagine that you want to create a search field that updates search results in real time as the user searches, without a page reload, but that also stores the search in the URL so a user can copy and paste it to share results with someone else.
+
+It turns out that the patterns we’ve learned so far make this easy to implement.
+
+```rust
+async fn fetch_results() {
+	// some async function to fetch our search results
+}
+
+#[component]
+pub fn Search(cx: Scope) -> impl IntoView {
+#[component]
+pub fn FormExample(cx: Scope) -> impl IntoView {
+    // reactive access to URL query strings
+    let query = use_query_map(cx);
+	// search stored as ?q=
+    let search = move || query().get("q").cloned().unwrap_or_default();
+	// a resource driven by the search string
+	let search_results = create_resource(cx, search, fetch_results);
+
+	view! { cx,
+		<Form method="GET" action="">
+			<input type="search" name="search" value=search/>
+			<input type="submit"/>
+		</Form>
+		<Transition fallback=move || ()>
+			/* render search results */
+		</Transition>
+	}
+}
+```
+
+Whenever you click `Submit`, the `<Form/>` will “navigate” to `?q={search}`. But because this navigation is done on the client side, there’s no page flicker or reload. The URL query string changes, which triggers `search` to update. Because `search` is the source signal for the `search_results` resource, this triggers `search_results` to reload its resource. The `<Transition/>` continues displaying the current search results until the new ones have loaded. When they are complete, it switches to displaying the new result.
+
+This is a great pattern. The data flow is extremely clear: all data flows from the URL to the resource into the UI. The current state of the application is stored in the URL, which means you can refresh the page or text the link to a friend and it will show exactly what you’re expecting. And once we introduce server rendering, this pattern will prove to be really fault-tolerant, too: because it uses a `<form>` element and URLs under the hood, it actually works really well without even loading your WASM on the client.
+
+We can actually take it a step further and do something kind of clever:
+
+```rust
+view! { cx,
+	<Form method="GET" action="">
+		<input type="search" name="search" value=search
+			oninput="this.form.requestSubmit()"
+		/>
+	</Form>
+}
+```
+
+You’ll notice that this version drops the `Submit` button. Instead, we add an `oninput` attribute to the input. Note that this is _not_ `on:input`, which would listen for the `input` event and run some Rust code. Without the colon, `oninput` is the plain HTML attribute. So the string is actually a JavaScript string. `this.form` gives us the form the input is attached to. `requestSubmit()` fires the `submit` event on the `<form>`, which is caught by `<Form/>` just as if we had clicked a `Submit` button. Now the form will “navigate” on every keystroke or input to keep the URL (and therefore the search) perfectly in sync with the user’s input as they type.
+
+[Click to open CodeSandbox.](https://codesandbox.io/p/sandbox/16-router-forked-hrrt3h?file=%2Fsrc%2Fmain.rs)
+
+<iframe src="https://codesandbox.io/p/sandbox/16-router-forked-hrrt3h?file=%2Fsrc%2Fmain.rs" width="100%" height="1000px" style="max-height: 100vh"></iframe>

docs/book/src/view/01_basic_component.md

@@ -1,14 +1,14 @@
 # A Basic Component
 
-That “Hello, world!” was a *very* simple example. Let’s move on to something a
+That “Hello, world!” was a _very_ simple example. Let’s move on to something a
 little more like an ordinary app.
 
 First, let’s edit the `main` function so that, instead of rendering the whole
 app, it just renders an `<App/>` component. Components are the basic unit of
-composition and design in most web frameworks, and Leptos is no exception. 
-Conceptually, they are similar to HTML elements: they represent a section of the 
-DOM, with self-contained, defined behavior. Unlike HTML elements, they are in 
-`PascalCase`, so most Leptos applications will start with something like an 
+composition and design in most web frameworks, and Leptos is no exception.
+Conceptually, they are similar to HTML elements: they represent a section of the
+DOM, with self-contained, defined behavior. Unlike HTML elements, they are in
+`PascalCase`, so most Leptos applications will start with something like an
 `<App/>` component.
 
 ```rust
@@ -39,11 +39,12 @@ fn App(cx: Scope) -> impl IntoView {
 ```
 
 ## The Component Signature
+
 ```rust
 #[component]
 ```
 
-Like all component definitions, this begins with the [`#[component]`](https://docs.rs/leptos/latest/leptos/attr.component.html) macro. `#[component]` annotates a function so it can be 
+Like all component definitions, this begins with the [`#[component]`](https://docs.rs/leptos/latest/leptos/attr.component.html) macro. `#[component]` annotates a function so it can be
 used as a component in your Leptos application. We’ll see some of the other features of
 this macro in a couple chapters.
 
@@ -52,6 +53,7 @@ fn App(cx: Scope) -> impl IntoView
 ```
 
 Every component is a function with the following characteristics
+
 1. It takes a reactive [`Scope`](https://docs.rs/leptos/latest/leptos/struct.Scope.html)
    as its first argument. This `Scope` is our entrypoint into the reactive system.
    By convention, it’s usually named `cx`.
@@ -60,7 +62,8 @@ Every component is a function with the following characteristics
    anything you could return from a Leptos `view`.
 
 ## The Component Body
-The body of the component function is a set-up function that runs once, not a 
+
+The body of the component function is a set-up function that runs once, not a
 render function that reruns multiple times. You’ll typically use it to create a
 few reactive variables, define any side effects that run in response to those values
 changing, and describe the user interface.
@@ -68,16 +71,17 @@ changing, and describe the user interface.
 ```rust
 let (count, set_count) = create_signal(cx, 0);
 ```
+
 [`create_signal`](https://docs.rs/leptos/latest/leptos/fn.create_signal.html)
 creates a signal, the basic unit of reactive change and state management in Leptos.
-This returns a `(getter, setter)` tuple. To access the current value, you’ll 
-use `count.get()` (or, on `nightly` Rust, the shorthand `count()`). To set the 
+This returns a `(getter, setter)` tuple. To access the current value, you’ll
+use `count.get()` (or, on `nightly` Rust, the shorthand `count()`). To set the
 current value, you’ll call `set_count.set(...)` (or `set_count(...)`).
 
-> `.get()` clones the value and `.set()` overwrites it. In many cases, it’s more 
-efficient to use `.with()` or `.update()`; check out the docs for [`ReadSignal`](https://docs.rs/leptos/latest/leptos/struct.ReadSignal.html) and [`WriteSignal`](https://docs.rs/leptos/latest/leptos/struct.WriteSignal.html) if you’d like to learn more about those trade-offs at this point.
+> `.get()` clones the value and `.set()` overwrites it. In many cases, it’s more
+> efficient to use `.with()` or `.update()`; check out the docs for [`ReadSignal`](https://docs.rs/leptos/latest/leptos/struct.ReadSignal.html) and [`WriteSignal`](https://docs.rs/leptos/latest/leptos/struct.WriteSignal.html) if you’d like to learn more about those trade-offs at this point.
 
-## The View 
+## The View
 
 Leptos defines user interfaces using a JSX-like format via the [`view`](https://docs.rs/leptos/latest/leptos/macro.view.html) macro.
 
@@ -100,25 +104,28 @@ view! { cx,
 This should mostly be easy to understand: it looks like HTML, with a special
 `on:click` to define a `click` event listener, a text node that’s formatted like
 a Rust string, and then...
+
 ```rust
 {move || count.get()}
 ```
+
 whatever that is.
 
-People sometimes joke that they use more closures in their first Leptos application 
-than they’ve ever used in their lives. And fair enough. Basically, passing a function 
+People sometimes joke that they use more closures in their first Leptos application
+than they’ve ever used in their lives. And fair enough. Basically, passing a function
 into the view tells the framework: “Hey, this is something that might change.”
 
-When we click the button and call `set_count`, the `count` signal is updated. This 
-`move || count.get()` closure, whose value depends on the value of `count`, reruns, 
-and the framework makes a targeted update to that one specific text node, touching 
+When we click the button and call `set_count`, the `count` signal is updated. This
+`move || count.get()` closure, whose value depends on the value of `count`, reruns,
+and the framework makes a targeted update to that one specific text node, touching
 nothing else in your application. This is what allows for extremely efficient updates
 to the DOM.
 
 Now, if you have Clippy on—or if you have a particularly sharp eye—you might notice
-that this closure is redundant, at least if you’re in `nightly` Rust. If you’re using 
+that this closure is redundant, at least if you’re in `nightly` Rust. If you’re using
 Leptos with `nightly` Rust, signals are already functions, so the closure is unnecessary.
-As a result, you can write a simpler view: 
+As a result, you can write a simpler view:
+
 ```rust
 view! { cx,
     <button /* ... */>
@@ -129,15 +136,17 @@ view! { cx,
 }
 ```
 
-Remember—and this is *very important*—only functions are reactive. This means that 
-`{count}` and `{count()}` do very different things in your view. `{count}` passes 
+Remember—and this is _very important_—only functions are reactive. This means that
+`{count}` and `{count()}` do very different things in your view. `{count}` passes
 in a function, telling the framework to update the view every time `count` changes.
-`{count()}` access the value of `count` once, and passes an `i32` into the view, 
+`{count()}` access the value of `count` once, and passes an `i32` into the view,
 rendering it once, unreactively. You can see the difference in the CodeSandbox below!
 
-> Throughout this tutorial, we’ll use CodeSandbox to show interactive examples. To 
-show the browser in the sandbox, you may need to click `Add DevTools >
-Other Previews > 8080.` Hover over any of the variables to show Rust-Analyzer details 
-and docs for what’s going on. Feel free to fork the examples to play with them yourself!
+> Throughout this tutorial, we’ll use CodeSandbox to show interactive examples. To
+> show the browser in the sandbox, you may need to click `Add DevTools >
+Other Previews > 8080.` Hover over any of the variables to show Rust-Analyzer details
+> and docs for what’s going on. Feel free to fork the examples to play with them yourself!
 
-<iframe src="https://codesandbox.io/p/sandbox/1-basic-component-3d74p3?file=%2Fsrc%2Fmain.rs&selection=%5B%7B%22endColumn%22%3A31%2C%22endLineNumber%22%3A19%2C%22startColumn%22%3A31%2C%22startLineNumber%22%3A19%7D%5D" width="100%" height="1000px"></iframe>
+[Click to open CodeSandbox.](https://codesandbox.io/p/sandbox/1-basic-component-3d74p3?file=%2Fsrc%2Fmain.rs&selection=%5B%7B%22endColumn%22%3A31%2C%22endLineNumber%22%3A19%2C%22startColumn%22%3A31%2C%22startLineNumber%22%3A19%7D%5D)
+
+<iframe src="https://codesandbox.io/p/sandbox/1-basic-component-3d74p3?file=%2Fsrc%2Fmain.rs&selection=%5B%7B%22endColumn%22%3A31%2C%22endLineNumber%22%3A19%2C%22startColumn%22%3A31%2C%22startLineNumber%22%3A19%7D%5D" width="100%" height="1000px" style="max-height: 100vh"></iframe>

docs/book/src/view/02_dynamic_attributes.md

@@ -1,13 +1,13 @@
 # `view`: Dynamic Attributes and Classes
 
-So far we’ve seen how to use the `view` macro to create event listeners and to 
+So far we’ve seen how to use the `view` macro to create event listeners and to
 create dynamic text by passing a function (such as a signal) into the view.
 
 But of course there are other things you might want to update in your user interface.
-In this section, we’ll look at how to update attributes and classes dynamically, 
+In this section, we’ll look at how to update attributes and classes dynamically,
 and we’ll introduce the concept of a **derived signal**.
 
-Let’s start with a simple component that should be familiar: click a button to 
+Let’s start with a simple component that should be familiar: click a button to
 increment a counter.
 
 ```rust
@@ -34,27 +34,31 @@ So far, this is just the example from the last chapter.
 
 Now let’s say I’d like to update the list of CSS classes on this element dynamically.
 For example, let’s say I want to add the class `red` when the count is odd. I can
-do this using the `class:` syntax. 
+do this using the `class:` syntax.
+
 ```rust
 class:red=move || count() % 2 == 1
 ```
+
 `class:` attributes take
+
 1. the class name, following the colon (`red`)
 2. a value, which can be a `bool` or a function that returns a `bool`
 
 When the value is `true`, the class is added. When the value is `false`, the class
-is removed. And if the value is a function that accesses a signal, the class will 
+is removed. And if the value is a function that accesses a signal, the class will
 reactively update when the signal changes.
 
-Now every time I click the button, the text should toggle between red and black as 
+Now every time I click the button, the text should toggle between red and black as
 the number switches between even and odd.
 
 ## Dynamic Attributes
 
 The same applies to plain attributes. Passing a plain string or primitive value to
 an attribute gives it a static value. Passing a function (including a signal) to
-an attribute causes it to update its value reactively. Let’s add another element 
+an attribute causes it to update its value reactively. Let’s add another element
 to our view:
+
 ```rust
 <progress
     max="50"
@@ -63,17 +67,18 @@ to our view:
 />
 ```
 
-Now every time we set the count, not only will the `class` of the `<button>` be 
-toggled, but the `value` of the `<progress>` bar will increase, which means that 
+Now every time we set the count, not only will the `class` of the `<button>` be
+toggled, but the `value` of the `<progress>` bar will increase, which means that
 our progress bar will move forward.
 
-## Derived Signals 
+## Derived Signals
 
 Let’s go one layer deeper, just for fun.
 
-You already know that we create reactive interfaces just by passing functions into 
+You already know that we create reactive interfaces just by passing functions into
 the `view`. This means that we can easily change our progress bar. For example,
 suppose we want it to move twice as fast:
+
 ```rust
 <progress
     max="50"
@@ -83,28 +88,31 @@ suppose we want it to move twice as fast:
 
 But imagine we want to reuse that calculation in more than one place. You can do this
 using a **derived signal**: a closure that accesses a signal.
+
 ```rust
 let double_count = move || count() * 2;
 
-/* insert the rest of the view */ 
+/* insert the rest of the view */
 <progress
     max="50"
     // we use it once here
     value=double_count
 />
 <p>
-    "Double Count: " 
+    "Double Count: "
     // and again here
     {double_count}
 </p>
 ```
 
-Derived signals let you create reactive computed values that can be used in multiple 
+Derived signals let you create reactive computed values that can be used in multiple
 places in your application with minimal overhead.
 
-> Note: Using a derived signal like this means that the calculation runs once per 
-signal change per place we access `double_count`; in other words, twice. This is a
-very cheap calculation, so that’s fine. We’ll look at memos in a later chapter, which 
-are designed to solve this problem for expensive calculations.
+> Note: Using a derived signal like this means that the calculation runs once per
+> signal change per place we access `double_count`; in other words, twice. This is a
+> very cheap calculation, so that’s fine. We’ll look at memos in a later chapter, which
+> are designed to solve this problem for expensive calculations.
 
-<iframe src="https://codesandbox.io/p/sandbox/2-dynamic-attribute-pqyvzl?file=%2Fsrc%2Fmain.rs&selection=%5B%7B%22endColumn%22%3A1%2C%22endLineNumber%22%3A2%2C%22startColumn%22%3A1%2C%22startLineNumber%22%3A2%7D%5D" width="100%" height="1000px"></iframe>
+[Click to open CodeSandbox.](https://codesandbox.io/p/sandbox/2-dynamic-attribute-pqyvzl?file=%2Fsrc%2Fmain.rs&selection=%5B%7B%22endColumn%22%3A1%2C%22endLineNumber%22%3A2%2C%22startColumn%22%3A1%2C%22startLineNumber%22%3A2%7D%5D)
+
+<iframe src="https://codesandbox.io/p/sandbox/2-dynamic-attribute-pqyvzl?file=%2Fsrc%2Fmain.rs&selection=%5B%7B%22endColumn%22%3A1%2C%22endLineNumber%22%3A2%2C%22startColumn%22%3A1%2C%22startLineNumber%22%3A2%7D%5D" width="100%" height="1000px" style="max-height: 100vh"></iframe>

docs/book/src/view/03_components.md

@@ -1,11 +1,11 @@
 # Components and Props
 
-So far, we’ve been building our whole application in a single component. This 
-is fine for really tiny examples, but in any real application you’ll need to 
-break the user interface out into multiple components, so you can break your 
+So far, we’ve been building our whole application in a single component. This
+is fine for really tiny examples, but in any real application you’ll need to
+break the user interface out into multiple components, so you can break your
 interface down into smaller, reusable, composable chunks.
 
-Let’s take our progress bar example. Imagine that you want two progress bars 
+Let’s take our progress bar example. Imagine that you want two progress bars
 instead of one: one that advances one tick per click, one that advances two ticks
 per click.
 
@@ -15,7 +15,7 @@ You _could_ do this by just creating two `<progress>` elements:
 let (count, set_count) = create_signal(cx, 0);
 let double_count = move || count() * 2;
 
-view! { 
+view! {
     <progress
         max="50"
         value=count
@@ -28,7 +28,7 @@ view! {
 ```
 
 But of course, this doesn’t scale very well. If you want to add a third progress
-bar, you need to add this code another time. And if you want to edit anything 
+bar, you need to add this code another time. And if you want to edit anything
 about it, you need to edit it in triplicate.
 
 Instead, let’s create a `<ProgressBar/>` component.
@@ -48,15 +48,15 @@ fn ProgressBar(
 }
 ```
 
-There’s just one problem: `progress` is not defined. Where should it come from? 
-When we were defining everything manually, we just used the local variable names. 
+There’s just one problem: `progress` is not defined. Where should it come from?
+When we were defining everything manually, we just used the local variable names.
 Now we need some way to pass an argument into the component.
 
-## Component Props 
+## Component Props
 
 We do this using component properties, or “props.” If you’ve used another frontend
-framework, this is probably a familiar idea. Basically, properties are to components 
-as attributes are to HTML elements: they let you pass additional information into 
+framework, this is probably a familiar idea. Basically, properties are to components
+as attributes are to HTML elements: they let you pass additional information into
 the component.
 
 In Leptos, you define props by giving additional arguments to the component function.
@@ -70,7 +70,7 @@ fn ProgressBar(
     view! { cx,
         <progress
             max="50"
-            // now this works 
+            // now this works
             value=progress
         />
     }
@@ -93,41 +93,45 @@ fn App(cx: Scope) -> impl IntoView {
 }
 ```
 
-Using a component in the view looks a lot like using an HTML element. You’ll 
-notice that you can easily tell the difference between an element and a component 
-because components always have `PascalCase` names. You pass the `progress` prop 
+Using a component in the view looks a lot like using an HTML element. You’ll
+notice that you can easily tell the difference between an element and a component
+because components always have `PascalCase` names. You pass the `progress` prop
 in as if it were an HTML element attribute. Simple.
 
-> ### Important Note 
-> For every `Component`, Leptos generates a corresponding `ComponentProps` type. This 
-is what allows us to have named props, when Rust does not have named function parameters.
-If you’re defining a component in one module and importing it into another, make 
-sure you include this `ComponentProps` type:
+> ### Important Note
+>
+> For every `Component`, Leptos generates a corresponding `ComponentProps` type. This
+> is what allows us to have named props, when Rust does not have named function parameters.
+> If you’re defining a component in one module and importing it into another, make
+> sure you include this `ComponentProps` type:
 >
 > `use progress_bar::{ProgressBar, ProgressBarProps};`
+>
+> **Note**: This is still true as of `0.2.5`, but the requirement has been removed on `main`
+> and will not apply to later versions.
 
 ### Reactive and Static Props
 
-You’ll notice that throughout this example, `progress` takes a reactive 
+You’ll notice that throughout this example, `progress` takes a reactive
 `ReadSignal<i32>`, and not a plain `i32`. This is **very important**.
 
-Component props have no special meaning attached to them. A component is simply 
-a function that runs once to set up the user interface. The only way to tell the 
-interface to respond to changing is to pass it a signal type. So if you have a 
-component property that will change over time, like our `progress`, it should 
+Component props have no special meaning attached to them. A component is simply
+a function that runs once to set up the user interface. The only way to tell the
+interface to respond to changing is to pass it a signal type. So if you have a
+component property that will change over time, like our `progress`, it should
 be a signal.
 
-### `optional` Props 
+### `optional` Props
 
-Right now the `max` setting is hard-coded. Let’s take that as a prop too. But 
-let’s add a catch: let’s make this prop optional by annotating the particular 
+Right now the `max` setting is hard-coded. Let’s take that as a prop too. But
+let’s add a catch: let’s make this prop optional by annotating the particular
 argument to the component function with `#[prop(optional)]`.
 
 ```rust
 #[component]
 fn ProgressBar(
     cx: Scope,
-    // mark this prop optional 
+    // mark this prop optional
     // you can specify it or not when you use <ProgressBar/>
     #[prop(optional)]
     max: u16,
@@ -143,7 +147,7 @@ fn ProgressBar(
 ```
 
 Now, we can use `<ProgressBar max=50 value=count/>`, or we can omit `max`
-to use the default value (i.e., `<ProgressBar value=count/>`). The default value 
+to use the default value (i.e., `<ProgressBar value=count/>`). The default value
 on an `optional` is its `Default::default()` value, which for a `u16` is going to
 be `0`. In the case of a progress bar, a max value of `0` is not very useful.
 
@@ -188,20 +192,20 @@ fn App(cx: Scope) -> impl IntoView {
             "Click me"
         </button>
         <ProgressBar progress=count/>
-        // add a second progress bar 
+        // add a second progress bar
         <ProgressBar progress=double_count/>
     }
 }
 ```
 
 Hm... this won’t compile. It should be pretty easy to understand why: we’ve declared
-that the `progress` prop takes `ReadSignal<i32>`, and `double_count` is not 
-`ReadSignal<i32>`. As rust-analyzer will tell you, its type is `|| -> i32`, i.e., 
+that the `progress` prop takes `ReadSignal<i32>`, and `double_count` is not
+`ReadSignal<i32>`. As rust-analyzer will tell you, its type is `|| -> i32`, i.e.,
 it’s a closure that returns an `i32`.
 
-There are a couple ways to handle this. One would be to say: “Well, I know that 
-a `ReadSignal` is a function, and I know that a closure is a function; maybe I 
-could just take any function?” If you’re savvy, you may know that both these 
+There are a couple ways to handle this. One would be to say: “Well, I know that
+a `ReadSignal` is a function, and I know that a closure is a function; maybe I
+could just take any function?” If you’re savvy, you may know that both these
 implement the trait `Fn() -> i32`. So you could use a generic component:
 
 ```rust
@@ -211,8 +215,8 @@ fn ProgressBar<F>(
     #[prop(default = 100)]
     max: u16,
     progress: F
-) -> impl IntoView 
-where 
+) -> impl IntoView
+where
     F: Fn() -> i32 + 'static,
 {
     view! { cx,
@@ -224,27 +228,26 @@ where
 }
 ```
 
-This is a perfectly reasonable way to write this component: `progress` now takes 
+This is a perfectly reasonable way to write this component: `progress` now takes
 any value that implements this `Fn()` trait.
 
 > Note that generic component props _cannot_ be specified inline (as `<F: Fn() -> i32>`)
-or as `progress: impl Fn() -> i32 + 'static,`, in part because they’re actually used to generate 
-a `struct ProgressBarProps`, and struct fields cannot be `impl` types.
+> or as `progress: impl Fn() -> i32 + 'static,`, in part because they’re actually used to generate
+> a `struct ProgressBarProps`, and struct fields cannot be `impl` types.
 
-### `into` Props 
+### `into` Props
 
-There’s one more way we could implement this, and it would be to use `#[prop(into)]`. 
+There’s one more way we could implement this, and it would be to use `#[prop(into)]`.
 This attribute automatically calls `.into()` on the values you pass as props,
 which allows you to easily pass props with different values.
 
-In this case, it’s helpful to know about the 
+In this case, it’s helpful to know about the
 [`Signal`](https://docs.rs/leptos/latest/leptos/struct.Signal.html) type. `Signal`
-is an enumerated type that represents any kind of readable reactive signal. It can 
-be useful when defining APIs for components you’ll want to reuse while passing 
-different sorts of signals. The [`MaybeSignal`](https://docs.rs/leptos/latest/leptos/enum.MaybeSignal.html) type is useful when you want to be able to take either a static or 
+is an enumerated type that represents any kind of readable reactive signal. It can
+be useful when defining APIs for components you’ll want to reuse while passing
+different sorts of signals. The [`MaybeSignal`](https://docs.rs/leptos/latest/leptos/enum.MaybeSignal.html) type is useful when you want to be able to take either a static or
 reactive value.
 
-
 ```rust
 #[component]
 fn ProgressBar(
@@ -253,7 +256,7 @@ fn ProgressBar(
     max: u16,
     #[prop(into)]
     progress: Signal<i32>
-) -> impl IntoView 
+) -> impl IntoView
 {
     view! { cx,
         <progress
@@ -282,12 +285,12 @@ fn App(cx: Scope) -> impl IntoView {
 
 ## Documenting Components
 
-This is one of the least essential but most important sections of this book. 
-It’s not strictly necessary to document your components and their props. It may 
-be very important, depending on the size of your team and your app. But it’s very 
+This is one of the least essential but most important sections of this book.
+It’s not strictly necessary to document your components and their props. It may
+be very important, depending on the size of your team and your app. But it’s very
 easy, and bears immediate fruit.
 
-To document a component and its props, you can simply add doc comments on the 
+To document a component and its props, you can simply add doc comments on the
 component function, and each one of the props:
 
 ```rust
@@ -310,9 +313,11 @@ That’s all you need to do. These behave like ordinary Rust doc comments, excep
 that you can document individual component props, which can’t be done with Rust
 function arguments.
 
-This will automatically generate documentation for your component, its `Props` 
-type, and each of the fields used to add props. It can be a little hard to 
-understand how powerful this is until you hover over the component name or props 
+This will automatically generate documentation for your component, its `Props`
+type, and each of the fields used to add props. It can be a little hard to
+understand how powerful this is until you hover over the component name or props
 and see the power of the `#[component]` macro combined with rust-analyzer here.
 
-<iframe src="https://codesandbox.io/p/sandbox/3-components-50t2e7?file=%2Fsrc%2Fmain.rs&selection=%5B%7B%22endColumn%22%3A1%2C%22endLineNumber%22%3A7%2C%22startColumn%22%3A1%2C%22startLineNumber%22%3A7%7D%5D" width="100%" height="1000px"></iframe>
+[Click to open CodeSandbox.](https://codesandbox.io/p/sandbox/3-components-50t2e7?file=%2Fsrc%2Fmain.rs&selection=%5B%7B%22endColumn%22%3A1%2C%22endLineNumber%22%3A7%2C%22startColumn%22%3A1%2C%22startLineNumber%22%3A7%7D%5D)
+
+<iframe src="https://codesandbox.io/p/sandbox/3-components-50t2e7?file=%2Fsrc%2Fmain.rs&selection=%5B%7B%22endColumn%22%3A1%2C%22endLineNumber%22%3A7%2C%22startColumn%22%3A1%2C%22startLineNumber%22%3A7%7D%5D" width="100%" height="1000px" style="max-height: 100vh"></iframe>

docs/book/src/view/04_iteration.md

@@ -1,18 +1,19 @@
 # Iteration
 
-Whether you’re listing todos, displaying a table, or showing product images, 
+Whether you’re listing todos, displaying a table, or showing product images,
 iterating over a list of items is a common task in web applications. Reconciling
 the differences between changing sets of items can also be one of the trickiest
 tasks for a framework to handle well.
 
 Leptos supports to two different patterns for iterating over items:
+
 1. For static views: `Vec<_>`
 2. For dynamic lists: `<For/>`
 
 ## Static Views with `Vec<_>`
 
-Sometimes you need to show an item repeatedly, but the list you’re drawing from 
-does not often change. In this case, it’s important to know that you can insert 
+Sometimes you need to show an item repeatedly, but the list you’re drawing from
+does not often change. In this case, it’s important to know that you can insert
 any `Vec<IV> where IV: IntoView` into your view. In other words, if you can render
 `T`, you can render `Vec<T>`.
 
@@ -58,31 +59,34 @@ view! { cx,
 }
 ```
 
-You _can_ render a `Fn() -> Vec<_>` reactively as well. But note that every time 
+You _can_ render a `Fn() -> Vec<_>` reactively as well. But note that every time
 it changes, this will rerender every item in the list. This is quite inefficient!
 Fortunately, there’s a better way.
 
 ## Dynamic Rendering with the `<For/>` Component
 
-The [`<For/>`](https://docs.rs/leptos/latest/leptos/fn.For.html) component is a 
+The [`<For/>`](https://docs.rs/leptos/latest/leptos/fn.For.html) component is a
 keyed dynamic list. It takes three props:
+
 - `each`: a function (such as a signal) that returns the items `T` to be iterated over
 - `key`: a key function that takes `&T` and returns a stable, unique key or ID
-- `view`: renders each `T` into a view 
+- `view`: renders each `T` into a view
 
 `key` is, well, the key. You can add, remove, and move items within the list. As
 long as each item’s key is stable over time, the framework does not need to rerender
 any of the items, unless they are new additions, and it can very efficiently add,
-remove, and move items as they change. This allows for extremely efficient updates 
+remove, and move items as they change. This allows for extremely efficient updates
 to the list as it changes, with minimal additional work.
 
-Creating a good `key` can be a little tricky. You generally do _not_ want to use 
-an index for this purpose, as it is not stable—if you remove or move items, their 
+Creating a good `key` can be a little tricky. You generally do _not_ want to use
+an index for this purpose, as it is not stable—if you remove or move items, their
 indices change.
 
-But it’s a great idea to do something like generating a unique ID for each row as 
+But it’s a great idea to do something like generating a unique ID for each row as
 it is generated, and using that as an ID for the key function.
 
 Check out the `<DynamicList/>` component below for an example.
 
-<iframe src="https://codesandbox.io/p/sandbox/4-iteration-sglt1o?file=%2Fsrc%2Fmain.rs&selection=%5B%7B%22endColumn%22%3A6%2C%22endLineNumber%22%3A55%2C%22startColumn%22%3A5%2C%22startLineNumber%22%3A31%7D%5D" width="100%" height="1000px"></iframe>
+[Click to open CodeSandbox.](https://codesandbox.io/p/sandbox/4-iteration-sglt1o?file=%2Fsrc%2Fmain.rs&selection=%5B%7B%22endColumn%22%3A6%2C%22endLineNumber%22%3A55%2C%22startColumn%22%3A5%2C%22startLineNumber%22%3A31%7D%5D)
+
+<iframe src="https://codesandbox.io/p/sandbox/4-iteration-sglt1o?file=%2Fsrc%2Fmain.rs&selection=%5B%7B%22endColumn%22%3A6%2C%22endLineNumber%22%3A55%2C%22startColumn%22%3A5%2C%22startLineNumber%22%3A31%7D%5D" width="100%" height="1000px" style="max-height: 100vh"></iframe>

docs/book/src/view/05_forms.md

@@ -1,23 +1,24 @@
 # Forms and Inputs
 
-Forms and form inputs are an important part of interactive apps. There are two 
+Forms and form inputs are an important part of interactive apps. There are two
 basic patterns for interacting with inputs in Leptos, which you may recognize
 if you’re familiar with React, SolidJS, or a similar framework: using **controlled**
 or **uncontrolled** inputs.
 
 ## Controlled Inputs
 
-In a "controlled input," the framework controls the state of the input 
-element. On every `input` event, it updates a local signal that holds the current 
+In a "controlled input," the framework controls the state of the input
+element. On every `input` event, it updates a local signal that holds the current
 state, which in turn updates the `value` prop of the input.
 
 There are two important things to remember:
-1. The `input` event fires on (almost) every change to the element, while the 
-   `change` event fires (more or less) when you unfocus the input. You probably 
+
+1. The `input` event fires on (almost) every change to the element, while the
+   `change` event fires (more or less) when you unfocus the input. You probably
    want `on:input`, but we give you the freedom to choose.
-2. The `value` *attribute* only sets the initial value of the input, i.e., it 
-   only updates the input up to the point that you begin typing. The `value` 
-   *property* continues updating the input after that. You usually want to set 
+2. The `value` _attribute_ only sets the initial value of the input, i.e., it
+   only updates the input up to the point that you begin typing. The `value`
+   _property_ continues updating the input after that. You usually want to set
    `prop:value` for this reason.
 
 ```rust
@@ -41,14 +42,14 @@ view! { cx,
 }
 ```
 
-## Uncontrolled Inputs 
+## Uncontrolled Inputs
 
-In an "uncontrolled input," the browser controls the state of the input element. 
-Rather than continuously updating a signal to hold its value, we use a 
-[`NodeRef`](https://docs.rs/leptos/latest/leptos/struct.NodeRef.html) to access 
+In an "uncontrolled input," the browser controls the state of the input element.
+Rather than continuously updating a signal to hold its value, we use a
+[`NodeRef`](https://docs.rs/leptos/latest/leptos/struct.NodeRef.html) to access
 the input once when we want to get its value.
 
-In this example, we only notify the framework when the `<form>` fires a `submit` 
+In this example, we only notify the framework when the `<form>` fires a `submit`
 event.
 
 ```rust
@@ -56,7 +57,8 @@ let (name, set_name) = create_signal(cx, "Uncontrolled".to_string());
 
 let input_element: NodeRef<Input> = create_node_ref(cx);
 ```
-`NodeRef` is a kind of reactive smart pointer: we can use it to access the 
+
+`NodeRef` is a kind of reactive smart pointer: we can use it to access the
 underlying DOM node. Its value will be set when the element is rendered.
 
 ```rust
@@ -76,13 +78,14 @@ let on_submit = move |ev: SubmitEvent| {
     set_name(value);
 };
 ```
+
 Our `on_submit` handler will access the input’s value and use it to call `set_name`.
 To access the DOM node stored in the `NodeRef`, we can simply call it as a function
-(or using `.get()`). This will return `Option<web_sys::HtmlInputElement>`, but we 
-know it will already have been filled when we rendered the view, so it’s safe to 
+(or using `.get()`). This will return `Option<web_sys::HtmlInputElement>`, but we
+know it will already have been filled when we rendered the view, so it’s safe to
 unwrap here.
 
-We can then call `.value()` to get the value out of the input, because `NodeRef` 
+We can then call `.value()` to get the value out of the input, because `NodeRef`
 gives us access to a correctly-typed HTML element.
 
 ```rust
@@ -97,11 +100,15 @@ view! { cx,
     <p>"Name is: " {name}</p>
 }
 ```
+
 The view should be pretty self-explanatory by now. Note two things:
+
 1. Unlike in the controlled input example, we use `value` (not `prop:value`).
-   This is because we’re just setting the initial value of the input, and letting 
+   This is because we’re just setting the initial value of the input, and letting
    the browser control its state. (We could use `prop:value` instead.)
 2. We use `node_ref` to fill the `NodeRef`. (Older examples sometimes use `_ref`.
    They are the same thing, but `node_ref` has better rust-analyzer support.)
 
-<iframe src="https://codesandbox.io/p/sandbox/5-form-inputs-ih9m62?file=%2Fsrc%2Fmain.rs&selection=%5B%7B%22endColumn%22%3A1%2C%22endLineNumber%22%3A12%2C%22startColumn%22%3A1%2C%22startLineNumber%22%3A12%7D%5D" width="100%" height="1000px"></iframe>
+[Click to open CodeSandbox.](https://codesandbox.io/p/sandbox/5-form-inputs-ih9m62?file=%2Fsrc%2Fmain.rs&selection=%5B%7B%22endColumn%22%3A1%2C%22endLineNumber%22%3A12%2C%22startColumn%22%3A1%2C%22startLineNumber%22%3A12%7D%5D)
+
+<iframe src="https://codesandbox.io/p/sandbox/5-form-inputs-ih9m62?file=%2Fsrc%2Fmain.rs&selection=%5B%7B%22endColumn%22%3A1%2C%22endLineNumber%22%3A12%2C%22startColumn%22%3A1%2C%22startLineNumber%22%3A12%7D%5D" width="100%" height="1000px" style="max-height: 100vh"></iframe>

docs/book/src/view/06_control_flow.md

@@ -282,4 +282,6 @@ view! { cx,
 }
 ```
 
-<iframe src="https://codesandbox.io/p/sandbox/6-control-flow-in-view-zttwfx?file=%2Fsrc%2Fmain.rs&selection=%5B%7B%22endColumn%22%3A1%2C%22endLineNumber%22%3A2%2C%22startColumn%22%3A1%2C%22startLineNumber%22%3A2%7D%5D" width="100%" height="1000px"></iframe>
+[Click to open CodeSandbox.](https://codesandbox.io/p/sandbox/6-control-flow-in-view-zttwfx?file=%2Fsrc%2Fmain.rs&selection=%5B%7B%22endColumn%22%3A1%2C%22endLineNumber%22%3A2%2C%22startColumn%22%3A1%2C%22startLineNumber%22%3A2%7D%5D)
+
+<iframe src="https://codesandbox.io/p/sandbox/6-control-flow-in-view-zttwfx?file=%2Fsrc%2Fmain.rs&selection=%5B%7B%22endColumn%22%3A1%2C%22endLineNumber%22%3A2%2C%22startColumn%22%3A1%2C%22startLineNumber%22%3A2%7D%5D" width="100%" height="1000px" style="max-height: 100vh"></iframe>

docs/book/src/view/07_errors.md

@@ -110,4 +110,6 @@ Not a number! Errors:
 If you fix the error, the error message will disappear and the content you’re wrapping in
 an `<ErrorBoundary/>` will appear again.
 
-<iframe src="https://codesandbox.io/p/sandbox/7-error-handling-and-error-boundaries-sroncx?file=%2Fsrc%2Fmain.rs&selection=%5B%7B%22endColumn%22%3A1%2C%22endLineNumber%22%3A2%2C%22startColumn%22%3A1%2C%22startLineNumber%22%3A2%7D%5D" width="100%" height="1000px"></iframe>
+[Click to open CodeSandbox.](https://codesandbox.io/p/sandbox/7-error-handling-and-error-boundaries-sroncx?file=%2Fsrc%2Fmain.rs&selection=%5B%7B%22endColumn%22%3A1%2C%22endLineNumber%22%3A2%2C%22startColumn%22%3A1%2C%22startLineNumber%22%3A2%7D%5D)
+
+<iframe src="https://codesandbox.io/p/sandbox/7-error-handling-and-error-boundaries-sroncx?file=%2Fsrc%2Fmain.rs&selection=%5B%7B%22endColumn%22%3A1%2C%22endLineNumber%22%3A2%2C%22startColumn%22%3A1%2C%22startLineNumber%22%3A2%7D%5D" width="100%" height="1000px" style="max-height: 100vh"></iframe>

docs/book/src/view/08_parent_child.md

@@ -285,4 +285,6 @@ in `<ButtonD/>` and a single text node in `<App/>`. It’s as if the components
 themselves don’t exist at all. And, well... at runtime, they don’t. It’s just
 signals and effects, all the way down.
 
-<iframe src="https://codesandbox.io/p/sandbox/8-parent-child-communication-84we8m?file=%2Fsrc%2Fmain.rs&selection=%5B%7B%22endColumn%22%3A1%2C%22endLineNumber%22%3A3%2C%22startColumn%22%3A1%2C%22startLineNumber%22%3A3%7D%5D" width="100%" height="1000px"></iframe>
+[Click to open CodeSandbox.](https://codesandbox.io/p/sandbox/8-parent-child-communication-84we8m?file=%2Fsrc%2Fmain.rs&selection=%5B%7B%22endColumn%22%3A1%2C%22endLineNumber%22%3A3%2C%22startColumn%22%3A1%2C%22startLineNumber%22%3A3%7D%5D)
+
+<iframe src="https://codesandbox.io/p/sandbox/8-parent-child-communication-84we8m?file=%2Fsrc%2Fmain.rs&selection=%5B%7B%22endColumn%22%3A1%2C%22endLineNumber%22%3A3%2C%22startColumn%22%3A1%2C%22startLineNumber%22%3A3%7D%5D" width="100%" height="1000px" style="max-height: 100vh"></iframe>

docs/book/src/view/09_component_children.md

@@ -123,4 +123,6 @@ view! { cx,
 }
 ```
 
-<iframe src="https://codesandbox.io/p/sandbox/9-component-children-2wrdfd?file=%2Fsrc%2Fmain.rs&selection=%5B%7B%22endColumn%22%3A12%2C%22endLineNumber%22%3A19%2C%22startColumn%22%3A12%2C%22startLineNumber%22%3A19%7D%5D" width="100%" height="1000px"></iframe>
+[Click to open CodeSandbox.](https://codesandbox.io/p/sandbox/9-component-children-2wrdfd?file=%2Fsrc%2Fmain.rs&selection=%5B%7B%22endColumn%22%3A12%2C%22endLineNumber%22%3A19%2C%22startColumn%22%3A12%2C%22startLineNumber%22%3A19%7D%5D)
+
+<iframe src="https://codesandbox.io/p/sandbox/9-component-children-2wrdfd?file=%2Fsrc%2Fmain.rs&selection=%5B%7B%22endColumn%22%3A12%2C%22endLineNumber%22%3A19%2C%22startColumn%22%3A12%2C%22startLineNumber%22%3A19%7D%5D" width="100%" height="1000px" style="max-height: 100vh"></iframe>

examples/counter/src/main.rs

@@ -1,4 +1,4 @@
-use counter::*;
+use counter::SimpleCounter;
 use leptos::*;
 
 pub fn main() {

examples/counters/src/main.rs

@@ -1,4 +1,4 @@
-use counters::{Counters, CountersProps};
+use counters::Counters;
 use leptos::*;
 
 fn main() {

examples/hackernews/src/routes/stories.rs

@@ -38,7 +38,7 @@ pub fn Stories(cx: Scope) -> impl IntoView {
     let (pending, set_pending) = create_signal(cx, false);
 
     let hide_more_link =
-        move || pending() || stories.read(cx).unwrap_or(None).unwrap_or_default().len() < 28;
+        move |cx| pending() || stories.read(cx).unwrap_or(None).unwrap_or_default().len() < 28;
 
     view! {
         cx,
@@ -65,16 +65,20 @@ pub fn Stories(cx: Scope) -> impl IntoView {
                     }}
                 </span>
                 <span>"page " {page}</span>
-                <span class="page-link"
-                    class:disabled=hide_more_link
-                    aria-hidden=hide_more_link
+                <Transition
+                    fallback=move || view! { cx,  <p>"Loading..."</p> }
                 >
-                    <a href=move || format!("/{}?page={}", story_type(), page() + 1)
-                        aria-label="Next Page"
+                    <span class="page-link"
+                        class:disabled=move || hide_more_link(cx)
+                        aria-hidden=move || hide_more_link(cx)
                     >
-                        "more >"
-                    </a>
-                </span>
+                        <a href=move || format!("/{}?page={}", story_type(), page() + 1)
+                            aria-label="Next Page"
+                        >
+                            "more >"
+                        </a>
+                    </span>
+                </Transition>
             </div>
             <main class="news-list">
                 <div>

examples/session_auth_axum/src/main.rs

@@ -6,7 +6,7 @@ if #[cfg(feature = "ssr")] {
     use axum::{
         response::{Response, IntoResponse},
         routing::{post, get},
-        extract::{Path, Extension},
+        extract::{Path, Extension, RawQuery},
         http::{Request, header::HeaderMap},
         body::Body as AxumBody,
         Router,
@@ -22,11 +22,12 @@ if #[cfg(feature = "ssr")] {
     use axum_database_sessions::{SessionConfig, SessionLayer, SessionStore};
     use axum_sessions_auth::{AuthSessionLayer, AuthConfig, SessionSqlitePool};
 
-    async fn server_fn_handler(Extension(pool): Extension<SqlitePool>, auth_session: AuthSession, path: Path<String>, headers: HeaderMap, request: Request<AxumBody>) -> impl IntoResponse {
+    async fn server_fn_handler(Extension(pool): Extension<SqlitePool>, auth_session: AuthSession, path: Path<String>, headers: HeaderMap, raw_query: RawQuery,
+    request: Request<AxumBody>) -> impl IntoResponse {
 
         log!("{:?}", path);
 
-        handle_server_fns_with_context(path, headers, move |cx| {
+        handle_server_fns_with_context(path, headers, raw_query, move |cx| {
             provide_context(cx, auth_session.clone());
             provide_context(cx, pool.clone());
         }, request).await
@@ -73,7 +74,7 @@ if #[cfg(feature = "ssr")] {
 
         // build our application with a route
         let app = Router::new()
-        .route("/api/*fn_name", post(server_fn_handler))
+        .route("/api/*fn_name", get(server_fn_handler).post(server_fn_handler))
         .leptos_routes_with_handler(routes, get(leptos_routes_handler) )
         .fallback(file_and_error_handler)
         .layer(AuthSessionLayer::<User, i64, SessionSqlitePool, SqlitePool>::new(Some(pool.clone()))

examples/todo_app_sqlite_viz/src/todo.rs

@@ -51,7 +51,8 @@ pub async fn get_todos(cx: Scope) -> Result<Vec<Todo>, ServerFnError> {
     let mut conn = db().await?;
 
     let mut todos = Vec::new();
-    let mut rows = sqlx::query_as::<_, Todo>("SELECT * FROM todos").fetch(&mut conn);
+    let mut rows =
+        sqlx::query_as::<_, Todo>("SELECT * FROM todos").fetch(&mut conn);
     while let Some(row) = rows
         .try_next()
         .await

integrations/actix/Cargo.toml

@@ -14,5 +14,6 @@ leptos = { workspace = true, features = ["ssr"] }
 leptos_meta = { workspace = true, features = ["ssr"] }
 leptos_router = { workspace = true, features = ["ssr"] }
 leptos_integration_utils = { workspace = true }
+serde_json = "1"
 parking_lot = "0.12.1"
 regex = "1.7.0"

integrations/actix/src/lib.rs

@@ -18,6 +18,7 @@ use http::StatusCode;
 use leptos::{
     leptos_dom::ssr::render_to_stream_with_prefix_undisposed_with_context,
     leptos_server::{server_fn_by_path, Payload},
+    server_fn::Encoding,
     *,
 };
 use leptos_integration_utils::{build_async_response, html_parts_separated};
@@ -150,9 +151,9 @@ pub fn handle_server_fns() -> Route {
     handle_server_fns_with_context(|_cx| {})
 }
 
-/// An Actix [Route](actix_web::Route) that listens for a `POST` request with
-/// Leptos server function arguments in the body, runs the server function if found,
-/// and returns the resulting [HttpResponse].
+/// An Actix [Route](actix_web::Route) that listens for `GET` or `POST` requests with
+/// Leptos server function arguments in the URL (`GET`) or body (`POST`),
+/// runs the server function if found, and returns the resulting [HttpResponse].
 ///
 /// This provides the [HttpRequest] to the server [Scope](leptos::Scope).
 ///
@@ -168,7 +169,7 @@ pub fn handle_server_fns() -> Route {
 pub fn handle_server_fns_with_context(
     additional_context: impl Fn(leptos::Scope) + 'static + Clone + Send,
 ) -> Route {
-    web::post().to(
+    web::to(
         move |req: HttpRequest, params: web::Path<String>, body: web::Bytes| {
             let additional_context = additional_context.clone();
             async move {
@@ -194,7 +195,13 @@ pub fn handle_server_fns_with_context(
                     provide_context(cx, req.clone());
                     provide_context(cx, res_options.clone());
 
-                    match server_fn(cx, body).await {
+                    let query = req.query_string().as_bytes();
+
+                    let data = match &server_fn.encoding {
+                        Encoding::Url | Encoding::Cbor => body,
+                        Encoding::GetJSON | Encoding::GetCBOR => query,
+                    };
+                    match (server_fn.trait_obj)(cx, data).await {
                         Ok(serialized) => {
                             let res_options =
                                 use_context::<ResponseOptions>(cx).unwrap();
@@ -257,8 +264,10 @@ pub fn handle_server_fns_with_context(
                                 }
                             }
                         }
-                        Err(e) => HttpResponse::InternalServerError()
-                            .body(e.to_string()),
+                        Err(e) => HttpResponse::InternalServerError().body(
+                            serde_json::to_string(&e)
+                                .unwrap_or_else(|_| e.to_string()),
+                        ),
                     }
                 } else {
                     HttpResponse::BadRequest().body(format!(

integrations/axum/Cargo.toml

@@ -16,5 +16,7 @@ leptos = { workspace = true, features = ["ssr"] }
 leptos_meta = { workspace = true, features = ["ssr"] }
 leptos_router = { workspace = true, features = ["ssr"] }
 leptos_integration_utils = { workspace = true }
+serde_json = "1"
 tokio = { version = "1", features = ["full"] }
 parking_lot = "0.12.1"
+tokio-util = {version = "0.7.7", features = ["rt"] }

integrations/axum/src/lib.rs

@@ -8,7 +8,7 @@
 
 use axum::{
     body::{Body, Bytes, Full, StreamBody},
-    extract::Path,
+    extract::{Path, RawQuery},
     http::{
         header::{HeaderName, HeaderValue},
         HeaderMap, Request, StatusCode,
@@ -24,6 +24,7 @@ use http::{header, method::Method, uri::Uri, version::Version, Response};
 use hyper::body;
 use leptos::{
     leptos_server::{server_fn_by_path, Payload},
+    server_fn::Encoding,
     ssr::*,
     *,
 };
@@ -31,8 +32,14 @@ use leptos_integration_utils::{build_async_response, html_parts_separated};
 use leptos_meta::{generate_head_metadata_separated, MetaContext};
 use leptos_router::*;
 use parking_lot::RwLock;
-use std::{io, pin::Pin, sync::Arc};
-use tokio::task::{spawn_blocking, LocalSet};
+use std::{
+    io,
+    pin::Pin,
+    sync::{Arc, OnceLock},
+    thread::available_parallelism,
+};
+use tokio::task::LocalSet;
+use tokio_util::task::LocalPoolHandle;
 
 /// A struct to hold the parts of the incoming Request. Since `http::Request` isn't cloneable, we're forced
 /// to construct this for Leptos to use in Axum
@@ -248,9 +255,10 @@ where
 pub async fn handle_server_fns(
     Path(fn_name): Path<String>,
     headers: HeaderMap,
+    RawQuery(query): RawQuery,
     req: Request<Body>,
 ) -> impl IntoResponse {
-    handle_server_fns_inner(fn_name, headers, |_| {}, req).await
+    handle_server_fns_inner(fn_name, headers, query, |_| {}, req).await
 }
 
 /// An Axum handlers to listens for a request with Leptos server function arguments in the body,
@@ -270,15 +278,18 @@ pub async fn handle_server_fns(
 pub async fn handle_server_fns_with_context(
     Path(fn_name): Path<String>,
     headers: HeaderMap,
+    RawQuery(query): RawQuery,
     additional_context: impl Fn(leptos::Scope) + 'static + Clone + Send,
     req: Request<Body>,
 ) -> impl IntoResponse {
-    handle_server_fns_inner(fn_name, headers, additional_context, req).await
+    handle_server_fns_inner(fn_name, headers, query, additional_context, req)
+        .await
 }
 
 async fn handle_server_fns_inner(
     fn_name: String,
     headers: HeaderMap,
+    query: Option<String>,
     additional_context: impl Fn(leptos::Scope) + 'static + Clone + Send,
     req: Request<Body>,
 ) -> impl IntoResponse {
@@ -289,133 +300,116 @@ async fn handle_server_fns_inner(
         .unwrap_or(fn_name);
 
     let (tx, rx) = futures::channel::oneshot::channel();
-    spawn_blocking({
-        move || {
-            tokio::runtime::Runtime::new()
-                .expect("couldn't spawn runtime")
-                .block_on({
-                    async move {
-                        let res = if let Some(server_fn) =
-                            server_fn_by_path(fn_name.as_str())
+    let pool_handle = get_leptos_pool();
+    pool_handle.spawn_pinned(move || {
+        async move {
+            let res = if let Some(server_fn) =
+                server_fn_by_path(fn_name.as_str())
+            {
+                let runtime = create_runtime();
+                let (cx, disposer) = raw_scope_and_disposer(runtime);
+
+                additional_context(cx);
+
+                let (req, req_parts) = generate_request_and_parts(req).await;
+                let leptos_req = generate_leptos_request(req).await; // Add this so we can get details about the Request
+                provide_context(cx, req_parts.clone());
+                provide_context(cx, leptos_req);
+                // Add this so that we can set headers and status of the response
+                provide_context(cx, ResponseOptions::default());
+
+                let query: &Bytes = &query.unwrap_or("".to_string()).into();
+                let data = match &server_fn.encoding {
+                    Encoding::Url | Encoding::Cbor => &req_parts.body,
+                    Encoding::GetJSON | Encoding::GetCBOR => query,
+                };
+                match (server_fn.trait_obj)(cx, data).await {
+                    Ok(serialized) => {
+                        // If ResponseOptions are set, add the headers and status to the request
+                        let res_options = use_context::<ResponseOptions>(cx);
+
+                        // clean up the scope, which we only needed to run the server fn
+                        disposer.dispose();
+                        runtime.dispose();
+
+                        // if this is Accept: application/json then send a serialized JSON response
+                        let accept_header = headers
+                            .get("Accept")
+                            .and_then(|value| value.to_str().ok());
+                        let mut res = Response::builder();
+
+                        // Add headers from ResponseParts if they exist. These should be added as long
+                        // as the server function returns an OK response
+                        let res_options_outer = res_options.unwrap().0;
+                        let res_options_inner = res_options_outer.read();
+                        let (status, mut res_headers) = (
+                            res_options_inner.status,
+                            res_options_inner.headers.clone(),
+                        );
+
+                        if accept_header == Some("application/json")
+                            || accept_header
+                                == Some("application/x-www-form-urlencoded")
+                            || accept_header == Some("application/cbor")
                         {
-                            let runtime = create_runtime();
-                            let (cx, disposer) =
-                                raw_scope_and_disposer(runtime);
-
-                            additional_context(cx);
-
-                            let (req, req_parts) =
-                                generate_request_and_parts(req).await;
-                            let leptos_req = generate_leptos_request(req).await; // Add this so we can get details about the Request
-                            provide_context(cx, req_parts.clone());
-                            provide_context(cx, leptos_req);
-                            // Add this so that we can set headers and status of the response
-                            provide_context(cx, ResponseOptions::default());
-
-                            match server_fn(cx, &req_parts.body).await {
-                                Ok(serialized) => {
-                                    // If ResponseOptions are set, add the headers and status to the request
-                                    let res_options =
-                                        use_context::<ResponseOptions>(cx);
-
-                                    // clean up the scope, which we only needed to run the server fn
-                                    disposer.dispose();
-                                    runtime.dispose();
-
-                                    // if this is Accept: application/json then send a serialized JSON response
-                                    let accept_header = headers
-                                        .get("Accept")
-                                        .and_then(|value| value.to_str().ok());
-                                    let mut res = Response::builder();
-
-                                    // Add headers from ResponseParts if they exist. These should be added as long
-                                    // as the server function returns an OK response
-                                    let res_options_outer =
-                                        res_options.unwrap().0;
-                                    let res_options_inner =
-                                        res_options_outer.read();
-                                    let (status, mut res_headers) = (
-                                        res_options_inner.status,
-                                        res_options_inner.headers.clone(),
-                                    );
-
-                                    if accept_header == Some("application/json")
-                                        || accept_header
-                                            == Some(
-                                                "application/\
-                                                 x-www-form-urlencoded",
-                                            )
-                                        || accept_header
-                                            == Some("application/cbor")
-                                    {
-                                        res = res.status(StatusCode::OK);
-                                    }
-                                    // otherwise, it's probably a <form> submit or something: redirect back to the referrer
-                                    else {
-                                        let referer = headers
-                                            .get("Referer")
-                                            .and_then(|value| {
-                                                value.to_str().ok()
-                                            })
-                                            .unwrap_or("/");
-
-                                        res = res
-                                            .status(StatusCode::SEE_OTHER)
-                                            .header("Location", referer);
-                                    }
-                                    // Override StatusCode if it was set in a Resource or Element
-                                    res = match status {
-                                        Some(status) => res.status(status),
-                                        None => res,
-                                    };
-                                    // This must be after the default referrer
-                                    // redirect so that it overwrites the one above
-                                    if let Some(header_ref) = res.headers_mut()
-                                    {
-                                        header_ref.extend(res_headers.drain());
-                                    };
-                                    match serialized {
-                                        Payload::Binary(data) => res
-                                            .header(
-                                                "Content-Type",
-                                                "application/cbor",
-                                            )
-                                            .body(Full::from(data)),
-                                        Payload::Url(data) => res
-                                            .header(
-                                                "Content-Type",
-                                                "application/\
-                                                 x-www-form-urlencoded",
-                                            )
-                                            .body(Full::from(data)),
-                                        Payload::Json(data) => res
-                                            .header(
-                                                "Content-Type",
-                                                "application/json",
-                                            )
-                                            .body(Full::from(data)),
-                                    }
-                                }
-                                Err(e) => Response::builder()
-                                    .status(StatusCode::INTERNAL_SERVER_ERROR)
-                                    .body(Full::from(e.to_string())),
-                            }
-                        } else {
-                            Response::builder()
-                                .status(StatusCode::BAD_REQUEST)
-                                .body(Full::from(format!(
-                                    "Could not find a server function at the \
-                                     route {fn_name}. \n\nIt's likely that \
-                                     you need to call ServerFn::register() on \
-                                     the server function type, somewhere in \
-                                     your `main` function."
-                                )))
+                            res = res.status(StatusCode::OK);
                         }
-                        .expect("could not build Response");
+                        // otherwise, it's probably a <form> submit or something: redirect back to the referrer
+                        else {
+                            let referer = headers
+                                .get("Referer")
+                                .and_then(|value| value.to_str().ok())
+                                .unwrap_or("/");
 
-                        _ = tx.send(res);
+                            res = res
+                                .status(StatusCode::SEE_OTHER)
+                                .header("Location", referer);
+                        }
+                        // Override StatusCode if it was set in a Resource or Element
+                        res = match status {
+                            Some(status) => res.status(status),
+                            None => res,
+                        };
+                        // This must be after the default referrer
+                        // redirect so that it overwrites the one above
+                        if let Some(header_ref) = res.headers_mut() {
+                            header_ref.extend(res_headers.drain());
+                        };
+                        match serialized {
+                            Payload::Binary(data) => res
+                                .header("Content-Type", "application/cbor")
+                                .body(Full::from(data)),
+                            Payload::Url(data) => res
+                                .header(
+                                    "Content-Type",
+                                    "application/x-www-form-urlencoded",
+                                )
+                                .body(Full::from(data)),
+                            Payload::Json(data) => res
+                                .header("Content-Type", "application/json")
+                                .body(Full::from(data)),
+                        }
                     }
-                })
+                    Err(e) => Response::builder()
+                        .status(StatusCode::INTERNAL_SERVER_ERROR)
+                        .body(Full::from(
+                            serde_json::to_string(&e)
+                                .unwrap_or_else(|_| e.to_string()),
+                        )),
+                }
+            } else {
+                Response::builder().status(StatusCode::BAD_REQUEST).body(
+                    Full::from(format!(
+                        "Could not find a server function at the route \
+                         {fn_name}. \n\nIt's likely that you need to call \
+                         ServerFn::register() on the server function type, \
+                         somewhere in your `main` function."
+                    )),
+                )
+            }
+            .expect("could not build Response");
+
+            _ = tx.send(res);
         }
     });
 
@@ -619,56 +613,33 @@ where
             let default_res_options = ResponseOptions::default();
             let res_options2 = default_res_options.clone();
             let res_options3 = default_res_options.clone();
+            let local_pool = get_leptos_pool();
+            let (tx, rx) = futures::channel::mpsc::channel(8);
+            local_pool.spawn_pinned(move || async move {
+                let app = {
+                    // Need to get the path and query string of the Request
+                    // For reasons that escape me, if the incoming URI protocol is https, it provides the absolute URI
+                    // if http, it returns a relative path. Adding .path() seems to make it explicitly return the relative uri
+                    let path = req.uri().path_and_query().unwrap().as_str();
 
-            async move {
-                // Need to get the path and query string of the Request
-                // For reasons that escape me, if the incoming URI protocol is https, it provides the absolute URI
-                // if http, it returns a relative path. Adding .path() seems to make it explicitly return the relative uri
-                let path = req.uri().path_and_query().unwrap().as_str();
-
-                let full_path = format!("http://leptos.dev{path}");
-
-                let (tx, rx) = futures::channel::mpsc::channel(8);
-
-                spawn_blocking({
-                    let app_fn = app_fn.clone();
-                    let add_context = add_context.clone();
-                    move || {
-                        tokio::runtime::Runtime::new()
-                            .expect("couldn't spawn runtime")
-                            .block_on({
-                                let app_fn = app_fn.clone();
-                                let add_context = add_context.clone();
-                                async move {
-                                    tokio::task::LocalSet::new()
-                                        .run_until(async {
-                                            let app = {
-                                                let full_path = full_path.clone();
-                                                let (req, req_parts) = generate_request_and_parts(req).await;
-                                                let leptos_req = generate_leptos_request(req).await;
-                                                move |cx| {
-                                                    provide_contexts(cx, full_path, req_parts,leptos_req, default_res_options);
-                                                    app_fn(cx).into_view(cx)
-                                                }
-                                            };
-
-                                            let (bundle, runtime, scope) =
-                                                leptos::leptos_dom::ssr::render_to_stream_with_prefix_undisposed_with_context(
-                                                    app,
-                                                    |cx| generate_head_metadata_separated(cx).1.into(),
-                                                    add_context,
-                                                );
-
-                                                forward_stream(&options, res_options2, bundle, runtime, scope, tx).await;
-                                        })
-                                        .await;
-                                }
-                            });
+                    let full_path = format!("http://leptos.dev{path}");
+                    let (req, req_parts) = generate_request_and_parts(req).await;
+                    let leptos_req = generate_leptos_request(req).await;
+                    move |cx| {
+                        provide_contexts(cx, full_path, req_parts,leptos_req, default_res_options);
+                        app_fn(cx).into_view(cx)
                     }
-                });
+                };
+                let (bundle, runtime, scope) =
+                    leptos::leptos_dom::ssr::render_to_stream_with_prefix_undisposed_with_context(
+                        app,
+                        |cx| generate_head_metadata_separated(cx).1.into(),
+                        add_context,
+                    );
 
-                generate_response(res_options3, rx).await
-            }
+                    forward_stream(&options, res_options2, bundle, runtime, scope, tx).await;
+            });
+            async move { generate_response(res_options3, rx).await }
         })
     }
 }
@@ -798,42 +769,26 @@ where
                 let full_path = format!("http://leptos.dev{path}");
 
                 let (tx, rx) = futures::channel::mpsc::channel(8);
+                let local_pool = get_leptos_pool();
+                local_pool.spawn_pinned(move || async move {
+                    let app = {
+                        let full_path = full_path.clone();
+                        let (req, req_parts) = generate_request_and_parts(req).await;
+                        let leptos_req = generate_leptos_request(req).await;
+                        move |cx| {
+                            provide_contexts(cx, full_path, req_parts,leptos_req, default_res_options);
+                            app_fn(cx).into_view(cx)
+                        }
+                    };
 
-                spawn_blocking({
-                    let app_fn = app_fn.clone();
-                    let add_context = add_context.clone();
-                    move || {
-                        tokio::runtime::Runtime::new()
-                            .expect("couldn't spawn runtime")
-                            .block_on({
-                                let app_fn = app_fn.clone();
-                                let add_context = add_context.clone();
-                                async move {
-                                    tokio::task::LocalSet::new()
-                                        .run_until(async {
-                                            let app = {
-                                                let full_path = full_path.clone();
-                                                let (req, req_parts) = generate_request_and_parts(req).await;
-                                                let leptos_req = generate_leptos_request(req).await;
-                                                move |cx| {
-                                                    provide_contexts(cx, full_path, req_parts,leptos_req, default_res_options);
-                                                    app_fn(cx).into_view(cx)
-                                                }
-                                            };
+                    let (bundle, runtime, scope) =
+                        leptos::ssr::render_to_stream_in_order_with_prefix_undisposed_with_context(
+                            app,
+                            |cx| generate_head_metadata_separated(cx).1.into(),
+                            add_context,
+                        );
 
-                                            let (bundle, runtime, scope) =
-                                                leptos::ssr::render_to_stream_in_order_with_prefix_undisposed_with_context(
-                                                    app,
-                                                    |cx| generate_head_metadata_separated(cx).1.into(),
-                                                    add_context,
-                                                );
-
-                                            forward_stream(&options, res_options2, bundle, runtime, scope, tx).await;
-                                        })
-                                        .await;
-                                }
-                            });
-                    }
+                    forward_stream(&options, res_options2, bundle, runtime, scope, tx).await;
                 });
 
                 generate_response(res_options3, rx).await
@@ -981,53 +936,39 @@ where
                 let full_path = format!("http://leptos.dev{path}");
 
                 let (tx, rx) = futures::channel::oneshot::channel();
+                let local_pool = get_leptos_pool();
+                local_pool.spawn_pinned(move || {
+                    async move {
+                        let app = {
+                            let full_path = full_path.clone();
+                            let (req, req_parts) = generate_request_and_parts(req).await;
+                            let leptos_req = generate_leptos_request(req).await;
+                            move |cx| {
+                                provide_contexts(cx, full_path, req_parts,leptos_req, default_res_options);
+                                app_fn(cx).into_view(cx)
+                            }
+                        };
 
-                spawn_blocking({
-                    let app_fn = app_fn.clone();
-                    let add_context = add_context.clone();
-                    move || {
-                        tokio::runtime::Runtime::new()
-                            .expect("couldn't spawn runtime")
-                            .block_on({
-                                let app_fn = app_fn.clone();
-                                let add_context = add_context.clone();
-                                async move {
-                                    tokio::task::LocalSet::new()
-                                        .run_until(async {
-                                            let app = {
-                                                let full_path = full_path.clone();
-                                                let (req, req_parts) = generate_request_and_parts(req).await;
-                                                let leptos_req = generate_leptos_request(req).await;
-                                                move |cx| {
-                                                    provide_contexts(cx, full_path, req_parts,leptos_req, default_res_options);
-                                                    app_fn(cx).into_view(cx)
-                                                }
-                                            };
+                        let (stream, runtime, scope) =
+                            render_to_stream_in_order_with_prefix_undisposed_with_context(
+                                app,
+                                |_| "".into(),
+                                add_context,
+                            );
 
-                                            let (stream, runtime, scope) =
-                                                render_to_stream_in_order_with_prefix_undisposed_with_context(
-                                                    app,
-                                                    |_| "".into(),
-                                                    add_context,
-                                                );
+                        // Extract the value of ResponseOptions from here
+                        let cx = leptos::Scope { runtime, id: scope };
+                        let res_options =
+                            use_context::<ResponseOptions>(cx).unwrap();
 
-                                            // Extract the value of ResponseOptions from here
-                                            let cx = leptos::Scope { runtime, id: scope };
-                                            let res_options =
-                                                use_context::<ResponseOptions>(cx).unwrap();
+                        let html = build_async_response(stream, &options, runtime, scope).await;
 
-                                            let html = build_async_response(stream, &options, runtime, scope).await;
+                        let new_res_parts = res_options.0.read().clone();
 
-                                            let new_res_parts = res_options.0.read().clone();
+                        let mut writable = res_options2.0.write();
+                        *writable = new_res_parts;
 
-                                            let mut writable = res_options2.0.write();
-                                            *writable = new_res_parts;
-
-                                            _ = tx.send(html);
-                                        })
-                                        .await;
-                                }
-                            });
+                        _ = tx.send(html);
                     }
                 });
 
@@ -1201,3 +1142,14 @@ impl LeptosRoutes for axum::Router {
         router
     }
 }
+
+fn get_leptos_pool() -> LocalPoolHandle {
+    static LOCAL_POOL: OnceLock<LocalPoolHandle> = OnceLock::new();
+    LOCAL_POOL
+        .get_or_init(|| {
+            tokio_util::task::LocalPoolHandle::new(
+                available_parallelism().map(Into::into).unwrap_or(1),
+            )
+        })
+        .clone()
+}

integrations/viz/Cargo.toml

@@ -16,5 +16,6 @@ leptos = { workspace = true, features = ["ssr"] }
 leptos_meta = { workspace = true, features = ["ssr"] }
 leptos_router = { workspace = true, features = ["ssr"] }
 leptos_integration_utils = { workspace = true }
+serde_json = "1"
 tokio = { version = "1", features = ["full"] }
 parking_lot = "0.12.1"

integrations/viz/src/lib.rs

@@ -14,6 +14,7 @@ use http::{header, method::Method, uri::Uri, version::Version, StatusCode};
 use hyper::body;
 use leptos::{
     leptos_server::{server_fn_by_path, Payload},
+    server_fn::Encoding,
     ssr::*,
     *,
 };
@@ -185,6 +186,7 @@ async fn handle_server_fns_inner(
 ) -> Result<Response> {
     let fn_name = req.params::<String>()?;
     let headers = req.headers().clone();
+    let query = req.query_string().unwrap_or("").to_owned().into();
     let (tx, rx) = futures::channel::oneshot::channel();
     spawn_blocking({
         move || {
@@ -207,7 +209,14 @@ async fn handle_server_fns_inner(
                             // Add this so that we can set headers and status of the response
                             provide_context(cx, ResponseOptions::default());
 
-                            match server_fn(cx, &req_parts.body).await {
+                            let data = match &server_fn.encoding {
+                                Encoding::Url | Encoding::Cbor => {
+                                    &req_parts.body
+                                }
+                                Encoding::GetJSON | Encoding::GetCBOR => &query,
+                            };
+
+                            match (server_fn.trait_obj)(cx, data).await {
                                 Ok(serialized) => {
                                     // If ResponseOptions are set, add the headers and status to the request
                                     let res_options =
@@ -292,7 +301,10 @@ async fn handle_server_fns_inner(
                                 }
                                 Err(e) => Response::builder()
                                     .status(StatusCode::INTERNAL_SERVER_ERROR)
-                                    .body(Body::from(e.to_string())),
+                                    .body(Body::from(
+                                        serde_json::to_string(&e)
+                                            .unwrap_or_else(|_| e.to_string()),
+                                    )),
                             }
                         } else {
                             Response::builder()

leptos/src/lib.rs

@@ -218,3 +218,21 @@ pub type ChildrenFnMut = Box<dyn FnMut(Scope) -> Fragment>;
 /// }
 /// ```
 pub type AttributeValue = Box<dyn IntoAttribute>;
+
+#[doc(hidden)]
+pub trait Component<P> {}
+
+#[doc(hidden)]
+pub trait Props {
+    type Builder;
+    fn builder() -> Self::Builder;
+}
+
+impl<P, F, R> Component<P> for F where F: FnOnce(::leptos::Scope, P) -> R {}
+
+#[doc(hidden)]
+pub fn component_props_builder<P: Props>(
+    _f: &impl Component<P>,
+) -> <P as Props>::Builder {
+    <P as Props>::builder()
+}

leptos/src/show.rs

@@ -1,6 +1,7 @@
 use leptos::component;
 use leptos_dom::{Fragment, IntoView};
-use leptos_reactive::{create_memo, signal_prelude::*, Scope};
+use leptos_reactive::{create_memo, signal_prelude::*, Scope, ScopeDisposer};
+use std::{cell::RefCell, rc::Rc};
 
 /// A component that will show its children when the `when` condition is `true`,
 /// and show the fallback when it is `false`, without rerendering every time
@@ -45,9 +46,18 @@ where
     IV: IntoView,
 {
     let memoized_when = create_memo(cx, move |_| when());
+    let prev_disposer = Rc::new(RefCell::new(None::<ScopeDisposer>));
 
-    move || match memoized_when.get() {
-        true => children(cx).into_view(cx),
-        false => fallback(cx).into_view(cx),
+    move || {
+        if let Some(disposer) = prev_disposer.take() {
+            disposer.dispose();
+        }
+        let (view, disposer) =
+            cx.run_child_scope(|cx| match memoized_when.get() {
+                true => children(cx).into_view(cx),
+                false => fallback(cx).into_view(cx),
+            });
+        *prev_disposer.borrow_mut() = Some(disposer);
+        view
     }
 }

leptos/src/suspense.rs

@@ -79,9 +79,9 @@ where
             cfg_if! {
                 if #[cfg(any(feature = "csr", feature = "hydrate"))] {
                     if context.ready() {
-                        orig_child(cx).into_view(cx)
+                        Fragment::lazy(Box::new(|| vec![orig_child(cx).into_view(cx)])).into_view(cx)
                     } else {
-                        fallback().into_view(cx)
+                        Fragment::lazy(Box::new(|| vec![fallback().into_view(cx)])).into_view(cx)
                     }
                 } else {
                     use leptos_reactive::signal_prelude::*;
@@ -108,10 +108,12 @@ where
                                     let orig_child = Rc::clone(&orig_child);
                                     move || {
                                         HydrationCtx::continue_from(current_id.clone());
-                                        DynChild::new(move || orig_child(cx))
-                                            .into_view(cx)
-                                            .render_to_string(cx)
-                                            .to_string()
+                                        Fragment::lazy(Box::new(move || {
+                                            vec![DynChild::new(move || orig_child(cx)).into_view(cx)]
+                                        }))
+                                        .into_view(cx)
+                                        .render_to_string(cx)
+                                        .to_string()
                                     }
                                 },
                                 // in-order streaming
@@ -119,11 +121,13 @@ where
                                     let current_id = current_id.clone();
                                     move || {
                                         HydrationCtx::continue_from(current_id.clone());
-                                        DynChild::new(move || orig_child(cx))
-                                            .into_view(cx)
-                                            .into_stream_chunks(cx)
+                                        Fragment::lazy(Box::new(move || {
+                                            vec![DynChild::new(move || orig_child(cx)).into_view(cx)]
+                                        }))
+                                        .into_view(cx)
+                                        .into_stream_chunks(cx)
                                     }
-                                }
+                                },
                             );
 
                             // return the fallback for now, wrapped in fragment identifier

leptos/tests/test_examples/suspense-tests/.gitignore

@@ -0,0 +1,13 @@
+# Generated by Cargo
+# will have compiled files and executables
+/target/
+pkg
+
+# These are backup files generated by rustfmt
+**/*.rs.bk
+
+# node e2e test tools and outputs
+node_modules/
+test-results/
+end2end/playwright-report/
+playwright/.cache/

leptos/tests/test_examples/suspense-tests/Cargo.toml

@@ -0,0 +1,78 @@
+[package]
+name = "leptos_start"
+version = "0.1.0"
+edition = "2021"
+
+[lib]
+crate-type = ["cdylib", "rlib"]
+
+[dependencies]
+actix-files = { version = "0.6", optional = true }
+actix-web = { version = "4", optional = true, features = ["macros"] }
+console_error_panic_hook = "0.1"
+console_log = "1"
+cfg-if = "1"
+leptos = { path = "../../..", default-features = false, features = ["serde"] }
+leptos_actix = { path = "../../../../integrations/actix", optional = true }
+leptos_router = { path = "../../../../router", default-features = false }
+log = "0.4"
+simple_logger = "4"
+wasm-bindgen = "0.2"
+serde = "1.0.159"
+tokio = { version = "1.27.0", features = ["time"], optional = true }
+
+[features]
+hydrate = ["leptos/hydrate", "leptos_router/hydrate"]
+ssr = [
+	"dep:actix-files",
+	"dep:actix-web",
+	"dep:leptos_actix",
+	"leptos/ssr",
+	"leptos_router/ssr",
+	"dep:tokio",
+]
+
+[package.metadata.leptos]
+# The name used by wasm-bindgen/cargo-leptos for the JS/WASM bundle. Defaults to the crate name   
+output-name = "leptos_start"
+# The site root folder is where cargo-leptos generate all output. WARNING: all content of this folder will be erased on a rebuild. Use it in your server setup.
+site-root = "target/site"
+# The site-root relative folder where all compiled output (JS, WASM and CSS) is written
+# Defaults to pkg	
+site-pkg-dir = "pkg"
+# The IP and port (ex: 127.0.0.1:3000) where the server serves the content. Use it in your server setup.
+site-addr = "127.0.0.1:3000"
+# The port to use for automatic reload monitoring
+reload-port = 3001
+# [Optional] Command to use when running end2end tests. It will run in the end2end dir.
+#   [Windows] for non-WSL use "npx.cmd playwright test"
+#   This binary name can be checked in Powershell with Get-Command npx
+end2end-cmd = "npx playwright test"
+end2end-dir = "end2end"
+#  The browserlist query used for optimizing the CSS.
+browserquery = "defaults"
+# Set by cargo-leptos watch when building with that tool. Controls whether autoreload JS will be included in the head
+watch = false
+# The environment Leptos will run in, usually either "DEV" or "PROD"
+env = "DEV"
+# The features to use when compiling the bin target
+#
+# Optional. Can be over-ridden with the command line parameter --bin-features
+bin-features = ["ssr"]
+
+# If the --no-default-features flag should be used when compiling the bin target
+#
+# Optional. Defaults to false.
+bin-default-features = false
+
+# The features to use when compiling the lib target
+#
+# Optional. Can be over-ridden with the command line parameter --lib-features
+lib-features = ["hydrate"]
+
+# If the --no-default-features flag should be used when compiling the lib target
+#
+# Optional. Defaults to false.
+lib-default-features = false
+
+[workspace]

leptos/tests/test_examples/suspense-tests/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 henrik
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

leptos/tests/test_examples/suspense-tests/README.md

@@ -0,0 +1,61 @@
+<picture>
+    <source srcset="https://raw.githubusercontent.com/leptos-rs/leptos/main/docs/logos/Leptos_logo_Solid_White.svg" media="(prefers-color-scheme: dark)">
+    <img src="https://raw.githubusercontent.com/leptos-rs/leptos/main/docs/logos/Leptos_logo_RGB.svg" alt="Leptos Logo">
+</picture>
+
+# Leptos Starter Template
+
+This is a template for use with the [Leptos](https://github.com/leptos-rs/leptos) web framework and the [cargo-leptos](https://github.com/akesson/cargo-leptos) tool.
+
+## Creating your template repo
+
+If you don't have `cargo-leptos` installed you can install it with
+
+`cargo install cargo-leptos`
+
+Then run
+
+`cargo leptos new --git leptos-rs/start`
+
+to generate a new project template.
+
+`cd {projectname}`
+
+to go to your newly created project.
+
+Of course you should explore around the project structure, but the best place to start with your application code is in `src/app.rs`.
+
+## Running your project
+
+`cargo leptos watch`
+
+## Installing Additional Tools
+
+By default, `cargo-leptos` uses `nightly` Rust, `cargo-generate`, and `sass`. If you run into any trouble, you may need to install one or more of these tools.
+
+1. `rustup toolchain install nightly --allow-downgrade` - make sure you have Rust nightly
+2. `rustup default nightly` - setup nightly as default, or you can use rust-toolchain file later on
+3. `rustup target add wasm32-unknown-unknown` - add the ability to compile Rust to WebAssembly
+4. `cargo install cargo-generate` - install `cargo-generate` binary (should be installed automatically in future)
+5. `npm install -g sass` - install `dart-sass` (should be optional in future)
+
+## Executing a Server on a Remote Machine Without the Toolchain
+After running a `cargo leptos build --release` the minimum files needed are:
+
+1. The server binary located in `target/server/release`
+2. The `site` directory and all files within located in `target/site`
+
+Copy these files to your remote server. The directory structure should be:
+```text
+leptos_start
+site/
+```
+Set the following enviornment variables (updating for your project as needed):
+```text
+LEPTOS_OUTPUT_NAME="leptos_start"
+LEPTOS_SITE_ROOT="site"
+LEPTOS_SITE_PKG_DIR="pkg"
+LEPTOS_SITE_ADDR="127.0.0.1:3000"
+LEPTOS_RELOAD_PORT="3001"
+```
+Finally, run the server binary.

leptos/tests/test_examples/suspense-tests/end2end/package-lock.json

@@ -0,0 +1,74 @@
+{
+  "name": "end2end",
+  "version": "1.0.0",
+  "lockfileVersion": 2,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "end2end",
+      "version": "1.0.0",
+      "license": "ISC",
+      "devDependencies": {
+        "@playwright/test": "^1.28.0"
+      }
+    },
+    "node_modules/@playwright/test": {
+      "version": "1.28.0",
+      "resolved": "https://registry.npmjs.org/@playwright/test/-/test-1.28.0.tgz",
+      "integrity": "sha512-vrHs5DFTPwYox5SGKq/7TDn/S4q6RA1zArd7uhO6EyP9hj3XgZBBM12ktMbnDQNxh/fL1IUKsTNLxihmsU38lQ==",
+      "dev": true,
+      "dependencies": {
+        "@types/node": "*",
+        "playwright-core": "1.28.0"
+      },
+      "bin": {
+        "playwright": "cli.js"
+      },
+      "engines": {
+        "node": ">=14"
+      }
+    },
+    "node_modules/@types/node": {
+      "version": "18.11.9",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-18.11.9.tgz",
+      "integrity": "sha512-CRpX21/kGdzjOpFsZSkcrXMGIBWMGNIHXXBVFSH+ggkftxg+XYP20TESbh+zFvFj3EQOl5byk0HTRn1IL6hbqg==",
+      "dev": true
+    },
+    "node_modules/playwright-core": {
+      "version": "1.28.0",
+      "resolved": "https://registry.npmjs.org/playwright-core/-/playwright-core-1.28.0.tgz",
+      "integrity": "sha512-nJLknd28kPBiCNTbqpu6Wmkrh63OEqJSFw9xOfL9qxfNwody7h6/L3O2dZoWQ6Oxcm0VOHjWmGiCUGkc0X3VZA==",
+      "dev": true,
+      "bin": {
+        "playwright": "cli.js"
+      },
+      "engines": {
+        "node": ">=14"
+      }
+    }
+  },
+  "dependencies": {
+    "@playwright/test": {
+      "version": "1.28.0",
+      "resolved": "https://registry.npmjs.org/@playwright/test/-/test-1.28.0.tgz",
+      "integrity": "sha512-vrHs5DFTPwYox5SGKq/7TDn/S4q6RA1zArd7uhO6EyP9hj3XgZBBM12ktMbnDQNxh/fL1IUKsTNLxihmsU38lQ==",
+      "dev": true,
+      "requires": {
+        "@types/node": "*",
+        "playwright-core": "1.28.0"
+      }
+    },
+    "@types/node": {
+      "version": "18.11.9",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-18.11.9.tgz",
+      "integrity": "sha512-CRpX21/kGdzjOpFsZSkcrXMGIBWMGNIHXXBVFSH+ggkftxg+XYP20TESbh+zFvFj3EQOl5byk0HTRn1IL6hbqg==",
+      "dev": true
+    },
+    "playwright-core": {
+      "version": "1.28.0",
+      "resolved": "https://registry.npmjs.org/playwright-core/-/playwright-core-1.28.0.tgz",
+      "integrity": "sha512-nJLknd28kPBiCNTbqpu6Wmkrh63OEqJSFw9xOfL9qxfNwody7h6/L3O2dZoWQ6Oxcm0VOHjWmGiCUGkc0X3VZA==",
+      "dev": true
+    }
+  }
+}

leptos/tests/test_examples/suspense-tests/end2end/package.json

@@ -0,0 +1,13 @@
+{
+  "name": "end2end",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {},
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "devDependencies": {
+    "@playwright/test": "^1.28.0"
+  }
+}

leptos/tests/test_examples/suspense-tests/end2end/playwright.config.ts

@@ -0,0 +1,107 @@
+import type { PlaywrightTestConfig } from "@playwright/test";
+import { devices } from "@playwright/test";
+
+/**
+ * Read environment variables from file.
+ * https://github.com/motdotla/dotenv
+ */
+// require('dotenv').config();
+
+/**
+ * See https://playwright.dev/docs/test-configuration.
+ */
+const config: PlaywrightTestConfig = {
+  testDir: "./tests",
+  /* Maximum time one test can run for. */
+  timeout: 30 * 1000,
+  expect: {
+    /**
+     * Maximum time expect() should wait for the condition to be met.
+     * For example in `await expect(locator).toHaveText();`
+     */
+    timeout: 5000,
+  },
+  /* Run tests in files in parallel */
+  fullyParallel: true,
+  /* Fail the build on CI if you accidentally left test.only in the source code. */
+  forbidOnly: !!process.env.CI,
+  /* Retry on CI only */
+  retries: process.env.CI ? 2 : 0,
+  /* Opt out of parallel tests on CI. */
+  workers: process.env.CI ? 1 : undefined,
+  /* Reporter to use. See https://playwright.dev/docs/test-reporters */
+  reporter: "html",
+  /* Shared settings for all the projects below. See https://playwright.dev/docs/api/class-testoptions. */
+  use: {
+    /* Maximum time each action such as `click()` can take. Defaults to 0 (no limit). */
+    actionTimeout: 0,
+    /* Base URL to use in actions like `await page.goto('/')`. */
+    // baseURL: 'http://localhost:3000',
+
+    /* Collect trace when retrying the failed test. See https://playwright.dev/docs/trace-viewer */
+    trace: "on-first-retry",
+  },
+
+  /* Configure projects for major browsers */
+  projects: [
+    {
+      name: "chromium",
+      use: {
+        ...devices["Desktop Chrome"],
+      },
+    },
+
+    {
+      name: "firefox",
+      use: {
+        ...devices["Desktop Firefox"],
+      },
+    },
+
+    {
+      name: "webkit",
+      use: {
+        ...devices["Desktop Safari"],
+      },
+    },
+
+    /* Test against mobile viewports. */
+    // {
+    //   name: 'Mobile Chrome',
+    //   use: {
+    //     ...devices['Pixel 5'],
+    //   },
+    // },
+    // {
+    //   name: 'Mobile Safari',
+    //   use: {
+    //     ...devices['iPhone 12'],
+    //   },
+    // },
+
+    /* Test against branded browsers. */
+    // {
+    //   name: 'Microsoft Edge',
+    //   use: {
+    //     channel: 'msedge',
+    //   },
+    // },
+    // {
+    //   name: 'Google Chrome',
+    //   use: {
+    //     channel: 'chrome',
+    //   },
+    // },
+  ],
+
+  /* Folder for test artifacts such as screenshots, videos, traces, etc. */
+  // outputDir: 'test-results/',
+
+  /* Run your local dev server before starting the tests */
+  // webServer: {
+  //   command: 'npm run start',
+  //   port: 3000,
+  // },
+};
+
+export default config;

leptos/tests/test_examples/suspense-tests/end2end/tests/example.spec.ts

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

leptos/tests/test_examples/suspense-tests/src/app.rs

@@ -0,0 +1,219 @@
+use leptos::*;
+use leptos_router::*;
+
+#[server(OneSecondFn "/api")]
+async fn one_second_fn(query: ()) -> Result<(), ServerFnError> {
+    tokio::time::sleep(tokio::time::Duration::from_secs(1)).await;
+
+    Ok(())
+}
+
+#[server(TwoSecondFn "/api")]
+async fn two_second_fn(query: ()) -> Result<(), ServerFnError> {
+    tokio::time::sleep(tokio::time::Duration::from_secs(2)).await;
+
+    Ok(())
+}
+
+#[component]
+pub fn App(cx: Scope) -> impl IntoView {
+    let style = r#"
+        nav {
+            display: flex;
+            width: 100%;
+            justify-content: space-around;
+        }
+
+        [aria-current] {
+            font-weight: bold;
+        }
+    "#;
+    view! {
+        cx,
+        <style>{style}</style>
+        <Router>
+            <nav>
+                <A href="/out-of-order">"Out-of-Order"</A>
+                <A href="/in-order">"In-Order"</A>
+                <A href="/async">"Async"</A>
+            </nav>
+            <main>
+                <Routes>
+                    <Route
+                        path=""
+                        view=|cx| view! { cx, <Redirect path="/out-of-order"/> }
+                    />
+                    // out-of-order
+                    <Route
+                        path="out-of-order"
+                        view=|cx| view! { cx,
+                            <SecondaryNav/>
+                            <h1>"Out-of-Order"</h1>
+                            <Outlet/>
+                        }
+                    >
+                        <Route path="" view=|cx| view! { cx, <Nested/> }/>
+                        <Route path="single" view=|cx| view! { cx, <Single/> }/>
+                        <Route path="parallel" view=|cx| view! { cx, <Parallel/> }/>
+                        <Route path="inside-component" view=|cx| view! { cx, <InsideComponent/> }/>
+                    </Route>
+                    // in-order
+                    <Route
+                        path="in-order"
+                        ssr=SsrMode::InOrder
+                        view=|cx| view! { cx,
+                            <SecondaryNav/>
+                            <h1>"In-Order"</h1>
+                            <Outlet/>
+                        }
+                    >
+                        <Route path="" view=|cx| view! { cx, <Nested/> }/>
+                        <Route path="single" view=|cx| view! { cx, <Single/> }/>
+                        <Route path="parallel" view=|cx| view! { cx, <Parallel/> }/>
+                        <Route path="inside-component" view=|cx| view! { cx, <InsideComponent/> }/>
+                    </Route>
+                    // async
+                    <Route
+                        path="async"
+                        ssr=SsrMode::Async
+                        view=|cx| view! { cx,
+                            <SecondaryNav/>
+                            <h1>"Async"</h1>
+                            <Outlet/>
+                        }
+                    >
+                        <Route path="" view=|cx| view! { cx, <Nested/> }/>
+                        <Route path="single" view=|cx| view! { cx, <Single/> }/>
+                        <Route path="parallel" view=|cx| view! { cx, <Parallel/> }/>
+                        <Route path="inside-component" view=|cx| view! { cx, <InsideComponent/> }/>
+                    </Route>
+                </Routes>
+            </main>
+        </Router>
+    }
+}
+
+#[component]
+fn SecondaryNav(cx: Scope) -> impl IntoView {
+    view! { cx,
+        <nav>
+            <A href="" exact=true>"Nested"</A>
+            <A href="single">"Single"</A>
+            <A href="parallel">"Parallel"</A>
+            <A href="inside-component">"Inside Component"</A>
+        </nav>
+    }
+}
+
+#[component]
+fn Nested(cx: Scope) -> impl IntoView {
+    let one_second = create_resource(cx, || (), one_second_fn);
+    let two_second = create_resource(cx, || (), two_second_fn);
+
+    view! { cx,
+        <div>
+            <Suspense fallback=|| "Loading 1...">
+                "One Second: "
+                {move || {
+                    one_second.read(cx).map(|_| "Loaded 1!")
+                }}
+                <br/><br/>
+                <Suspense fallback=|| "Loading 2...">
+                    "Two Second: "
+                    {move || {
+                        two_second.read(cx).map(|_| "Loaded 2!")
+                    }}
+                </Suspense>
+            </Suspense>
+        </div>
+    }
+}
+
+#[component]
+fn Parallel(cx: Scope) -> impl IntoView {
+    let one_second = create_resource(cx, || (), one_second_fn);
+    let two_second = create_resource(cx, || (), two_second_fn);
+    let (count, set_count) = create_signal(cx, 0);
+
+    view! { cx,
+        <div>
+            <Suspense fallback=|| "Loading 1...">
+                "One Second: "
+                {move || {
+                    one_second.read(cx).map(move |_| view! { cx,
+                        "Loaded 1"
+                        <button on:click=move |_| set_count.update(|n| *n += 1)>
+                            {count}
+                        </button>
+                    })
+                }}
+            </Suspense>
+            <br/><br/>
+            <Suspense fallback=|| "Loading 2...">
+                "Two Second: "
+                {move || {
+                    two_second.read(cx).map(move |_| view! { cx,
+                        "Loaded 2"
+                        <button on:click=move |_| set_count.update(|n| *n += 1)>
+                            {count}
+                        </button>
+                    })
+                }}
+            </Suspense>
+        </div>
+    }
+}
+
+#[component]
+fn Single(cx: Scope) -> impl IntoView {
+    let one_second = create_resource(cx, || (), one_second_fn);
+    let (count, set_count) = create_signal(cx, 0);
+
+    view! { cx,
+        <div>
+            <Suspense fallback=|| "Loading 1...">
+                "One Second: "
+                {move || {
+                    one_second.read(cx).map(|_| "Loaded 1!")
+                }}
+            </Suspense>
+            <p>"Children following " <code>"<Suspense/>"</code> " should hydrate properly."</p>
+            <div>
+                <button on:click=move |_| set_count.update(|n| *n += 1)>
+                    {count}
+                </button>
+            </div>
+        </div>
+    }
+}
+
+#[component]
+fn InsideComponent(cx: Scope) -> impl IntoView {
+    let (count, set_count) = create_signal(cx, 0);
+
+    view! { cx,
+        <div>
+            <p><code>"<Suspense/>"</code> " inside another component should work."</p>
+            <InsideComponentChild/>
+            <p>"Children following " <code>"<Suspense/>"</code> " should hydrate properly."</p>
+            <div>
+                <button on:click=move |_| set_count.update(|n| *n += 1)>
+                    {count}
+                </button>
+            </div>
+        </div>
+    }
+}
+
+#[component]
+fn InsideComponentChild(cx: Scope) -> impl IntoView {
+    let one_second = create_resource(cx, || (), one_second_fn);
+    view! { cx,
+        <Suspense fallback=|| "Loading 1...">
+            "One Second: "
+            {move || {
+                one_second.read(cx).map(|_| "Loaded 1!")
+            }}
+        </Suspense>
+    }
+}

leptos/tests/test_examples/suspense-tests/src/lib.rs

@@ -0,0 +1,23 @@
+pub mod app;
+use cfg_if::cfg_if;
+
+cfg_if! {
+if #[cfg(feature = "hydrate")] {
+
+  use wasm_bindgen::prelude::wasm_bindgen;
+
+    #[wasm_bindgen]
+    pub fn hydrate() {
+      use app::*;
+      use leptos::*;
+
+      // initializes logging using the `log` crate
+      _ = console_log::init_with_level(log::Level::Debug);
+      console_error_panic_hook::set_once();
+
+      leptos::mount_to_body(move |cx| {
+          view! { cx, <App/> }
+      });
+    }
+}
+}

leptos/tests/test_examples/suspense-tests/src/main.rs

@@ -0,0 +1,42 @@
+#[cfg(feature = "ssr")]
+#[actix_web::main]
+async fn main() -> std::io::Result<()> {
+    use actix_files::Files;
+    use actix_web::*;
+    use leptos::*;
+    use leptos_actix::{generate_route_list, LeptosRoutes};
+    use leptos_start::app::*;
+
+    let conf = get_configuration(None).await.unwrap();
+    let addr = conf.leptos_options.site_addr;
+    // Generate the list of routes in your Leptos App
+    let routes = generate_route_list(|cx| view! { cx, <App/> });
+
+    OneSecondFn::register().unwrap();
+    TwoSecondFn::register().unwrap();
+
+    HttpServer::new(move || {
+        let leptos_options = &conf.leptos_options;
+        let site_root = &leptos_options.site_root;
+
+        App::new()
+            .route("/api/{tail:.*}", leptos_actix::handle_server_fns())
+            .leptos_routes(
+                leptos_options.to_owned(),
+                routes.to_owned(),
+                |cx| view! { cx, <App/> },
+            )
+            .service(Files::new("/", site_root))
+        //.wrap(middleware::Compress::default())
+    })
+    .bind(addr)?
+    .run()
+    .await
+}
+
+#[cfg(not(feature = "ssr"))]
+pub fn main() {
+    // no client-side main function
+    // unless we want this to work with e.g., Trunk for pure client-side testing
+    // see lib.rs for hydration function instead
+}

leptos_config/Cargo.toml

@@ -10,7 +10,6 @@ readme = "../README.md"
 
 [dependencies]
 config = "0.13.3"
-fs = "0.0.5"
 regex = "1.7.0"
 serde = { version = "1.0.151", features = ["derive"] }
 thiserror = "1.0.38"

leptos_dom/Cargo.toml

@@ -50,6 +50,7 @@ features = [
   "TreeWalker",
 
   # Events we cast to in leptos_macro -- added here so we don't force users to import them
+  "AddEventListenerOptions",
   "AnimationEvent",
   "BeforeUnloadEvent",
   "ClipboardEvent",

leptos_dom/src/events.rs

@@ -28,9 +28,15 @@ pub fn add_event_helper<E: crate::ev::EventDescriptor + 'static>(
             event.event_delegation_key(),
             event_name,
             event_handler,
+            &None,
         );
     } else {
-        add_event_listener_undelegated(target, &event_name, event_handler);
+        add_event_listener_undelegated(
+            target,
+            &event_name,
+            event_handler,
+            &None,
+        );
     }
 }
 
@@ -43,6 +49,7 @@ pub fn add_event_listener<E>(
     event_name: Cow<'static, str>,
     #[cfg(debug_assertions)] mut cb: impl FnMut(E) + 'static,
     #[cfg(not(debug_assertions))] cb: impl FnMut(E) + 'static,
+    options: &Option<web_sys::AddEventListenerOptions>,
 ) where
     E: FromWasmAbi + 'static,
 {
@@ -50,8 +57,10 @@ pub fn add_event_listener<E>(
       if #[cfg(debug_assertions)] {
         let span = ::tracing::Span::current();
         let cb = move |e| {
+          leptos_reactive::SpecialNonReactiveZone::enter();
           let _guard = span.enter();
           cb(e);
+          leptos_reactive::SpecialNonReactiveZone::exit();
         };
       }
     }
@@ -59,7 +68,7 @@ pub fn add_event_listener<E>(
     let cb = Closure::wrap(Box::new(cb) as Box<dyn FnMut(E)>).into_js_value();
     let key = intern(&key);
     _ = js_sys::Reflect::set(target, &JsValue::from_str(&key), &cb);
-    add_delegated_event_listener(&key, event_name);
+    add_delegated_event_listener(&key, event_name, options);
 }
 
 #[doc(hidden)]
@@ -69,22 +78,35 @@ pub(crate) fn add_event_listener_undelegated<E>(
     event_name: &str,
     #[cfg(debug_assertions)] mut cb: impl FnMut(E) + 'static,
     #[cfg(not(debug_assertions))] cb: impl FnMut(E) + 'static,
+    options: &Option<web_sys::AddEventListenerOptions>,
 ) where
     E: FromWasmAbi + 'static,
 {
     cfg_if::cfg_if! {
       if #[cfg(debug_assertions)] {
+        leptos_reactive::SpecialNonReactiveZone::enter();
         let span = ::tracing::Span::current();
         let cb = move |e| {
           let _guard = span.enter();
           cb(e);
         };
+        leptos_reactive::SpecialNonReactiveZone::exit();
       }
     }
 
     let event_name = intern(event_name);
     let cb = Closure::wrap(Box::new(cb) as Box<dyn FnMut(E)>).into_js_value();
-    _ = target.add_event_listener_with_callback(event_name, cb.unchecked_ref());
+    if let Some(options) = options {
+        _ = target
+            .add_event_listener_with_callback_and_add_event_listener_options(
+                event_name,
+                cb.unchecked_ref(),
+                options,
+            );
+    } else {
+        _ = target
+            .add_event_listener_with_callback(event_name, cb.unchecked_ref());
+    }
 }
 
 // cf eventHandler in ryansolid/dom-expressions
@@ -92,6 +114,7 @@ pub(crate) fn add_event_listener_undelegated<E>(
 pub(crate) fn add_delegated_event_listener(
     key: &str,
     event_name: Cow<'static, str>,
+    options: &Option<web_sys::AddEventListenerOptions>,
 ) {
     GLOBAL_EVENTS.with(|global_events| {
         let mut events = global_events.borrow_mut();
@@ -163,10 +186,19 @@ pub(crate) fn add_delegated_event_listener(
 
             let handler = Box::new(handler) as Box<dyn FnMut(web_sys::Event)>;
             let handler = Closure::wrap(handler).into_js_value();
-            _ = crate::window().add_event_listener_with_callback(
-                &event_name,
-                handler.unchecked_ref(),
-            );
+            if let Some(options) = options {
+                _ = crate::window().add_event_listener_with_callback_and_add_event_listener_options(
+                    &event_name,
+                    handler.unchecked_ref(),
+                    options,
+                );
+            } else {
+                _ = crate::window().add_event_listener_with_callback(
+                    &event_name,
+                    handler.unchecked_ref(),
+                );
+
+            }
 
             // register that we've created handler
             events.insert(event_name);

leptos_dom/src/events/typed.rs

@@ -22,6 +22,12 @@ pub trait EventDescriptor: Clone {
     fn bubbles(&self) -> bool {
         true
     }
+
+    /// Return the options for this type. This is only used when you create a [`Custom`] event
+    /// handler.
+    fn options(&self) -> &Option<web_sys::AddEventListenerOptions> {
+        &None
+    }
 }
 
 /// Overrides the [`EventDescriptor::bubbles`] method to always return
@@ -49,6 +55,7 @@ impl<Ev: EventDescriptor> EventDescriptor for undelegated<Ev> {
 /// A custom event.
 pub struct Custom<E: FromWasmAbi = web_sys::Event> {
     name: Cow<'static, str>,
+    options: Option<web_sys::AddEventListenerOptions>,
     _event_type: PhantomData<E>,
 }
 
@@ -56,6 +63,7 @@ impl<E: FromWasmAbi> Clone for Custom<E> {
     fn clone(&self) -> Self {
         Self {
             name: self.name.clone(),
+            options: self.options.clone(),
             _event_type: PhantomData,
         }
     }
@@ -75,6 +83,10 @@ impl<E: FromWasmAbi> EventDescriptor for Custom<E> {
     fn bubbles(&self) -> bool {
         false
     }
+
+    fn options(&self) -> &Option<web_sys::AddEventListenerOptions> {
+        &self.options
+    }
 }
 
 impl<E: FromWasmAbi> Custom<E> {
@@ -84,9 +96,35 @@ impl<E: FromWasmAbi> Custom<E> {
     pub fn new(name: impl Into<Cow<'static, str>>) -> Self {
         Self {
             name: name.into(),
+            options: None,
             _event_type: PhantomData,
         }
     }
+
+    /// Modify the [`AddEventListenerOptions`] used for this event listener.
+    ///
+    /// ```rust
+    /// # use leptos::*;
+    /// # run_scope(create_runtime(), |cx| {
+    /// # let canvas_ref: NodeRef<html::Canvas> = create_node_ref(cx);
+    /// let mut non_passive_wheel = ev::Custom::<ev::WheelEvent>::new("wheel");
+    /// # if false {
+    /// let options = non_passive_wheel.options_mut();
+    /// options.passive(false);
+    /// # }
+    /// canvas_ref.on_load(cx, move |canvas: HtmlElement<html::Canvas>| {
+    ///     canvas.on(non_passive_wheel, move |_event| {
+    ///         // Handle _event
+    ///     });
+    /// });
+    /// # });
+    /// ```
+    ///
+    /// [`AddEventListenerOptions`]: web_sys::AddEventListenerOptions
+    pub fn options_mut(&mut self) -> &mut web_sys::AddEventListenerOptions {
+        self.options
+            .get_or_insert_with(web_sys::AddEventListenerOptions::new)
+    }
 }
 
 macro_rules! generate_event_types {

leptos_dom/src/helpers.rs

@@ -203,8 +203,10 @@ pub fn set_timeout_with_handle(
       if #[cfg(debug_assertions)] {
         let span = ::tracing::Span::current();
         let cb = move || {
+          leptos_reactive::SpecialNonReactiveZone::enter();
           let _guard = span.enter();
           cb();
+          leptos_reactive::SpecialNonReactiveZone::exit();
         };
       }
     }
@@ -241,7 +243,7 @@ pub fn set_timeout_with_handle(
 pub fn debounce<T: 'static>(
     cx: Scope,
     delay: Duration,
-    mut cb: impl FnMut(T) + 'static,
+    #[allow(unused_mut)] mut cb: impl FnMut(T) + 'static,
 ) -> impl FnMut(T) {
     use std::{
         cell::{Cell, RefCell},
@@ -252,8 +254,10 @@ pub fn debounce<T: 'static>(
       if #[cfg(debug_assertions)] {
         let span = ::tracing::Span::current();
         let cb = move |value| {
+          leptos_reactive::SpecialNonReactiveZone::enter();
           let _guard = span.enter();
           cb(value);
+          leptos_reactive::SpecialNonReactiveZone::exit();
         };
       }
     }
@@ -319,8 +323,10 @@ pub fn set_interval(
       if #[cfg(debug_assertions)] {
         let span = ::tracing::Span::current();
         let cb = move || {
+          leptos_reactive::SpecialNonReactiveZone::enter();
           let _guard = span.enter();
           cb();
+          leptos_reactive::SpecialNonReactiveZone::exit();
         };
       }
     }
@@ -349,8 +355,10 @@ pub fn set_interval_with_handle(
       if #[cfg(debug_assertions)] {
         let span = ::tracing::Span::current();
         let cb = move || {
+          leptos_reactive::SpecialNonReactiveZone::enter();
           let _guard = span.enter();
           cb();
+          leptos_reactive::SpecialNonReactiveZone::exit();
         };
       }
     }
@@ -377,8 +385,10 @@ pub fn window_event_listener(
       if #[cfg(debug_assertions)] {
         let span = ::tracing::Span::current();
         let cb = move |e| {
+          leptos_reactive::SpecialNonReactiveZone::enter();
           let _guard = span.enter();
           cb(e);
+          leptos_reactive::SpecialNonReactiveZone::exit();
         };
       }
     }

leptos_dom/src/html.rs

@@ -849,12 +849,14 @@ impl<El: ElementDescriptor + 'static> HtmlElement<El> {
                     key,
                     event_name,
                     event_handler,
+                    event.options(),
                 );
             } else {
                 add_event_listener_undelegated(
                     self.element.as_ref(),
                     &event_name,
                     event_handler,
+                    event.options(),
                 );
             }
 

leptos_dom/src/lib.rs

@@ -681,12 +681,13 @@ impl View {
             match &self {
               Self::Element(el) => {
                 if event.bubbles() {
-                  add_event_listener(&el.element, event.event_delegation_key(), event.name(), event_handler);
+                  add_event_listener(&el.element, event.event_delegation_key(), event.name(), event_handler, &None);
                 } else {
                   add_event_listener_undelegated(
                     &el.element,
                     &event.name(),
                     event_handler,
+                    &None,
                   );
                 }
               }

leptos_dom/src/macro_helpers/into_property.rs

@@ -91,7 +91,7 @@ pub(crate) fn property_helper(
     match value {
         Property::Fn(cx, f) => {
             let el = el.clone();
-            create_render_effect(cx, move |old| {
+            create_render_effect(cx, move |_| {
                 let new = f();
                 let prop_name = wasm_bindgen::intern(&name);
                 property_expression(&el, prop_name, new.clone());

leptos_dom/src/ssr.rs

@@ -219,8 +219,8 @@ fn fragments_to_chunks(
                 <template id="{fragment_id}f">{html}</template>
                 <script>
                     var id = "{fragment_id}";
-                    var open;
-                    var close;
+                    var open = undefined;
+                    var close = undefined;
                     var walker = document.createTreeWalker(document.body, NodeFilter.SHOW_COMMENT);
                     while(walker.nextNode()) {{
                          if(walker.currentNode.textContent == `suspense-open-${{id}}`) {{
@@ -249,7 +249,9 @@ impl View {
 
     pub(crate) fn render_to_string_helper(self) -> Cow<'static, str> {
         match self {
-            View::Text(node) => node.content,
+            View::Text(node) => {
+                html_escape::encode_safe(&node.content).to_string().into()
+            }
             View::Component(node) => {
                 let content = || {
                     node.children

leptos_dom/src/ssr_in_order.rs

@@ -392,12 +392,12 @@ impl View {
                                                     StreamChunk::Sync(
                                                         format!(
                                                             "<!>{}",
-                                                            t.content
+                                                            html_escape::encode_safe(&t.content)
                                                         )
                                                         .into(),
                                                     )
                                                 } else {
-                                                    StreamChunk::Sync(t.content)
+                                                    StreamChunk::Sync(html_escape::encode_safe(&t.content).to_string().into())
                                                 },
                                             );
                                         } else {

leptos_macro/src/component.rs

@@ -137,6 +137,7 @@ impl ToTokens for Model {
         let lifetimes = body.sig.generics.lifetimes();
 
         let props_name = format_ident!("{name}Props");
+        let props_builder_name = format_ident!("{name}PropsBuilder");
         let trace_name = format!("<{name} />");
 
         let prop_builder_fields = prop_builder_fields(vis, props);
@@ -200,6 +201,13 @@ impl ToTokens for Model {
                 #prop_builder_fields
             }
 
+            impl #generics ::leptos::Props for #props_name #generics #where_clause {
+                type Builder = #props_builder_name #generics;
+                fn builder() -> Self::Builder {
+                    #props_name::builder()
+                }
+            }
+
             #docs
             #component_fn_prop_docs
             #[allow(non_snake_case, clippy::too_many_arguments)]

leptos_macro/src/lib.rs

@@ -697,6 +697,7 @@ pub fn component(args: proc_macro::TokenStream, s: TokenStream) -> TokenStream {
 ///   can be a Leptos `Scope`. This scope can be used to inject dependencies like the HTTP request
 ///   or response or other server-only dependencies, but it does *not* have access to reactive state that exists in the client.
 #[proc_macro_attribute]
+#[proc_macro_error]
 pub fn server(args: proc_macro::TokenStream, s: TokenStream) -> TokenStream {
     let context = ServerContext {
         ty: syn::parse_quote!(Scope),

leptos_macro/src/view.rs

@@ -1062,7 +1062,6 @@ pub(crate) fn component_to_tokens(
     let name = &node.name;
     let component_name = ident_from_tag_name(&node.name);
     let span = node.name.span();
-    let component_props_name = format_ident!("{component_name}Props");
 
     let attrs = node.attributes.iter().filter_map(|node| {
         if let Node::Attribute(node) = node {
@@ -1154,7 +1153,7 @@ pub(crate) fn component_to_tokens(
     let component = quote! {
         #name(
             #cx,
-            #component_props_name::builder()
+            ::leptos::component_props_builder(&#name)
                 #(#props)*
                 #children
                 .build()

leptos_reactive/Cargo.toml

@@ -42,8 +42,13 @@ web-sys = { version = "0.3", optional = true, features = [
 ] }
 cfg-if = "1"
 indexmap = "1"
+ouroboros = { version = "0.15.6", default-features = false }
 
 [dev-dependencies]
+criterion = { version = "0.4.0", features = ["html_reports"] }
+reactive-signals = { version = "0.1.0-alpha.4", features = ["profile"] }
+l021 = { package = "leptos", version = "0.2.1" }
+sycamore = { version = "0.8", features = ["ssr"] }
 log = "0.4"
 tokio-test = "0.4"
 leptos = { path = "../leptos" }
@@ -109,3 +114,15 @@ skip_feature_sets = [
     "rkyv",
   ],
 ]
+
+[[bench]]
+name = "deep_update"
+harness = false
+
+[[bench]]
+name = "fan_out"
+harness = false
+
+[[bench]]
+name = "narrow_down"
+harness = false

leptos_reactive/benches/deep_update.rs

@@ -0,0 +1,110 @@
+use criterion::{criterion_group, criterion_main, Criterion};
+
+fn rs_deep_update(c: &mut Criterion) {
+    use reactive_signals::{
+        runtimes::ClientRuntime, signal, types::Func, Signal,
+    };
+
+    c.bench_function("rs_deep_update", |b| {
+        b.iter(|| {
+            let sc = ClientRuntime::bench_root_scope();
+            let signal = signal!(sc, 0);
+            let mut memos = Vec::<Signal<Func<i32>, ClientRuntime>>::new();
+            for i in 0..1000usize {
+                let prev = memos.get(i.saturating_sub(1)).copied();
+                if let Some(prev) = prev {
+                    memos.push(signal!(sc, move || prev.get() + 1))
+                } else {
+                    memos.push(signal!(sc, move || signal.get() + 1))
+                }
+            }
+            signal.set(1);
+            assert_eq!(memos[999].get(), 1001);
+        });
+    });
+}
+
+fn l021_deep_update(c: &mut Criterion) {
+    use l021::*;
+
+    c.bench_function("l021_deep_update", |b| {
+        let runtime = create_runtime();
+        b.iter(|| {
+            create_scope(runtime, |cx| {
+                let signal = create_rw_signal(cx, 0);
+                let mut memos = Vec::<Memo<usize>>::new();
+                for i in 0..1000usize {
+                    let prev = memos.get(i.saturating_sub(1)).copied();
+                    if let Some(prev) = prev {
+                        memos.push(create_memo(cx, move |_| prev.get() + 1));
+                    } else {
+                        memos.push(create_memo(cx, move |_| signal.get() + 1));
+                    }
+                }
+                signal.set(1);
+                assert_eq!(memos[999].get(), 1001);
+            })
+            .dispose()
+        });
+        runtime.dispose();
+    });
+}
+
+fn sycamore_deep_update(c: &mut Criterion) {
+    use sycamore::reactive::*;
+
+    c.bench_function("sycamore_deep_update", |b| {
+        b.iter(|| {
+            let d = create_scope(|cx| {
+                let signal = create_signal(cx, 0);
+                let mut memos = Vec::<&ReadSignal<usize>>::new();
+                for i in 0..1000usize {
+                    let prev = memos.get(i.saturating_sub(1)).copied();
+                    if let Some(prev) = prev {
+                        memos.push(create_memo(cx, move || *prev.get() + 1));
+                    } else {
+                        memos.push(create_memo(cx, move || *signal.get() + 1));
+                    }
+                }
+                signal.set(1);
+                assert_eq!(*memos[999].get(), 1001);
+            });
+            unsafe { d.dispose() };
+        });
+    });
+}
+
+fn leptos_deep_update(c: &mut Criterion) {
+    use leptos::*;
+    let runtime = create_runtime();
+
+    c.bench_function("leptos_deep_update", |b| {
+        b.iter(|| {
+            create_scope(runtime, |cx| {
+                let signal = create_rw_signal(cx, 0);
+                let mut memos = Vec::<Memo<usize>>::new();
+                for i in 0..1000usize {
+                    let prev = memos.get(i.saturating_sub(1)).copied();
+                    if let Some(prev) = prev {
+                        memos.push(create_memo(cx, move |_| prev.get() + 1));
+                    } else {
+                        memos.push(create_memo(cx, move |_| signal.get() + 1));
+                    }
+                }
+                signal.set(1);
+                assert_eq!(memos[999].get(), 1001);
+            })
+            .dispose()
+        });
+    });
+    runtime.dispose();
+}
+
+criterion_group!(
+    deep,
+    rs_deep_update,
+    l021_deep_update,
+    sycamore_deep_update,
+    leptos_deep_update
+);
+criterion_main!(deep);

leptos_reactive/benches/fan_out.rs

@@ -0,0 +1,93 @@
+use criterion::{criterion_group, criterion_main, Criterion};
+
+fn rs_fan_out(c: &mut Criterion) {
+    use reactive_signals::{
+        runtimes::ClientRuntime, signal, types::Func, Signal,
+    };
+
+    c.bench_function("rs_fan_out", |b| {
+        b.iter(|| {
+            let cx = ClientRuntime::bench_root_scope();
+            let sig = signal!(cx, 0);
+            let memos = (0..1000)
+                .map(|_| signal!(cx, move || sig.get()))
+                .collect::<Vec<_>>();
+            assert_eq!(memos.iter().map(|m| m.get()).sum::<i32>(), 0);
+            sig.set(1);
+            assert_eq!(memos.iter().map(|m| m.get()).sum::<i32>(), 1000);
+        });
+    });
+}
+
+fn l021_fan_out(c: &mut Criterion) {
+    use l021::*;
+
+    c.bench_function("l021_fan_out", |b| {
+        let runtime = create_runtime();
+        b.iter(|| {
+            create_scope(runtime, |cx| {
+                let sig = create_rw_signal(cx, 0);
+                let memos = (0..1000)
+                    .map(|_| create_memo(cx, move |_| sig.get()))
+                    .collect::<Vec<_>>();
+                assert_eq!(memos.iter().map(|m| m.get()).sum::<i32>(), 0);
+                sig.set(1);
+                assert_eq!(memos.iter().map(|m| m.get()).sum::<i32>(), 1000);
+            })
+            .dispose()
+        });
+        runtime.dispose();
+    });
+}
+
+fn sycamore_fan_out(c: &mut Criterion) {
+    use sycamore::reactive::*;
+
+    c.bench_function("sycamore_fan_out", |b| {
+        b.iter(|| {
+            let d = create_scope(|cx| {
+                let sig = create_signal(cx, 0);
+                let memos = (0..1000)
+                    .map(|_| create_memo(cx, move || sig.get()))
+                    .collect::<Vec<_>>();
+                assert_eq!(memos.iter().map(|m| *(*m.get())).sum::<i32>(), 0);
+                sig.set(1);
+                assert_eq!(
+                    memos.iter().map(|m| *(*m.get())).sum::<i32>(),
+                    1000
+                );
+            });
+            unsafe { d.dispose() };
+        });
+    });
+}
+
+fn leptos_fan_out(c: &mut Criterion) {
+    use leptos_reactive::*;
+    let runtime = create_runtime();
+
+    c.bench_function("leptos_fan_out", |b| {
+        b.iter(|| {
+            create_scope(runtime, |cx| {
+                let sig = create_rw_signal(cx, 0);
+                let memos = (0..1000)
+                    .map(|_| create_memo(cx, move |_| sig.get()))
+                    .collect::<Vec<_>>();
+                assert_eq!(memos.iter().map(|m| m.get()).sum::<i32>(), 0);
+                sig.set(1);
+                assert_eq!(memos.iter().map(|m| m.get()).sum::<i32>(), 1000);
+            })
+            .dispose()
+        });
+    });
+    runtime.dispose();
+}
+
+criterion_group!(
+    fan_out,
+    rs_fan_out,
+    l021_fan_out,
+    sycamore_fan_out,
+    leptos_fan_out
+);
+criterion_main!(fan_out);

leptos_reactive/benches/narrow_down.rs

@@ -0,0 +1,98 @@
+use criterion::{criterion_group, criterion_main, Criterion};
+use std::{cell::Cell, rc::Rc};
+
+fn rs_narrow_down(c: &mut Criterion) {
+    use reactive_signals::{
+        runtimes::ClientRuntime, signal, types::Func, Signal,
+    };
+
+    c.bench_function("rs_narrow_down", |b| {
+        b.iter(|| {
+            let cx = ClientRuntime::bench_root_scope();
+            let acc = Rc::new(Cell::new(0));
+            let sigs =
+                Rc::new((0..1000).map(|n| signal!(cx, n)).collect::<Vec<_>>());
+            let memo = signal!(cx, {
+                let sigs = Rc::clone(&sigs);
+                move || sigs.iter().map(|r| r.get()).sum::<i32>()
+            });
+            assert_eq!(memo.get(), 499500);
+        });
+    });
+}
+
+fn l021_narrow_down(c: &mut Criterion) {
+    use l021::*;
+
+    c.bench_function("l021_narrow_down", |b| {
+        let runtime = create_runtime();
+        b.iter(|| {
+            create_scope(runtime, |cx| {
+                let acc = Rc::new(Cell::new(0));
+                let sigs =
+                    (0..1000).map(|n| create_signal(cx, n)).collect::<Vec<_>>();
+                let reads = sigs.iter().map(|(r, _)| *r).collect::<Vec<_>>();
+                let writes = sigs.iter().map(|(_, w)| *w).collect::<Vec<_>>();
+                let memo = create_memo(cx, move |_| {
+                    reads.iter().map(|r| r.get()).sum::<i32>()
+                });
+                assert_eq!(memo(), 499500);
+            })
+            .dispose()
+        });
+        runtime.dispose();
+    });
+}
+
+fn sycamore_narrow_down(c: &mut Criterion) {
+    use sycamore::reactive::*;
+
+    c.bench_function("sycamore_narrow_down", |b| {
+        b.iter(|| {
+            let d = create_scope(|cx| {
+                let acc = Rc::new(Cell::new(0));
+                let sigs = Rc::new(
+                    (0..1000).map(|n| create_signal(cx, n)).collect::<Vec<_>>(),
+                );
+                let memo = create_memo(cx, {
+                    let sigs = Rc::clone(&sigs);
+                    move || sigs.iter().map(|r| *r.get()).sum::<i32>()
+                });
+                assert_eq!(*memo.get(), 499500);
+            });
+            unsafe { d.dispose() };
+        });
+    });
+}
+
+fn leptos_narrow_down(c: &mut Criterion) {
+    use leptos_reactive::*;
+    let runtime = create_runtime();
+
+    c.bench_function("leptos_narrow_down", |b| {
+        b.iter(|| {
+            create_scope(runtime, |cx| {
+                let acc = Rc::new(Cell::new(0));
+                let sigs =
+                    (0..1000).map(|n| create_signal(cx, n)).collect::<Vec<_>>();
+                let reads = sigs.iter().map(|(r, _)| *r).collect::<Vec<_>>();
+                let writes = sigs.iter().map(|(_, w)| *w).collect::<Vec<_>>();
+                let memo = create_memo(cx, move |_| {
+                    reads.iter().map(|r| r.get()).sum::<i32>()
+                });
+                assert_eq!(memo(), 499500);
+            })
+            .dispose()
+        });
+    });
+    runtime.dispose();
+}
+
+criterion_group!(
+    narrow_down,
+    rs_narrow_down,
+    l021_narrow_down,
+    sycamore_narrow_down,
+    leptos_narrow_down
+);
+criterion_main!(narrow_down);

leptos_reactive/src/diagnostics.rs

@@ -0,0 +1,77 @@
+use cfg_if::cfg_if;
+
+// The point of these diagnostics is to give useful error messages when someone
+// tries to access a reactive variable outside the reactive scope. They track when
+// you create a signal/memo, and where you access it non-reactively.
+
+#[cfg(debug_assertions)]
+#[allow(dead_code)] // allowed for SSR
+#[derive(Copy, Clone)]
+pub(crate) struct AccessDiagnostics {
+    pub defined_at: &'static std::panic::Location<'static>,
+    pub called_at: &'static std::panic::Location<'static>,
+}
+
+#[cfg(not(debug_assertions))]
+#[derive(Copy, Clone, Default)]
+pub(crate) struct AccessDiagnostics {}
+
+/// This just tracks whether we're currently in a context in which it really doesn't
+/// matter whether something is reactive: for example, in an event listener or timeout.
+/// Entering this zone basically turns off the warnings, and exiting it turns them back on.
+/// All of this is a no-op in release mode.
+#[doc(hidden)]
+pub struct SpecialNonReactiveZone {}
+
+cfg_if! {
+    if #[cfg(debug_assertions)] {
+        use std::cell::Cell;
+
+        thread_local! {
+            static IS_SPECIAL_ZONE: Cell<bool> = Cell::new(false);
+        }
+    }
+}
+
+impl SpecialNonReactiveZone {
+    #[allow(dead_code)] // allowed for SSR
+    pub(crate) fn is_inside() -> bool {
+        #[cfg(debug_assertions)]
+        {
+            IS_SPECIAL_ZONE.with(|val| val.get())
+        }
+        #[cfg(not(debug_assertions))]
+        false
+    }
+
+    pub fn enter() {
+        #[cfg(debug_assertions)]
+        {
+            IS_SPECIAL_ZONE.with(|val| val.set(true))
+        }
+    }
+
+    pub fn exit() {
+        #[cfg(debug_assertions)]
+        {
+            IS_SPECIAL_ZONE.with(|val| val.set(false))
+        }
+    }
+}
+
+#[doc(hidden)]
+#[macro_export]
+macro_rules! diagnostics {
+    ($this:ident) => {{
+        cfg_if! {
+            if #[cfg(debug_assertions)] {
+                AccessDiagnostics {
+                    defined_at: $this.defined_at,
+                    called_at: std::panic::Location::caller()
+                }
+            } else {
+                AccessDiagnostics { }
+            }
+        }
+    }};
+}

leptos_reactive/src/lib.rs

@@ -72,6 +72,8 @@ extern crate tracing;
 #[macro_use]
 mod signal;
 mod context;
+#[macro_use]
+mod diagnostics;
 mod effect;
 mod hydration;
 mod memo;
@@ -90,6 +92,7 @@ mod stored_value;
 pub mod suspense;
 
 pub use context::*;
+pub use diagnostics::SpecialNonReactiveZone;
 pub use effect::*;
 pub use memo::*;
 pub use resource::*;
@@ -127,8 +130,11 @@ mod macros {
 }
 
 pub(crate) fn console_warn(s: &str) {
-    #[cfg(not(any(feature = "csr", feature = "hydrate")))]
-    eprintln!("{s}");
-    #[cfg(any(feature = "csr", feature = "hydrate"))]
-    web_sys::console::warn_1(&wasm_bindgen::JsValue::from_str(s));
+    cfg_if::cfg_if! {
+        if #[cfg(all(target_arch = "wasm32", any(feature = "csr", feature = "hydrate")))] {
+            web_sys::console::warn_1(&wasm_bindgen::JsValue::from_str(s));
+        } else {
+            eprintln!("{s}");
+        }
+    }
 }

leptos_reactive/src/memo.rs

@@ -1,9 +1,10 @@
 #![forbid(unsafe_code)]
 use crate::{
-    create_effect, node::NodeId, on_cleanup, with_runtime, AnyComputation,
-    RuntimeId, Scope, SignalDispose, SignalGet, SignalGetUntracked,
-    SignalStream, SignalWith, SignalWithUntracked,
+    create_effect, diagnostics::AccessDiagnostics, node::NodeId, on_cleanup,
+    with_runtime, AnyComputation, RuntimeId, Scope, SignalDispose, SignalGet,
+    SignalGetUntracked, SignalStream, SignalWith, SignalWithUntracked,
 };
+use cfg_if::cfg_if;
 use std::{any::Any, cell::RefCell, fmt::Debug, marker::PhantomData, rc::Rc};
 
 /// Creates an efficient derived reactive value based on other reactive values.
@@ -70,6 +71,7 @@ use std::{any::Any, cell::RefCell, fmt::Debug, marker::PhantomData, rc::Rc};
         )
     )
 )]
+#[track_caller]
 pub fn create_memo<T>(
     cx: Scope,
     f: impl Fn(Option<&T>) -> T + 'static,
@@ -306,6 +308,7 @@ impl<T: Clone> SignalGet<T> for Memo<T> {
             )
         )
     )]
+    #[track_caller]
     fn get(&self) -> T {
         self.with(T::clone)
     }
@@ -323,6 +326,7 @@ impl<T: Clone> SignalGet<T> for Memo<T> {
             )
         )
     )]
+    #[track_caller]
     fn try_get(&self) -> Option<T> {
         self.try_with(T::clone)
     }
@@ -342,6 +346,7 @@ impl<T> SignalWith<T> for Memo<T> {
             )
         )
     )]
+    #[track_caller]
     fn with<O>(&self, f: impl FnOnce(&T) -> O) -> O {
         match self.try_with(f) {
             Some(t) => t,
@@ -365,13 +370,16 @@ impl<T> SignalWith<T> for Memo<T> {
             )
         )
     )]
+    #[track_caller]
     fn try_with<O>(&self, f: impl FnOnce(&T) -> O) -> Option<O> {
         // memo is stored as Option<T>, but will always have T available
         // after latest_value() called, so we can unwrap safely
         let f = move |maybe_value: &Option<T>| f(maybe_value.as_ref().unwrap());
 
+        let diagnostics = diagnostics!(self);
+
         with_runtime(self.runtime, |runtime| {
-            self.id.subscribe(runtime);
+            self.id.subscribe(runtime, diagnostics);
             self.id.try_with_no_subscription(runtime, f).ok()
         })
         .ok()

leptos_reactive/src/node.rs

@@ -25,4 +25,7 @@ pub(crate) enum ReactiveNodeState {
     Clean,
     Check,
     Dirty,
+
+    /// Dirty and Marked as visited
+    DirtyMarked,
 }

leptos_reactive/src/runtime.rs

@@ -76,11 +76,20 @@ impl Runtime {
         if self.current_state(node_id) == ReactiveNodeState::Check {
             let sources = {
                 let sources = self.node_sources.borrow();
-                sources.get(node_id).map(|n| n.borrow().clone())
+
+                // rather than cloning the entire FxIndexSet, only allocate a `Vec` for the node ids
+                sources.get(node_id).map(|n| {
+                    let sources = n.borrow();
+                    // in case Vec::from_iterator specialization doesn't work, do it manually
+                    let mut sources_vec = Vec::with_capacity(sources.len());
+                    sources_vec.extend(sources.iter().cloned());
+                    sources_vec
+                })
             };
+
             for source in sources.into_iter().flatten() {
                 self.update_if_necessary(source);
-                if self.current_state(node_id) == ReactiveNodeState::Dirty {
+                if self.current_state(node_id) >= ReactiveNodeState::Dirty {
                     // as soon as a single parent has marked us dirty, we can
                     // stop checking them to avoid over-re-running
                     break;
@@ -89,7 +98,7 @@ impl Runtime {
         }
 
         // if we're dirty at this point, update
-        if self.current_state(node_id) == ReactiveNodeState::Dirty {
+        if self.current_state(node_id) >= ReactiveNodeState::Dirty {
             self.update(node_id);
         }
 
@@ -103,10 +112,7 @@ impl Runtime {
             let nodes = self.nodes.borrow();
             nodes.get(node_id).cloned()
         };
-        let subs = {
-            let subs = self.node_subscribers.borrow();
-            subs.get(node_id).cloned()
-        };
+
         if let Some(node) = node {
             // memos and effects rerun
             // signals simply have their value
@@ -126,7 +132,9 @@ impl Runtime {
 
             // mark children dirty
             if changed {
-                if let Some(subs) = subs {
+                let subs = self.node_subscribers.borrow();
+
+                if let Some(subs) = subs.get(node_id) {
                     let mut nodes = self.nodes.borrow_mut();
                     for sub_id in subs.borrow().iter() {
                         if let Some(sub) = nodes.get_mut(*sub_id) {
@@ -179,6 +187,7 @@ impl Runtime {
         }
     }
 
+    #[allow(clippy::await_holding_refcell_ref)] // not using this part of ouroboros
     pub(crate) fn mark_dirty(&self, node: NodeId) {
         //crate::macros::debug_warn!("marking {node:?} dirty");
         let mut nodes = self.nodes.borrow_mut();
@@ -196,24 +205,89 @@ impl Runtime {
                 current_observer,
             );
 
-            // mark all children check
-            // this can probably be done in a better way
-            let mut descendants = Default::default();
-            Runtime::gather_descendants(&subscribers, node, &mut descendants);
-            for descendant in descendants {
-                if let Some(node) = nodes.get_mut(descendant) {
-                    Runtime::mark(
-                        descendant,
-                        node,
-                        ReactiveNodeState::Check,
-                        &mut pending_effects,
-                        current_observer,
-                    );
+            /*
+             * Depth-first DAG traversal that uses a stack of iterators instead of
+             * buffering the entire to-visit list. Visited nodes are either marked as
+             * `Check` or `DirtyMarked`.
+             *
+             * Because `RefCell`, borrowing the iterators all at once is difficult,
+             * so a self-referential struct is used instead. ouroboros produces safe
+             * code, but it would not be recommended to use this outside of this
+             * algorithm.
+             */
+
+            #[ouroboros::self_referencing]
+            struct RefIter<'a> {
+                set: std::cell::Ref<'a, FxIndexSet<NodeId>>,
+
+                // Boxes the iterator internally
+                #[borrows(set)]
+                #[covariant]
+                iter: indexmap::set::Iter<'this, NodeId>,
+            }
+
+            /// Due to the limitations of ouroboros, we cannot borrow the
+            /// stack and iter simultaneously, or directly within the loop,
+            /// therefore this must be used to command the outside scope
+            /// of what to do.
+            enum IterResult<'a> {
+                Continue,
+                Empty,
+                NewIter(RefIter<'a>),
+            }
+
+            let mut stack = Vec::new();
+
+            if let Some(children) = subscribers.get(node) {
+                stack.push(RefIter::new(children.borrow(), |children| {
+                    children.iter()
+                }));
+            }
+
+            while let Some(iter) = stack.last_mut() {
+                let res = iter.with_iter_mut(|iter| {
+                    let Some(&child) = iter.next() else {
+                        return IterResult::Empty;
+                    };
+
+                    if let Some(node) = nodes.get_mut(child) {
+                        if node.state == ReactiveNodeState::Check
+                            || node.state == ReactiveNodeState::DirtyMarked
+                        {
+                            return IterResult::Continue;
+                        }
+
+                        Runtime::mark(
+                            child,
+                            node,
+                            ReactiveNodeState::Check,
+                            &mut pending_effects,
+                            current_observer,
+                        );
+
+                        if let Some(children) = subscribers.get(child) {
+                            return IterResult::NewIter(RefIter::new(
+                                children.borrow(),
+                                |children| children.iter(),
+                            ));
+                        }
+                    }
+
+                    IterResult::Continue
+                });
+
+                match res {
+                    IterResult::Continue => continue,
+                    IterResult::NewIter(iter) => stack.push(iter),
+                    IterResult::Empty => {
+                        stack.pop();
+                    }
                 }
             }
         }
     }
 
+    #[inline(always)] // small function, used in hot loop
     fn mark(
         //nodes: &mut SlotMap<NodeId, ReactiveNode>,
         node_id: NodeId,
@@ -226,24 +300,16 @@ impl Runtime {
         if level > node.state {
             node.state = level;
         }
-        if matches!(node.node_type, ReactiveNodeType::Effect { .. })
-            && current_observer != Some(node_id)
+
+        if matches!(node.node_type, ReactiveNodeType::Effect { .. } if current_observer != Some(node_id))
         {
             //crate::macros::debug_warn!("pushing effect {node_id:?}");
-            pending_effects.push(node_id);
+            //debug_assert!(!pending_effects.contains(&node_id));
+            pending_effects.push(node_id)
         }
-    }
 
-    fn gather_descendants(
-        subscribers: &SecondaryMap<NodeId, RefCell<FxIndexSet<NodeId>>>,
-        node: NodeId,
-        descendants: &mut FxIndexSet<NodeId>,
-    ) {
-        if let Some(children) = subscribers.get(node) {
-            for child in children.borrow().iter() {
-                descendants.insert(*child);
-                Runtime::gather_descendants(subscribers, *child, descendants);
-            }
+        if node.state == ReactiveNodeState::Dirty {
+            node.state = ReactiveNodeState::DirtyMarked;
         }
     }
 
@@ -314,11 +380,17 @@ pub fn create_runtime() -> RuntimeId {
     }
 }
 
+#[cfg(not(any(feature = "csr", feature = "hydrate")))]
 slotmap::new_key_type! {
     /// Unique ID assigned to a [Runtime](crate::Runtime).
     pub struct RuntimeId;
 }
 
+/// Unique ID assigned to a [Runtime](crate::Runtime).
+#[cfg(any(feature = "csr", feature = "hydrate"))]
+#[derive(Default, Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct RuntimeId;
+
 impl RuntimeId {
     /// Removes the runtime, disposing all its child [Scope](crate::Scope)s.
     pub fn dispose(self) {

leptos_reactive/src/scope.rs

@@ -5,7 +5,8 @@ use crate::{
     node::NodeId,
     runtime::{with_runtime, RuntimeId},
     suspense::StreamChunk,
-    PinnedFuture, ResourceId, StoredValueId, SuspenseContext,
+    PinnedFuture, ResourceId, SpecialNonReactiveZone, StoredValueId,
+    SuspenseContext,
 };
 use futures::stream::FuturesUnordered;
 use std::{
@@ -176,9 +177,11 @@ impl Scope {
     /// ```
     pub fn untrack<T>(&self, f: impl FnOnce() -> T) -> T {
         with_runtime(self.runtime, |runtime| {
+            SpecialNonReactiveZone::enter();
             let prev_observer = runtime.observer.take();
             let untracked_result = f();
             runtime.observer.set(prev_observer);
+            SpecialNonReactiveZone::exit();
             untracked_result
         })
         .expect(

leptos_reactive/src/signal.rs

@@ -1,6 +1,7 @@
 #![forbid(unsafe_code)]
 use crate::{
-    console_warn, create_effect,
+    console_warn, create_effect, diagnostics,
+    diagnostics::*,
     macros::debug_warn,
     node::NodeId,
     on_cleanup,
@@ -532,6 +533,7 @@ impl<T: Clone> SignalGetUntracked<T> for ReadSignal<T> {
             )
         )
     )]
+    #[track_caller]
     fn try_get_untracked(&self) -> Option<T> {
         with_runtime(self.runtime, |runtime| {
             self.id.try_with_no_subscription(runtime, Clone::clone).ok()
@@ -572,12 +574,17 @@ impl<T> SignalWithUntracked<T> for ReadSignal<T> {
             )
         )
     )]
+    #[track_caller]
     fn try_with_untracked<O>(&self, f: impl FnOnce(&T) -> O) -> Option<O> {
-        with_runtime(self.runtime, |runtime| self.id.try_with(runtime, f))
-            .ok()
-            .transpose()
-            .ok()
-            .flatten()
+        let diagnostics = diagnostics!(self);
+
+        with_runtime(self.runtime, |runtime| {
+            self.id.try_with(runtime, f, diagnostics)
+        })
+        .ok()
+        .transpose()
+        .ok()
+        .flatten()
     }
 }
 
@@ -613,9 +620,14 @@ impl<T> SignalWith<T> for ReadSignal<T> {
             )
         )
     )]
+    #[track_caller]
     fn with<O>(&self, f: impl FnOnce(&T) -> O) -> O {
-        match with_runtime(self.runtime, |runtime| self.id.try_with(runtime, f))
-            .expect("runtime to be alive ")
+        let diagnostics = diagnostics!(self);
+
+        match with_runtime(self.runtime, |runtime| {
+            self.id.try_with(runtime, f, diagnostics)
+        })
+        .expect("runtime to be alive ")
         {
             Ok(o) => o,
             Err(_) => panic_getting_dead_signal(
@@ -638,10 +650,15 @@ impl<T> SignalWith<T> for ReadSignal<T> {
             )
         )
     )]
+    #[track_caller]
     fn try_with<O>(&self, f: impl FnOnce(&T) -> O) -> Option<O> {
-        with_runtime(self.runtime, |runtime| self.id.try_with(runtime, f).ok())
-            .ok()
-            .flatten()
+        let diagnostics = diagnostics!(self);
+
+        with_runtime(self.runtime, |runtime| {
+            self.id.try_with(runtime, f, diagnostics).ok()
+        })
+        .ok()
+        .flatten()
     }
 }
 
@@ -672,9 +689,12 @@ impl<T: Clone> SignalGet<T> for ReadSignal<T> {
             )
         )
     )]
+    #[track_caller]
     fn get(&self) -> T {
+        let diagnostics = diagnostics!(self);
+
         match with_runtime(self.runtime, |runtime| {
-            self.id.try_with(runtime, T::clone)
+            self.id.try_with(runtime, T::clone, diagnostics)
         })
         .expect("runtime to be alive")
         {
@@ -751,12 +771,16 @@ where
 
     /// Applies the function to the current Signal, if it exists, and subscribes
     /// the running effect.
+    #[track_caller]
     pub(crate) fn try_with<U>(
         &self,
         f: impl FnOnce(&T) -> U,
     ) -> Result<U, SignalError> {
-        match with_runtime(self.runtime, |runtime| self.id.try_with(runtime, f))
-        {
+        let diagnostics = diagnostics!(self);
+
+        match with_runtime(self.runtime, |runtime| {
+            self.id.try_with(runtime, f, diagnostics)
+        }) {
             Ok(Ok(v)) => Ok(v),
             Ok(Err(e)) => Err(e),
             Err(_) => Err(SignalError::RuntimeDisposed),
@@ -1245,12 +1269,17 @@ impl<T> SignalWithUntracked<T> for RwSignal<T> {
             )
         )
     )]
+    #[track_caller]
     fn try_with_untracked<O>(&self, f: impl FnOnce(&T) -> O) -> Option<O> {
-        with_runtime(self.runtime, |runtime| self.id.try_with(runtime, f))
-            .ok()
-            .transpose()
-            .ok()
-            .flatten()
+        let diagnostics = diagnostics!(self);
+
+        with_runtime(self.runtime, |runtime| {
+            self.id.try_with(runtime, f, diagnostics)
+        })
+        .ok()
+        .transpose()
+        .ok()
+        .flatten()
     }
 }
 
@@ -1388,9 +1417,14 @@ impl<T> SignalWith<T> for RwSignal<T> {
             )
         )
     )]
+    #[track_caller]
     fn with<O>(&self, f: impl FnOnce(&T) -> O) -> O {
-        match with_runtime(self.runtime, |runtime| self.id.try_with(runtime, f))
-            .expect("runtime to be alive")
+        let diagnostics = diagnostics!(self);
+
+        match with_runtime(self.runtime, |runtime| {
+            self.id.try_with(runtime, f, diagnostics)
+        })
+        .expect("runtime to be alive")
         {
             Ok(o) => o,
             Err(_) => panic_getting_dead_signal(
@@ -1413,10 +1447,15 @@ impl<T> SignalWith<T> for RwSignal<T> {
             )
         )
     )]
+    #[track_caller]
     fn try_with<O>(&self, f: impl FnOnce(&T) -> O) -> Option<O> {
-        with_runtime(self.runtime, |runtime| self.id.try_with(runtime, f).ok())
-            .ok()
-            .flatten()
+        let diagnostics = diagnostics!(self);
+
+        with_runtime(self.runtime, |runtime| {
+            self.id.try_with(runtime, f, diagnostics).ok()
+        })
+        .ok()
+        .flatten()
     }
 }
 
@@ -1448,12 +1487,15 @@ impl<T: Clone> SignalGet<T> for RwSignal<T> {
             )
         )
     )]
+    #[track_caller]
     fn get(&self) -> T
     where
         T: Clone,
     {
+        let diagnostics = diagnostics!(self);
+
         match with_runtime(self.runtime, |runtime| {
-            self.id.try_with(runtime, T::clone)
+            self.id.try_with(runtime, T::clone, diagnostics)
         })
         .expect("runtime to be alive")
         {
@@ -1478,9 +1520,12 @@ impl<T: Clone> SignalGet<T> for RwSignal<T> {
             )
         )
     )]
+    #[track_caller]
     fn try_get(&self) -> Option<T> {
+        let diagnostics = diagnostics!(self);
+
         with_runtime(self.runtime, |runtime| {
-            self.id.try_with(runtime, Clone::clone).ok()
+            self.id.try_with(runtime, Clone::clone, diagnostics).ok()
         })
         .ok()
         .flatten()
@@ -1763,7 +1808,12 @@ pub(crate) enum SignalError {
 }
 
 impl NodeId {
-    pub(crate) fn subscribe(&self, runtime: &Runtime) {
+    #[track_caller]
+    pub(crate) fn subscribe(
+        &self,
+        runtime: &Runtime,
+        #[allow(unused)] diagnostics: AccessDiagnostics,
+    ) {
         // add subscriber
         if let Some(observer) = runtime.observer.get() {
             // add this observer to this node's dependencies (to allow notification)
@@ -1778,9 +1828,36 @@ impl NodeId {
                 let sources = sources.or_default();
                 sources.borrow_mut().insert(*self);
             }
+        } else {
+            #[cfg(all(debug_assertions, not(feature = "ssr")))]
+            {
+                if !SpecialNonReactiveZone::is_inside() {
+                    let AccessDiagnostics {
+                        called_at,
+                        defined_at,
+                    } = diagnostics;
+                    crate::macros::debug_warn!(
+                        "At {called_at}, you access a signal or memo (defined \
+                         at {defined_at}) outside a reactive tracking \
+                         context. This might mean your app is not responding \
+                         to changes in signal values in the way you \
+                         expect.\n\nHere’s how to fix it:\n\n1. If this is \
+                         inside a `view!` macro, make sure you are passing a \
+                         function, not a value.\n  ❌ NO  <p>{{x.get() * \
+                         2}}</p>\n  ✅ YES <p>{{move || x.get() * \
+                         2}}</p>\n\n2. If it’s in the body of a component, \
+                         try wrapping this access in a closure: \n  ❌ NO  \
+                         let y = x.get() * 2\n  ✅ YES let y = move || \
+                         x.get() * 2.\n\n3. If you’re *trying* to access the \
+                         value without tracking, use `.get_untracked()` or \
+                         `.with_untracked()` instead."
+                    );
+                }
+            }
         }
     }
 
+    #[track_caller]
     pub(crate) fn try_with_no_subscription<T, U>(
         &self,
         runtime: &Runtime,
@@ -1804,15 +1881,17 @@ impl NodeId {
         Ok(f(value))
     }
 
+    #[track_caller]
     pub(crate) fn try_with<T, U>(
         &self,
         runtime: &Runtime,
         f: impl FnOnce(&T) -> U,
+        diagnostics: AccessDiagnostics,
     ) -> Result<U, SignalError>
     where
         T: 'static,
     {
-        self.subscribe(runtime);
+        self.subscribe(runtime, diagnostics);
 
         self.try_with_no_subscription(runtime, f)
     }

leptos_server/src/lib.rs

@@ -94,28 +94,38 @@ use std::{
 #[cfg(any(feature = "ssr", doc))]
 type ServerFnTraitObj = server_fn::ServerFnTraitObj<Scope>;
 
+#[allow(unused)]
+type ServerFunction = server_fn::ServerFunction<Scope>;
+
 #[cfg(any(feature = "ssr", doc))]
 lazy_static::lazy_static! {
-    static ref REGISTERED_SERVER_FUNCTIONS: Arc<RwLock<HashMap<&'static str, Arc<ServerFnTraitObj>>>> = Default::default();
+    static ref REGISTERED_SERVER_FUNCTIONS: Arc<RwLock<HashMap<&'static str, ServerFunction>>> = Default::default();
 }
 
 #[cfg(any(feature = "ssr", doc))]
 /// The registry of all Leptos server functions.
 pub struct LeptosServerFnRegistry;
 
-#[cfg(any(feature = "ssr"))]
+#[cfg(any(feature = "ssr", doc))]
 impl server_fn::ServerFunctionRegistry<Scope> for LeptosServerFnRegistry {
     type Error = ServerRegistrationFnError;
 
     fn register(
         url: &'static str,
-        server_function: Arc<ServerFnTraitObj>,
+        trait_obj: Arc<ServerFnTraitObj>,
+        encoding: Encoding,
     ) -> Result<(), Self::Error> {
         // store it in the hashmap
-        let mut write = REGISTERED_SERVER_FUNCTIONS
+        let mut func_write = REGISTERED_SERVER_FUNCTIONS
             .write()
             .map_err(|e| ServerRegistrationFnError::Poisoned(e.to_string()))?;
-        let prev = write.insert(url, server_function);
+        let prev = func_write.insert(
+            url,
+            ServerFunction {
+                trait_obj,
+                encoding,
+            },
+        );
 
         // if there was already a server function with this key,
         // return Err
@@ -134,13 +144,28 @@ impl server_fn::ServerFunctionRegistry<Scope> for LeptosServerFnRegistry {
     }
 
     /// Returns the server function registered at the given URL, or `None` if no function is registered at that URL.
-    fn get(url: &str) -> Option<Arc<ServerFnTraitObj>> {
+    fn get(url: &str) -> Option<ServerFunction> {
         REGISTERED_SERVER_FUNCTIONS
             .read()
             .ok()
             .and_then(|fns| fns.get(url).cloned())
     }
 
+    /// Returns the server function trait obj registered at the given URL, or `None` if no function is registered at that URL.
+    fn get_trait_obj(url: &str) -> Option<Arc<ServerFnTraitObj>> {
+        REGISTERED_SERVER_FUNCTIONS
+            .read()
+            .ok()
+            .and_then(|fns| fns.get(url).map(|sf| sf.trait_obj.clone()))
+    }
+    /// Return the
+    fn get_encoding(url: &str) -> Option<Encoding> {
+        REGISTERED_SERVER_FUNCTIONS
+            .read()
+            .ok()
+            .and_then(|fns| fns.get(url).map(|sf| sf.encoding.clone()))
+    }
+
     /// Returns a list of all registered server functions.
     fn paths_registered() -> Vec<&'static str> {
         REGISTERED_SERVER_FUNCTIONS
@@ -165,6 +190,12 @@ pub enum ServerRegistrationFnError {
     Poisoned(String),
 }
 
+/// Get a ServerFunction struct containing info about the server fn
+#[cfg(any(feature = "ssr", doc))]
+pub fn server_fn_by_path(path: &str) -> Option<ServerFunction> {
+    server_fn::server_fn_by_path::<Scope, LeptosServerFnRegistry>(path)
+}
+
 /// Attempts to find a server function registered at the given path.
 ///
 /// This can be used by a server to handle the requests, as in the following example (using `actix-web`)
@@ -181,10 +212,13 @@ pub enum ServerRegistrationFnError {
 ///         .headers()
 ///         .get("Accept")
 ///         .and_then(|value| value.to_str().ok());
-///
 ///     if let Some(server_fn) = server_fn_by_path(path.as_str()) {
-///         let body: &[u8] = &body;
-///         match server_fn(&body).await {
+///         let query = req.query_string().as_bytes();
+///         let data = match &server_fn.encoding {
+///             Encoding::Url | Encoding::Cbor => &body,
+///             Encoding::GetJSON | Encoding::GetCBOR => query,
+///         };
+///         match (server_fn.trait_obj)(data).await {
 ///             Ok(serialized) => {
 ///                 // if this is Accept: application/json then send a serialized JSON response
 ///                 if let Some("application/json") = accept_header {
@@ -209,8 +243,18 @@ pub enum ServerRegistrationFnError {
 /// }
 /// ```
 #[cfg(any(feature = "ssr", doc))]
-pub fn server_fn_by_path(path: &str) -> Option<Arc<ServerFnTraitObj>> {
-    server_fn::server_fn_by_path::<Scope, LeptosServerFnRegistry>(path)
+pub fn server_fn_trait_obj_by_path(
+    path: &str,
+) -> Option<Arc<ServerFnTraitObj>> {
+    server_fn::server_fn_trait_obj_by_path::<Scope, LeptosServerFnRegistry>(
+        path,
+    )
+}
+
+/// Get the Encoding of a server fn if one is registered at that path. Otherwise, return None
+#[cfg(any(feature = "ssr", doc))]
+pub fn server_fn_encoding_by_path(path: &str) -> Option<Encoding> {
+    server_fn::server_fn_encoding_by_path::<Scope, LeptosServerFnRegistry>(path)
 }
 
 /// Returns the set of currently-registered server function paths, for debugging purposes.

meta/src/body.rs

@@ -83,6 +83,9 @@ pub fn Body(
     #[prop(optional, into)]
     attributes: Option<MaybeSignal<AdditionalAttributes>>,
 ) -> impl IntoView {
+    #[cfg(debug_assertions)]
+    crate::feature_warning();
+
     cfg_if! {
         if #[cfg(any(feature = "csr", feature = "hydrate"))] {
             let el = document().body().expect("there to be a <body> element");

meta/src/html.rs

@@ -98,6 +98,9 @@ pub fn Html(
     #[prop(optional, into)]
     attributes: Option<MaybeSignal<AdditionalAttributes>>,
 ) -> impl IntoView {
+    #[cfg(debug_assertions)]
+    crate::feature_warning();
+
     cfg_if! {
         if #[cfg(any(feature = "csr", feature = "hydrate"))] {
             let el = document().document_element().expect("there to be a <html> element");

meta/src/lib.rs

@@ -206,6 +206,9 @@ pub fn provide_meta_context(cx: Scope) {
 /// call `use_head()` but a single [MetaContext] has not been provided at the application root.
 /// The best practice is always to call [provide_meta_context] early in the application.
 pub fn use_head(cx: Scope) -> MetaContext {
+    #[cfg(debug_assertions)]
+    feature_warning();
+
     match use_context::<MetaContext>(cx) {
         None => {
             debug_warn!(
@@ -343,3 +346,10 @@ where
         TextProp(Rc::new(s))
     }
 }
+
+#[cfg(debug_assertions)]
+pub(crate) fn feature_warning() {
+    if !cfg!(any(feature = "csr", feature = "hydrate", feature = "ssr")) {
+        leptos::debug_warn!("WARNING: `leptos_meta` does nothing unless you enable one of its features (`csr`, `hydrate`, or `ssr`). See the docs at https://docs.rs/leptos_meta/latest/leptos_meta/ for more information.");
+    }
+}

meta/src/stylesheet.rs

@@ -1,4 +1,4 @@
-use crate::{Link, LinkProps};
+use crate::Link;
 use leptos::*;
 
 /// Injects an [HTMLLinkElement](https://developer.mozilla.org/en-US/docs/Web/API/HTMLLinkElement) into the document

router/Cargo.toml

@@ -4,7 +4,7 @@ version = "0.2.5"
 edition = "2021"
 authors = ["Greg Johnston"]
 license = "MIT"
-README = "../README.md"
+readme = "../README.md"
 repository = "https://github.com/leptos-rs/leptos"
 description = "Router for the Leptos web framework."
 

router/src/components/redirect.rs

@@ -21,6 +21,7 @@ pub fn Redirect<P>(
     path: P,
     /// Navigation options to be used on the client side.
     #[prop(optional)]
+    #[allow(unused)]
     options: Option<NavigateOptions>,
 ) -> impl IntoView
 where
@@ -36,12 +37,23 @@ where
     }
     // redirect on the client
     else {
+        #[allow(unused)]
         let navigate = use_navigate(cx);
+        #[cfg(any(feature = "csr", feature = "hydrate"))]
         leptos::request_animation_frame(move || {
             if let Err(e) = navigate(&path, options.unwrap_or_default()) {
                 leptos::error!("<Redirect/> error: {e:?}");
             }
         });
+        #[cfg(not(any(feature = "csr", feature = "hydrate")))]
+        {
+            leptos::debug_warn!(
+                "<Redirect/> is trying to redirect without \
+                 `ServerRedirectFunction` being provided. (If you’re getting \
+                 this on initial server start-up, it’s okay to ignore. It \
+                 just means that your root route is a redirect.)"
+            );
+        }
     }
 }
 

router/src/components/route.rs

@@ -72,7 +72,7 @@ where
     P: std::fmt::Display + 'static,
     C: Fn(Scope) -> bool + 'static,
 {
-    use crate::{Redirect, RedirectProps};
+    use crate::Redirect;
     let redirect_path = redirect_path.to_string();
 
     define_route(

router/src/components/router.rs

@@ -104,7 +104,7 @@ impl RouterContext {
         let base_path = resolve_path("", base, None);
 
         if let Some(base_path) = &base_path {
-            if source.with(|s| s.value.is_empty()) {
+            if source.with_untracked(|s| s.value.is_empty()) {
                 history.navigate(&LocationChange {
                     value: base_path.to_string(),
                     replace: true,
@@ -116,11 +116,11 @@ impl RouterContext {
 
         // the current URL
         let (reference, set_reference) =
-            create_signal(cx, source.with(|s| s.value.clone()));
+            create_signal(cx, source.with_untracked(|s| s.value.clone()));
 
         // the current History.state
         let (state, set_state) =
-            create_signal(cx, source.with(|s| s.state.clone()));
+            create_signal(cx, source.with_untracked(|s| s.state.clone()));
 
         // we'll use this transition to wait for async resources to load when navigating to a new route
         #[cfg(feature = "transition")]

server_fn/server_fn_macro_default/Cargo.toml

@@ -19,4 +19,4 @@ server_fn = { version = "0.2" }
 serde = "1"
 
 [features]
-stable = []
+stable = ["server_fn_macro/stable"]

server_fn/src/lib.rs

@@ -85,16 +85,13 @@ use proc_macro2::TokenStream;
 use quote::TokenStreamExt;
 use serde::{de::DeserializeOwned, Deserialize, Serialize};
 pub use server_fn_macro_default::server;
-#[cfg(any(feature = "ssr", doc))]
-use std::sync::Arc;
-use std::{future::Future, pin::Pin, str::FromStr};
+use std::{future::Future, pin::Pin, str::FromStr, sync::Arc};
 use syn::parse_quote;
 use thiserror::Error;
 // used by the macro
 #[doc(hidden)]
 pub use xxhash_rust;
 
-#[cfg(any(feature = "ssr", doc))]
 /// Something that can register a server function.
 pub trait ServerFunctionRegistry<T> {
     /// An error that can occur when registering a server function.
@@ -103,13 +100,28 @@ pub trait ServerFunctionRegistry<T> {
     fn register(
         url: &'static str,
         server_function: Arc<ServerFnTraitObj<T>>,
+        encoding: Encoding,
     ) -> Result<(), Self::Error>;
     /// Returns the server function registered at the given URL, or `None` if no function is registered at that URL.
-    fn get(url: &str) -> Option<Arc<ServerFnTraitObj<T>>>;
+    fn get(url: &str) -> Option<ServerFunction<T>>;
+
+    /// Returns the server function registered at the given URL, or `None` if no function is registered at that URL.
+    fn get_trait_obj(url: &str) -> Option<Arc<ServerFnTraitObj<T>>>;
+    /// Returns the encoding of the server FN at the given URL, or `None` if no function is
+    /// registered at that URL
+    fn get_encoding(url: &str) -> Option<Encoding>;
     /// Returns a list of all registered server functions.
     fn paths_registered() -> Vec<&'static str>;
 }
 
+/// A Struct to hold information about a ServerFunction
+#[derive(Clone)]
+pub struct ServerFunction<T> {
+    /// A trait obj for the server fn that can be called
+    pub trait_obj: Arc<ServerFnTraitObj<T>>,
+    /// The encoding and method to serialize and deserialize the server fn
+    pub encoding: Encoding,
+}
 /// A server function that can be called from the client.
 pub type ServerFnTraitObj<T> = dyn Fn(
         T,
@@ -148,7 +160,7 @@ pub enum Payload {
 ///
 ///     if let Some(server_fn) = server_fn_by_path::<MyRegistry>(path.as_str()) {
 ///         let body: &[u8] = &body;
-///         match server_fn(&body).await {
+///         match (server_fn.trait_obj)(&body).await {
 ///             Ok(serialized) => {
 ///                 // if this is Accept: application/json then send a serialized JSON response
 ///                 if let Some("application/json") = accept_header {
@@ -175,10 +187,26 @@ pub enum Payload {
 #[cfg(any(feature = "ssr", doc))]
 pub fn server_fn_by_path<T: 'static, R: ServerFunctionRegistry<T>>(
     path: &str,
-) -> Option<Arc<ServerFnTraitObj<T>>> {
+) -> Option<ServerFunction<T>> {
     R::get(path)
 }
 
+/// Returns a trait obj of the server fn for calling purposes
+#[cfg(any(feature = "ssr", doc))]
+pub fn server_fn_trait_obj_by_path<T: 'static, R: ServerFunctionRegistry<T>>(
+    path: &str,
+) -> Option<Arc<ServerFnTraitObj<T>>> {
+    R::get_trait_obj(path)
+}
+
+/// Returns the Encoding of the server fn  at a particular path
+#[cfg(any(feature = "ssr", doc))]
+pub fn server_fn_encoding_by_path<T: 'static, R: ServerFunctionRegistry<T>>(
+    path: &str,
+) -> Option<Encoding> {
+    R::get_encoding(path)
+}
+
 /// Returns the set of currently-registered server function paths, for debugging purposes.
 #[cfg(any(feature = "ssr", doc))]
 pub fn server_fns_by_path<T: 'static, R: ServerFunctionRegistry<T>>(
@@ -188,12 +216,17 @@ pub fn server_fns_by_path<T: 'static, R: ServerFunctionRegistry<T>>(
 
 /// Holds the current options for encoding types.
 /// More could be added, but they need to be serde
-#[derive(Debug, PartialEq)]
+#[derive(Debug, Clone, Default, PartialEq)]
 pub enum Encoding {
     /// A Binary Encoding Scheme Called Cbor
     Cbor,
     /// The Default URL-encoded encoding method
+    #[default]
     Url,
+    /// Pass arguments to server fns as part of the query string. Cacheable. Returns JSON
+    GetJSON,
+    /// Pass arguments to server fns as part of the query string. Cacheable. Returns CBOR
+    GetCBOR,
 }
 
 impl FromStr for Encoding {
@@ -203,6 +236,8 @@ impl FromStr for Encoding {
         match input {
             "URL" => Ok(Encoding::Url),
             "Cbor" => Ok(Encoding::Cbor),
+            "GetCbor" => Ok(Encoding::GetCBOR),
+            "GetJson" => Ok(Encoding::GetJSON),
             _ => Err(()),
         }
     }
@@ -213,6 +248,8 @@ impl quote::ToTokens for Encoding {
         let option: syn::Ident = match *self {
             Encoding::Cbor => parse_quote!(Cbor),
             Encoding::Url => parse_quote!(Url),
+            Encoding::GetJSON => parse_quote!(GetJSON),
+            Encoding::GetCBOR => parse_quote!(GetCBOR),
         };
         let expansion: syn::Ident = syn::parse_quote! {
           Encoding::#option
@@ -261,7 +298,7 @@ where
     ) -> Pin<Box<dyn Future<Output = Result<Self::Output, ServerFnError>>>>;
 
     /// Registers the server function, allowing the server to query it by URL.
-    #[cfg(any(feature = "ssr", doc))]
+    #[cfg(any(feature = "ssr", doc,))]
     fn register_in<R: ServerFunctionRegistry<T>>() -> Result<(), ServerFnError>
     {
         // create the handler for this server function
@@ -270,8 +307,11 @@ where
         let run_server_fn = Arc::new(|cx: T, data: &[u8]| {
             // decode the args
             let value = match Self::encoding() {
-                Encoding::Url => serde_urlencoded::from_bytes(data)
-                    .map_err(|e| ServerFnError::Deserialization(e.to_string())),
+                Encoding::Url | Encoding::GetJSON | Encoding::GetCBOR => {
+                    serde_urlencoded::from_bytes(data).map_err(|e| {
+                        ServerFnError::Deserialization(e.to_string())
+                    })
+                }
                 Encoding::Cbor => ciborium::de::from_reader(data)
                     .map_err(|e| ServerFnError::Deserialization(e.to_string())),
             };
@@ -289,14 +329,15 @@ where
 
                 // serialize the output
                 let result = match Self::encoding() {
-                    Encoding::Url => match serde_json::to_string(&result)
-                        .map_err(|e| {
+                    Encoding::Url | Encoding::GetJSON => {
+                        match serde_json::to_string(&result).map_err(|e| {
                             ServerFnError::Serialization(e.to_string())
                         }) {
-                        Ok(r) => Payload::Url(r),
-                        Err(e) => return Err(e),
-                    },
-                    Encoding::Cbor => {
+                            Ok(r) => Payload::Url(r),
+                            Err(e) => return Err(e),
+                        }
+                    }
+                    Encoding::Cbor | Encoding::GetCBOR => {
                         let mut buffer: Vec<u8> = Vec::new();
                         match ciborium::ser::into_writer(&result, &mut buffer)
                             .map_err(|e| {
@@ -314,7 +355,7 @@ where
         });
 
         // store it in the hashmap
-        R::register(Self::url(), run_server_fn)
+        R::register(Self::url(), run_server_fn, Self::encoding())
             .map_err(|e| ServerFnError::Registration(e.to_string()))
     }
 }
@@ -366,7 +407,7 @@ where
         Url(String),
     }
     let args_encoded = match &enc {
-        Encoding::Url => Payload::Url(
+        Encoding::Url | Encoding::GetJSON | Encoding::GetCBOR => Payload::Url(
             serde_urlencoded::to_string(&args)
                 .map_err(|e| ServerFnError::Serialization(e.to_string()))?,
         ),
@@ -379,54 +420,94 @@ where
     };
 
     let content_type_header = match &enc {
-        Encoding::Url => "application/x-www-form-urlencoded",
+        Encoding::Url | Encoding::GetJSON | Encoding::GetCBOR => {
+            "application/x-www-form-urlencoded"
+        }
         Encoding::Cbor => "application/cbor",
     };
 
     let accept_header = match &enc {
-        Encoding::Url => "application/x-www-form-urlencoded",
-        Encoding::Cbor => "application/cbor",
+        Encoding::Url | Encoding::GetJSON => {
+            "application/x-www-form-urlencoded"
+        }
+        Encoding::Cbor | Encoding::GetCBOR => "application/cbor",
     };
 
     #[cfg(target_arch = "wasm32")]
-    let resp = match args_encoded {
-        Payload::Binary(b) => {
-            let slice_ref: &[u8] = &b;
-            let js_array = js_sys::Uint8Array::from(slice_ref).buffer();
-            gloo_net::http::Request::post(url)
+    let resp = match &enc {
+        Encoding::Url | Encoding::Cbor => match args_encoded {
+            Payload::Binary(b) => {
+                let slice_ref: &[u8] = &b;
+                let js_array = js_sys::Uint8Array::from(slice_ref).buffer();
+                gloo_net::http::Request::post(url)
+                    .header("Content-Type", content_type_header)
+                    .header("Accept", accept_header)
+                    .body(js_array)
+                    .send()
+                    .await
+                    .map_err(|e| ServerFnError::Request(e.to_string()))?
+            }
+            Payload::Url(s) => gloo_net::http::Request::post(url)
                 .header("Content-Type", content_type_header)
                 .header("Accept", accept_header)
-                .body(js_array)
+                .body(s)
                 .send()
                 .await
-                .map_err(|e| ServerFnError::Request(e.to_string()))?
-        }
-        Payload::Url(s) => gloo_net::http::Request::post(url)
-            .header("Content-Type", content_type_header)
-            .header("Accept", accept_header)
-            .body(s)
-            .send()
-            .await
-            .map_err(|e| ServerFnError::Request(e.to_string()))?,
+                .map_err(|e| ServerFnError::Request(e.to_string()))?,
+        },
+        Encoding::GetCBOR | Encoding::GetJSON => match args_encoded {
+            Payload::Binary(_) => panic!(
+                "Binary data cannot be transferred via GET request in a query \
+                 string. Please try using the CBOR encoding."
+            ),
+            Payload::Url(s) => {
+                let full_url = format!("{url}?{s}");
+                gloo_net::http::Request::get(&full_url)
+                    .header("Content-Type", content_type_header)
+                    .header("Accept", accept_header)
+                    .send()
+                    .await
+                    .map_err(|e| ServerFnError::Request(e.to_string()))?
+            }
+        },
     };
     #[cfg(not(target_arch = "wasm32"))]
-    let resp = match args_encoded {
-        Payload::Binary(b) => CLIENT
-            .post(url)
-            .header("Content-Type", content_type_header)
-            .header("Accept", accept_header)
-            .body(b)
-            .send()
-            .await
-            .map_err(|e| ServerFnError::Request(e.to_string()))?,
-        Payload::Url(s) => CLIENT
-            .post(url)
-            .header("Content-Type", content_type_header)
-            .header("Accept", accept_header)
-            .body(s)
-            .send()
-            .await
-            .map_err(|e| ServerFnError::Request(e.to_string()))?,
+    let resp = match &enc {
+        Encoding::Url | Encoding::Cbor => match args_encoded {
+            Payload::Binary(b) => CLIENT
+                .post(url)
+                .header("Content-Type", content_type_header)
+                .header("Accept", accept_header)
+                .body(b)
+                .send()
+                .await
+                .map_err(|e| ServerFnError::Request(e.to_string()))?,
+            Payload::Url(s) => CLIENT
+                .post(url)
+                .header("Content-Type", content_type_header)
+                .header("Accept", accept_header)
+                .body(s)
+                .send()
+                .await
+                .map_err(|e| ServerFnError::Request(e.to_string()))?,
+        },
+        Encoding::GetJSON | Encoding::GetCBOR => match args_encoded {
+            Payload::Binary(_) => panic!(
+                "Binary data cannot be transferred via GET request in a query \
+                 string. Please try using the CBOR encoding."
+            ),
+
+            Payload::Url(s) => {
+                let full_url = format!("{url}?{s}");
+                CLIENT
+                    .get(full_url)
+                    .header("Content-Type", content_type_header)
+                    .header("Accept", accept_header)
+                    .send()
+                    .await
+                    .map_err(|e| ServerFnError::Request(e.to_string()))?
+            }
+        },
     };
 
     // check for error status
@@ -434,14 +515,17 @@ where
     #[cfg(not(target_arch = "wasm32"))]
     let status = status.as_u16();
     if (500..=599).contains(&status) {
+        let text = resp.text().await.unwrap_or_default();
         #[cfg(target_arch = "wasm32")]
         let status_text = resp.status_text();
         #[cfg(not(target_arch = "wasm32"))]
         let status_text = status.to_string();
-        return Err(ServerFnError::ServerError(status_text));
+        return Err(serde_json::from_str(&text)
+            .unwrap_or(ServerFnError::ServerError(status_text)));
     }
 
-    if enc == Encoding::Cbor {
+    // Decoding the body of the request
+    if (enc == Encoding::Cbor) || (enc == Encoding::GetCBOR) {
         #[cfg(target_arch = "wasm32")]
         let binary = resp
             .binary()

server_fn_macro/src/lib.rs

@@ -114,18 +114,6 @@ pub fn server_macro_impl(
             .as_ref()
             .and_then(|ctx| fn_arg_is_cx(f, ctx).then_some(f))
     });
-    let cx_assign_statement = if let Some(FnArg::Typed(arg)) = cx_arg {
-        if let Pat::Ident(id) = &*arg.pat {
-            quote! {
-                #[allow(unused)]
-                let #id = cx;
-            }
-        } else {
-            quote! {}
-        }
-    } else {
-        quote! {}
-    };
     let cx_fn_arg = if cx_arg.is_some() {
         quote! { cx, }
     } else {
@@ -140,9 +128,9 @@ pub fn server_macro_impl(
             FnArg::Typed(t) => t,
         };
         let is_cx = if let Some(ctx) = &server_context {
-            !fn_arg_is_cx(f, ctx)
+            fn_arg_is_cx(f, ctx)
         } else {
-            true
+            false
         };
         if is_cx {
             quote! {
@@ -230,7 +218,6 @@ pub fn server_macro_impl(
             #[cfg(feature = "ssr")]
             fn call_fn(self, cx: #server_ctx_path) -> std::pin::Pin<Box<dyn std::future::Future<Output = Result<Self::Output, server_fn::ServerFnError>>>> {
                 let #struct_name { #(#field_names),* } = self;
-                #cx_assign_statement;
                 Box::pin(async move { #fn_name( #cx_fn_arg #(#field_names_2),*).await })
             }
 
@@ -247,10 +234,17 @@ pub fn server_macro_impl(
         }
 
         #[cfg(not(feature = "ssr"))]
+        #[allow(unused_variables)]
         #vis async fn #fn_name(#(#fn_args_2),*) #output_arrow #return_ty {
-            let prefix = #struct_name::prefix().to_string();
-            let url = prefix + "/" + #struct_name::url();
-            #server_fn_path::call_server_fn(&url, #struct_name { #(#field_names_5),* }, #encoding).await
+
+            #server_fn_path::call_server_fn(
+                &{
+                    let prefix = #struct_name::prefix().to_string();
+                    prefix + "/" + #struct_name::url()
+                },
+                #struct_name { #(#field_names_5),* },
+                #encoding
+            ).await
         }
     })
 }
@@ -271,10 +265,14 @@ impl Parse for ServerFnName {
         let _comma2 = input.parse()?;
         let encoding = input
             .parse::<Literal>()
-            .map(|encoding| match encoding.to_string().as_str() {
-                "\"Url\"" => syn::parse_quote!(Encoding::Url),
-                "\"Cbor\"" => syn::parse_quote!(Encoding::Cbor),
-                _ => abort!(encoding, "Encoding Not Found"),
+            .map(|encoding| {
+                match encoding.to_string().to_lowercase().as_str() {
+                    "\"url\"" => syn::parse_quote!(Encoding::Url),
+                    "\"cbor\"" => syn::parse_quote!(Encoding::Cbor),
+                    "\"getcbor\"" => syn::parse_quote!(Encoding::GetCBOR),
+                    "\"getjson\"" => syn::parse_quote!(Encoding::GetJSON),
+                    _ => abort!(encoding, "Encoding Not Found"),
+                }
             })
             .unwrap_or_else(|_| syn::parse_quote!(Encoding::Url));