fix: hot-reloading still only supported in debug

Fixes the case when struct had a generic arguments by adding missing generic arguments into the generated trait and the said trait implementation.

.github/ISSUE_TEMPLATE/bug_report.md

@@ -33,10 +33,11 @@ Steps to reproduce the behavior:
 If applicable, add screenshots to help explain your problem.
 
 **Next Steps**
-[ ] I will make a PR
-[ ] I would like to make a PR, but need help getting started
-[ ] I want someone else to take the time to fix this
-[ ] This is a low priority for me and is just shared for your information
+
+- [ ] I will make a PR
+- [ ] I would like to make a PR, but need help getting started
+- [ ] I want someone else to take the time to fix this
+- [ ] This is a low priority for me and is just shared for your information
 
 **Additional context**
 Add any other context about the problem here.

.github/dependabot.yml

@@ -0,0 +1,19 @@
+version: 2
+updates:
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+  # Grouping all dependencies in one PR weekly
+  - package-ecosystem: cargo
+    directory: "/"
+    schedule:
+      interval: weekly
+      day: monday
+    open-pull-requests-limit: 1
+    allow:
+      - dependency-type: "all"
+    groups:
+      rust-dependencies:
+        patterns:
+          - "*"

.github/workflows/autofix.yml

@@ -21,34 +21,26 @@ jobs:
     steps:
       - uses: actions/checkout@v4
       - uses: actions-rust-lang/setup-rust-toolchain@v1
-        with: {toolchain: nightly, components: "rustfmt, clippy", target: "wasm32-unknown-unknown", rustflags: ""}
+        with:
+          {
+            toolchain: "nightly-2025-07-16",
+            components: "rustfmt, clippy",
+            target: "wasm32-unknown-unknown",
+            rustflags: "",
+          }
       - name: Install Glib
         run: |
           sudo apt-get update
           sudo apt-get install -y libglib2.0-dev
+      - name: Install cargo-all-features
+        run: cargo install --git https://github.com/sabify/cargo-all-features --branch arbitrary-command-support
       - name: Install jq
         run: sudo apt-get install jq
-      - run: |
-          echo "Formatting the workspace"
-          cargo fmt --all
-
-          echo "Running Clippy against each member's features (default features included)"
-          for member in $(cargo metadata --no-deps --format-version 1 | jq -r '.packages[] | .name'); do
-              echo "Working on member $member":
-              echo -e "\tdefault-features/no-features:"
-              # this will also run on members with no features or default features
-              cargo clippy --allow-dirty --fix --lib --package "$member"
-
-              features=$(cargo metadata --no-deps --format-version 1 | jq -r ".packages[] | select(.name == \"$member\") | .features | keys[]")
-              for feature in $features; do
-                  if [ "$feature" = "default" ]; then
-                    continue
-                  fi
-                  echo -e "\tfeature $feature"
-                  cargo clippy --allow-dirty --fix --lib --package "$member" --features "$feature"
-              done
-          done
-      - uses: autofix-ci/action@v1.3.1
+      - name: Format the workspace
+        run: cargo fmt --all
+      - name: Clippy the workspace
+        run: cargo all-features clippy --allow-dirty --fix --lib --no-deps
+      - uses: autofix-ci/action@v1.3.2
         if: ${{ always() }}
         with:
           fail-fast: false

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

@@ -18,7 +18,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        toolchain: [stable, nightly-2025-03-05]
+        toolchain: [stable, nightly-2025-07-16]
         erased_mode: [true, false]
     steps:
       - name: Free Disk Space
@@ -72,6 +72,14 @@ jobs:
         run: cargo binstall cargo-nextest --no-confirm
       - name: Install cargo-all-features
         run: cargo install --git https://github.com/sabify/cargo-all-features --branch arbitrary-command-support
+      # Part of direct-minimal-versions check
+      - name: Install cargo-hack
+        if: contains(matrix.toolchain, 'nightly')
+        uses: taiki-e/install-action@cargo-hack
+      # Part of direct-minimal-versions check
+      - name: Install cargo-minimal-versions
+        if: contains(matrix.toolchain, 'nightly')
+        uses: taiki-e/install-action@cargo-minimal-versions
       - name: Install Trunk
         if: contains(inputs.directory, 'examples')
         run: cargo binstall trunk --no-confirm
@@ -160,6 +168,16 @@ jobs:
         run: |
           cd '${{ inputs.directory }}'
           cargo make --no-workspace --profile=github-actions ci
+          # check the direct-minimal-versions on release
+          if [[ "${{ github.ref_name }}" =~ ^v[0-9]+\.[0-9]+\.[0-9]+$ ]]; then
+            cargo make --no-workspace --profile=github-actions check-minimal-versions
+          fi
+      # Check if the counter_isomorphic can be built with leptos_debuginfo cfg flag in release mode
+      - name: ${{ inputs.cargo_make_task }} with --cfg=leptos_debuginfo
+        if: contains(inputs.directory, 'counter_isomorphic')
+        run: |
+          cd '${{ inputs.directory }}'
+          RUSTFLAGS="$RUSTFLAGS --cfg leptos_debuginfo" cargo leptos build --release
       - name: Clean up ${{ inputs.directory }}
         if: always()
         run: |

Cargo.toml

@@ -40,44 +40,131 @@ members = [
 exclude = ["benchmarks", "examples", "projects"]
 
 [workspace.package]
-version = "0.8.0-rc3"
+version = "0.8.3"
 edition = "2021"
-rust-version = "1.76"
+rust-version = "1.88"
 
 [workspace.dependencies]
-convert_case = "0.8"
+# members
 throw_error = { path = "./any_error/", version = "0.3.0" }
-any_spawner = { path = "./any_spawner/", version = "0.3.0-rc3" }
+any_spawner = { path = "./any_spawner/", version = "0.3.0" }
 const_str_slice_concat = { path = "./const_str_slice_concat", version = "0.1" }
-either_of = { path = "./either_of/", version = "0.1.5" }
+either_of = { path = "./either_of/", version = "0.1.6" }
 hydration_context = { path = "./hydration_context", version = "0.3.0" }
-itertools = "0.14.0"
-leptos = { path = "./leptos", version = "0.8.0-rc3" }
-leptos_config = { path = "./leptos_config", version = "0.8.0-rc3" }
-leptos_dom = { path = "./leptos_dom", version = "0.8.0-rc3" }
-leptos_hot_reload = { path = "./leptos_hot_reload", version = "0.8.0-rc3" }
-leptos_integration_utils = { path = "./integrations/utils", version = "0.8.0-rc3" }
-leptos_macro = { path = "./leptos_macro", version = "0.8.0-rc3" }
-leptos_router = { path = "./router", version = "0.8.0-rc3" }
-leptos_router_macro = { path = "./router_macro", version = "0.8.0-rc3" }
-leptos_server = { path = "./leptos_server", version = "0.8.0-rc3" }
-leptos_meta = { path = "./meta", version = "0.8.0-rc3" }
+leptos = { path = "./leptos", version = "0.8.3" }
+leptos_config = { path = "./leptos_config", version = "0.8.3" }
+leptos_dom = { path = "./leptos_dom", version = "0.8.3" }
+leptos_hot_reload = { path = "./leptos_hot_reload", version = "0.8.3" }
+leptos_integration_utils = { path = "./integrations/utils", version = "0.8.3" }
+leptos_macro = { path = "./leptos_macro", version = "0.8.3" }
+leptos_router = { path = "./router", version = "0.8.3" }
+leptos_router_macro = { path = "./router_macro", version = "0.8.3" }
+leptos_server = { path = "./leptos_server", version = "0.8.3" }
+leptos_meta = { path = "./meta", version = "0.8.3" }
 next_tuple = { path = "./next_tuple", version = "0.1.0" }
 oco_ref = { path = "./oco", version = "0.2.0" }
 or_poisoned = { path = "./or_poisoned", version = "0.1.0" }
-reactive_graph = { path = "./reactive_graph", version = "0.2.0-rc3" }
-reactive_stores = { path = "./reactive_stores", version = "0.2.0-rc3" }
-reactive_stores_macro = { path = "./reactive_stores_macro", version = "0.2.0-rc3" }
-rustversion = "1"
-serde_json = "1.0.0"
-server_fn = { path = "./server_fn", version = "0.8.0-rc3" }
-server_fn_macro = { path = "./server_fn_macro", version = "0.8.0-rc3" }
-server_fn_macro_default = { path = "./server_fn/server_fn_macro_default", version = "0.8.0-rc3" }
-tachys = { path = "./tachys", version = "0.2.0-rc3" }
-trybuild = "1"
-typed-builder = "0.21.0"
-thiserror = "2.0.12"
-wasm-bindgen = "0.2.100"
+reactive_graph = { path = "./reactive_graph", version = "0.2.3" }
+reactive_stores = { path = "./reactive_stores", version = "0.2.3" }
+reactive_stores_macro = { path = "./reactive_stores_macro", version = "0.2.3" }
+server_fn = { path = "./server_fn", version = "0.8.3" }
+server_fn_macro = { path = "./server_fn_macro", version = "0.8.3" }
+server_fn_macro_default = { path = "./server_fn/server_fn_macro_default", version = "0.8.3" }
+tachys = { path = "./tachys", version = "0.2.4" }
+
+# members deps
+itertools = { default-features = false, version = "0.14.0" }
+convert_case = { default-features = false, version = "0.8.0" }
+serde_json = { default-features = false, version = "1.0.140" }
+trybuild = { default-features = false, version = "1.0.105" }
+typed-builder = { default-features = false, version = "0.21.0" }
+thiserror = { default-features = false, version = "2.0.12" }
+wasm-bindgen = { default-features = false, version = "0.2.100" }
+indexmap = { default-features = false, version = "2.9.0" }
+rstml = { default-features = false, version = "0.12.1" }
+rustc_version = { default-features = false, version = "0.4.1" }
+guardian = { default-features = false, version = "1.3.0" }
+rustc-hash = { default-features = false, version = "2.1.1" }
+actix-web = { default-features = false, version = "4.11.0" }
+tracing = { default-features = false, version = "0.1.41" }
+slotmap = { default-features = false, version = "1.0.7" }
+futures = { default-features = false, version = "0.3.31" }
+dashmap = { default-features = false, version = "6.1.0" }
+pin-project-lite = { default-features = false, version = "0.2.16" }
+send_wrapper = { default-features = false, version = "0.6.0" }
+tokio-test = { default-features = false, version = "0.4.4" }
+html-escape = { default-features = false, version = "0.2.13" }
+proc-macro-error2 = { default-features = false, version = "2.0.1" }
+const_format = { default-features = false, version = "0.2.34" }
+gloo-net = { default-features = false, version = "0.6.0" }
+url = { default-features = false, version = "2.5.4" }
+tokio = { default-features = false, version = "1.45.1" }
+base64 = { default-features = false, version = "0.22.1" }
+cfg-if = { default-features = false, version = "1.0.0" }
+wasm-bindgen-futures = { default-features = false, version = "0.4.50" }
+tower = { default-features = false, version = "0.5.2" }
+proc-macro2 = { default-features = false, version = "1.0.95" }
+serde = { default-features = false, version = "1.0.219" }
+parking_lot = { default-features = false, version = "0.12.4" }
+axum = { default-features = false, version = "0.8.4" }
+serde_qs = { default-features = false, version = "0.15.0" }
+syn = { default-features = false, version = "2.0.104" }
+xxhash-rust = { default-features = false, version = "0.8.15" }
+paste = { default-features = false, version = "1.0.15" }
+quote = { default-features = false, version = "1.0.40" }
+web-sys = { default-features = false, version = "0.3.77" }
+js-sys = { default-features = false, version = "0.3.77" }
+rand = { default-features = false, version = "0.9.1" }
+serde-lite = { default-features = false, version = "0.5.0" }
+tokio-tungstenite = { default-features = false, version = "0.27.0" }
+serial_test = { default-features = false, version = "3.2.0" }
+erased = { default-features = false, version = "0.1.2" }
+glib = { default-features = false, version = "0.20.12" }
+async-trait = { default-features = false, version = "0.1.88" }
+typed-builder-macro = { default-features = false, version = "0.21.0" }
+linear-map = { default-features = false, version = "1.2.0" }
+anyhow = { default-features = false, version = "1.0.98" }
+walkdir = { default-features = false, version = "2.5.0" }
+actix-ws = { default-features = false, version = "0.3.0" }
+tower-http = { default-features = false, version = "0.6.4" }
+prettyplease = { default-features = false, version = "0.2.35" }
+inventory = { default-features = false, version = "0.3.20" }
+config = { default-features = false, version = "0.15.11" }
+camino = { default-features = false, version = "1.1.9" }
+ciborium = { default-features = false, version = "0.2.2" }
+multer = { default-features = false, version = "3.1.0" }
+leptos-spin-macro = { default-features = false, version = "0.2.0" }
+sledgehammer_utils = { default-features = false, version = "0.3.1" }
+sledgehammer_bindgen = { default-features = false, version = "0.6.0" }
+wasm-streams = { default-features = false, version = "0.4.2" }
+rkyv = { default-features = false, version = "0.8.10" }
+temp-env = { default-features = false, version = "0.3.6" }
+uuid = { default-features = false, version = "1.17.0" }
+bytes = { default-features = false, version = "1.10.1" }
+http = { default-features = false, version = "1.3.1" }
+regex = { default-features = false, version = "1.11.1" }
+drain_filter_polyfill = { default-features = false, version = "0.1.3" }
+tempfile = { default-features = false, version = "3.20.0" }
+futures-lite = { default-features = false, version = "2.6.0" }
+log = { default-features = false, version = "0.4.27" }
+percent-encoding = { default-features = false, version = "2.3.1" }
+async-executor = { default-features = false, version = "1.13.2" }
+const-str = { default-features = false, version = "0.6.2" }
+http-body-util = { default-features = false, version = "0.1.3" }
+hyper = { default-features = false, version = "1.6.0" }
+postcard = { default-features = false, version = "1.1.1" }
+rmp-serde = { default-features = false, version = "1.3.0" }
+reqwest = { default-features = false, version = "0.12.18" }
+tower-layer = { default-features = false, version = "0.3.3" }
+attribute-derive = { default-features = false, version = "0.10.3" }
+insta = { default-features = false, version = "1.43.1" }
+codee = { default-features = false, version = "0.3.0" }
+actix-http = { default-features = false, version = "3.11.0" }
+wasm-bindgen-test = { default-features = false, version = "0.3.50" }
+rustversion = { default-features = false, version = "1.0.21" }
+getrandom = { default-features = false, version = "0.3.3" }
+actix-files = { default-features = false, version = "0.6.6" }
+async-lock = { default-features = false, version = "3.4.0" }
 
 [profile.release]
 codegen-units = 1

README.md

@@ -90,35 +90,13 @@ Here are some resources for learning more about Leptos:
 - [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!)
 
-## `nightly` Note
-
-Most of the examples assume you’re using `nightly` version of Rust and the `nightly` feature of Leptos. To use `nightly` Rust, you can either set your toolchain globally or on per-project basis.
-
-To set `nightly` as a default toolchain for all projects (and add the ability to compile Rust to WebAssembly, if you haven’t already):
-
-```
-rustup toolchain install nightly
-rustup default nightly
-rustup target add wasm32-unknown-unknown
-```
-
-If you'd like to use `nightly` only in your Leptos project however, add [`rust-toolchain.toml`](https://rust-lang.github.io/rustup/overrides.html#the-toolchain-file) file with the following content:
-
-```toml
-[toolchain]
-channel = "nightly"
-targets = ["wasm32-unknown-unknown"]
-```
-
-The `nightly` feature enables the function call syntax for accessing and setting signals, as opposed to `.get()` and `.set()`. This leads to a consistent mental model in which accessing a reactive value of any kind (a signal, memo, or derived signal) is always represented as a function call. This is only possible with nightly Rust and the `nightly` feature.
-
 ## `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 templates for [Actix](https://github.com/leptos-rs/start) or [Axum](https://github.com/leptos-rs/start-axum).
 
 ```bash
 cargo install cargo-leptos
-cargo leptos new --git https://github.com/leptos-rs/start
+cargo leptos new --git https://github.com/leptos-rs/start-axum
 cd [your project name]
 cargo leptos watch
 ```

any_error/Cargo.toml

@@ -10,4 +10,4 @@ rust-version.workspace = true
 edition.workspace = true
 
 [dependencies]
-pin-project-lite = "0.2.15"
+pin-project-lite = { workspace = true, default-features = true }

any_spawner/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "any_spawner"
-version = "0.3.0-rc3"
+version = "0.3.0"
 authors = ["Greg Johnston"]
 license = "MIT"
 readme = "../README.md"
@@ -9,25 +9,25 @@ description = "Spawn asynchronous tasks in an executor-independent way."
 edition.workspace = true
 
 [dependencies]
-async-executor = { version = "1.13.1", optional = true }
-futures = "0.3.31"
-glib = { version = "0.20.6", optional = true }
-thiserror = { workspace = true }
-tokio = { version = "1.41", optional = true, default-features = false, features = [
+async-executor = { optional = true , workspace = true, default-features = true }
+futures = { workspace = true, default-features = true }
+glib = { optional = true , workspace = true, default-features = true }
+thiserror = { workspace = true , default-features = true }
+tokio = { optional = true, default-features = false, features = [
   "rt",
-] }
-tracing = { version = "0.1.41", optional = true }
-wasm-bindgen-futures = { version = "0.4.50", optional = true }
+] , workspace = true }
+tracing = { optional = true , workspace = true, default-features = true }
+wasm-bindgen-futures = { optional = true , workspace = true, default-features = true }
 
 [dev-dependencies]
-futures-lite = { version = "2.6.0", default-features = false }
-tokio = { version = "1.41", default-features = false, features = [
+futures-lite = { default-features = false , workspace = true }
+tokio = { default-features = false, features = [
   "rt",
   "macros",
   "time",
-] }
-wasm-bindgen-test = { version = "0.3.50" }
-serial_test = "3.2.0"
+] , workspace = true }
+wasm-bindgen-test = { workspace = true, default-features = true }
+serial_test = { workspace = true, default-features = true }
 
 [features]
 async-executor = ["dep:async-executor"]

benchmarks/Cargo.toml

@@ -2,8 +2,6 @@
 name = "benchmarks"
 version = "0.1.0"
 edition = "2021"
-# std::sync::LazyLock is stabilized in Rust version 1.80.0
-rust-version = "1.80.0"
 
 [dependencies]
 l0410 = { package = "leptos", version = "0.4.10", features = [

cargo-make/check-minimal-versions.toml

@@ -0,0 +1,14 @@
+[tasks.check-minimal-versions]
+condition = { channels = ["nightly"] }
+command = "cargo"
+args = [
+  "all-features",
+  "minimal-versions",
+  "check",
+  "--ignore-private",
+  "--detach-path-deps",
+  "--direct",
+]
+install_script = '''
+cargo install --git https://github.com/sabify/cargo-all-features --branch arbitrary-command-support
+'''

cargo-make/main.toml

@@ -1,4 +1,8 @@
-extend = [{ path = "./lint.toml" }, { path = "./test.toml" }]
+extend = [
+  { path = "./lint.toml" },
+  { path = "./test.toml" },
+  { path = "./check-minimal-versions.toml" },
+]
 
 [env]
 RUSTFLAGS = ""

const_str_slice_concat/src/lib.rs

@@ -31,7 +31,7 @@ pub const fn const_concat(
         let mut i = 0;
 
         // have it iterate over bytes manually, because, again,
-        // no mutable refernces in const fns
+        // no mutable references in const fns
         while i < x.len() {
             buffer[position] = x[i];
             position += 1;
@@ -59,7 +59,7 @@ pub const fn const_concat_with_prefix(
         let mut i = 0;
 
         // have it iterate over bytes manually, because, again,
-        // no mutable refernces in const fns
+        // no mutable references in const fns
         while i < x.len() {
             buffer[position] = x[i];
             position += 1;
@@ -116,7 +116,7 @@ pub const fn const_concat_with_separator(
         let mut i = 0;
 
         // have it iterate over bytes manually, because, again,
-        // no mutable refernces in const fns
+        // no mutable references in const fns
         while i < x.len() {
             buffer[position] = x[i];
             position += 1;

either_of/Cargo.toml

@@ -10,8 +10,8 @@ rust-version.workspace = true
 edition.workspace = true
 
 [dependencies]
-pin-project-lite = "0.2.16"
-paste = "1.0.15"
+pin-project-lite = { workspace = true, default-features = true }
+paste = { workspace = true, default-features = true }
 
 [features]
 default = ["no_std"]

examples/counter_isomorphic/Cargo.toml

@@ -2,8 +2,6 @@
 name = "counter_isomorphic"
 version = "0.1.0"
 edition = "2021"
-# std::sync::LazyLock is stabilized in Rust version 1.80.0
-rust-version = "1.80.0"
 
 [lib]
 crate-type = ["cdylib", "rlib"]
@@ -23,7 +21,6 @@ leptos = { path = "../../leptos" }
 leptos_actix = { path = "../../integrations/actix", optional = true }
 leptos_router = { path = "../../router" }
 log = "0.4.22"
-once_cell = "1.19"
 gloo-net = { version = "0.6.0" }
 wasm-bindgen = "0.2.93"
 serde = { version = "1.0", features = ["derive"] }

examples/fetch/src/main.rs

@@ -7,7 +7,7 @@ pub fn main() {
 
     fmt()
         .with_writer(
-            // To avoide trace events in the browser from showing their
+            // To avoid trace events in the browser from showing their
             // JS backtrace, which is very annoying, in my opinion
             MakeConsoleWriter::default()
                 .map_trace_level_to(tracing::Level::DEBUG),

examples/hackernews/src/routes/story.rs

@@ -6,7 +6,7 @@ use leptos_router::{components::A, hooks::use_params_map};
 #[component]
 pub fn Story() -> impl IntoView {
     let params = use_params_map();
-    let story = Resource::new(
+    let story = Resource::new_blocking(
         move || params.read().get("id").unwrap_or_default(),
         move |id| async move {
             if id.is_empty() {

examples/hackernews_axum/src/routes/story.rs

@@ -6,7 +6,7 @@ use leptos_router::{components::A, hooks::use_params_map};
 #[component]
 pub fn Story() -> impl IntoView {
     let params = use_params_map();
-    let story = Resource::new(
+    let story = Resource::new_blocking(
         move || params.read().get("id").unwrap_or_default(),
         move |id| async move {
             if id.is_empty() {

examples/hackernews_islands_axum/src/routes/story.rs

@@ -13,7 +13,7 @@ pub async fn fetch_story(
 #[component]
 pub fn Story() -> impl IntoView {
     let params = use_params_map();
-    let story = Resource::new(
+    let story = Resource::new_blocking(
         move || params.read().get("id").unwrap_or_default(),
         move |id| async move {
             if id.is_empty() {

examples/hackernews_js_fetch/src/routes/story.rs

@@ -7,7 +7,7 @@ use send_wrapper::SendWrapper;
 #[component]
 pub fn Story() -> impl IntoView {
     let params = use_params_map();
-    let story = Resource::new(
+    let story = Resource::new_blocking(
         move || params.read().get("id").unwrap_or_default(),
         move |id| {
             SendWrapper::new(async move {

examples/regression/Cargo.toml

@@ -0,0 +1,90 @@
+[package]
+name = "regression"
+version = "0.1.0"
+edition = "2021"
+
+[lib]
+crate-type = ["cdylib", "rlib"]
+
+[dependencies]
+axum = { version = "0.8.1", optional = true }
+console_error_panic_hook = "0.1.7"
+console_log = "1.0"
+leptos = { path = "../../leptos", features = ["tracing"] }
+leptos_meta = { path = "../../meta" }
+leptos_axum = { path = "../../integrations/axum", optional = true }
+leptos_router = { path = "../../router" }
+serde = { version = "1.0", features = ["derive"] }
+thiserror = "1.0"
+tokio = { version = "1.39", features = [ "rt-multi-thread", "macros", "time" ], optional = true }
+wasm-bindgen = "0.2.92"
+
+[features]
+hydrate = [
+  "leptos/hydrate",
+]
+ssr = [
+  "dep:axum",
+  "dep:tokio",
+  "leptos/ssr",
+  "leptos_meta/ssr",
+  "dep:leptos_axum",
+  "leptos_router/ssr",
+]
+
+[profile.release]
+panic = "abort"
+
+[profile.wasm-release]
+inherits = "release"
+opt-level = 'z'
+lto = true
+codegen-units = 1
+panic = "abort"
+
+[package.metadata.cargo-all-features]
+denylist = ["axum", "tower", "tower-http", "tokio", "sqlx", "leptos_axum"]
+skip_feature_sets = [["ssr", "hydrate"]]
+
+[package.metadata.leptos]
+# The name used by wasm-bindgen/cargo-leptos for the JS/WASM bundle. Defaults to the crate name
+output-name = "regression"
+# 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 = "cargo make test-ui"
+end2end-dir = "e2e"
+#  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

examples/regression/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Leptos
+
+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.

examples/regression/Makefile.toml

@@ -0,0 +1,8 @@
+extend = [
+    { path = "../cargo-make/main.toml" },
+    { path = "../cargo-make/cargo-leptos-webdriver-test.toml" },
+]
+
+[env]
+
+CLIENT_PROCESS_NAME = "regression"

examples/regression/README.md

@@ -0,0 +1,8 @@
+# Regression Tests
+
+This example functions as a catch-all for all current and future regression
+test cases that typically happens at integration.
+
+## Quick Start
+
+Run `cargo leptos watch` to run this example.

examples/regression/e2e/Cargo.toml

@@ -0,0 +1,18 @@
+[package]
+name = "regression_e2e"
+version = "0.1.0"
+edition = "2021"
+
+[dev-dependencies]
+anyhow = "1.0"
+async-trait = "0.1.81"
+cucumber = "0.21.1"
+fantoccini = "0.21.1"
+pretty_assertions = "1.4"
+serde_json = "1.0"
+tokio = { version = "1.39", features = ["macros", "rt-multi-thread", "time"] }
+url = "2.5"
+
+[[test]]
+name = "app_suite"
+harness = false    # Allow Cucumber to print output instead of libtest

examples/regression/e2e/Makefile.toml

@@ -0,0 +1,20 @@
+extend = { path = "../../cargo-make/main.toml" }
+
+[tasks.test]
+env = { RUN_AUTOMATICALLY = false }
+condition = { env_true = ["RUN_AUTOMATICALLY"] }
+
+[tasks.ci]
+
+[tasks.test-ui]
+command = "cargo"
+args = [
+  "test",
+  "--test",
+  "app_suite",
+  "--",
+  "--retry",
+  "2",
+  "--fail-fast",
+  "${@}",
+]

examples/regression/e2e/README.md

@@ -0,0 +1,34 @@
+# E2E Testing
+
+This example demonstrates e2e testing with Rust using executable requirements.
+
+## Testing Stack
+
+|    |      Role      |  Description |
+|---|---|---|
+| [Cucumber](https://github.com/cucumber-rs/cucumber/tree/main) | Test Runner | Run [Gherkin](https://cucumber.io/docs/gherkin/reference/) specifications as Rust tests |
+| [Fantoccini](https://github.com/jonhoo/fantoccini/tree/main) | Browser Client | Interact with web pages through WebDriver |
+| [Cargo Leptos](https://github.com/leptos-rs/cargo-leptos) | Build Tool |  Compile example and start the server and end-2-end tests |
+| [chromedriver](https://chromedriver.chromium.org/downloads) | WebDriver | Provide WebDriver for Chrome |
+
+## Testing Organization
+
+Testing is organized around what a user can do and see/not see. Test scenarios are grouped by the **user action** and the **object** of that action. This makes it easier to locate and reason about requirements.
+
+Here is a brief overview of how things fit together.
+
+```bash
+features
+└── {action}_{object}.feature   # Specify test scenarios
+tests
+├── fixtures
+│   ├── action.rs               # Perform a user action (click, type, etc.)
+│   ├── check.rs                # Assert what a user can see/not see
+│   ├── find.rs                 # Query page elements
+│   ├── mod.rs
+│   └── world
+│       ├── action_steps.rs     # Map Gherkin steps to user actions
+│       ├── check_steps.rs      # Map Gherkin steps to user expectations
+│       └── mod.rs
+└── app_suite.rs                # Test main
+```

examples/regression/e2e/features/issue_4088.feature

@@ -0,0 +1,20 @@
+@check_issue_4088
+Feature: Check that issue 4088 does not reappear
+
+	Scenario: I can see the navbar
+		Given I see the app
+		And I can access regression test 4088
+		Then I see the navbar
+
+	Scenario: The user info is shared via context
+		Given I see the app
+		And I can access regression test 4088
+		When I select the link Class 1
+		Then I see the result is the string Assignments for team of user with id 42
+
+	Scenario: The user info is shared via context
+		Given I see the app
+		And I can access regression test 4088
+		When I select the link Class 1
+		When I refresh the browser
+		Then I see the result is the string Assignments for team of user with id 42

examples/regression/e2e/features/pr_4015.feature

@@ -0,0 +1,8 @@
+@check_pr_4015
+Feature: Check that PR 4015 does not regress
+
+	Scenario: The correct text appears
+		Given I see the app
+		And I can access regression test 4015
+		Then I see the result is the string Some(42)
+

examples/regression/e2e/features/pr_4091.feature

@@ -0,0 +1,48 @@
+@check_pr_4091
+Feature: Regression from pull request 4091
+
+    Scenario: Signal for testing should work
+        Given I see the app
+        And I can access regression test 4091
+        When I select the link test1
+        Then I see the result is the string Test1
+
+    Scenario: The result returns to empty due to on_cleanup
+        Given I see the app
+        And I can access regression test 4091
+        When I select the following links
+            | test1     |
+            | 4091 Home |
+        Then I see the result is empty
+
+    Scenario: The result does not accumulate due to on_cleanup
+        Given I see the app
+        And I can access regression test 4091
+        When I select the following links
+            | test1     |
+            | 4091 Home |
+            | test1     |
+            | 4091 Home |
+        Then I see the result is empty
+
+    Scenario: I can see the navbar
+        Given I see the app
+        And I can access regression test 4091
+        Then I see the navbar
+
+    Scenario: If I navigate to home and back, I can still see the navbar
+        Given I see the app
+        And I can access regression test 4091
+        When I select the following links
+            | Home |
+            | 4091 |
+        Then I see the navbar
+
+    Scenario: The signal is not disposed too early
+        Given I see the app
+        And I can access regression test 4091
+        When I select the following links
+            | test1 |
+            | Home  |
+            | 4091  |
+        Then I see the navbar

examples/regression/e2e/tests/app_suite.rs

@@ -0,0 +1,30 @@
+mod fixtures;
+
+use anyhow::Result;
+use cucumber::World;
+use fixtures::world::AppWorld;
+use std::{ffi::OsStr, fs::read_dir};
+
+#[tokio::main]
+async fn main() -> Result<()> {
+    // Normally the below is done, but it's now gotten to the point of
+    // having a sufficient number of tests where the resource contention
+    // of the concurrently running browsers will cause failures on CI.
+    // AppWorld::cucumber()
+    //     .fail_on_skipped()
+    //     .run_and_exit("./features")
+    //     .await;
+
+    // Mitigate the issue by manually stepping through each feature,
+    // rather than letting cucumber glob them and dispatch all at once.
+    for entry in read_dir("./features")? {
+        let path = entry?.path();
+        if path.extension() == Some(OsStr::new("feature")) {
+            AppWorld::cucumber()
+                .fail_on_skipped()
+                .run_and_exit(path)
+                .await;
+        }
+    }
+    Ok(())
+}

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

@@ -0,0 +1,17 @@
+use super::{find, world::HOST};
+use anyhow::Result;
+use fantoccini::Client;
+use std::result::Result::Ok;
+
+pub async fn goto_path(client: &Client, path: &str) -> Result<()> {
+    let url = format!("{}{}", HOST, path);
+    client.goto(&url).await?;
+
+    Ok(())
+}
+
+pub async fn click_link(client: &Client, text: &str) -> Result<()> {
+    let link = find::link_with_text(&client, &text).await?;
+    link.click().await?;
+    Ok(())
+}

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

@@ -0,0 +1,20 @@
+use crate::fixtures::find;
+use anyhow::{Ok, Result};
+use fantoccini::Client;
+use pretty_assertions::assert_eq;
+
+pub async fn result_text_is(
+    client: &Client,
+    expected_text: &str,
+) -> Result<()> {
+    let actual = find::text_at_id(client, "result").await?;
+    assert_eq!(&actual, expected_text);
+    Ok(())
+}
+
+pub async fn element_exists(client: &Client, id: &str) -> Result<()> {
+    find::element_by_id(client, id)
+        .await
+        .expect(&format!("could not find element with id `{id}`"));
+    Ok(())
+}

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

@@ -0,0 +1,23 @@
+use anyhow::{Ok, Result};
+use fantoccini::{elements::Element, Client, Locator};
+
+pub async fn text_at_id(client: &Client, id: &str) -> Result<String> {
+    let element = element_by_id(client, id)
+        .await
+        .expect(format!("no such element with id `{}`", id).as_str());
+    let text = element.text().await?;
+    Ok(text)
+}
+
+pub async fn link_with_text(client: &Client, text: &str) -> Result<Element> {
+    let link = client
+        .wait()
+        .for_element(Locator::LinkText(text))
+        .await
+        .expect(format!("Link not found by `{}`", text).as_str());
+    Ok(link)
+}
+
+pub async fn element_by_id(client: &Client, id: &str) -> Result<Element> {
+    Ok(client.wait().for_element(Locator::Id(id)).await?)
+}

examples/regression/e2e/tests/fixtures/mod.rs

@@ -0,0 +1,4 @@
+pub mod action;
+pub mod check;
+pub mod find;
+pub mod world;

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

@@ -0,0 +1,47 @@
+use crate::fixtures::{action, world::AppWorld};
+use anyhow::{Ok, Result};
+use cucumber::{gherkin::Step, given, when};
+
+#[given("I see the app")]
+#[when("I open the app")]
+async fn i_open_the_app(world: &mut AppWorld) -> Result<()> {
+    let client = &world.client;
+    action::goto_path(client, "").await?;
+
+    Ok(())
+}
+
+#[given(regex = "^I can access regression test (.*)$")]
+#[when(regex = "^I select the link (.*)$")]
+async fn i_select_the_link(world: &mut AppWorld, text: String) -> Result<()> {
+    let client = &world.client;
+    action::click_link(client, &text).await?;
+
+    Ok(())
+}
+
+#[given(expr = "I select the following links")]
+#[when(expr = "I select the following links")]
+async fn i_select_the_following_links(
+    world: &mut AppWorld,
+    step: &Step,
+) -> Result<()> {
+    let client = &world.client;
+
+    if let Some(table) = step.table.as_ref() {
+        for row in table.rows.iter() {
+            action::click_link(client, &row[0]).await?;
+        }
+    }
+
+    Ok(())
+}
+
+#[given(regex = "^I (refresh|reload) the (browser|page)$")]
+#[when(regex = "^I (refresh|reload) the (browser|page)$")]
+async fn i_refresh_the_browser(world: &mut AppWorld) -> Result<()> {
+    let client = &world.client;
+    client.refresh().await?;
+
+    Ok(())
+}

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

@@ -0,0 +1,27 @@
+use crate::fixtures::{check, world::AppWorld};
+use anyhow::{Ok, Result};
+use cucumber::then;
+
+#[then(regex = r"^I see the result is empty$")]
+async fn i_see_the_result_is_empty(world: &mut AppWorld) -> Result<()> {
+    let client = &world.client;
+    check::result_text_is(client, "").await?;
+    Ok(())
+}
+
+#[then(regex = r"^I see the result is the string (.*)$")]
+async fn i_see_the_result_is_the_string(
+    world: &mut AppWorld,
+    text: String,
+) -> Result<()> {
+    let client = &world.client;
+    check::result_text_is(client, &text).await?;
+    Ok(())
+}
+
+#[then(regex = r"^I see the navbar$")]
+async fn i_see_the_navbar(world: &mut AppWorld) -> Result<()> {
+    let client = &world.client;
+    check::element_exists(client, "nav").await?;
+    Ok(())
+}

examples/regression/e2e/tests/fixtures/world/mod.rs

@@ -0,0 +1,39 @@
+pub mod action_steps;
+pub mod check_steps;
+
+use anyhow::Result;
+use cucumber::World;
+use fantoccini::{
+    error::NewSessionError, wd::Capabilities, Client, ClientBuilder,
+};
+
+pub const HOST: &str = "http://127.0.0.1:3000";
+
+#[derive(Debug, World)]
+#[world(init = Self::new)]
+pub struct AppWorld {
+    pub client: Client,
+}
+
+impl AppWorld {
+    async fn new() -> Result<Self, anyhow::Error> {
+        let webdriver_client = build_client().await?;
+
+        Ok(Self {
+            client: webdriver_client,
+        })
+    }
+}
+
+async fn build_client() -> Result<Client, NewSessionError> {
+    let mut cap = Capabilities::new();
+    let arg = serde_json::from_str("{\"args\": [\"-headless\"]}").unwrap();
+    cap.insert("goog:chromeOptions".to_string(), arg);
+
+    let client = ClientBuilder::native()
+        .capabilities(cap)
+        .connect("http://localhost:4444")
+        .await?;
+
+    Ok(client)
+}

examples/regression/src/app.rs

@@ -0,0 +1,65 @@
+use crate::{issue_4088::Routes4088, pr_4015::Routes4015, pr_4091::Routes4091};
+use leptos::prelude::*;
+use leptos_meta::{MetaTags, *};
+use leptos_router::{
+    components::{Route, Router, Routes},
+    path,
+};
+
+pub fn shell(options: LeptosOptions) -> impl IntoView {
+    view! {
+        <!DOCTYPE html>
+        <html lang="en">
+            <head>
+                <meta charset="utf-8"/>
+                <meta name="viewport" content="width=device-width, initial-scale=1"/>
+                <AutoReload options=options.clone()/>
+                <HydrationScripts options/>
+                <MetaTags/>
+            </head>
+            <body>
+                <App/>
+            </body>
+        </html>
+    }
+}
+
+#[component]
+pub fn App() -> impl IntoView {
+    provide_meta_context();
+    let fallback = || view! { "Page not found." }.into_view();
+    view! {
+        <Stylesheet id="leptos" href="/pkg/regression.css"/>
+        <Router>
+            <main>
+                <Routes fallback>
+                    <Route path=path!("") view=HomePage/>
+                    <Routes4091/>
+                    <Routes4015/>
+                    <Routes4088/>
+                </Routes>
+            </main>
+        </Router>
+    }
+}
+
+#[server]
+async fn server_call() -> Result<(), ServerFnError> {
+    tokio::time::sleep(std::time::Duration::from_millis(1)).await;
+    Ok(())
+}
+
+#[component]
+fn HomePage() -> impl IntoView {
+    view! {
+        <Title text="Regression Tests"/>
+        <h1>"Listing of regression tests"</h1>
+        <nav>
+            <ul>
+                <li><a href="/4091/">"4091"</a></li>
+                <li><a href="/4015/">"4015"</a></li>
+                <li><a href="/4088/">"4088"</a></li>
+            </ul>
+        </nav>
+    }
+}

examples/regression/src/issue_4088.rs

@@ -0,0 +1,119 @@
+use leptos::{either::Either, prelude::*};
+#[allow(unused_imports)]
+use leptos_router::{
+    components::{Outlet, ParentRoute, Redirect, Route},
+    path, MatchNestedRoutes, NavigateOptions,
+};
+use serde::{Deserialize, Serialize};
+
+#[component]
+pub fn Routes4088() -> impl MatchNestedRoutes + Clone {
+    view! {
+        <ParentRoute path=path!("4088") view=|| view!{ <LoggedIn/> }>
+			<ParentRoute path=path!("") view=||view!{<AssignmentsSelector/>}>
+				<Route path=path!("/:team_id") view=||view!{<AssignmentsForTeam/>} />
+				<Route path=path!("") view=||view!{ <p>No class selected</p> }/>
+			</ParentRoute>
+        </ParentRoute>
+    }
+    .into_inner()
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
+pub struct UserInfo {
+    pub id: usize,
+}
+
+#[server]
+pub async fn get_user_info() -> Result<Option<UserInfo>, ServerFnError> {
+    Ok(Some(UserInfo { id: 42 }))
+}
+
+#[component]
+pub fn LoggedIn() -> impl IntoView {
+    let user_info_resource =
+        Resource::new(|| (), move |_| async { get_user_info().await });
+
+    view! {
+
+      <Transition fallback=move || view!{
+            "loading"
+            }
+        >
+        {move || {
+            user_info_resource.get()
+                .map(|a|
+                    match a {
+                        Ok(Some(a)) => Either::Left(view! {
+                            <LoggedInContent user_info={a} />
+                        }),
+                        _ => Either::Right(view!{
+                            <Redirect path="/not_logged_in"/>
+                        })
+                    })
+        }}
+        </Transition>
+    }
+}
+
+#[component]
+/// Component which provides UserInfo and renders it's child
+/// Can also contain some code to check for specific situations (e.g. privacy policies accepted or not? redirect if needed...)
+pub fn LoggedInContent(user_info: UserInfo) -> impl IntoView {
+    provide_context(user_info.clone());
+
+    if user_info.id == 42 {
+        Either::Left(Outlet())
+    } else {
+        Either::Right(
+            view! { <Redirect path="/somewhere" options={NavigateOptions::default()}/> },
+        )
+    }
+}
+
+#[component]
+/// This component also uses Outlet (so nested Outlet)
+fn AssignmentsSelector() -> impl IntoView {
+    let user_info = use_context::<UserInfo>().expect("user info not provided");
+
+    view! {
+        <p>"Assignments for user with ID: "{user_info.id}</p>
+        <ul id="nav">
+            <li><a href="/4088/1">"Class 1"</a></li>
+            <li><a href="/4088/2">"Class 2"</a></li>
+            <li><a href="/4088/3">"Class 3"</a></li>
+        </ul>
+
+        <Outlet />
+    }
+}
+
+#[component]
+fn AssignmentsForTeam() -> impl IntoView {
+    // THIS FAILS -> Because of the nested outlet in LoggedInContent > AssignmentsSelector?
+    // It did not fail when LoggedIn did not use a resource and transition (but a hardcoded UserInfo in the component)
+    let user_info = use_context::<UserInfo>().expect("user info not provided");
+
+    let items = vec!["Assignment 1", "Assignment 2", "Assignment 3"];
+    view! {
+        <p id="result">"Assignments for team of user with id " {user_info.id}</p>
+        <ul>
+            {
+            items.into_iter().map(|item| {
+                view! {
+                    <Assignment name=item.to_string() />
+                }
+            }).collect_view()
+            }
+        </ul>
+    }
+}
+
+#[component]
+fn Assignment(name: String) -> impl IntoView {
+    let user_info = use_context::<UserInfo>().expect("user info not provided");
+
+    view! {
+        <li>{name}" "{user_info.id}</li>
+    }
+}

examples/regression/src/lib.rs

@@ -0,0 +1,12 @@
+pub mod app;
+mod issue_4088;
+mod pr_4015;
+mod pr_4091;
+
+#[cfg(feature = "hydrate")]
+#[wasm_bindgen::prelude::wasm_bindgen]
+pub fn hydrate() {
+    use app::*;
+    console_error_panic_hook::set_once();
+    leptos::mount::hydrate_body(App);
+}

examples/regression/src/main.rs

@@ -0,0 +1,37 @@
+#[cfg(feature = "ssr")]
+#[tokio::main]
+async fn main() {
+    use axum::Router;
+    use leptos::prelude::*;
+    use leptos_axum::{generate_route_list, LeptosRoutes};
+    use regression::app::{shell, App};
+
+    let conf = get_configuration(None).unwrap();
+    let addr = conf.leptos_options.site_addr;
+    let leptos_options = conf.leptos_options;
+    // Generate the list of routes in your Leptos App
+    let routes = generate_route_list(App);
+
+    let app = Router::new()
+        .leptos_routes(&leptos_options, routes, {
+            let leptos_options = leptos_options.clone();
+            move || shell(leptos_options.clone())
+        })
+        .fallback(leptos_axum::file_and_error_handler(shell))
+        .with_state(leptos_options);
+
+    // run our app with hyper
+    // `axum::Server` is a re-export of `hyper::Server`
+    println!("listening on http://{}", &addr);
+    let listener = tokio::net::TcpListener::bind(&addr).await.unwrap();
+    axum::serve(listener, app.into_make_service())
+        .await
+        .unwrap();
+}
+
+#[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
+}

examples/regression/src/pr_4015.rs

@@ -0,0 +1,29 @@
+use leptos::{context::Provider, prelude::*};
+use leptos_router::{
+    components::{ParentRoute, Route},
+    nested_router::Outlet,
+    path,
+};
+
+#[component]
+pub fn Routes4015() -> impl leptos_router::MatchNestedRoutes + Clone {
+    view! {
+        <ParentRoute path=path!("4015") view=|| view! {
+            <Provider value=42i32>
+                <Outlet/>
+            </Provider>
+        }>
+            <Route path=path!("") view=Child/>
+        </ParentRoute>
+    }
+    .into_inner()
+}
+
+#[component]
+fn Child() -> impl IntoView {
+    let value = use_context::<i32>();
+
+    view! {
+        <p id="result">{format!("{value:?}")}</p>
+    }
+}

examples/regression/src/pr_4091.rs

@@ -0,0 +1,68 @@
+use leptos::{context::Provider, prelude::*};
+use leptos_router::{
+    components::{ParentRoute, Route, A},
+    nested_router::Outlet,
+    path,
+};
+
+// FIXME This should be a set rather than a naive vec for push and pop, as
+// it may be possible for unexpected token be popped/pushed on multi-level
+// navigation.  For basic naive tests it should be Fine(TM).
+#[derive(Clone)]
+struct Expectations(Vec<&'static str>);
+
+#[component]
+pub fn Routes4091() -> impl leptos_router::MatchNestedRoutes + Clone {
+    view! {
+        <ParentRoute path=path!("4091") view=Container>
+            <Route path=path!("") view=Root/>
+            <Route path=path!("test1") view=Test1/>
+        </ParentRoute>
+    }
+    .into_inner()
+}
+
+#[component]
+fn Container() -> impl IntoView {
+    let rw_signal = RwSignal::new(Expectations(Vec::new()));
+    provide_context(rw_signal);
+
+    view! {
+        <nav id="nav">
+            <ul>
+                <li><A href="/">"Home"</A></li>
+                <li><A href="./">"4091 Home"</A></li>
+                <li><A href="test1">"test1"</A></li>
+            </ul>
+        </nav>
+        <div id="result">{move || {
+            rw_signal.with(|ex| ex.0.iter().fold(String::new(), |a, b| a + b + " "))
+        }}</div>
+        <Provider value=rw_signal>
+            <Outlet/>
+        </Provider>
+    }
+}
+
+#[component]
+fn Root() -> impl IntoView {
+    view! {
+        <div>"This is Root"</div>
+    }
+}
+
+#[component]
+fn Test1() -> impl IntoView {
+    let signal = expect_context::<RwSignal<Expectations>>();
+
+    on_cleanup(move || {
+        signal.update(|ex| {
+            ex.0.pop();
+        });
+    });
+
+    view! {
+        {move || signal.update(|ex| ex.0.push("Test1"))}
+        <div>"This is Test1"</div>
+    }
+}

examples/regression/style/main.scss

@@ -0,0 +1,3 @@
+body {
+    font-family: sans-serif;
+}

examples/server_fns_axum/Cargo.toml

@@ -38,7 +38,6 @@ strum = { version = "0.27.1", features = ["strum_macros", "derive"] }
 notify = { version = "8.0", optional = true }
 pin-project-lite = "0.2.14"
 dashmap = { version = "6.0", optional = true }
-once_cell = { version = "1.19", optional = true }
 async-broadcast = { version = "0.7.1", optional = true }
 bytecheck = "0.8.0"
 rkyv = { version = "0.8.8" }
@@ -54,7 +53,6 @@ ssr = [
   "dep:leptos_axum",
   "dep:notify",
   "dep:dashmap",
-  "dep:once_cell",
   "dep:async-broadcast",
 ]
 

examples/server_fns_axum/src/app.rs

@@ -424,7 +424,7 @@ pub fn FileUploadWithProgress() -> impl IntoView {
         use async_broadcast::{broadcast, Receiver, Sender};
         use dashmap::DashMap;
         use futures::Stream;
-        use once_cell::sync::Lazy;
+        use std::sync::LazyLock;
 
         struct File {
             total: usize,
@@ -432,7 +432,8 @@ pub fn FileUploadWithProgress() -> impl IntoView {
             rx: Receiver<usize>,
         }
 
-        static FILES: Lazy<DashMap<String, File>> = Lazy::new(DashMap::new);
+        static FILES: LazyLock<DashMap<String, File>> =
+            LazyLock::new(DashMap::new);
 
         pub async fn add_chunk(filename: &str, len: usize) {
             println!("[{filename}]\tadding {len}");

examples/ssr_modes/Cargo.toml

@@ -2,8 +2,6 @@
 name = "ssr_modes"
 version = "0.1.0"
 edition = "2021"
-# std::sync::LazyLock is stabilized in Rust version 1.80.0
-rust-version = "1.80.0"
 
 [lib]
 crate-type = ["cdylib", "rlib"]

examples/ssr_modes_axum/Cargo.toml

@@ -2,8 +2,6 @@
 name = "ssr_modes_axum"
 version = "0.1.0"
 edition = "2021"
-# std::sync::LazyLock is stabilized in Rust version 1.80.0
-rust-version = "1.80.0"
 
 [lib]
 crate-type = ["cdylib", "rlib"]

examples/stores/README.md

@@ -1,6 +1,6 @@
-# Leptos Counter Example
+# Stores Example
 
-This example creates a simple counter in a client side rendered app with Rust and WASM!
+This example shows how to use reactive stores, by building a client-side rendered TODO application.
 
 ## Getting Started
 

examples/stores/src/lib.rs

@@ -159,7 +159,7 @@ fn TodoRow(
 
     view! {
         <li style:text-decoration=move || {
-            status.done().then_some("line-through").unwrap_or_default()
+          if status.done() { "line-through" } else { Default::default() }
         }>
 
             <p

examples/suspense_tests/e2e/features/check_instrumented_issue_3719.feature

@@ -52,7 +52,7 @@ Feature: Using instrumented counters to test regression from #3502.
             | list_items         | 1 |
             | get_item           | 1 |
             | inspect_item_root  | 0 |
-            | inspect_item_field | 4 |
+            | inspect_item_field | 3 |
 
     Scenario: Follow paths ordinarily down to a target
         Given I select the following links

examples/suspense_tests/src/instrumented.rs

@@ -477,6 +477,8 @@ fn ItemInspect() -> impl IntoView {
         move || params.get().map(|p| p.path),
         move |p| async move {
             // leptos::logging::log!("res_inspect: res_overview.await");
+            // Note: this resource is untracked here, though `params` changing
+            // will nonetheless results in the "expected" tracked updates.
             let overview = res_overview.await;
             // leptos::logging::log!("res_inspect: resolved res_overview.await");
             // let result =
@@ -561,7 +563,7 @@ fn ShowCounters() -> impl IntoView {
     //
     // However, upon `Reset Counters`, the mode from which the reset
     // was issued will result in the rendering be reflected as such, so
-    // if the intial state was SSR, resetting under CSR will result in
+    // if the initial state was SSR, resetting under CSR will result in
     // the CSR counters be rendered after.  However for the intents and
     // purpose for the testing only the CSR is cared for.
     //

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

@@ -10,19 +10,9 @@ pub async fn goto_path(client: &Client, path: &str) -> Result<()> {
     Ok(())
 }
 
-pub async fn add_text(client: &Client, text: &str) -> Result<String> {
-    fill_input(client, text).await?;
-    get_label(client).await
-}
-
 pub async fn fill_input(client: &Client, text: &str) -> Result<()> {
     let textbox = find::input(client).await;
     textbox.send_keys(text).await?;
 
     Ok(())
 }
-
-pub async fn get_label(client: &Client) -> Result<String> {
-    let label = find::label(client).await;
-    Ok(label.text().await?)
-}

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

@@ -9,13 +9,3 @@ pub async fn input(client: &Client) -> Element {
 
     textbox
 }
-
-pub async fn label(client: &Client) -> Element {
-    let label = client
-        .wait()
-        .for_element(Locator::Css("p"))
-        .await
-        .expect("");
-
-    label
-}

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

@@ -14,7 +14,7 @@ async fn i_open_the_app(world: &mut AppWorld) -> Result<()> {
 #[given(regex = "^I add a text as (.*)$")]
 async fn i_add_a_text(world: &mut AppWorld, text: String) -> Result<()> {
     let client = &world.client;
-    action::add_text(client, text.as_str()).await?;
+    action::fill_input(client, text.as_str()).await?;
 
     Ok(())
 }

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

@@ -20,7 +20,7 @@ async fn i_see_the_label_of_the_input_is(
     world: &mut AppWorld,
     text: String,
 ) -> Result<()> {
-    sleep(Duration::from_millis(50)).await;
+    sleep(Duration::from_millis(500)).await;
     let client = &world.client;
     check::text_on_element(client, "p", &text).await?;
 

hydration_context/Cargo.toml

@@ -12,12 +12,11 @@ edition.workspace = true
 [dependencies]
 throw_error = { workspace = true }
 or_poisoned = { workspace = true }
-futures = "0.3.31"
-serde = { version = "1.0", features = ["derive"] }
-wasm-bindgen = { workspace = true, optional = true }
-js-sys = { version = "0.3.74", optional = true }
-once_cell = "1.20"
-pin-project-lite = "0.2.15"
+futures = { workspace = true, default-features = true }
+serde = { features = ["derive"] , workspace = true, default-features = true }
+wasm-bindgen = { workspace = true, optional = true , default-features = true }
+js-sys = { optional = true , workspace = true, default-features = true }
+pin-project-lite = { workspace = true, default-features = true }
 
 [features]
 browser = ["dep:wasm-bindgen", "dep:js-sys"]

hydration_context/src/hydrate.rs

@@ -7,10 +7,12 @@ use super::{SerializedDataId, SharedContext};
 use crate::{PinnedFuture, PinnedStream};
 use core::fmt::Debug;
 use js_sys::Array;
-use once_cell::sync::Lazy;
 use std::{
     fmt::Display,
-    sync::atomic::{AtomicBool, AtomicUsize, Ordering},
+    sync::{
+        atomic::{AtomicBool, AtomicUsize, Ordering},
+        LazyLock,
+    },
 };
 use throw_error::{Error, ErrorId};
 use wasm_bindgen::{prelude::wasm_bindgen, JsCast};
@@ -79,8 +81,8 @@ pub struct HydrateSharedContext {
     id: AtomicUsize,
     is_hydrating: AtomicBool,
     during_hydration: AtomicBool,
-    errors: Lazy<Vec<(SerializedDataId, ErrorId, Error)>>,
-    incomplete: Lazy<Vec<SerializedDataId>>,
+    errors: LazyLock<Vec<(SerializedDataId, ErrorId, Error)>>,
+    incomplete: LazyLock<Vec<SerializedDataId>>,
 }
 
 impl HydrateSharedContext {
@@ -90,8 +92,8 @@ impl HydrateSharedContext {
             id: AtomicUsize::new(0),
             is_hydrating: AtomicBool::new(true),
             during_hydration: AtomicBool::new(true),
-            errors: Lazy::new(serialized_errors),
-            incomplete: Lazy::new(incomplete_chunks),
+            errors: LazyLock::new(serialized_errors),
+            incomplete: LazyLock::new(incomplete_chunks),
         }
     }
 
@@ -104,8 +106,8 @@ impl HydrateSharedContext {
             id: AtomicUsize::new(0),
             is_hydrating: AtomicBool::new(false),
             during_hydration: AtomicBool::new(true),
-            errors: Lazy::new(serialized_errors),
-            incomplete: Lazy::new(incomplete_chunks),
+            errors: LazyLock::new(serialized_errors),
+            incomplete: LazyLock::new(incomplete_chunks),
         }
     }
 }

integrations/actix/Cargo.toml

@@ -9,10 +9,10 @@ rust-version.workspace = true
 edition.workspace = true
 
 [dependencies]
-actix-http = "3.9"
-actix-files = "0.6"
-actix-web = "4.9"
-futures = "0.3.31"
+actix-http = { workspace = true, default-features = true }
+actix-files = { workspace = true, default-features = true }
+actix-web = { workspace = true, default-features = true }
+futures = { workspace = true, default-features = true }
 any_spawner = { workspace = true, features = ["tokio"] }
 hydration_context = { workspace = true }
 leptos = { workspace = true, features = ["nonce", "ssr"] }
@@ -22,13 +22,12 @@ leptos_meta = { workspace = true, features = ["nonce"] }
 leptos_router = { workspace = true, features = ["ssr"] }
 server_fn = { workspace = true, features = ["actix"] }
 tachys = { workspace = true }
-serde_json = { workspace = true }
-parking_lot = "0.12.3"
-tracing = { version = "0.1", optional = true }
-tokio = { version = "1.43", features = ["rt", "fs"] }
-send_wrapper = "0.6.0"
-dashmap = "6"
-once_cell = "1"
+serde_json = { workspace = true , default-features = true }
+parking_lot = { workspace = true, default-features = true }
+tracing = { optional = true , workspace = true, default-features = true }
+tokio = { features = ["rt", "fs"] , workspace = true, default-features = true }
+send_wrapper = { workspace = true, default-features = true }
+dashmap = { workspace = true, default-features = true }
 
 [package.metadata.docs.rs]
 rustdoc-args = ["--generate-link-to-definition"]

integrations/actix/src/lib.rs

@@ -38,7 +38,6 @@ use leptos_router::{
     static_routes::{RegenerationFn, ResolvedStaticPath},
     ExpandOptionals, Method, PathSegment, RouteList, RouteListing, SsrMode,
 };
-use once_cell::sync::Lazy;
 use parking_lot::RwLock;
 use send_wrapper::SendWrapper;
 use server_fn::{
@@ -51,7 +50,7 @@ use std::{
     future::Future,
     ops::{Deref, DerefMut},
     path::Path,
-    sync::Arc,
+    sync::{Arc, LazyLock},
 };
 
 /// This struct lets you define headers and override the status of the Response from an Element or a Server Function
@@ -1210,8 +1209,8 @@ impl StaticRouteGenerator {
     }
 }
 
-static STATIC_HEADERS: Lazy<DashMap<String, ResponseOptions>> =
-    Lazy::new(DashMap::new);
+static STATIC_HEADERS: LazyLock<DashMap<String, ResponseOptions>> =
+    LazyLock::new(DashMap::new);
 
 fn was_404(owner: &Owner) -> bool {
     let resp = owner.with(|| expect_context::<ResponseOptions>());

integrations/axum/Cargo.toml

@@ -4,18 +4,18 @@ authors = ["Greg Johnston"]
 license = "MIT"
 repository = "https://github.com/leptos-rs/leptos"
 description = "Axum integrations for the Leptos web framework."
-version = "0.8.0-rc3"
+version = "0.8.3"
 rust-version.workspace = true
 edition.workspace = true
 
 [dependencies]
 any_spawner = { workspace = true, features = ["tokio"] }
 hydration_context = { workspace = true }
-axum = { version = "0.8.1", default-features = false, features = [
+axum = { default-features = false, features = [
   "matched-path",
-] }
-dashmap = "6"
-futures = "0.3.31"
+], workspace = true }
+dashmap = { workspace = true, default-features = true }
+futures = { workspace = true, default-features = true }
 leptos = { workspace = true, features = ["nonce", "ssr"] }
 server_fn = { workspace = true, features = ["axum-no-default"] }
 leptos_macro = { workspace = true, features = ["axum"] }
@@ -23,16 +23,18 @@ leptos_meta = { workspace = true, features = ["ssr", "nonce"] }
 leptos_router = { workspace = true, features = ["ssr"] }
 leptos_integration_utils = { workspace = true }
 tachys = { workspace = true }
-once_cell = "1"
-parking_lot = "0.12.3"
-tokio = { version = "1.43", default-features = false }
-tower = { version = "0.5.1", features = ["util"] }
-tower-http = "0.6.2"
-tracing = { version = "0.1.41", optional = true }
+parking_lot = { workspace = true, default-features = true }
+tokio = { default-features = false, workspace = true }
+tower = { features = ["util"], workspace = true, default-features = true }
+tower-http = { workspace = true, default-features = true }
+tracing = { optional = true, workspace = true, default-features = true }
 
 [dev-dependencies]
-axum = "0.8.1"
-tokio = { version = "1.43", features = ["net", "rt-multi-thread"] }
+axum = { workspace = true, default-features = true }
+tokio = { features = [
+  "net",
+  "rt-multi-thread",
+], workspace = true, default-features = true }
 
 [features]
 wasm = []

integrations/axum/src/lib.rs

@@ -69,12 +69,12 @@ use leptos_router::{
     static_routes::RegenerationFn, ExpandOptionals, PathSegment, RouteList,
     RouteListing, SsrMode,
 };
-#[cfg(feature = "default")]
-use once_cell::sync::Lazy;
 use parking_lot::RwLock;
 use server_fn::{error::ServerFnErrorErr, redirect::REDIRECT_HEADER};
 #[cfg(feature = "default")]
 use std::path::Path;
+#[cfg(feature = "default")]
+use std::sync::LazyLock;
 use std::{collections::HashSet, fmt::Debug, io, pin::Pin, sync::Arc};
 #[cfg(feature = "default")]
 use tower::util::ServiceExt;
@@ -590,7 +590,7 @@ where
 /// Returns an Axum [Handler](axum::handler::Handler) that listens for a `GET` request and tries
 /// to route it using [leptos_router], serving an HTML stream of your application.
 ///
-/// This version allows us to pass Axum State/Extension/Extractor or other infro from Axum or network
+/// This version allows us to pass Axum State/Extension/Extractor or other info from Axum or network
 /// layers above Leptos itself. To use it, you'll need to write your own handler function that provides
 /// the data to leptos in a closure. An example is below
 /// ```
@@ -796,7 +796,7 @@ where
 /// This stream will pause at each `<Suspense/>` node and wait for it to resolve before
 /// sending down its HTML. The app will become interactive once it has fully loaded.
 ///
-/// This version allows us to pass Axum State/Extension/Extractor or other infro from Axum or network
+/// This version allows us to pass Axum State/Extension/Extractor or other info from Axum or network
 /// layers above Leptos itself. To use it, you'll need to write your own handler function that provides
 /// the data to leptos in a closure. An example is below
 /// ```
@@ -879,7 +879,8 @@ where
     }
 }
 
-fn handle_response_inner<IV>(
+/// Can be used in conjunction with a custom [file_and_error_handler_with_context] to process an Axum [Request](axum::extract::Request) into an Axum [Response](axum::response::Response)
+pub fn handle_response_inner<IV>(
     additional_context: impl Fn() + 'static + Clone + Send,
     app_fn: impl FnOnce() -> IV + Send + 'static,
     req: Request<Body>,
@@ -1022,7 +1023,7 @@ where
 /// to route it using [leptos_router], asynchronously rendering an HTML page after all
 /// `async` resources have loaded.
 ///
-/// This version allows us to pass Axum State/Extension/Extractor or other infro from Axum or network
+/// This version allows us to pass Axum State/Extension/Extractor or other info from Axum or network
 /// layers above Leptos itself. To use it, you'll need to write your own handler function that provides
 /// the data to leptos in a closure. An example is below
 /// ```
@@ -1089,7 +1090,7 @@ where
 /// to route it using [leptos_router], asynchronously rendering an HTML page after all
 /// `async` resources have loaded.
 ///
-/// This version allows us to pass Axum State/Extension/Extractor or other infro from Axum or network
+/// This version allows us to pass Axum State/Extension/Extractor or other info from Axum or network
 /// layers above Leptos itself. To use it, you'll need to write your own handler function that provides
 /// the data to leptos in a closure. An example is below
 /// ```
@@ -1521,8 +1522,8 @@ impl StaticRouteGenerator {
 }
 
 #[cfg(feature = "default")]
-static STATIC_HEADERS: Lazy<DashMap<String, ResponseOptions>> =
-    Lazy::new(DashMap::new);
+static STATIC_HEADERS: LazyLock<DashMap<String, ResponseOptions>> =
+    LazyLock::new(DashMap::new);
 
 #[cfg(feature = "default")]
 fn was_404(owner: &Owner) -> bool {

integrations/utils/Cargo.toml

@@ -9,7 +9,7 @@ rust-version.workspace = true
 edition.workspace = true
 
 [dependencies]
-futures = "0.3.31"
+futures = { workspace = true, default-features = true }
 hydration_context = { workspace = true }
 leptos = { workspace = true, features = ["nonce"] }
 leptos_meta = { workspace = true, features = ["ssr"] }

leptos/Cargo.toml

@@ -15,8 +15,8 @@ any_spawner = { workspace = true, features = [
   "wasm-bindgen",
   "futures-executor",
 ] }
-base64 = { version = "0.22.1", optional = true }
-cfg-if = "1.0"
+base64 = { optional = true, workspace = true, default-features = true }
+cfg-if = { workspace = true, default-features = true }
 hydration_context = { workspace = true }
 either_of = { workspace = true }
 leptos_dom = { workspace = true }
@@ -24,38 +24,38 @@ leptos_hot_reload = { workspace = true }
 leptos_macro = { workspace = true }
 leptos_server = { workspace = true, features = ["tachys"] }
 leptos_config = { workspace = true }
-leptos-spin-macro = { version = "0.2.0", optional = true }
+leptos-spin-macro = { optional = true , workspace = true, default-features = true }
 oco_ref = { workspace = true }
 or_poisoned = { workspace = true }
-paste = "1.0"
-rand = { version = "0.8.5", optional = true }
-# NOTE: While not used directly, `getrandom`'s `js` feature is needed when `rand` is used on WASM to
+paste = { workspace = true, default-features = true }
+rand = { optional = true , workspace = true, default-features = true }
+# NOTE: While not used directly, `getrandom`'s `wasm_js` feature is needed when `rand` is used on WASM to
 #       avoid a compilation error
-getrandom = { version = "0.2", optional = true }
+getrandom = { optional = true , workspace = true, default-features = true }
 reactive_graph = { workspace = true, features = ["serde"] }
-rustc-hash = "2.0"
+rustc-hash = { workspace = true, default-features = true }
 tachys = { workspace = true, features = [
   "reactive_graph",
   "reactive_stores",
   "oco",
 ] }
-thiserror = { workspace = true }
-tracing = { version = "0.1.41", optional = true }
-typed-builder = { workspace = true }
-typed-builder-macro = "0.21.0"
-serde = "1.0"
-serde_json = { version = "1.0", optional = true }
+thiserror = { workspace = true, default-features = true }
+tracing = { optional = true, workspace = true, default-features = true }
+typed-builder = { workspace = true, default-features = true }
+typed-builder-macro = { workspace = true, default-features = true }
+serde = { workspace = true, default-features = true }
+serde_json = { optional = true, workspace = true, default-features = true }
 server_fn = { workspace = true, features = ["form-redirects", "browser"] }
-web-sys = { version = "0.3.72", features = [
+web-sys = { features = [
   "ShadowRoot",
   "ShadowRootInit",
   "ShadowRootMode",
-] }
-wasm-bindgen = { workspace = true }
-serde_qs = "0.14.0"
-slotmap = "1.0"
-futures = "0.3.31"
-send_wrapper = "0.6.0"
+], workspace = true, default-features = true }
+wasm-bindgen = { workspace = true, default-features = true }
+serde_qs = { workspace = true, default-features = true }
+slotmap = { workspace = true, default-features = true }
+futures = { workspace = true, default-features = true }
+send_wrapper = { workspace = true, default-features = true }
 
 [features]
 hydration = [
@@ -64,13 +64,13 @@ hydration = [
   "hydration_context/browser",
   "leptos_dom/hydration",
 ]
-csr = ["leptos_macro/csr", "reactive_graph/effects", "getrandom?/js"]
+csr = ["leptos_macro/csr", "reactive_graph/effects", "getrandom?/wasm_js"]
 hydrate = [
   "leptos_macro/hydrate",
   "hydration",
   "tachys/hydrate",
   "reactive_graph/effects",
-  "getrandom?/js",
+  "getrandom?/wasm_js",
 ]
 default-tls = ["server_fn/default-tls"]
 rustls = ["server_fn/rustls"]
@@ -101,8 +101,13 @@ trace-component-props = [
 delegation = ["tachys/delegation"]
 islands-router = ["tachys/mark_branches"]
 
+[dev-dependencies]
+tokio = { features = ["rt-multi-thread", "macros"] , workspace = true, default-features = true }
+tokio-test = { workspace = true, default-features = true }
+any_spawner = { workspace = true, features = ["futures-executor", "tokio"] }
+
 [build-dependencies]
-rustc_version = "0.4.1"
+rustc_version = { workspace = true, default-features = true }
 
 # Having an erasure feature rather than normal --cfg erase_components for the proc macro crate is a workaround for this rust issue:
 # https://github.com/rust-lang/cargo/issues/4423

leptos/build.rs

@@ -1,8 +1,15 @@
 use rustc_version::{version_meta, Channel};
 
 fn main() {
+    let target = std::env::var("TARGET").unwrap_or_default();
+
     // Set cfg flags depending on release channel
     if matches!(version_meta().unwrap().channel, Channel::Nightly) {
         println!("cargo:rustc-cfg=rustc_nightly");
     }
+    // Set cfg flag for getrandom wasm_js
+    if target == "wasm32-unknown-unknown" {
+        // Set a custom cfg flag for wasm builds
+        println!("cargo:rustc-cfg=getrandom_backend=\"wasm_js\"");
+    }
 }

leptos/src/children.rs

@@ -47,7 +47,7 @@ type BoxedChildrenFn = Box<dyn Fn() -> AnyView + Send>;
 ///
 /// Different component types take different types for their `children` prop, some of which cannot
 /// be directly constructed. Using `ToChildren` allows the component user to pass children without
-/// explicity constructing the correct type.
+/// explicitly constructing the correct type.
 ///
 /// ## Examples
 ///

leptos/src/form.rs

@@ -255,7 +255,7 @@ where
     ) -> Result<Self, serde_qs::Error>;
 }
 
-/// Errors that can arise when coverting from an HTML event or form into a Rust data type.
+/// Errors that can arise when converting from an HTML event or form into a Rust data type.
 #[derive(Error, Debug)]
 pub enum FromFormDataError {
     /// Could not find a `<form>` connected to the event.

leptos/src/hydration/island_script.js

@@ -1,5 +1,5 @@
 ((root, pkg_path, output_name, wasm_output_name) => {
-	let MOST_RECENT_CHILDREN_CB;
+	let MOST_RECENT_CHILDREN_CB = [];
 
 	function idle(c) {
 		if ("requestIdleCallback" in window) {
@@ -22,12 +22,18 @@
 						traverse(child, children);
 					}
 				} else {
-					if(tag === 'leptos-children') {
-						MOST_RECENT_CHILDREN_CB = node.$$on_hydrate;
+					if (tag === 'leptos-children') {
+						MOST_RECENT_CHILDREN_CB.push(node.$$on_hydrate);
+						for(const child of node.children) {
+							traverse(child);
+						};
+						// un-set the "most recent children"
+						MOST_RECENT_CHILDREN_CB.pop();
+					} else {
+						for(const child of node.children) {
+							traverse(child);
+						};
 					}
-					for(const child of node.children) {
-						traverse(child);
-					};
 				}
 			}
 		}
@@ -37,8 +43,9 @@
 	function hydrateIsland(el, id, mod) {
 		const islandFn = mod[id];
 		if (islandFn) {
-			if (MOST_RECENT_CHILDREN_CB) {
-				MOST_RECENT_CHILDREN_CB();
+			const children_cb = MOST_RECENT_CHILDREN_CB[MOST_RECENT_CHILDREN_CB.length-1];
+			if (children_cb) {
+				children_cb();
 			}
 			islandFn(el);
 		} else {
@@ -48,7 +55,7 @@
 	idle(() => {
 		import(`${root}/${pkg_path}/${output_name}.js`)
 			.then(mod => {
-				mod.default(`${root}/${pkg_path}/${wasm_output_name}.wasm`).then(() => {
+				mod.default({module_or_path: `${root}/${pkg_path}/${wasm_output_name}.wasm`}).then(() => {
 					mod.hydrate();
 					hydrateIslands(document.body, mod);
 				});

leptos/src/hydration/islands_routing.js

@@ -17,6 +17,10 @@ window.addEventListener("popstate", async (ev) => {
 });
 
 window.addEventListener("submit", async (ev) => {
+	if (ev.defaultPrevented) {
+		return;
+	}
+		
 	const req = submitToReq(ev);
 	if(!req) {
 		return;
@@ -194,6 +198,15 @@ function diffRange(oldDocument, oldRoot, newDocument, newRoot, oldEnd, newEnd) {
 		else if (oldNode.nodeType === Node.TEXT_NODE) {
 			oldNode.textContent = newNode.textContent;
 		}
+		// islands should not be diffed on the client, because we do not want to overwrite client-side state 
+		// but their children should be diffed still, because they could contain new server content
+		else if (oldNode.nodeType === Node.ELEMENT_NODE && oldNode.tagName === "LEPTOS-ISLAND") {
+			// TODO: diff the leptos-children 
+
+			// skip over leptos-island otherwise
+			oldDocWalker.nextSibling();
+			newDocWalker.nextSibling();
+		}
 		// if it's an element, replace if it's a different tag, or update attributes
 		else if (oldNode.nodeType === Node.ELEMENT_NODE) {
 			diffElement(oldNode, newNode);

leptos/src/hydration/mod.rs

@@ -83,6 +83,10 @@ pub fn HydrationScripts(
                     }
                 }
             }
+        } else {
+            leptos::logging::error!(
+                "File hashing is active but no hash file was found"
+            );
         }
     } else if std::option_env!("LEPTOS_OUTPUT_NAME").is_none() {
         wasm_file_name.push_str("_bg");

leptos/src/hydration/reload_script.js

@@ -7,7 +7,7 @@ ws.onmessage = (ev) => {
 		let found = false;
 		document.querySelectorAll("link").forEach((link) => {
 			if (link.getAttribute('href').includes(msg.css)) {
-				let newHref = '/' + msg.css + '?version=' + new Date().getMilliseconds();
+				let newHref = '/' + msg.css + '?version=' + Date.now();
 				link.setAttribute('href', newHref);
 				found = true;
 			}

leptos/src/into_view.rs

@@ -90,6 +90,7 @@ impl<T: RenderHtml> RenderHtml for View<T> {
     type Owned = View<T::Owned>;
 
     const MIN_LENGTH: usize = <T as RenderHtml>::MIN_LENGTH;
+    const EXISTS: bool = <T as RenderHtml>::EXISTS;
 
     async fn resolve(self) -> Self::AsyncOutput {
         self.inner.resolve().await
@@ -107,9 +108,14 @@ impl<T: RenderHtml> RenderHtml for View<T> {
         mark_branches: bool,
         extra_attrs: Vec<AnyAttribute>,
     ) {
-        #[cfg(all(debug_assertions, feature = "nightly", rustc_nightly))]
-        let vm = self.view_marker.to_owned();
-        #[cfg(all(debug_assertions, feature = "nightly", rustc_nightly))]
+        #[cfg(debug_assertions)]
+        let vm = if option_env!("LEPTOS_WATCH").is_some() {
+            self.view_marker.to_owned()
+        } else {
+            None
+        };
+
+        #[cfg(debug_assertions)]
         if let Some(vm) = vm.as_ref() {
             buf.push_str(&format!("<!--hot-reload|{vm}|open-->"));
         }
@@ -122,7 +128,7 @@ impl<T: RenderHtml> RenderHtml for View<T> {
             extra_attrs,
         );
 
-        #[cfg(all(debug_assertions, feature = "nightly", rustc_nightly))]
+        #[cfg(debug_assertions)]
         if let Some(vm) = vm.as_ref() {
             buf.push_str(&format!("<!--hot-reload|{vm}|close-->"));
         }
@@ -138,9 +144,14 @@ impl<T: RenderHtml> RenderHtml for View<T> {
     ) where
         Self: Sized,
     {
-        #[cfg(all(debug_assertions, feature = "nightly", rustc_nightly))]
-        let vm = self.view_marker.to_owned();
-        #[cfg(all(debug_assertions, feature = "nightly", rustc_nightly))]
+        #[cfg(debug_assertions)]
+        let vm = if option_env!("LEPTOS_WATCH").is_some() {
+            self.view_marker.to_owned()
+        } else {
+            None
+        };
+
+        #[cfg(debug_assertions)]
         if let Some(vm) = vm.as_ref() {
             buf.push_sync(&format!("<!--hot-reload|{vm}|open-->"));
         }
@@ -153,7 +164,7 @@ impl<T: RenderHtml> RenderHtml for View<T> {
             extra_attrs,
         );
 
-        #[cfg(all(debug_assertions, feature = "nightly", rustc_nightly))]
+        #[cfg(debug_assertions)]
         if let Some(vm) = vm.as_ref() {
             buf.push_sync(&format!("<!--hot-reload|{vm}|close-->"));
         }

leptos/src/nonce.rs

@@ -4,7 +4,7 @@ use base64::{
     engine::{self, general_purpose},
     Engine,
 };
-use rand::{thread_rng, RngCore};
+use rand::{rng, RngCore};
 use std::{fmt::Display, ops::Deref, sync::Arc};
 use tachys::html::attribute::AttributeValue;
 
@@ -171,9 +171,9 @@ const NONCE_ENGINE: engine::GeneralPurpose =
 impl Nonce {
     /// Generates a new nonce from 16 bytes (128 bits) of random data.
     pub fn new() -> Self {
-        let mut thread_rng = thread_rng();
+        let mut rng = rng();
         let mut bytes = [0; 16];
-        thread_rng.fill_bytes(&mut bytes);
+        rng.fill_bytes(&mut bytes);
         Nonce(NONCE_ENGINE.encode(bytes).into())
     }
 }

leptos/src/portal.rs

@@ -8,7 +8,7 @@ use std::sync::Arc;
 ///
 /// Useful for inserting modals and tooltips outside of a cropping layout.
 /// If no mount point is given, the portal is inserted in `document.body`;
-/// it is wrapped in a `<div>` unless  `is_svg` is `true` in which case it's wrappend in a `<g>`.
+/// it is wrapped in a `<div>` unless  `is_svg` is `true` in which case it's wrapped in a `<g>`.
 /// Setting `use_shadow` to `true` places the element in a shadow root to isolate styles.
 #[cfg_attr(feature = "tracing", tracing::instrument(level = "trace", skip_all))]
 #[component]
@@ -42,11 +42,15 @@ where
         let children = children.into_inner();
 
         Effect::new(move |_| {
-            let tag = if is_svg { "g" } else { "div" };
-
-            let container = document()
-                .create_element(tag)
-                .expect("element creation to work");
+            let container = if is_svg {
+                document()
+                    .create_element_ns(Some("http://www.w3.org/2000/svg"), "g")
+                    .expect("SVG element creation to work")
+            } else {
+                document()
+                    .create_element("div")
+                    .expect("HTML element creation to work")
+            };
 
             let render_root = if use_shadow {
                 container

leptos/tests/pr_4061.rs

@@ -0,0 +1,79 @@
+#[cfg(feature = "ssr")]
+mod imports {
+    pub use any_spawner::Executor;
+    pub use futures::StreamExt;
+    pub use leptos::prelude::*;
+}
+
+#[cfg(feature = "ssr")]
+#[tokio::test]
+async fn chain_await_resource() {
+    use imports::*;
+
+    _ = Executor::init_tokio();
+    let owner = Owner::new();
+    owner.set();
+
+    let (rs, ws) = signal(0);
+    let source = Resource::new(
+        || (),
+        move |_| async move {
+            #[cfg(feature = "ssr")]
+            tokio::time::sleep(std::time::Duration::from_millis(1)).await;
+            1
+        },
+    );
+    let consuming = Resource::new(
+        || (),
+        move |_| async move {
+            let result = source.await;
+            ws.update(|s| *s += 1);
+            result
+        },
+    );
+    let app = view! {
+        <Suspense>{
+            move || {
+                Suspend::new(async move {
+                    consuming.await;
+                    rs.get()
+                })
+            }
+        }</Suspense>
+    };
+
+    assert_eq!(app.to_html_stream_in_order().collect::<String>().await, "1");
+}
+
+#[cfg(feature = "ssr")]
+#[tokio::test]
+async fn chain_no_await_resource() {
+    use imports::*;
+
+    _ = Executor::init_tokio();
+    let owner = Owner::new();
+    owner.set();
+
+    let (rs, ws) = signal(0);
+    let source = Resource::new(|| (), move |_| async move { 1 });
+    let consuming = Resource::new(
+        || (),
+        move |_| async move {
+            let result = source.await;
+            ws.update(|s| *s += 1);
+            result
+        },
+    );
+    let app = view! {
+        <Suspense>{
+            move || {
+                Suspend::new(async move {
+                    consuming.await;
+                    rs.get()
+                })
+            }
+        }</Suspense>
+    };
+
+    assert_eq!(app.to_html_stream_in_order().collect::<String>().await, "1");
+}

leptos_config/Cargo.toml

@@ -10,19 +10,19 @@ rust-version.workspace = true
 edition.workspace = true
 
 [dependencies]
-config = { version = "0.15.8", default-features = false, features = [
+config = { default-features = false, features = [
   "toml",
   "convert-case",
-] }
-regex = "1.11"
-serde = { version = "1.0", features = ["derive", "rc"] }
-thiserror = { workspace = true }
-typed-builder = { workspace = true }
+] , workspace = true }
+regex = { workspace = true, default-features = true }
+serde = { features = ["derive", "rc"] , workspace = true, default-features = true }
+thiserror = { workspace = true , default-features = true }
+typed-builder = { workspace = true , default-features = true }
 
 [dev-dependencies]
-tokio = { version = "1.43", features = ["rt", "macros"] }
-tempfile = "3.14"
-temp-env = { version = "0.3.6", features = ["async_closure"] }
+tokio = { features = ["rt", "macros"] , workspace = true, default-features = true }
+tempfile = { workspace = true, default-features = true }
+temp-env = { features = ["async_closure"] , workspace = true, default-features = true }
 
 [package.metadata.docs.rs]
 rustdoc-args = ["--generate-link-to-definition"]

leptos_dom/Cargo.toml

@@ -12,19 +12,20 @@ edition.workspace = true
 tachys = { workspace = true }
 reactive_graph = { workspace = true }
 or_poisoned = { workspace = true }
-js-sys = "0.3.74"
-send_wrapper = "0.6.0"
-tracing = { version = "0.1.41", optional = true }
-wasm-bindgen = { workspace = true }
-serde_json = { version = "1.0", optional = true }
-serde = { version = "1.0", optional = true }
+js-sys = { workspace = true, default-features = true }
+send_wrapper = { workspace = true, default-features = true }
+tracing = { optional = true , workspace = true, default-features = true }
+wasm-bindgen = { workspace = true , default-features = true }
+serde_json = { optional = true , workspace = true, default-features = true }
+serde = { optional = true , workspace = true, default-features = true }
 
 [dev-dependencies]
 leptos = { path = "../leptos" }
 
 [dependencies.web-sys]
-version = "0.3.72"
 features = ["Location"]
+workspace = true
+default-features = true
 
 [features]
 default = []

leptos_hot_reload/Cargo.toml

@@ -10,19 +10,19 @@ rust-version.workspace = true
 edition.workspace = true
 
 [dependencies]
-anyhow = "1.0"
-serde = { version = "1.0", features = ["derive"] }
-syn = { version = "2.0", features = [
+anyhow = { workspace = true, default-features = true }
+serde = { features = ["derive"] , workspace = true, default-features = true }
+syn = { features = [
   "full",
   "parsing",
   "extra-traits",
   "visit",
   "printing",
-] }
-quote = "1.0"
-rstml = "0.12.0"
-proc-macro2 = { version = "1.0", features = ["span-locations", "nightly"] }
-parking_lot = "0.12.3"
-walkdir = "2.5"
-camino = "1.1"
-indexmap = "2.6"
+] , workspace = true, default-features = true }
+quote = { workspace = true, default-features = true }
+rstml = { workspace = true, default-features = true }
+proc-macro2 = { features = ["span-locations", "nightly"] , workspace = true, default-features = true }
+parking_lot = { workspace = true, default-features = true }
+walkdir = { workspace = true, default-features = true }
+camino = { workspace = true, default-features = true }
+indexmap = { workspace = true, default-features = true }

leptos_hot_reload/src/patch.js

@@ -1,4 +1,3 @@
-console.log("[HOT RELOADING] Connected to server.\n\nNote: `cargo-leptos watch --hot-reload` only works with the `nightly` feature enabled on Leptos.");
 function patch(json) {
   try {
     const views = JSON.parse(json);

leptos_macro/Cargo.toml

@@ -13,39 +13,39 @@ edition.workspace = true
 proc-macro = true
 
 [dependencies]
-attribute-derive = { version = "0.10.3", features = ["syn-full"] }
-cfg-if = "1.0"
-html-escape = "0.2.13"
-itertools = { workspace = true }
-prettyplease = "0.2.25"
-proc-macro-error2 = { version = "2.0", default-features = false }
-proc-macro2 = "1.0"
-quote = "1.0"
-syn = { version = "2.0", features = ["full"] }
-rstml = "0.12.0"
+attribute-derive = { features = ["syn-full"] , workspace = true, default-features = true }
+cfg-if = { workspace = true, default-features = true }
+html-escape = { workspace = true, default-features = true }
+itertools = { workspace = true , default-features = true }
+prettyplease = { workspace = true, default-features = true }
+proc-macro-error2 = { default-features = false , workspace = true }
+proc-macro2 = { workspace = true, default-features = true }
+quote = { workspace = true, default-features = true }
+syn = { features = ["full"] , workspace = true, default-features = true }
+rstml = { workspace = true, default-features = true }
 leptos_hot_reload = { workspace = true }
 server_fn_macro = { workspace = true }
-convert_case = { workspace = true }
-uuid = { version = "1.11", features = ["v4"] }
-tracing = { version = "0.1.41", optional = true }
+convert_case = { workspace = true , default-features = true }
+uuid = { features = ["v4"] , workspace = true, default-features = true }
+tracing = { optional = true , workspace = true, default-features = true }
 
 [dev-dependencies]
-log = "0.4.22"
-typed-builder = "0.20.0"
-trybuild = { workspace = true }
+log = { workspace = true, default-features = true }
+typed-builder = { workspace = true, default-features = true }
+trybuild = { workspace = true , default-features = true }
 leptos = { path = "../leptos" }
 leptos_router = { path = "../router", features = ["ssr"] }
 server_fn = { path = "../server_fn", features = ["cbor"] }
-insta = "1.41"
-serde = "1.0"
+insta = { workspace = true, default-features = true }
+serde = { workspace = true, default-features = true }
 
 [build-dependencies]
-rustc_version = "0.4.1"
+rustc_version = { workspace = true, default-features = true }
 
 [features]
 csr = []
 hydrate = []
-ssr = ["server_fn_macro/ssr", "leptos/ssr"]
+ssr = ["server_fn_macro/ssr"]
 nightly = ["server_fn_macro/nightly"]
 tracing = ["dep:tracing"]
 islands = []

leptos_macro/src/component.rs

@@ -357,38 +357,13 @@ impl ToTokens for Model {
 
         // add island wrapper if island
         let component = if is_island {
-            let is_server = cfg!(feature = "ssr");
             let hydrate_fn_name = hydrate_fn_name.as_ref().unwrap();
-            if is_server {
-                quote! {
-                    {
-                        // if we're on the server, and inside another island already,
-                        // *don't* add a <leptos-island> (this will hydrate them both separately)
-                        if ::leptos::context::use_context::<::leptos::reactive::owner::IsHydrating>()
-                            .map(|h| h.0)
-                            .unwrap_or(false) {
-                            ::leptos::either::Either::Left(
-                                #component
-                            )
-                        } else {
-                            ::leptos::either::Either::Right(
-                                ::leptos::tachys::html::islands::Island::new(
-                                    stringify!(#hydrate_fn_name),
-                                    #component
-                                )
-                                 #island_serialized_props
-                            )
-                        }
-                    }
-                }
-            } else {
-                quote! {
-                    ::leptos::tachys::html::islands::Island::new(
-                        stringify!(#hydrate_fn_name),
-                        #component
-                    )
-                    #island_serialized_props
-                }
+            quote! {
+                ::leptos::tachys::html::islands::Island::new(
+                    stringify!(#hydrate_fn_name),
+                    #component
+                )
+                #island_serialized_props
             }
         } else {
             component
@@ -659,7 +634,13 @@ impl Parse for DummyModel {
         let mut attrs = input.call(Attribute::parse_outer)?;
         // Drop unknown attributes like #[deprecated]
         drain_filter(&mut attrs, |attr| {
-            !(attr.path().is_ident("doc") || attr.path().is_ident("allow"))
+            let path = attr.path();
+            !(path.is_ident("doc")
+                || path.is_ident("allow")
+                || path.is_ident("expect")
+                || path.is_ident("warn")
+                || path.is_ident("deny")
+                || path.is_ident("forbid"))
         });
 
         let vis: Visibility = input.parse()?;
@@ -948,13 +929,20 @@ impl UnknownAttrs {
         let attrs = attrs
             .iter()
             .filter_map(|attr| {
-                if attr.path().is_ident("doc") {
+                let path = attr.path();
+
+                if path.is_ident("doc") {
                     if let Meta::NameValue(_) = &attr.meta {
                         return None;
                     }
                 }
 
-                if attr.path().is_ident("allow") {
+                if path.is_ident("allow")
+                    || path.is_ident("expect")
+                    || path.is_ident("warn")
+                    || path.is_ident("deny")
+                    || path.is_ident("forbid")
+                {
                     return None;
                 }
 

leptos_macro/src/lib.rs

@@ -358,16 +358,14 @@ fn view_macro_impl(tokens: TokenStream, template: bool) -> TokenStream {
 }
 
 fn normalized_call_site(site: proc_macro::Span) -> Option<String> {
-    cfg_if::cfg_if! {
-        if #[cfg(all(debug_assertions, feature = "nightly", rustc_nightly))] {
-            Some(leptos_hot_reload::span_to_stable_id(
-                site.file(),
-                site.start().line()
-            ))
-        } else {
-            _ = site;
-            None
-        }
+    if cfg!(debug_assertions) {
+        Some(leptos_hot_reload::span_to_stable_id(
+            site.file(),
+            site.start().line(),
+        ))
+    } else {
+        _ = site;
+        None
     }
 }
 
@@ -409,6 +407,7 @@ pub fn include_view(tokens: TokenStream) -> TokenStream {
 /// generate documentation for the component.
 ///
 /// Here’s how you would define and use a simple Leptos component which can accept custom properties for a name and age:
+///
 /// ```rust
 /// # use leptos::prelude::*;
 /// use std::time::Duration;
@@ -446,6 +445,7 @@ pub fn include_view(tokens: TokenStream) -> TokenStream {
 /// ```
 ///
 /// Here are some important details about how Leptos components work within the framework:
+///
 /// * **The component function only runs once.** Your component function is not a “render” function
 ///    that re-runs whenever changes happen in the state. It’s a “setup” function that runs once to
 ///    create the user interface, and sets up a reactive system to update it. This means it’s okay
@@ -458,7 +458,6 @@ pub fn include_view(tokens: TokenStream) -> TokenStream {
 ///
 /// ```
 /// # use leptos::prelude::*;
-///
 /// // PascalCase: Generated component will be called MyComponent
 /// #[component]
 /// fn MyComponent() -> impl IntoView {}
@@ -500,8 +499,10 @@ pub fn include_view(tokens: TokenStream) -> TokenStream {
 /// ```
 ///
 /// ## Customizing Properties
+///
 /// You can use the `#[prop]` attribute on individual component properties (function arguments) to
 /// customize the types that component property can receive. You can use the following attributes:
+///
 /// * `#[prop(into)]`: This will call `.into()` on any value passed into the component prop. (For example,
 ///   you could apply `#[prop(into)]` to a prop that takes
 ///   [Signal](https://docs.rs/leptos/latest/leptos/struct.Signal.html), which would
@@ -514,6 +515,11 @@ pub fn include_view(tokens: TokenStream) -> TokenStream {
 /// * `#[prop(optional_no_strip)]`: The same as `optional`, but requires values to be passed as `None` or
 ///   `Some(T)` explicitly. This means that the optional property can be omitted (and be `None`), or explicitly
 ///   specified as either `None` or `Some(T)`.
+/// * `#[prop(default = <expr>)]`: Optional property that specifies a default value, which is used when the
+///   property is not specified.
+/// * `#[prop(name = "new_name")]`: Specifiy a different name for the property. Can be used to destructure
+///   fields in component function parameters (see example below).
+///
 /// ```rust
 /// # use leptos::prelude::*;
 ///
@@ -522,6 +528,8 @@ pub fn include_view(tokens: TokenStream) -> TokenStream {
 ///     #[prop(into)] name: String,
 ///     #[prop(optional)] optional_value: Option<i32>,
 ///     #[prop(optional_no_strip)] optional_no_strip: Option<i32>,
+///     #[prop(default = 7)] optional_default: i32,
+///     #[prop(name = "data")] UserInfo { email, user_id }: UserInfo,
 /// ) -> impl IntoView {
 ///     // whatever UI you need
 /// }
@@ -530,16 +538,24 @@ pub fn include_view(tokens: TokenStream) -> TokenStream {
 /// pub fn App() -> impl IntoView {
 ///     view! {
 ///       <MyComponent
-///         name="Greg" // automatically converted to String with `.into()`
-///         optional_value=42 // received as `Some(42)`
-///         optional_no_strip=Some(42) // received as `Some(42)`
+///         name="Greg"  // automatically converted to String with `.into()`
+///         optional_value=42  // received as `Some(42)`
+///         optional_no_strip=Some(42)  // received as `Some(42)`
+///         optional_default=42  // received as `42`
+///         data=UserInfo {email: "foo", user_id: "bar" }
 ///       />
 ///       <MyComponent
 ///         name="Bob" // automatically converted to String with `.into()`
-///         // optional values can both be omitted, and received as `None`
+///         data=UserInfo {email: "foo", user_id: "bar" }
+///         // optional values can be omitted
 ///       />
 ///     }
 /// }
+///
+/// pub struct UserInfo {
+///     pub email: &'static str,
+///     pub user_id: &'static str,
+/// }
 /// ```
 #[proc_macro_error2::proc_macro_error]
 #[proc_macro_attribute]

leptos_macro/src/view/mod.rs

@@ -44,6 +44,8 @@ pub fn render_view(
     view_marker: Option<String>,
     disable_inert_html: bool,
 ) -> Option<TokenStream> {
+    let disable_inert_html = disable_inert_html || global_class.is_some();
+
     let (base, should_add_view) = match nodes.len() {
         0 => {
             let span = Span::call_site();
@@ -112,9 +114,9 @@ fn is_inert_element(orig_node: &Node<impl CustomNode>) -> bool {
                 return false;
             }
 
-            // also doesn't work if the top-level element is an SVG/MathML element
+            // also doesn't work if the top-level element is a MathML element
             let el_name = el.name().to_string();
-            if is_svg_element(&el_name) || is_math_ml_element(&el_name) {
+            if is_math_ml_element(&el_name) {
                 return false;
             }
         }
@@ -300,7 +302,7 @@ fn inert_element_to_tokens(
     node: &Node<impl CustomNode>,
     escape_text: bool,
     global_class: Option<&TokenTree>,
-) -> Option<TokenStream> {
+) -> TokenStream {
     let mut html = InertElementBuilder::new(global_class);
     let mut nodes = VecDeque::from([Item::Node(node, escape_text)]);
 
@@ -396,9 +398,117 @@ fn inert_element_to_tokens(
 
     html.finish();
 
-    Some(quote! {
+    quote! {
         ::leptos::tachys::html::InertElement::new(#html)
-    })
+    }
+}
+
+/// # Note
+/// Should not be used on top level `<svg>` elements.
+/// Use [`inert_element_to_tokens`] instead.
+fn inert_svg_element_to_tokens(
+    node: &Node<impl CustomNode>,
+    escape_text: bool,
+    global_class: Option<&TokenTree>,
+) -> TokenStream {
+    let mut html = InertElementBuilder::new(global_class);
+    let mut nodes = VecDeque::from([Item::Node(node, escape_text)]);
+
+    while let Some(current) = nodes.pop_front() {
+        match current {
+            Item::ClosingTag(tag) => {
+                // closing tag
+                html.push_str("</");
+                html.push_str(&tag);
+                html.push('>');
+            }
+            Item::Node(current, escape) => {
+                match current {
+                    Node::RawText(raw) => {
+                        let text = raw.to_string_best();
+                        let text = if escape {
+                            html_escape::encode_text(&text)
+                        } else {
+                            text.into()
+                        };
+                        html.push_str(&text);
+                    }
+                    Node::Text(text) => {
+                        let text = text.value_string();
+                        let text = if escape {
+                            html_escape::encode_text(&text)
+                        } else {
+                            text.into()
+                        };
+                        html.push_str(&text);
+                    }
+                    Node::Element(node) => {
+                        let self_closing = is_self_closing(node);
+                        let el_name = node.name().to_string();
+                        let escape = el_name != "script"
+                            && el_name != "style"
+                            && el_name != "textarea";
+
+                        // opening tag
+                        html.push('<');
+                        html.push_str(&el_name);
+
+                        for attr in node.attributes() {
+                            if let NodeAttribute::Attribute(attr) = attr {
+                                let attr_name = attr.key.to_string();
+                                // trim r# from raw identifiers like r#as
+                                let attr_name =
+                                    attr_name.trim_start_matches("r#");
+                                if attr_name != "class" {
+                                    html.push(' ');
+                                    html.push_str(attr_name);
+                                }
+
+                                if let Some(value) =
+                                    attr.possible_value.to_value()
+                                {
+                                    if let KVAttributeValue::Expr(Expr::Lit(
+                                        lit,
+                                    )) = &value.value
+                                    {
+                                        if let Lit::Str(txt) = &lit.lit {
+                                            let value = txt.value();
+                                            let value = html_escape::encode_double_quoted_attribute(&value);
+                                            if attr_name == "class" {
+                                                html.push_class(&value);
+                                            } else {
+                                                html.push_str("=\"");
+                                                html.push_str(&value);
+                                                html.push('"');
+                                            }
+                                        }
+                                    }
+                                };
+                            }
+                        }
+
+                        html.push('>');
+
+                        // render all children
+                        if !self_closing {
+                            nodes.push_front(Item::ClosingTag(el_name));
+                            let children = node.children.iter().rev();
+                            for child in children {
+                                nodes.push_front(Item::Node(child, escape));
+                            }
+                        }
+                    }
+                    _ => {}
+                }
+            }
+        }
+    }
+
+    html.finish();
+
+    quote! {
+        ::leptos::tachys::svg::InertElement::new(#html)
+    }
 }
 
 fn element_children_to_tokens(
@@ -431,7 +541,9 @@ fn element_children_to_tokens(
     } else if cfg!(feature = "__internal_erase_components") {
         Some(quote! {
             .child(
-                leptos::tachys::view::iterators::StaticVec::from(vec![#(#children.into_maybe_erased()),*])
+                ::leptos::tachys::view::iterators::StaticVec::from(vec![#(
+                    ::leptos::prelude::IntoMaybeErased::into_maybe_erased(#children)
+                ),*])
             )
         })
     } else if children.len() > 16 {
@@ -481,7 +593,9 @@ fn fragment_to_tokens(
         children.into_iter().next()
     } else if cfg!(feature = "__internal_erase_components") {
         Some(quote! {
-            leptos::tachys::view::iterators::StaticVec::from(vec![#(#children.into_maybe_erased()),*])
+            ::leptos::tachys::view::iterators::StaticVec::from(vec![#(
+                ::leptos::prelude::IntoMaybeErased::into_maybe_erased(#children)
+            ),*])
         })
     } else if children.len() > 16 {
         // implementations of various traits used in routing and rendering are implemented for
@@ -593,7 +707,17 @@ fn node_to_tokens(
                 let escape = el_name != "script"
                     && el_name != "style"
                     && el_name != "textarea";
-                inert_element_to_tokens(node, escape, global_class)
+
+                let el_name = el_node.name().to_string();
+                if is_svg_element(&el_name) && el_name != "svg" {
+                    Some(inert_svg_element_to_tokens(
+                        node,
+                        escape,
+                        global_class,
+                    ))
+                } else {
+                    Some(inert_element_to_tokens(node, escape, global_class))
+                }
             } else {
                 element_to_tokens(
                     el_node,

leptos_macro/tests/component.rs

@@ -119,3 +119,45 @@ fn returns_static_lifetime() {
         WithLifetime(WithLifetimeProps::builder().data(&val).build())
     }
 }
+
+// an attempt to catch unhygienic macros regression
+mod macro_hygiene {
+    // To ensure no relative module path to leptos inside macros.
+    mod leptos {}
+
+    // doing this separately to below due to this being the smallest
+    // unit with the lowest import surface.
+    #[test]
+    fn view() {
+        use ::leptos::IntoView;
+        use ::leptos_macro::{component, view};
+
+        #[component]
+        fn Component() -> impl IntoView {
+            view! {
+                {()}
+                {()}
+            }
+        }
+    }
+
+    // may extend this test with other items as necessary.
+    #[test]
+    fn view_into_any() {
+        use ::leptos::{
+            prelude::{ElementChild, IntoAny},
+            IntoView,
+        };
+        use ::leptos_macro::{component, view};
+
+        #[component]
+        fn Component() -> impl IntoView {
+            view! {
+                <div>
+                    {().into_any()}
+                    {()}
+                </div>
+            }
+        }
+    }
+}

leptos_server/Cargo.toml

@@ -10,24 +10,24 @@ rust-version.workspace = true
 edition.workspace = true
 
 [dependencies]
-base64 = "0.22.1"
-codee = { version = "0.3.0", features = ["json_serde"] }
+base64 = { workspace = true, default-features = true }
+codee = { features = ["json_serde"] , workspace = true, default-features = true }
 hydration_context = { workspace = true }
 reactive_graph = { workspace = true, features = ["hydration"] }
 server_fn = { workspace = true }
-tracing = { version = "0.1.41", optional = true }
-futures = "0.3.31"
+tracing = { optional = true , workspace = true, default-features = true }
+futures = { workspace = true, default-features = true }
 
 any_spawner = { workspace = true }
 or_poisoned = { workspace = true }
 tachys = { workspace = true, optional = true, features = ["reactive_graph"] }
-send_wrapper = "0.6"
+send_wrapper = { workspace = true, default-features = true }
 
 # serialization formats
-serde = { version = "1.0" }
-js-sys = { version = "0.3.74", optional = true }
-wasm-bindgen = { workspace = true, optional = true }
-serde_json = { workspace = true }
+serde = { workspace = true, default-features = true }
+js-sys = { optional = true , workspace = true, default-features = true }
+wasm-bindgen = { workspace = true, optional = true , default-features = true }
+serde_json = { workspace = true , default-features = true }
 
 [features]
 ssr = []

leptos_server/src/local_resource.rs

@@ -14,11 +14,13 @@ use reactive_graph::{
         ArcRwSignal, RwSignal,
     },
     traits::{
-        DefinedAt, IsDisposed, ReadUntracked, Track, Update, With, Write,
+        DefinedAt, IsDisposed, Notify, ReadUntracked, Track, UntrackableGuard,
+        Update, With, Write,
     },
 };
 use std::{
     future::{pending, Future, IntoFuture},
+    ops::{Deref, DerefMut},
     panic::Location,
 };
 
@@ -41,6 +43,14 @@ impl<T> Clone for ArcLocalResource<T> {
     }
 }
 
+impl<T> Deref for ArcLocalResource<T> {
+    type Target = ArcAsyncDerived<T>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.data
+    }
+}
+
 impl<T> ArcLocalResource<T> {
     /// Creates the resource.
     ///
@@ -62,7 +72,7 @@ impl<T> ArcLocalResource<T> {
                     pending().await
                 } else {
                     // LocalResources that are immediately available can cause a hydration error,
-                    // because the future *looks* like it is alredy ready (and therefore would
+                    // because the future *looks* like it is already ready (and therefore would
                     // already have been rendered to html on the server), but in fact was ignored
                     // on the server. the simplest way to avoid this is to ensure that we always
                     // wait a tick before resolving any value for a localresource.
@@ -157,6 +167,32 @@ impl<T> DefinedAt for ArcLocalResource<T> {
     }
 }
 
+impl<T> Notify for ArcLocalResource<T>
+where
+    T: 'static,
+{
+    fn notify(&self) {
+        self.data.notify()
+    }
+}
+
+impl<T> Write for ArcLocalResource<T>
+where
+    T: 'static,
+{
+    type Value = Option<T>;
+
+    fn try_write(&self) -> Option<impl UntrackableGuard<Target = Self::Value>> {
+        self.data.try_write()
+    }
+
+    fn try_write_untracked(
+        &self,
+    ) -> Option<impl DerefMut<Target = Self::Value>> {
+        self.data.try_write_untracked()
+    }
+}
+
 impl<T> ReadUntracked for ArcLocalResource<T>
 where
     T: 'static,
@@ -241,6 +277,14 @@ pub struct LocalResource<T> {
     defined_at: &'static Location<'static>,
 }
 
+impl<T> Deref for LocalResource<T> {
+    type Target = AsyncDerived<T>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.data
+    }
+}
+
 impl<T> Clone for LocalResource<T> {
     fn clone(&self) -> Self {
         *self
@@ -270,7 +314,7 @@ impl<T> LocalResource<T> {
                     pending().await
                 } else {
                     // LocalResources that are immediately available can cause a hydration error,
-                    // because the future *looks* like it is alredy ready (and therefore would
+                    // because the future *looks* like it is already ready (and therefore would
                     // already have been rendered to html on the server), but in fact was ignored
                     // on the server. the simplest way to avoid this is to ensure that we always
                     // wait a tick before resolving any value for a localresource.
@@ -300,6 +344,34 @@ impl<T> LocalResource<T> {
     pub fn refetch(&self) {
         self.refetch.try_update(|n| *n += 1);
     }
+
+    /// Synchronously, reactively reads the current value of the resource and applies the function
+    /// `f` to its value if it is `Some(_)`.
+    #[track_caller]
+    pub fn map<U>(&self, f: impl FnOnce(&T) -> U) -> Option<U>
+    where
+        T: 'static,
+    {
+        self.data.try_with(|n| n.as_ref().map(f))?
+    }
+}
+
+impl<T, E> LocalResource<Result<T, E>>
+where
+    T: 'static,
+    E: Clone + 'static,
+{
+    /// Applies the given function when a resource that returns `Result<T, E>`
+    /// has resolved and loaded an `Ok(_)`, rather than requiring nested `.map()`
+    /// calls over the `Option<Result<_, _>>` returned by the resource.
+    ///
+    /// This is useful when used with features like server functions, in conjunction
+    /// with `<ErrorBoundary/>` and `<Suspense/>`, when these other components are
+    /// left to handle the `None` and `Err(_)` states.
+    #[track_caller]
+    pub fn and_then<U>(&self, f: impl FnOnce(&T) -> U) -> Option<Result<U, E>> {
+        self.map(|data| data.as_ref().map(f).map_err(|e| e.clone()))
+    }
 }
 
 impl<T> IntoFuture for LocalResource<T>
@@ -336,6 +408,32 @@ impl<T> DefinedAt for LocalResource<T> {
     }
 }
 
+impl<T> Notify for LocalResource<T>
+where
+    T: 'static,
+{
+    fn notify(&self) {
+        self.data.notify()
+    }
+}
+
+impl<T> Write for LocalResource<T>
+where
+    T: 'static,
+{
+    type Value = Option<T>;
+
+    fn try_write(&self) -> Option<impl UntrackableGuard<Target = Self::Value>> {
+        self.data.try_write()
+    }
+
+    fn try_write_untracked(
+        &self,
+    ) -> Option<impl DerefMut<Target = Self::Value>> {
+        self.data.try_write_untracked()
+    }
+}
+
 impl<T> ReadUntracked for LocalResource<T>
 where
     T: 'static,

leptos_server/src/resource.rs

@@ -26,7 +26,7 @@ use reactive_graph::{
 };
 use std::{
     future::{pending, IntoFuture},
-    ops::Deref,
+    ops::{Deref, DerefMut},
     panic::Location,
     sync::{
         atomic::{AtomicBool, Ordering},
@@ -162,6 +162,32 @@ where
     }
 }
 
+impl<T, Ser> Notify for ArcResource<T, Ser>
+where
+    T: 'static,
+{
+    fn notify(&self) {
+        self.data.notify()
+    }
+}
+
+impl<T, Ser> Write for ArcResource<T, Ser>
+where
+    T: 'static,
+{
+    type Value = Option<T>;
+
+    fn try_write(&self) -> Option<impl UntrackableGuard<Target = Self::Value>> {
+        self.data.try_write()
+    }
+
+    fn try_write_untracked(
+        &self,
+    ) -> Option<impl DerefMut<Target = Self::Value>> {
+        self.data.try_write_untracked()
+    }
+}
+
 impl<T, Ser> ReadUntracked for ArcResource<T, Ser>
 where
     T: 'static,
@@ -842,6 +868,32 @@ where
     }
 }
 
+impl<T, Ser> Notify for Resource<T, Ser>
+where
+    T: Send + Sync + 'static,
+{
+    fn notify(&self) {
+        self.data.notify()
+    }
+}
+
+impl<T, Ser> Write for Resource<T, Ser>
+where
+    T: Send + Sync + 'static,
+{
+    type Value = Option<T>;
+
+    fn try_write(&self) -> Option<impl UntrackableGuard<Target = Self::Value>> {
+        self.data.try_write()
+    }
+
+    fn try_write_untracked(
+        &self,
+    ) -> Option<impl DerefMut<Target = Self::Value>> {
+        self.data.try_write_untracked()
+    }
+}
+
 impl<T, Ser> ReadUntracked for Resource<T, Ser>
 where
     T: Send + Sync + 'static,

meta/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "leptos_meta"
-version = "0.8.0-rc3"
+version = "0.8.3"
 authors = ["Greg Johnston"]
 license = "MIT"
 repository = "https://github.com/leptos-rs/leptos"
@@ -10,17 +10,17 @@ edition.workspace = true
 
 [dependencies]
 leptos = { workspace = true }
-once_cell = "1.20"
 or_poisoned = { workspace = true }
-indexmap = "2.6"
-send_wrapper = "0.6.0"
-tracing = { version = "0.1.41", optional = true }
-wasm-bindgen = { workspace = true }
-futures = "0.3.31"
+indexmap = { workspace = true, default-features = true }
+send_wrapper = { workspace = true, default-features = true }
+tracing = { optional = true, workspace = true, default-features = true }
+wasm-bindgen = { workspace = true, default-features = true }
+futures = { workspace = true, default-features = true }
 
 [dependencies.web-sys]
-version = "0.3.72"
 features = ["HtmlLinkElement", "HtmlMetaElement", "HtmlTitleElement"]
+workspace = true
+default-features = true
 
 [features]
 default = []

meta/src/lib.rs

@@ -63,13 +63,12 @@ use leptos::{
     },
     IntoView,
 };
-use once_cell::sync::Lazy;
 use send_wrapper::SendWrapper;
 use std::{
     fmt::Debug,
     sync::{
         mpsc::{channel, Receiver, Sender},
-        Arc,
+        Arc, LazyLock,
     },
 };
 use wasm_bindgen::JsCast;
@@ -101,7 +100,7 @@ pub struct MetaContext {
     /// Metadata associated with the `<title>` element.
     pub(crate) title: TitleContext,
     /// The hydration cursor for the location in the `<head>` for arbitrary tags will be rendered.
-    pub(crate) cursor: Arc<Lazy<SendWrapper<Cursor>>>,
+    pub(crate) cursor: Arc<LazyLock<SendWrapper<Cursor>>>,
 }
 
 impl MetaContext {
@@ -143,7 +142,7 @@ impl Default for MetaContext {
             ))
         };
 
-        let cursor = Arc::new(Lazy::new(build_cursor));
+        let cursor = Arc::new(LazyLock::new(build_cursor));
         Self {
             title: Default::default(),
             cursor,
@@ -216,6 +215,13 @@ impl ServerMetaContextOutput {
         self,
         mut stream: impl Stream<Item = String> + Send + Unpin,
     ) -> impl Stream<Item = String> + Send {
+        // if the first chunk consists of a synchronously-available Suspend,
+        // inject_meta_context can accidentally run a tick before it, but the Suspend
+        // when both are available. waiting a tick before awaiting the first chunk
+        // in the Stream ensures that this always runs after that first chunk
+        // see https://github.com/leptos-rs/leptos/issues/3976 for the original issue
+        leptos::task::tick().await;
+
         // wait for the first chunk of the stream, to ensure our components hve run
         let mut first_chunk = stream.next().await.unwrap_or_default();
 
@@ -242,23 +248,22 @@ impl ServerMetaContextOutput {
             let head_loc = first_chunk
                 .find("</head>")
                 .expect("you are using leptos_meta without a </head> tag");
-            let marker_loc =
-                first_chunk.find("<!--HEAD-->").unwrap_or_else(|| {
+            let marker_loc = first_chunk
+                .find("<!--HEAD-->")
+                .map(|pos| pos + "<!--HEAD-->".len())
+                .unwrap_or_else(|| {
                     first_chunk.find("</head>").unwrap_or(head_loc)
                 });
             let (before_marker, after_marker) =
                 first_chunk.split_at_mut(marker_loc);
-            let (before_head_close, after_head) =
-                after_marker.split_at_mut(head_loc - marker_loc);
             buf.push_str(before_marker);
+            buf.push_str(&meta_buf);
             if let Some(title) = title {
                 buf.push_str("<title>");
                 buf.push_str(&title);
                 buf.push_str("</title>");
             }
-            buf.push_str(before_head_close);
-            buf.push_str(&meta_buf);
-            buf.push_str(after_head);
+            buf.push_str(after_marker);
             buf
         };
 
@@ -408,6 +413,7 @@ where
     type Owned = RegisteredMetaTag<E, At::CloneableOwned, Ch::Owned>;
 
     const MIN_LENGTH: usize = 0;
+    const EXISTS: bool = false;
 
     fn dry_resolve(&mut self) {
         self.el.dry_resolve()

meta/src/title.rs

@@ -322,6 +322,7 @@ impl RenderHtml for TitleView {
     type Owned = Self;
 
     const MIN_LENGTH: usize = 0;
+    const EXISTS: bool = false;
 
     fn dry_resolve(&mut self) {}
 

oco/Cargo.toml

@@ -9,8 +9,8 @@ rust-version.workspace = true
 edition.workspace = true
 
 [dependencies]
-serde = "1.0"
-thiserror = { workspace = true }
+serde = { workspace = true, default-features = true }
+thiserror = { workspace = true , default-features = true }
 
 [dev-dependencies]
-serde_json = { workspace = true }
+serde_json = { workspace = true , default-features = true }

projects/ory-kratos/e2e/Cargo.toml

@@ -21,7 +21,6 @@ fake = "2.9"
 tokio-tungstenite = "0.23.1"
 futures-util = "0.3.30"
 uuid = { version = "1.10", features = ["serde"] }
-once_cell = "1.19"
 futures = "0.3.30"
 
 [[test]]
@@ -33,6 +32,5 @@ harness = false    # Allow Cucumber to print output instead of libtest
 ssr = []
 
 [dependencies]
-once_cell = "1.19.0"
 regex = "1.10.6"
 serde.workspace = true

projects/ory-kratos/e2e/tests/app_suite.rs

@@ -18,14 +18,14 @@ use chromiumoxide::{
 use cucumber::World;
 use futures::channel::mpsc::Sender;
 use futures_util::stream::StreamExt;
-use once_cell::sync::Lazy;
+use std::sync::LazyLock;
 use serde::{Deserialize, Serialize};
 use std::{collections::HashMap, sync::Arc, time::Duration};
 use tokio::sync::RwLock;
 use tokio_tungstenite::connect_async;
 use uuid::Uuid;
-static EMAIL_ID_MAP: Lazy<RwLock<HashMap<String, String>>> =
-    Lazy::new(|| RwLock::new(HashMap::new()));
+static EMAIL_ID_MAP: LazyLock<RwLock<HashMap<String, String>>> =
+    LazyLock::new(|| RwLock::new(HashMap::new()));
 
 #[derive(Clone, Debug, PartialEq)]
 pub struct RequestPair {
@@ -93,7 +93,7 @@ impl RequestPair {
 async fn main() -> Result<()> {
     // create a thread and store a
     //  tokio-tungstenite client that connectsto http://127.0.0.1:1080/ws
-    // and then stores the recieved messages in a once_cell::Lazy<RwLock<Vec<MailCrabMsg>>>
+    // and then stores the recieved messages in a std::sync::LazyLock<RwLock<Vec<MailCrabMsg>>>
     // or a custom struct that matches the body or has specific impls for verify codes, links etc.
     let _ = tokio::spawn(async move {
         let (mut socket, _) = connect_async(
@@ -152,7 +152,7 @@ async fn main() -> Result<()> {
 
                 tokio::task::spawn(async move {
                     while let Some(event) = log_events.next().await {
-                        if let Some(EventEntryAdded { entry }) = 
+                        if let Some(EventEntryAdded { entry }) =
                         Arc::<EventEntryAdded>::into_inner(event) {
                             console_logs.write().await.push(format!(" {entry:#?} "));
                         } else {
@@ -171,7 +171,7 @@ async fn main() -> Result<()> {
                         } else {
                             tracing::error!("tried to into inner but none")
                         }
-                       
+
                     }
                 });
 
@@ -208,7 +208,7 @@ async fn main() -> Result<()> {
                                         thing.cookies_before_request = cookies;
 
                                     }
-                                    
+
                                 }
                                 CookieEnum::AfterResp(req_id) => {
                                     let cookies = page
@@ -293,8 +293,8 @@ async fn main() -> Result<()> {
                         } else {
                             tracing::error!(" uhh err here")
                         }
-                     
-                        
+
+
                     }
                 });
                 // We don't need to join on our join handles, they will run detached and clean up whenever.

projects/session_auth_axum/Cargo.toml

@@ -19,9 +19,9 @@ leptos_router = { path = "../../router" }
 log = "0.4.0"
 simple_logger = "5.0"
 serde = { version = "1.0", features = ["derive"] }
-axum = { version = "0.7.0", optional = true, features = ["macros"] }
-tower = { version = "0.4.0", optional = true }
-tower-http = { version = "0.5.0", features = ["fs"], optional = true }
+axum = { version = "0.8.0", optional = true, features = ["macros"] }
+tower = { version = "0.5.0", optional = true }
+tower-http = { version = "0.6.0", features = ["fs"], optional = true }
 tokio = { version = "1.0", features = ["full"], optional = true }
 http = { version = "1.0" }
 sqlx = { version = "0.8.0", features = [
@@ -30,10 +30,13 @@ sqlx = { version = "0.8.0", features = [
 ], optional = true }
 thiserror = "1.0"
 wasm-bindgen = "0.2.0"
-axum_session_auth = { version = "0.14.0", features = [], optional = true }
-axum_session = { version = "0.14.0", features = [], optional = true }
-axum_session_sqlx = { version = "0.3.0", features = [ "sqlite", "tls-rustls"], optional = true }
-bcrypt = { version = "0.15.0", optional = true }
+axum_session_auth = { version = "0.16.0", features = [], optional = true }
+axum_session = { version = "0.16.0", features = [], optional = true }
+axum_session_sqlx = { version = "0.5.0", features = [
+  "sqlite",
+  "tls-rustls",
+], optional = true }
+bcrypt = { version = "0.17.0", optional = true }
 async-trait = { version = "0.1.0", optional = true }
 
 [features]

projects/session_auth_axum/src/auth.rs

@@ -185,7 +185,7 @@ pub async fn foo() -> Result<String, ServerFnError> {
 pub async fn get_user() -> Result<Option<User>, ServerFnError> {
     use crate::todo::ssr::auth;
 
-    let auth = auth()?;
+    let auth = auth().await?;
 
     Ok(auth.current_user)
 }
@@ -199,7 +199,7 @@ pub async fn login(
     use self::ssr::*;
 
     let pool = pool()?;
-    let auth = auth()?;
+    let auth = auth().await?;
 
     let (user, UserPasshash(expected_passhash)) =
         User::get_from_username_with_passhash(username, &pool)
@@ -229,7 +229,7 @@ pub async fn signup(
     use self::ssr::*;
 
     let pool = pool()?;
-    let auth = auth()?;
+    let auth = auth().await?;
 
     if password != password_confirmation {
         return Err(ServerFnError::ServerError(
@@ -264,7 +264,7 @@ pub async fn signup(
 pub async fn logout() -> Result<(), ServerFnError> {
     use self::ssr::*;
 
-    let auth = auth()?;
+    let auth = auth().await?;
 
     auth.logout_user();
     leptos_axum::redirect("/");

projects/session_auth_axum/src/main.rs

@@ -1,62 +1,12 @@
-use axum::{
-    body::Body as AxumBody,
-    extract::{Path, State},
-    http::Request,
-    response::{IntoResponse, Response},
-    routing::get,
-    Router,
-};
+use axum::Router;
 use axum_session::{SessionConfig, SessionLayer, SessionStore};
 use axum_session_auth::{AuthConfig, AuthSessionLayer};
 use axum_session_sqlx::SessionSqlitePool;
-use leptos::{
-    config::get_configuration, logging::log, prelude::provide_context,
-};
-use leptos_axum::{
-    generate_route_list, handle_server_fns_with_context, LeptosRoutes,
-};
-use session_auth_axum::{
-    auth::{ssr::AuthSession, User},
-    state::AppState,
-    todo::*,
-};
+use leptos::{config::get_configuration, logging::log};
+use leptos_axum::{generate_route_list, LeptosRoutes};
+use session_auth_axum::{auth::User, state::AppState, todo::*};
 use sqlx::{sqlite::SqlitePoolOptions, SqlitePool};
 
-async fn server_fn_handler(
-    State(app_state): State<AppState>,
-    auth_session: AuthSession,
-    path: Path<String>,
-    request: Request<AxumBody>,
-) -> impl IntoResponse {
-    log!("{:?}", path);
-
-    handle_server_fns_with_context(
-        move || {
-            provide_context(auth_session.clone());
-            provide_context(app_state.pool.clone());
-        },
-        request,
-    )
-    .await
-}
-
-async fn leptos_routes_handler(
-    auth_session: AuthSession,
-    state: State<AppState>,
-    req: Request<AxumBody>,
-) -> Response {
-    let State(app_state) = state.clone();
-    let handler = leptos_axum::render_route_with_context(
-        app_state.routes.clone(),
-        move || {
-            provide_context(auth_session.clone());
-            provide_context(app_state.pool.clone());
-        },
-        move || shell(app_state.leptos_options.clone()),
-    );
-    handler(state, req).await.into_response()
-}
-
 #[tokio::main]
 async fn main() {
     simple_logger::init_with_level(log::Level::Info)
@@ -82,18 +32,6 @@ async fn main() {
         eprintln!("{e:?}");
     }
 
-    // Explicit server function registration is no longer required
-    // on the main branch. On 0.3.0 and earlier, uncomment the lines
-    // below to register the server functions.
-    // _ = GetTodos::register();
-    // _ = AddTodo::register();
-    // _ = DeleteTodo::register();
-    // _ = Login::register();
-    // _ = Logout::register();
-    // _ = Signup::register();
-    // _ = GetUser::register();
-    // _ = Foo::register();
-
     // Setting this to None means we'll be using cargo-leptos and its env vars
     let conf = get_configuration(None).unwrap();
     let leptos_options = conf.leptos_options;
@@ -108,11 +46,10 @@ async fn main() {
 
     // build our application with a route
     let app = Router::new()
-        .route(
-            "/api/*fn_name",
-            get(server_fn_handler).post(server_fn_handler),
-        )
-        .leptos_routes_with_handler(routes, get(leptos_routes_handler))
+        .leptos_routes(&app_state, routes, {
+            let options = app_state.leptos_options.clone();
+            move || shell(options.clone())
+        })
         .fallback(leptos_axum::file_and_error_handler::<AppState, _>(shell))
         .layer(
             AuthSessionLayer::<User, i64, SessionSqlitePool, SqlitePool>::new(

projects/session_auth_axum/src/todo.rs

@@ -1,7 +1,7 @@
 use crate::{auth::*, error_template::ErrorTemplate};
 use leptos::prelude::*;
 use leptos_meta::*;
-use leptos_router::{components::*, *};
+use leptos_router::{components::*, path};
 use serde::{Deserialize, Serialize};
 
 #[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
@@ -16,19 +16,21 @@ pub struct Todo {
 #[cfg(feature = "ssr")]
 pub mod ssr {
     use super::Todo;
-    use crate::auth::{ssr::AuthSession, User};
+    use crate::{
+        auth::{ssr::AuthSession, User},
+        state::AppState,
+    };
     use leptos::prelude::*;
     use sqlx::SqlitePool;
 
     pub fn pool() -> Result<SqlitePool, ServerFnError> {
-        use_context::<SqlitePool>()
+        with_context::<AppState, _>(|state| state.pool.clone())
             .ok_or_else(|| ServerFnError::ServerError("Pool missing.".into()))
     }
 
-    pub fn auth() -> Result<AuthSession, ServerFnError> {
-        use_context::<AuthSession>().ok_or_else(|| {
-            ServerFnError::ServerError("Auth session missing.".into())
-        })
+    pub async fn auth() -> Result<AuthSession, ServerFnError> {
+        let auth = leptos_axum::extract().await?;
+        Ok(auth)
     }
 
     #[derive(sqlx::FromRow, Clone)]
@@ -165,7 +167,7 @@ pub fn TodoApp() -> impl IntoView {
                                         ", "
                                         <A href="/login">"Login"</A>
                                         ", "
-                                        <span>{format!("Login error: {}", e)}</span>
+                                        <span>{format!("Login error: {e}")}</span>
                                     }
                                         .into_any()
                                 }

projects/tauri-from-scratch/.gitignore

@@ -1 +1,2 @@
 /target
+gen/