cargo fmt

.github/workflows/ci-changed-examples.yml

@@ -1,21 +1,23 @@
 name: CI Changed Examples
+
 on:
   push:
     branches:
       - main
-      - leptos_0.6
   pull_request:
     branches:
       - main
-      - leptos_0.6
+
 jobs:
   get-example-changed:
     uses: ./.github/workflows/get-example-changed.yml
+
   get-matrix:
     needs: [get-example-changed]
     uses: ./.github/workflows/get-changed-examples-matrix.yml
     with:
       example_changed: ${{ fromJSON(needs.get-example-changed.outputs.example_changed) }}
+
   test:
     name: CI
     needs: [get-example-changed, get-matrix]

.github/workflows/ci-examples.yml

@@ -1,13 +1,13 @@
 name: CI Examples
+
 on:
   push:
     branches:
       - main
-      - leptos_0.6
   pull_request:
     branches:
       - main
-      - leptos_0.6
+
 jobs:
   get-leptos-changed:
     uses: ./.github/workflows/get-leptos-changed.yml

.github/workflows/ci-semver.yml

@@ -1,24 +1,27 @@
 name: CI semver
+
 on:
   push:
     branches:
       - main
-      - leptos_0.6
   pull_request:
     branches:
       - main
-      - leptos_0.6
+
 jobs:
   get-leptos-changed:
     uses: ./.github/workflows/get-leptos-changed.yml
+
   test:
     needs: [get-leptos-changed]
     if: github.event.pull_request.labels[0].name == 'semver' # needs.get-leptos-changed.outputs.leptos_changed == 'true' && github.event.pull_request.labels[0].name != 'breaking'
     name: Run semver check (nightly-2024-08-01)
     runs-on: ubuntu-latest
+
     steps:
       - name: Checkout
         uses: actions/checkout@v4
+
       - name: Semver Checks
         uses: obi1kenobi/cargo-semver-checks-action@v2
         with:

.github/workflows/ci.yml

@@ -1,25 +1,50 @@
 name: CI
+
 on:
   push:
     branches:
       - main
-      - leptos_0.6
   pull_request:
     branches:
       - main
-      - leptos_0.6
+
 jobs:
   get-leptos-changed:
     uses: ./.github/workflows/get-leptos-changed.yml
-  get-leptos-matrix:
-    uses: ./.github/workflows/get-leptos-matrix.yml
+
   test:
     name: CI
-    needs: [get-leptos-changed, get-leptos-matrix]
+    needs: [get-leptos-changed]
     if: needs.get-leptos-changed.outputs.leptos_changed == 'true'
     strategy:
-      matrix: ${{ fromJSON(needs.get-leptos-matrix.outputs.matrix) }}
-      fail-fast: false
+      matrix:
+        directory:
+          [
+            any_error,
+            any_spawner,
+            const_str_slice_concat,
+            either_of,
+            hydration_context,
+            integrations/actix,
+            integrations/axum,
+            integrations/utils,
+            leptos,
+            leptos_config,
+            leptos_dom,
+            leptos_hot_reload,
+            leptos_macro,
+            leptos_server,
+            meta,
+            next_tuple,
+            oco,
+            or_poisoned,
+            reactive_graph,
+            router,
+            router_macro,
+            server_fn,
+            server_fn/server_fn_macro_default,
+            server_fn_macro,
+          ]
     uses: ./.github/workflows/run-cargo-make-task.yml
     with:
       directory: ${{ matrix.directory }}

.github/workflows/get-example-changed.yml

@@ -1,10 +1,12 @@
 name: Examples Changed Call
+
 on:
   workflow_call:
     outputs:
       example_changed:
         description: "Example Changed"
         value: ${{ jobs.get-example-changed.outputs.example_changed }}
+
 jobs:
   get-example-changed:
     name: Get Example Changed
@@ -16,6 +18,7 @@ jobs:
         uses: actions/checkout@v4
         with:
           fetch-depth: 0
+
       - name: Get example files that changed
         id: changed-files
         uses: tj-actions/changed-files@v45
@@ -23,10 +26,13 @@ jobs:
           files: |
             examples/**
             !examples/cargo-make/**
+            !examples/gtk/**
             !examples/Makefile.toml
             !examples/*.md
+
       - name: List example files that changed
         run: echo '${{ steps.changed-files.outputs.all_changed_files }}'
+
       - name: Set example_changed
         id: set-example-changed
         run: |

.github/workflows/get-examples-matrix.yml

@@ -1,34 +1,38 @@
 name: Get Examples Matrix Call
+
 on:
   workflow_call:
     outputs:
       matrix:
         description: "Matrix"
         value: ${{ jobs.create.outputs.matrix }}
+
 jobs:
   create:
     name: Create Examples Matrix
     runs-on: ubuntu-latest
     outputs:
       matrix: ${{ steps.set-matrix.outputs.matrix }}
-    env:
-      # separate examples using "|" (vertical bar) char like "a|b|c".
-      # cargo-make should be excluded by default.
-      EXCLUDED_EXAMPLES: cargo-make
     steps:
       - name: Checkout
         uses: actions/checkout@v4
+
       - name: Install jq
         run: sudo apt-get install jq
+
       - name: Set Matrix
         id: set-matrix
         run: |
-          examples=$(ls -1d examples/*/ |
-          grep -vE "($EXCLUDED_EXAMPLES)" |
-          sed 's/\/$//' |
+          examples=$(ls examples |
+          awk '{print "examples/" $0}' |
+          grep -v .md |
+          grep -v examples/Makefile.toml |
+          grep -v examples/cargo-make |
+          grep -v examples/gtk |
           jq -R -s -c 'split("\n")[:-1]')
           echo "Example Directories: $examples"
           echo "matrix={\"directory\":$examples}" >> "$GITHUB_OUTPUT"
+
       - name: Print Location Info
         run: |
           echo "Workspace: ${{ github.workspace }}"

.github/workflows/get-leptos-changed.yml

@@ -1,10 +1,12 @@
 name: Get Leptos Changed Call
+
 on:
   workflow_call:
     outputs:
       leptos_changed:
         description: "Leptos Changed"
         value: ${{ jobs.create.outputs.leptos_changed }}
+
 jobs:
   create:
     name: Detect Source Change
@@ -16,19 +18,40 @@ jobs:
         uses: actions/checkout@v4
         with:
           fetch-depth: 0
+
       - name: Get source files that changed
         id: changed-source
         uses: tj-actions/changed-files@v45
         with:
-          files_ignore: |
-            .*/**/*
-            cargo-make/**/*
-            examples/**/*
-            projects/**/*
-            benchmarks/**/*
-            docs/**/*
+          files: |
+            any_error/**
+            any_spawner/**
+            const_str_slice_concat/**
+            either_of/**
+            hydration_context/**
+            integrations/actix/**
+            integrations/axum/**
+            integrations/utils/**
+            leptos/**
+            leptos_config/**
+            leptos_dom/**
+            leptos_hot_reload/**
+            leptos_macro/**
+            leptos_server/**
+            meta/**
+            next_tuple/**
+            oco/**
+            or_poisoned/**
+            reactive_graph/**
+            router/**
+            router_macro/**
+            server_fn/**
+            server_fn/server_fn_macro_default/**
+            server_fn_macro/**
+
       - name: List source files that changed
         run: echo '${{ steps.changed-source.outputs.all_changed_files }}'
+
       - name: Set leptos_changed
         id: set-source-changed
         run: |

.github/workflows/get-leptos-matrix.yml

@@ -1,32 +0,0 @@
-name: Get Leptos Matrix Call
-on:
-  workflow_call:
-    outputs:
-      matrix:
-        description: "Matrix"
-        value: ${{ jobs.create.outputs.matrix }}
-jobs:
-  create:
-    name: Create Leptos Matrix
-    runs-on: ubuntu-latest
-    outputs:
-      matrix: ${{ steps.set-matrix.outputs.matrix }}
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-      - name: Install jq
-        run: sudo apt-get install jq
-      - name: Set Matrix
-        id: set-matrix
-        run: |
-          crates=$(cargo metadata --no-deps --quiet --format-version 1 |
-          jq -r '.packages[] | select(.name != "workspace") | .manifest_path| rtrimstr("/Cargo.toml")' |
-          sed "s|$(pwd)/||" |
-          jq -R -s -c 'split("\n")[:-1]')
-          echo "Leptos Directories: $crates"
-          echo "matrix={\"directory\":$crates}" >> "$GITHUB_OUTPUT"
-      - name: Print Location Info
-        run: |
-          echo "Workspace: ${{ github.workspace }}"
-          pwd
-          ls | sort -u

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

@@ -1,4 +1,5 @@
 name: Run Task
+
 on:
   workflow_call:
     inputs:
@@ -11,53 +12,70 @@ on:
       toolchain:
         required: true
         type: string
+
 env:
   CARGO_TERM_COLOR: always
   CARGO_REGISTRIES_CRATES_IO_PROTOCOL: sparse
+
 jobs:
   test:
     name: Run ${{ inputs.cargo_make_task }} (${{ inputs.toolchain }})
     runs-on: ubuntu-latest
+
     steps:
       # Setup environment
       - uses: actions/checkout@v4
+
       - name: Setup Rust
         uses: dtolnay/rust-toolchain@master
         with:
           toolchain: ${{ inputs.toolchain }}
+
       - name: Add wasm32-unknown-unknown
         run: rustup target add wasm32-unknown-unknown
+
       - name: Setup cargo-make
         uses: davidB/rust-cargo-make@v1
+
       - name: Cargo generate-lockfile
         run: cargo generate-lockfile
+
       - uses: Swatinem/rust-cache@v2
+
       - name: Install binstall
         uses: cargo-bins/cargo-binstall@main
+
       - name: Install wasm-bindgen
         run: cargo binstall wasm-bindgen-cli --no-confirm
+
       - name: Install cargo-leptos
         run: cargo binstall cargo-leptos --no-confirm
+
       - name: Install Trunk
         uses: jetli/trunk-action@v0.5.0
         with:
           version: "latest"
+
       - name: Print Trunk Version
         run: trunk --version
+
       - name: Install Node.js
         uses: actions/setup-node@v4
         with:
           node-version: 20
+
       - uses: pnpm/action-setup@v4
         name: Install pnpm
         id: pnpm-install
         with:
           version: 8
           run_install: false
+
       - name: Get pnpm store directory
         id: pnpm-cache
         run: |
           echo "STORE_PATH=$(pnpm store path)" >> $GITHUB_OUTPUT
+
       - uses: actions/cache@v4
         name: Setup pnpm cache
         with:
@@ -65,6 +83,7 @@ jobs:
           key: ${{ runner.os }}-pnpm-store-${{ hashFiles('**/pnpm-lock.yaml') }}
           restore-keys: |
             ${{ runner.os }}-pnpm-store-
+
       - name: Maybe install chromedriver
         run: |
           project_makefile=${{inputs.directory}}/Makefile.toml
@@ -80,6 +99,7 @@ jobs:
           else
               echo chromedriver is not required
           fi
+
       - name: Maybe install playwright browser dependencies
         run: |
           for pw_path in $(find ${{inputs.directory}} -name playwright.config.ts)
@@ -93,16 +113,12 @@ jobs:
               echo Playwright is not required
             fi
           done
+
       - name: Install Deno
-        uses: denoland/setup-deno@v2
+        uses: denoland/setup-deno@v1
         with:
           deno-version: v1.x
-      - name: Maybe install gtk-rs dependencies
-        run: |
-          if [ ! -z $(echo ${{inputs.directory}} | grep gtk) ]; then
-            sudo apt-get update
-            sudo apt-get install -y libglib2.0-dev libgio2.0-cil-dev libgraphene-1.0-dev libcairo2-dev libpango1.0-dev libgtk-4-dev
-          fi
+
       # Run Cargo Make Task
       - name: ${{ inputs.cargo_make_task }}
         run: |

Cargo.toml

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

any_error/Cargo.toml

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

benchmarks/Cargo.toml

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

benchmarks/src/ssr.rs

@@ -18,7 +18,7 @@ fn leptos_ssr_bench(b: &mut Bencher) {
 				}
 			}
 
-			let rendered = view! {
+			let rendered = view! { 
 				<main>
 					<h1>"Welcome to our benchmark page."</h1>
 					<p>"Here's some introductory text."</p>
@@ -58,7 +58,7 @@ fn tachys_ssr_bench(b: &mut Bencher) {
 			}
 		}
 
-		let rendered = view! {
+		let rendered = view! { 
 			<main>
 				<h1>"Welcome to our benchmark page."</h1>
 				<p>"Here's some introductory text."</p>
@@ -92,13 +92,13 @@ fn tera_ssr_bench(b: &mut Bencher) {
 	{% endfor %}
 	</main>"#;
 
-
-    static  LazyCell<TERA>: Tera = LazyLock::new(|| {
-        let mut tera = Tera::default();
-        tera.add_raw_templates(vec![("template.html", TEMPLATE)]).unwrap();
-        tera
-    });
-
+    lazy_static::lazy_static! {
+        static ref TERA: Tera = {
+            let mut tera = Tera::default();
+            tera.add_raw_templates(vec![("template.html", TEMPLATE)]).unwrap();
+            tera
+        };
+    }
 
     #[derive(Serialize, Deserialize)]
     struct Counter {

benchmarks/src/todomvc/tera.rs

@@ -55,7 +55,7 @@ static TEMPLATE: &str = r#"<main>
 						{% else %}
 						 <li><a href="/">All</a></li>
 						{% endif %}
-
+				
 						{% if mode_active %}
                         <li><a href="/active" class="selected">Active</a></li>
 						{% else %}
@@ -91,13 +91,13 @@ fn tera_todomvc_ssr(b: &mut Bencher) {
     use serde::{Deserialize, Serialize};
     use tera::*;
 
-
-        static LazyLock<TERA>: Tera = LazyLock( || {
+    lazy_static::lazy_static! {
+        static ref TERA: Tera = {
             let mut tera = Tera::default();
             tera.add_raw_templates(vec![("template.html", TEMPLATE)]).unwrap();
             tera
-        });
-
+        };
+    }
 
     #[derive(Serialize, Deserialize)]
     struct Todo {
@@ -131,13 +131,13 @@ fn tera_todomvc_ssr_1000(b: &mut Bencher) {
     use serde::{Deserialize, Serialize};
     use tera::*;
 
-
-    static  TERA: LazyLock<Tera> = LazyLock::new(|| {
-        let mut tera = Tera::default();
-        tera.add_raw_templates(vec![("template.html", TEMPLATE)]).unwrap();
-        tera
-    });
-
+    lazy_static::lazy_static! {
+        static ref TERA: Tera = {
+            let mut tera = Tera::default();
+            tera.add_raw_templates(vec![("template.html", TEMPLATE)]).unwrap();
+            tera
+        };
+    }
 
     #[derive(Serialize, Deserialize)]
     struct Todo {

either_of/src/lib.rs

@@ -133,104 +133,3 @@ tuples!(EitherOf13 + EitherOf13Future + EitherOf13FutureProj => A, B, C, D, E, F
 tuples!(EitherOf14 + EitherOf14Future + EitherOf14FutureProj => A, B, C, D, E, F, G, H, I, J, K, L, M, N);
 tuples!(EitherOf15 + EitherOf15Future + EitherOf15FutureProj => A, B, C, D, E, F, G, H, I, J, K, L, M, N, O);
 tuples!(EitherOf16 + EitherOf16Future + EitherOf16FutureProj => A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P);
-
-/// Matches over the first expression and returns an either ([`Either`], [`EitherOf3`], ... [`EitherOf6`])
-/// composed of the values returned by the match arms.
-///
-/// The pattern syntax is exactly the same as found in a match arm.
-///
-/// # Examples
-///
-/// ```
-/// # use either_of::*;
-/// let either2 = either!(Some("hello"),
-///     Some(s) => s.len(),
-///     None => 0.0,
-/// );
-/// assert!(matches!(either2, Either::<usize, f64>::Left(5)));
-///
-/// let either3 = either!(Some("admin"),
-///     Some("admin") => "hello admin",
-///     Some(_) => 'x',
-///     _ => 0,
-/// );
-/// assert!(matches!(either3, EitherOf3::<&str, char, i32>::A("hello admin")));
-/// ```
-#[macro_export]
-macro_rules! either {
-    ($match:expr, $left_pattern:pat => $left_expression:expr, $right_pattern:pat => $right_expression:expr,) => {
-        match $match {
-            $left_pattern => $crate::Either::Left($left_expression),
-            $right_pattern => $crate::Either::Right($right_expression),
-        }
-    };
-    ($match:expr, $a_pattern:pat => $a_expression:expr, $b_pattern:pat => $b_expression:expr, $c_pattern:pat => $c_expression:expr,) => {
-        match $match {
-            $a_pattern => $crate::EitherOf3::A($a_expression),
-            $b_pattern => $crate::EitherOf3::B($b_expression),
-            $c_pattern => $crate::EitherOf3::C($c_expression),
-        }
-    };
-    ($match:expr, $a_pattern:pat => $a_expression:expr, $b_pattern:pat => $b_expression:expr, $c_pattern:pat => $c_expression:expr, $d_pattern:pat => $d_expression:expr,) => {
-        match $match {
-            $a_pattern => $crate::EitherOf4::A($a_expression),
-            $b_pattern => $crate::EitherOf4::B($b_expression),
-            $c_pattern => $crate::EitherOf4::C($c_expression),
-            $d_pattern => $crate::EitherOf4::D($d_expression),
-        }
-    };
-    ($match:expr, $a_pattern:pat => $a_expression:expr, $b_pattern:pat => $b_expression:expr, $c_pattern:pat => $c_expression:expr, $d_pattern:pat => $d_expression:expr, $e_pattern:pat => $e_expression:expr,) => {
-        match $match {
-            $a_pattern => $crate::EitherOf5::A($a_expression),
-            $b_pattern => $crate::EitherOf5::B($b_expression),
-            $c_pattern => $crate::EitherOf5::C($c_expression),
-            $d_pattern => $crate::EitherOf5::D($d_expression),
-            $e_pattern => $crate::EitherOf5::E($e_expression),
-        }
-    };
-    ($match:expr, $a_pattern:pat => $a_expression:expr, $b_pattern:pat => $b_expression:expr, $c_pattern:pat => $c_expression:expr, $d_pattern:pat => $d_expression:expr, $e_pattern:pat => $e_expression:expr, $f_pattern:pat => $f_expression:expr,) => {
-        match $match {
-            $a_pattern => $crate::EitherOf6::A($a_expression),
-            $b_pattern => $crate::EitherOf6::B($b_expression),
-            $c_pattern => $crate::EitherOf6::C($c_expression),
-            $d_pattern => $crate::EitherOf6::D($d_expression),
-            $e_pattern => $crate::EitherOf6::E($e_expression),
-            $f_pattern => $crate::EitherOf6::F($f_expression),
-        }
-    }; // if you need more eithers feel free to open a PR ;-)
-}
-
-// compile time test
-#[test]
-fn either_macro() {
-    let _: Either<&str, f64> = either!(12,
-        12 => "12",
-        _ => 0.0,
-    );
-    let _: EitherOf3<&str, f64, i32> = either!(12,
-        12 => "12",
-        13 => 0.0,
-        _ => 12,
-    );
-    let _: EitherOf4<&str, f64, char, i32> = either!(12,
-        12 => "12",
-        13 => 0.0,
-        14 => ' ',
-        _ => 12,
-    );
-    let _: EitherOf5<&str, f64, char, f32, i32> = either!(12,
-        12 => "12",
-        13 => 0.0,
-        14 => ' ',
-        15 => 0.0f32,
-        _ => 12,
-    );
-    let _: EitherOf6<&str, f64, char, f32, u8, i32> = either!(12,
-        12 => "12",
-        13 => 0.0,
-        14 => ' ',
-        15 => 0.0f32,
-        16 => 24u8,
-        _ => 12,
-    );
-}

examples/axum_js_ssr/src/app.rs

@@ -32,6 +32,7 @@ pub fn App() -> impl IntoView {
     // Provides context that manages stylesheets, titles, meta tags, etc.
     provide_meta_context();
     let fallback = || view! { "Page not found." }.into_view();
+    let ssr = SsrMode::Async;
 
     view! {
         <Stylesheet id="leptos" href="/pkg/axum_js_ssr.css"/>
@@ -78,19 +79,19 @@ pub fn App() -> impl IntoView {
                     <h1>"Leptos JavaScript Integration Demo with SSR in Axum"</h1>
                     <FlatRoutes fallback>
                         <Route path=path!("") view=HomePage/>
-                        <Route path=path!("naive") view=Naive ssr=SsrMode::Async/>
-                        <Route path=path!("naive-alt") view=|| view! { <NaiveEvent/> } ssr=SsrMode::Async/>
-                        <Route path=path!("naive-hook") view=|| view! { <NaiveEvent hook=true/> } ssr=SsrMode::Async/>
+                        <Route path=path!("naive") view=Naive ssr/>
+                        <Route path=path!("naive-alt") view=|| view! { <NaiveEvent/> } ssr/>
+                        <Route path=path!("naive-hook") view=|| view! { <NaiveEvent hook=true/> } ssr/>
                         <Route path=path!("naive-fallback") view=|| view! {
                             <NaiveEvent hook=true fallback=true/>
-                        } ssr=SsrMode::Async/>
-                        <Route path=path!("signal-effect-script") view=CodeDemoSignalEffect ssr=SsrMode::Async/>
-                        <Route path=path!("custom-event") view=CustomEvent ssr=SsrMode::Async/>
-                        <Route path=path!("wasm-bindgen-naive") view=WasmBindgenNaive ssr=SsrMode::Async/>
-                        <Route path=path!("wasm-bindgen-event") view=WasmBindgenJSHookReadyEvent ssr=SsrMode::Async/>
-                        <Route path=path!("wasm-bindgen-effect") view=WasmBindgenEffect ssr=SsrMode::Async/>
-                        <Route path=path!("wasm-bindgen-direct") view=WasmBindgenDirect ssr=SsrMode::Async/>
-                        <Route path=path!("wasm-bindgen-direct-fixed") view=WasmBindgenDirectFixed ssr=SsrMode::Async/>
+                        } ssr/>
+                        <Route path=path!("signal-effect-script") view=CodeDemoSignalEffect ssr/>
+                        <Route path=path!("custom-event") view=CustomEvent ssr/>
+                        <Route path=path!("wasm-bindgen-naive") view=WasmBindgenNaive ssr/>
+                        <Route path=path!("wasm-bindgen-event") view=WasmBindgenJSHookReadyEvent ssr/>
+                        <Route path=path!("wasm-bindgen-effect") view=WasmBindgenEffect ssr/>
+                        <Route path=path!("wasm-bindgen-direct") view=WasmBindgenDirect ssr/>
+                        <Route path=path!("wasm-bindgen-direct-fixed") view=WasmBindgenDirectFixed ssr/>
                     </FlatRoutes>
                 </article>
             </main>

examples/counter/tests/web.rs

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

examples/counter_isomorphic/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"]
@@ -19,6 +17,7 @@ broadcaster = "1.0"
 console_log = "1.0"
 console_error_panic_hook = "0.1.7"
 futures = "0.3.30"
+lazy_static = "1.5"
 leptos = { path = "../../leptos" }
 leptos_actix = { path = "../../integrations/actix", optional = true }
 leptos_router = { path = "../../router" }
@@ -47,13 +46,13 @@ denylist = ["actix-files", "actix-web", "leptos_actix"]
 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
+# The name used by wasm-bindgen/cargo-leptos for the JS/WASM bundle. Defaults to the crate name   
 output-name = "counter_isomorphic"
 # 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.
 # When NOT using cargo-leptos this must be updated to "." or the counters will not work. The above warning still applies if you do switch to cargo-leptos later.
 site-root = "target/site"
 # The site-root relative folder where all compiled output (JS, WASM and CSS) is written
-# Defaults to pkg
+# Defaults to pkg	
 site-pkg-dir = "pkg"
 # [Optional] The source CSS file. If it ends with .sass or .scss then it will be compiled by dart-sass into CSS. The CSS is optimized by Lightning CSS before being written to <site-root>/<site-pkg>/app.css
 # style-file = "src/styles/tailwind.css"

examples/counter_isomorphic/src/counters.rs

@@ -1,4 +1,4 @@
-use leptos::prelude::*;
+use leptos::{prelude::*, reactive_graph::actions::Action};
 use leptos_router::{
     components::{FlatRoutes, Route, Router, A},
     StaticSegment,
@@ -10,12 +10,12 @@ use tracing::instrument;
 pub mod ssr_imports {
     pub use broadcaster::BroadcastChannel;
     pub use std::sync::atomic::{AtomicI32, Ordering};
-    use std::sync::LazyLock;
 
     pub static COUNT: AtomicI32 = AtomicI32::new(0);
 
-    pub static COUNT_CHANNEL: LazyLock<BroadcastChannel<i32>> =
-        LazyLock::new(BroadcastChannel::<i32>::new);
+    lazy_static::lazy_static! {
+        pub static ref COUNT_CHANNEL: BroadcastChannel<i32> = BroadcastChannel::new();
+    }
 }
 
 #[server]

examples/counter_without_macros/tests/web.rs

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

examples/counters/tests/web.rs

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

examples/directives/tests/web.rs

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

examples/gtk/Cargo.toml

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

examples/gtk/index.html

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

examples/gtk/src/leptos_gtk.rs

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

examples/gtk/src/main.rs

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

examples/hackernews_islands_axum/Cargo.toml

@@ -31,6 +31,7 @@ tokio = { version = "1.39", features = ["full"], optional = true }
 http = { version = "1.1", optional = true }
 web-sys = { version = "0.3.70", features = ["AbortController", "AbortSignal"] }
 wasm-bindgen = "0.2.93"
+lazy_static = "1.5"
 rust-embed = { version = "8.5", features = [
   "axum",
   "mime_guess",

examples/islands_router/Cargo.toml

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

examples/islands_router/README.md

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

examples/js-framework-benchmark/src/lib.rs

@@ -162,24 +162,22 @@ pub fn App() -> impl IntoView {
             <table class="table table-hover table-striped test-data">
                 <tbody>
                     <For
-                        each=move || data.get()
-                        key=|row| row.id
+                        each={move || data.get()}
+                        key={|row| row.id}
                         children=move |row: RowData| {
                             let row_id = row.id;
                             let label = row.label;
                             let is_selected = is_selected.clone();
-                            template! {
-                                < tr class : danger = { move || is_selected.selected(Some(row_id)) }
-                                > < td class = "col-md-1" > { row_id.to_string() } </ td > < td
-                                class = "col-md-4" >< a on : click = move | _ | set_selected
-                                .set(Some(row_id)) > { move || label.get() } </ a ></ td > < td
-                                class = "col-md-1" >< a on : click = move | _ | remove(row_id) ><
-                                span class = "glyphicon glyphicon-remove" aria - hidden = "true" ></
-                                span ></ a ></ td > < td class = "col-md-6" /> </ tr >
-                            }
+                            ViewTemplate::new(view! {
+                                <tr class:danger={move || is_selected.selected(Some(row_id))}>
+                                    <td class="col-md-1">{row_id.to_string()}</td>
+                                    <td class="col-md-4"><a on:click=move |_| set_selected.set(Some(row_id))>{move || label.get()}</a></td>
+                                    <td class="col-md-1"><a on:click=move |_| remove(row_id)><span class="glyphicon glyphicon-remove" aria-hidden="true"></span></a></td>
+                                    <td class="col-md-6"/>
+                                </tr>
+                            })
                         }
                     />
-
                 </tbody>
             </table>
             <span class="preloadicon glyphicon glyphicon-remove" aria-hidden="true"></span>

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

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

examples/portal/tests/web.rs

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

examples/router/src/lib.rs

@@ -64,8 +64,8 @@ pub fn RouterExample() -> impl IntoView {
 
 // You can define other routes in their own component.
 // Routes implement the MatchNestedRoutes
-#[component(transparent)]
-pub fn ContactRoutes() -> impl MatchNestedRoutes + Clone {
+#[component]
+pub fn ContactRoutes() -> impl MatchNestedRoutes<Dom> + Clone {
     view! {
         <ParentRoute path=path!("") view=ContactList>
             <Route path=path!("/") view=|| "Select a contact."/>

examples/server_fns_axum/Cargo.toml

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

examples/server_fns_axum/src/app.rs

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

examples/server_fns_axum/src/main.rs

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

examples/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"]
@@ -13,6 +11,7 @@ actix-files = { version = "0.6.6", optional = true }
 actix-web = { version = "4.8", optional = true, features = ["macros"] }
 console_error_panic_hook = "0.1.7"
 console_log = "1.0"
+lazy_static = "1.5"
 leptos = { path = "../../leptos" }
 leptos_meta = { path = "../../meta" }
 leptos_actix = { path = "../../integrations/actix", optional = true }
@@ -39,12 +38,12 @@ denylist = ["actix-files", "actix-web", "leptos_actix"]
 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
+# The name used by wasm-bindgen/cargo-leptos for the JS/WASM bundle. Defaults to the crate name   
 output-name = "ssr_modes"
 # 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
+# Defaults to pkg	
 site-pkg-dir = "pkg"
 # [Optional] The source CSS file. If it ends with .sass or .scss then it will be compiled by dart-sass into CSS. The CSS is optimized by Lightning CSS before being written to <site-root>/<site-pkg>/app.css
 style-file = "style/main.scss"

examples/ssr_modes/src/app.rs

@@ -1,5 +1,4 @@
-use std::sync::LazyLock;
-
+use lazy_static::lazy_static;
 use leptos::prelude::*;
 use leptos_meta::*;
 use leptos_router::{
@@ -147,9 +146,8 @@ fn Post() -> impl IntoView {
 }
 
 // Dummy API
-
-static POSTS: LazyLock<[Post; 3]> = LazyLock::new(|| {
-    [
+lazy_static! {
+    static ref POSTS: Vec<Post> = vec![
         Post {
             id: 0,
             title: "My first post".to_string(),
@@ -165,8 +163,8 @@ static POSTS: LazyLock<[Post; 3]> = LazyLock::new(|| {
             title: "My third post".to_string(),
             content: "This is my third post".to_string(),
         },
-    ]
-});
+    ];
+}
 
 #[derive(Error, Debug, Copy, Clone, PartialEq, Eq, Serialize, Deserialize)]
 pub enum PostError {

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"]
@@ -11,6 +9,7 @@ crate-type = ["cdylib", "rlib"]
 [dependencies]
 console_error_panic_hook = "0.1.7"
 console_log = "1.0"
+lazy_static = "1.5"
 leptos = { path = "../../leptos", features = [
   "hydration",
 ] } #"nightly", "hydration"] }

examples/ssr_modes_axum/src/app.rs

@@ -1,5 +1,4 @@
-use std::sync::LazyLock;
-
+use lazy_static::lazy_static;
 use leptos::prelude::*;
 use leptos_meta::MetaTags;
 use leptos_meta::*;
@@ -262,9 +261,8 @@ pub fn Admin() -> impl IntoView {
 }
 
 // Dummy API
-
-static POSTS: LazyLock<[Post; 3]> = LazyLock::new(|| {
-    [
+lazy_static! {
+    static ref POSTS: Vec<Post> = vec![
         Post {
             id: 0,
             title: "My first post".to_string(),
@@ -280,8 +278,8 @@ static POSTS: LazyLock<[Post; 3]> = LazyLock::new(|| {
             title: "My third post".to_string(),
             content: "This is my third post".to_string(),
         },
-    ]
-});
+    ];
+}
 
 #[derive(Error, Debug, Copy, Clone, PartialEq, Eq, Serialize, Deserialize)]
 pub enum PostError {

examples/stores/Cargo.toml

@@ -13,9 +13,6 @@ leptos = { path = "../../leptos", features = ["csr"] }
 reactive_stores = { path = "../../reactive_stores" }
 reactive_stores_macro = { path = "../../reactive_stores_macro" }
 console_error_panic_hook = "0.1.7"
-chrono = { version = "0.4.38", features = ["serde"] }
-serde = { version = "1.0.210", features = ["derive"] }
-serde_json = "1.0.128"
 
 [dev-dependencies]
 wasm-bindgen = "0.2.93"

examples/stores/index.html

@@ -3,11 +3,6 @@
 	<head>
 		<link data-trunk rel="rust" data-wasm-opt="z"/>
 		<link data-trunk rel="icon" type="image/ico" href="/public/favicon.ico"/>
-		<style>
-		.hidden {
-			display: none;
-		}
-		</style>
 	</head>
 	<body></body>
-</html>
+</html>

examples/stores/src/lib.rs

@@ -1,88 +1,43 @@
-use std::sync::atomic::{AtomicUsize, Ordering};
-
-use chrono::{Local, NaiveDate};
 use leptos::prelude::*;
-use reactive_stores::{Field, Patch, Store};
-use reactive_stores_macro::{Patch, Store};
-use serde::{Deserialize, Serialize};
+use reactive_stores::{Field, Store, StoreFieldIterator};
+use reactive_stores_macro::Store;
 
-// ID starts higher than 0 because we have a few starting todos by default
-static NEXT_ID: AtomicUsize = AtomicUsize::new(3);
-
-#[derive(Debug, Store, Serialize, Deserialize)]
+#[derive(Debug, Store)]
 struct Todos {
-    user: User,
-    #[store(key: usize = |todo| todo.id)]
+    user: String,
     todos: Vec<Todo>,
 }
 
-#[derive(Debug, Store, Patch, Serialize, Deserialize)]
-struct User {
-    name: String,
-    email: String,
-}
-
-#[derive(Debug, Store, Serialize, Deserialize)]
+#[derive(Debug, Store)]
 struct Todo {
-    id: usize,
     label: String,
-    status: Status,
-}
-
-#[derive(Debug, Default, Clone, Store, Serialize, Deserialize)]
-enum Status {
-    #[default]
-    Pending,
-    Scheduled,
-    ScheduledFor {
-        date: NaiveDate,
-    },
-    Done,
-}
-
-impl Status {
-    pub fn next_step(&mut self) {
-        *self = match self {
-            Status::Pending => Status::ScheduledFor {
-                date: Local::now().naive_local().into(),
-            },
-            Status::Scheduled | Status::ScheduledFor { .. } => Status::Done,
-            Status::Done => Status::Done,
-        };
-    }
+    completed: bool,
 }
 
 impl Todo {
     pub fn new(label: impl ToString) -> Self {
         Self {
-            id: NEXT_ID.fetch_add(1, Ordering::Relaxed),
             label: label.to_string(),
-            status: Status::Pending,
+            completed: false,
         }
     }
 }
 
 fn data() -> Todos {
     Todos {
-        user: User {
-            name: "Bob".to_string(),
-            email: "lawblog@bobloblaw.com".into(),
-        },
+        user: "Bob".to_string(),
         todos: vec![
             Todo {
-                id: 0,
                 label: "Create reactive store".to_string(),
-                status: Status::Pending,
+                completed: true,
             },
             Todo {
-                id: 1,
                 label: "???".to_string(),
-                status: Status::Pending,
+                completed: false,
             },
             Todo {
-                id: 2,
                 label: "Profit".to_string(),
-                status: Status::Pending,
+                completed: false,
             },
         ],
     }
@@ -94,10 +49,17 @@ pub fn App() -> impl IntoView {
 
     let input_ref = NodeRef::new();
 
+    let rows = move || {
+        store
+            .todos()
+            .iter()
+            .enumerate()
+            .map(|(idx, todo)| view! { <TodoRow store idx todo/> })
+            .collect_view()
+    };
+
     view! {
-        <p>"Hello, " {move || store.user().name().get()}</p>
-        <UserForm user=store.user()/>
-        <hr/>
+        <p>"Hello, " {move || store.user().get()}</p>
         <form on:submit=move |ev| {
             ev.prevent_default();
             store.todos().write().push(Todo::new(input_ref.get().unwrap().value()));
@@ -105,69 +67,30 @@ pub fn App() -> impl IntoView {
             <label>"Add a Todo" <input type="text" node_ref=input_ref/></label>
             <input type="submit"/>
         </form>
-        <ol>
-            // because `todos` is a keyed field, `store.todos()` returns a struct that
-            // directly implements IntoIterator, so we can use it in <For/> and
-            // it will manage reactivity for the store fields correctly
-            <For
-                each=move || {
-                    leptos::logging::log!("RERUNNING FOR CALCULATION");
-                    store.todos()
-                }
-
-                key=|row| row.id().get()
-                let:todo
-            >
-                <TodoRow store todo/>
-            </For>
-
-        </ol>
-        <pre>{move || serde_json::to_string_pretty(&*store.read())}</pre>
-    }
-}
-
-#[component]
-fn UserForm(#[prop(into)] user: Field<User>) -> impl IntoView {
-    let error = RwSignal::new(None);
-
-    view! {
-        {move || error.get().map(|n| view! { <p>{n}</p> })}
-        <form on:submit:target=move |ev| {
-            ev.prevent_default();
-            match User::from_event(&ev) {
-                Ok(new_user) => {
-                    error.set(None);
-                    user.patch(new_user);
-                }
-                Err(e) => error.set(Some(e.to_string())),
-            }
-        }>
-            <label>
-                "Name" <input type="text" name="name" prop:value=move || user.name().get()/>
-            </label>
-            <label>
-                "Email" <input type="email" name="email" prop:value=move || user.email().get()/>
-            </label>
-            <input type="submit"/>
-        </form>
+        <ol>{rows}</ol>
+        <div style="display: flex"></div>
     }
 }
 
 #[component]
 fn TodoRow(
     store: Store<Todos>,
+    idx: usize,
     #[prop(into)] todo: Field<Todo>,
 ) -> impl IntoView {
-    let status = todo.status();
+    let completed = todo.completed();
     let title = todo.label();
 
-    let editing = RwSignal::new(true);
+    let editing = RwSignal::new(false);
 
     view! {
-        <li style:text-decoration=move || {
-            status.done().then_some("line-through").unwrap_or_default()
-        }>
+        <li
+            style:text-decoration=move || {
+                completed.get().then_some("line-through").unwrap_or_default()
+            }
 
+            class:foo=move || completed.get()
+        >
             <p
                 class:hidden=move || editing.get()
                 on:click=move |_| {
@@ -183,48 +106,25 @@ fn TodoRow(
                 prop:value=move || title.get()
                 on:change=move |ev| {
                     title.set(event_target_value(&ev));
+                    editing.set(false);
                 }
+
+                on:blur=move |_| editing.set(false)
+                autofocus
             />
-
-            <button on:click=move |_| {
-                status.write().next_step()
-            }>
-                {move || {
-                    if todo.status().done() {
-                        "Done"
-                    } else if status.scheduled() || status.scheduled_for() {
-                        "Scheduled"
-                    } else {
-                        "Pending"
-                    }
-                }}
-
-            </button>
-
-            <button on:click=move |_| {
-                let id = todo.id().get();
-                store.todos().write().retain(|todo| todo.id != id);
-            }>"X"</button>
             <input
-                type="date"
-                prop:value=move || {
-                    todo.status().scheduled_for_date().map(|n| n.get().to_string())
-                }
-
-                class:hidden=move || !todo.status().scheduled_for()
-                on:change:target=move |ev| {
-                    if let Some(date) = todo.status().scheduled_for_date() {
-                        let value = ev.target().value();
-                        match NaiveDate::parse_from_str(&value, "%Y-%m-%d") {
-                            Ok(new_date) => {
-                                date.set(new_date);
-                            }
-                            Err(e) => warn!("{e}"),
-                        }
-                    }
-                }
+                type="checkbox"
+                prop:checked=move || completed.get()
+                on:click=move |_| { completed.update(|n| *n = !*n) }
             />
 
+            <button on:click=move |_| {
+                store
+                    .todos()
+                    .update(|todos| {
+                        todos.remove(idx);
+                    });
+            }>"X"</button>
         </li>
     }
 }

examples/todomvc/src/lib.rs

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

flake.lock

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

hydration_context/Cargo.toml

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

integrations/actix/Cargo.toml

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

integrations/actix/src/lib.rs

@@ -24,7 +24,7 @@ use leptos::{
     config::LeptosOptions,
     context::{provide_context, use_context},
     prelude::expect_context,
-    reactive::{computed::ScopedFuture, owner::Owner},
+    reactive_graph::{computed::ScopedFuture, owner::Owner},
     IntoView,
 };
 use leptos_integration_utils::{
@@ -749,7 +749,7 @@ where
     IV: IntoView + 'static,
 {
     Box::pin(async move {
-        let app = if cfg!(feature = "dont-use-islands-router") {
+        let app = if cfg!(feature = "islands-router") {
             app.to_html_stream_in_order_branching()
         } else {
             app.to_html_stream_in_order()
@@ -1381,41 +1381,39 @@ where
                         ),
                     )
                 } else {
-                    router
-                        .route(path, web::head().to(HttpResponse::Ok))
-                        .route(
-                            path,
-                            match mode {
-                                SsrMode::OutOfOrder => {
-                                    render_app_to_stream_with_context(
-                                        additional_context_and_method.clone(),
-                                        app_fn.clone(),
-                                        method,
-                                    )
-                                }
-                                SsrMode::PartiallyBlocked => {
-                                    render_app_to_stream_with_context_and_replace_blocks(
-                                        additional_context_and_method.clone(),
-                                        app_fn.clone(),
-                                        method,
-                                        true,
-                                    )
-                                }
-                                SsrMode::InOrder => {
-                                    render_app_to_stream_in_order_with_context(
-                                        additional_context_and_method.clone(),
-                                        app_fn.clone(),
-                                        method,
-                                    )
-                                }
-                                SsrMode::Async => render_app_async_with_context(
-                                    additional_context_and_method.clone(),
-                                    app_fn.clone(),
-                                    method,
-                                ),
-                                _ => unreachable!()
-                            },
-                        )
+                    router.route(
+                    path,
+                    match mode {
+                        SsrMode::OutOfOrder => {
+                            render_app_to_stream_with_context(
+                                additional_context_and_method.clone(),
+                                app_fn.clone(),
+                                method,
+                            )
+                        }
+                        SsrMode::PartiallyBlocked => {
+                            render_app_to_stream_with_context_and_replace_blocks(
+                                additional_context_and_method.clone(),
+                                app_fn.clone(),
+                                method,
+                                true,
+                            )
+                        }
+                        SsrMode::InOrder => {
+                            render_app_to_stream_in_order_with_context(
+                                additional_context_and_method.clone(),
+                                app_fn.clone(),
+                                method,
+                            )
+                        }
+                        SsrMode::Async => render_app_async_with_context(
+                            additional_context_and_method.clone(),
+                            app_fn.clone(),
+                            method,
+                        ),
+                        _ => unreachable!()
+                    },
+                )
                 };
             }
         }

integrations/axum/Cargo.toml

@@ -28,7 +28,7 @@ once_cell = "1"
 parking_lot = "0.12.3"
 serde_json = "1.0"
 tokio = { version = "1.39", default-features = false }
-tower = { version = "0.4.13", features = ["util"] }
+tower = "0.4.13"
 tower-http = "0.5.2"
 tracing = { version = "0.1.40", optional = true }
 
@@ -38,8 +38,8 @@ tokio = { version = "1.39", features = ["net", "rt-multi-thread"] }
 
 [features]
 wasm = []
-default = ["tokio/fs", "tokio/sync", "tower-http/fs", "tower/util"]
-dont-use-islands-router = []
+default = ["tokio/fs", "tokio/sync", "tower-http/fs"]
+islands-router = []
 tracing = ["dep:tracing"]
 
 [package.metadata.docs.rs]

integrations/axum/src/lib.rs

@@ -53,7 +53,7 @@ use leptos::{
     config::LeptosOptions,
     context::{provide_context, use_context},
     prelude::*,
-    reactive::{computed::ScopedFuture, owner::Owner},
+    reactive_graph::{computed::ScopedFuture, owner::Owner},
     IntoView,
 };
 use leptos_integration_utils::{
@@ -76,7 +76,7 @@ use server_fn::{redirect::REDIRECT_HEADER, ServerFnError};
 use std::path::Path;
 use std::{fmt::Debug, io, pin::Pin, sync::Arc};
 #[cfg(feature = "default")]
-use tower::util::ServiceExt;
+use tower::ServiceExt;
 #[cfg(feature = "default")]
 use tower_http::services::ServeDir;
 // use tracing::Instrument; // TODO check tracing span -- was this used in 0.6 for a missing link?
@@ -784,7 +784,7 @@ where
     _ = replace_blocks; // TODO
     handle_response(additional_context, app_fn, |app, chunks| {
         Box::pin(async move {
-            let app = if cfg!(feature = "dont-use-islands-router") {
+            let app = if cfg!(feature = "islands-router") {
                 app.to_html_stream_out_of_order_branching()
             } else {
                 app.to_html_stream_out_of_order()
@@ -849,7 +849,7 @@ where
     IV: IntoView + 'static,
 {
     handle_response(additional_context, app_fn, |app, chunks| {
-        let app = if cfg!(feature = "dont-use-islands-router") {
+        let app = if cfg!(feature = "islands-router") {
             app.to_html_stream_in_order_branching()
         } else {
             app.to_html_stream_in_order()
@@ -1069,7 +1069,7 @@ where
 {
     handle_response(additional_context, app_fn, |app, chunks| {
         Box::pin(async move {
-            let app = if cfg!(feature = "dont-use-islands-router") {
+            let app = if cfg!(feature = "islands-router") {
                 app.to_html_stream_in_order_branching()
             } else {
                 app.to_html_stream_in_order()
@@ -1146,7 +1146,7 @@ where
     IV: IntoView + 'static,
 {
     Box::pin(async move {
-        let app = if cfg!(feature = "dont-use-islands-router") {
+        let app = if cfg!(feature = "islands-router") {
             app.to_html_stream_in_order_branching()
         } else {
             app.to_html_stream_in_order()

integrations/utils/src/lib.rs

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

leptos/src/await_.rs

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

leptos/src/callback.rs

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

leptos/src/children.rs

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

leptos/src/error_boundary.rs

@@ -4,16 +4,16 @@ use leptos_macro::component;
 use reactive_graph::{
     computed::ArcMemo,
     effect::RenderEffect,
-    owner::{provide_context, Owner},
+    owner::Owner,
     signal::ArcRwSignal,
     traits::{Get, Update, With, WithUntracked},
 };
 use rustc_hash::FxHashMap;
-use std::{fmt::Debug, sync::Arc};
+use std::{fmt::Debug, marker::PhantomData, sync::Arc};
 use tachys::{
     html::attribute::Attribute,
     hydration::Cursor,
-    reactive_graph::OwnedView,
+    renderer::Renderer,
     ssr::StreamBuilder,
     view::{
         add_attr::AddAnyAttr, Mountable, Position, PositionState, Render,
@@ -96,33 +96,27 @@ where
     let hook = hook as Arc<dyn ErrorHook>;
 
     let _guard = throw_error::set_error_hook(Arc::clone(&hook));
+    let children = children.into_inner()();
 
-    let owner = Owner::new();
-    let children = owner.with(|| {
-        provide_context(Arc::clone(&hook));
-        children.into_inner()()
-    });
-
-    OwnedView::new_with_owner(
-        ErrorBoundaryView {
-            hook,
-            boundary_id,
-            errors_empty,
-            children,
-            errors,
-            fallback,
-        },
-        owner,
-    )
+    ErrorBoundaryView {
+        hook,
+        boundary_id,
+        errors_empty,
+        children,
+        errors,
+        fallback,
+        rndr: PhantomData,
+    }
 }
 
-struct ErrorBoundaryView<Chil, FalFn> {
+struct ErrorBoundaryView<Chil, FalFn, Rndr> {
     hook: Arc<dyn ErrorHook>,
     boundary_id: SerializedDataId,
     errors_empty: ArcMemo<bool>,
     children: Chil,
     fallback: FalFn,
     errors: ArcRwSignal<Errors>,
+    rndr: PhantomData<Rndr>,
 }
 
 struct ErrorBoundaryViewState<Chil, Fal> {
@@ -131,10 +125,11 @@ struct ErrorBoundaryViewState<Chil, Fal> {
     fallback: Option<Fal>,
 }
 
-impl<Chil, Fal> Mountable for ErrorBoundaryViewState<Chil, Fal>
+impl<Chil, Fal, Rndr> Mountable<Rndr> for ErrorBoundaryViewState<Chil, Fal>
 where
-    Chil: Mountable,
-    Fal: Mountable,
+    Chil: Mountable<Rndr>,
+    Fal: Mountable<Rndr>,
+    Rndr: Renderer,
 {
     fn unmount(&mut self) {
         if let Some(fallback) = &mut self.fallback {
@@ -144,11 +139,7 @@ where
         }
     }
 
-    fn mount(
-        &mut self,
-        parent: &tachys::renderer::types::Element,
-        marker: Option<&tachys::renderer::types::Node>,
-    ) {
+    fn mount(&mut self, parent: &Rndr::Element, marker: Option<&Rndr::Node>) {
         if let Some(fallback) = &mut self.fallback {
             fallback.mount(parent, marker);
         } else {
@@ -156,7 +147,7 @@ where
         }
     }
 
-    fn insert_before_this(&self, child: &mut dyn Mountable) -> bool {
+    fn insert_before_this(&self, child: &mut dyn Mountable<Rndr>) -> bool {
         if let Some(fallback) = &self.fallback {
             fallback.insert_before_this(child)
         } else {
@@ -165,11 +156,13 @@ where
     }
 }
 
-impl<Chil, FalFn, Fal> Render for ErrorBoundaryView<Chil, FalFn>
+impl<Chil, FalFn, Fal, Rndr> Render<Rndr>
+    for ErrorBoundaryView<Chil, FalFn, Rndr>
 where
-    Chil: Render + 'static,
+    Chil: Render<Rndr> + 'static,
     FalFn: FnMut(ArcRwSignal<Errors>) -> Fal + Send + 'static,
-    Fal: Render + 'static,
+    Fal: Render<Rndr> + 'static,
+    Rndr: Renderer,
 {
     type State = RenderEffect<ErrorBoundaryViewState<Chil::State, Fal::State>>;
 
@@ -226,21 +219,26 @@ where
     }
 }
 
-impl<Chil, FalFn, Fal> AddAnyAttr for ErrorBoundaryView<Chil, FalFn>
+impl<Chil, FalFn, Fal, Rndr> AddAnyAttr<Rndr>
+    for ErrorBoundaryView<Chil, FalFn, Rndr>
 where
-    Chil: RenderHtml + 'static,
+    Chil: RenderHtml<Rndr> + 'static,
     FalFn: FnMut(ArcRwSignal<Errors>) -> Fal + Send + 'static,
-    Fal: RenderHtml + Send + 'static,
+    Fal: RenderHtml<Rndr> + Send + 'static,
+    Rndr: Renderer,
 {
-    type Output<SomeNewAttr: Attribute> =
-        ErrorBoundaryView<Chil::Output<SomeNewAttr::CloneableOwned>, FalFn>;
+    type Output<SomeNewAttr: Attribute<Rndr>> = ErrorBoundaryView<
+        Chil::Output<SomeNewAttr::CloneableOwned>,
+        FalFn,
+        Rndr,
+    >;
 
-    fn add_any_attr<NewAttr: Attribute>(
+    fn add_any_attr<NewAttr: Attribute<Rndr>>(
         self,
         attr: NewAttr,
     ) -> Self::Output<NewAttr>
     where
-        Self::Output<NewAttr>: RenderHtml,
+        Self::Output<NewAttr>: RenderHtml<Rndr>,
     {
         let ErrorBoundaryView {
             hook,
@@ -249,6 +247,7 @@ where
             children,
             fallback,
             errors,
+            rndr,
         } = self;
         ErrorBoundaryView {
             hook,
@@ -257,17 +256,20 @@ where
             children: children.add_any_attr(attr.into_cloneable_owned()),
             fallback,
             errors,
+            rndr,
         }
     }
 }
 
-impl<Chil, FalFn, Fal> RenderHtml for ErrorBoundaryView<Chil, FalFn>
+impl<Chil, FalFn, Fal, Rndr> RenderHtml<Rndr>
+    for ErrorBoundaryView<Chil, FalFn, Rndr>
 where
-    Chil: RenderHtml + Send + 'static,
+    Chil: RenderHtml<Rndr> + Send + 'static,
     FalFn: FnMut(ArcRwSignal<Errors>) -> Fal + Send + 'static,
-    Fal: RenderHtml + Send + 'static,
+    Fal: RenderHtml<Rndr> + Send + 'static,
+    Rndr: Renderer,
 {
-    type AsyncOutput = ErrorBoundaryView<Chil::AsyncOutput, FalFn>;
+    type AsyncOutput = ErrorBoundaryView<Chil::AsyncOutput, FalFn, Rndr>;
 
     const MIN_LENGTH: usize = Chil::MIN_LENGTH;
 
@@ -292,6 +294,7 @@ where
             children: children.resolve().await,
             fallback,
             errors,
+            rndr: PhantomData,
         }
     }
 
@@ -365,7 +368,7 @@ where
 
     fn hydrate<const FROM_SERVER: bool>(
         mut self,
-        cursor: &Cursor,
+        cursor: &Cursor<Rndr>,
         position: &PositionState,
     ) -> Self::State {
         let mut children = Some(self.children);

leptos/src/for_loop.rs

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

leptos/src/hydration/hydration_script.js

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

leptos/src/hydration/island_script.js

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

leptos/src/into_view.rs

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

leptos/src/lib.rs

@@ -168,12 +168,13 @@ pub mod prelude {
         pub use leptos_server::*;
         pub use oco_ref::*;
         pub use reactive_graph::{
-            actions::*, computed::*, effect::*, graph::untrack, owner::*,
-            signal::*, wrappers::read::*,
+            actions::*, computed::*, effect::*, owner::*, signal::*,
+            wrappers::read::*,
         };
         pub use server_fn::{self, ServerFnError};
         pub use tachys::{
-            reactive_graph::{bind::BindAttribute, node_ref::*, Suspend},
+            self,
+            reactive_graph::{node_ref::*, Suspend},
             view::template::ViewTemplate,
         };
     }
@@ -200,11 +201,10 @@ pub mod error {
     pub use throw_error::*;
 }
 
-/// Control-flow components like `<Show>`, `<For>`, and `<Await>`.
+/// Control-flow components like `<Show>` and `<For>`.
 pub mod control_flow {
-    pub use crate::{await_::*, for_loop::*, show::*};
+    pub use crate::{for_loop::*, show::*};
 }
-mod await_;
 mod for_loop;
 mod show;
 
@@ -230,7 +230,6 @@ mod suspense_component;
 pub mod text_prop;
 mod transition;
 pub use leptos_macro::*;
-#[doc(inline)]
 pub use server_fn;
 #[doc(hidden)]
 pub use typed_builder;
@@ -238,22 +237,16 @@ pub use typed_builder;
 pub use typed_builder_macro;
 mod into_view;
 pub use into_view::IntoView;
-#[doc(inline)]
 pub use leptos_dom;
 mod provider;
-#[doc(inline)]
 pub use tachys;
 /// Tools to mount an application to the DOM, or to hydrate it from server-rendered HTML.
 pub mod mount;
-#[doc(inline)]
 pub use leptos_config as config;
-#[doc(inline)]
 pub use oco_ref as oco;
 mod from_form_data;
-#[doc(inline)]
 pub use either_of as either;
-#[doc(inline)]
-pub use reactive_graph as reactive;
+pub use reactive_graph;
 
 /// Provide and access data along the reactive graph, sharing data without directly passing arguments.
 pub mod context {
@@ -261,22 +254,17 @@ pub mod context {
     pub use reactive_graph::owner::{provide_context, use_context};
 }
 
-#[doc(inline)]
 pub use leptos_server as server;
 /// HTML attribute types.
-#[doc(inline)]
 pub use tachys::html::attribute as attr;
 /// HTML element types.
-#[doc(inline)]
 pub use tachys::html::element as html;
 /// HTML event types.
 #[doc(no_inline)]
 pub use tachys::html::event as ev;
 /// MathML element types.
-#[doc(inline)]
 pub use tachys::mathml as math;
 /// SVG element types.
-#[doc(inline)]
 pub use tachys::svg;
 
 /// Utilities for simple isomorphic logging to the console or terminal.
@@ -284,7 +272,7 @@ pub mod logging {
     pub use leptos_dom::{debug_warn, error, log, warn};
 }
 
-pub mod task {
+pub mod spawn {
     pub use any_spawner::Executor;
     use std::future::Future;
 
@@ -302,14 +290,9 @@ pub mod task {
         Executor::spawn_local(fut)
     }
 
-    /// Waits until the next "tick" of the current async executor.
     pub async fn tick() {
         Executor::tick().await
     }
-
-    pub use reactive_graph::{
-        spawn_local_scoped, spawn_local_scoped_with_cancellation,
-    };
 }
 
 // these reexports are used in islands
@@ -329,6 +312,7 @@ pub use web_sys;
 
 /*mod additional_attributes;
 pub use additional_attributes::*;
+mod await_;
 pub use await_::*;
 pub use leptos_config::{self, get_configuration, LeptosOptions};
 #[cfg(not(all(

leptos/src/mount.rs

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

leptos/src/nonce.rs

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

leptos/src/portal.rs

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

leptos/src/provider.rs

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

leptos/src/suspense_component.rs

@@ -13,7 +13,7 @@ use reactive_graph::{
     effect::RenderEffect,
     owner::{provide_context, use_context, Owner},
     signal::ArcRwSignal,
-    traits::{Dispose, Get, Read, Track, With},
+    traits::{Get, Read, Track, With},
 };
 use slotmap::{DefaultKey, SlotMap};
 use tachys::{
@@ -21,6 +21,7 @@ use tachys::{
     html::attribute::Attribute,
     hydration::Cursor,
     reactive_graph::{OwnedView, OwnedViewState},
+    renderer::Renderer,
     ssr::StreamBuilder,
     view::{
         add_attr::AddAnyAttr,
@@ -134,14 +135,15 @@ pub(crate) struct SuspenseBoundary<const TRANSITION: bool, Fal, Chil> {
     pub children: Chil,
 }
 
-impl<const TRANSITION: bool, Fal, Chil> Render
+impl<const TRANSITION: bool, Fal, Chil, Rndr> Render<Rndr>
     for SuspenseBoundary<TRANSITION, Fal, Chil>
 where
-    Fal: Render + Send + 'static,
-    Chil: Render + Send + 'static,
+    Fal: Render<Rndr> + Send + 'static,
+    Chil: Render<Rndr> + Send + 'static,
+    Rndr: Renderer + 'static,
 {
     type State = RenderEffect<
-        OwnedViewState<EitherKeepAliveState<Chil::State, Fal::State>>,
+        OwnedViewState<EitherKeepAliveState<Chil::State, Fal::State>, Rndr>,
     >;
 
     fn build(self) -> Self::State {
@@ -185,24 +187,25 @@ where
     }
 }
 
-impl<const TRANSITION: bool, Fal, Chil> AddAnyAttr
+impl<const TRANSITION: bool, Fal, Chil, Rndr> AddAnyAttr<Rndr>
     for SuspenseBoundary<TRANSITION, Fal, Chil>
 where
-    Fal: RenderHtml + Send + 'static,
-    Chil: RenderHtml + Send + 'static,
+    Fal: RenderHtml<Rndr> + Send + 'static,
+    Chil: RenderHtml<Rndr> + Send + 'static,
+    Rndr: Renderer + 'static,
 {
-    type Output<SomeNewAttr: Attribute> = SuspenseBoundary<
+    type Output<SomeNewAttr: Attribute<Rndr>> = SuspenseBoundary<
         TRANSITION,
         Fal,
         Chil::Output<SomeNewAttr::CloneableOwned>,
     >;
 
-    fn add_any_attr<NewAttr: Attribute>(
+    fn add_any_attr<NewAttr: Attribute<Rndr>>(
         self,
         attr: NewAttr,
     ) -> Self::Output<NewAttr>
     where
-        Self::Output<NewAttr>: RenderHtml,
+        Self::Output<NewAttr>: RenderHtml<Rndr>,
     {
         let attr = attr.into_cloneable_owned();
         let SuspenseBoundary {
@@ -220,11 +223,12 @@ where
     }
 }
 
-impl<const TRANSITION: bool, Fal, Chil> RenderHtml
+impl<const TRANSITION: bool, Fal, Chil, Rndr> RenderHtml<Rndr>
     for SuspenseBoundary<TRANSITION, Fal, Chil>
 where
-    Fal: RenderHtml + Send + 'static,
-    Chil: RenderHtml + Send + 'static,
+    Fal: RenderHtml<Rndr> + Send + 'static,
+    Chil: RenderHtml<Rndr> + Send + 'static,
+    Rndr: Renderer + 'static,
 {
     // i.e., if this is the child of another Suspense during SSR, don't wait for it: it will handle
     // itself
@@ -282,7 +286,7 @@ where
         self.children.dry_resolve();
 
         // check the set of tasks to see if it is empty, now or later
-        let eff = reactive_graph::effect::Effect::new_isomorphic({
+        let eff = reactive_graph::effect::RenderEffect::new_isomorphic({
             move |_| {
                 tasks.track();
                 if tasks.read().is_empty() {
@@ -334,7 +338,7 @@ where
                             }
                             children = children => {
                                 // clean up the (now useless) effect
-                                eff.dispose();
+                                drop(eff);
 
                                 Some(OwnedView::new_with_owner(children, owner))
                             }
@@ -401,7 +405,7 @@ where
 
     fn hydrate<const FROM_SERVER: bool>(
         self,
-        cursor: &Cursor,
+        cursor: &Cursor<Rndr>,
         position: &PositionState,
     ) -> Self::State {
         let cursor = cursor.to_owned();
@@ -451,9 +455,10 @@ impl<T> Unsuspend<T> {
     }
 }
 
-impl<T> Render for Unsuspend<T>
+impl<T, Rndr> Render<Rndr> for Unsuspend<T>
 where
-    T: Render,
+    T: Render<Rndr>,
+    Rndr: Renderer,
 {
     type State = T::State;
 
@@ -466,28 +471,30 @@ where
     }
 }
 
-impl<T> AddAnyAttr for Unsuspend<T>
+impl<T, Rndr> AddAnyAttr<Rndr> for Unsuspend<T>
 where
-    T: AddAnyAttr + 'static,
+    T: AddAnyAttr<Rndr> + 'static,
+    Rndr: Renderer,
 {
-    type Output<SomeNewAttr: Attribute> =
+    type Output<SomeNewAttr: Attribute<Rndr>> =
         Unsuspend<T::Output<SomeNewAttr::CloneableOwned>>;
 
-    fn add_any_attr<NewAttr: Attribute>(
+    fn add_any_attr<NewAttr: Attribute<Rndr>>(
         self,
         attr: NewAttr,
     ) -> Self::Output<NewAttr>
     where
-        Self::Output<NewAttr>: RenderHtml,
+        Self::Output<NewAttr>: RenderHtml<Rndr>,
     {
         let attr = attr.into_cloneable_owned();
         Unsuspend::new(move || (self.0)().add_any_attr(attr))
     }
 }
 
-impl<T> RenderHtml for Unsuspend<T>
+impl<T, Rndr> RenderHtml<Rndr> for Unsuspend<T>
 where
-    T: RenderHtml + 'static,
+    T: RenderHtml<Rndr> + 'static,
+    Rndr: Renderer,
 {
     type AsyncOutput = Self;
 
@@ -528,7 +535,7 @@ where
 
     fn hydrate<const FROM_SERVER: bool>(
         self,
-        cursor: &Cursor,
+        cursor: &Cursor<Rndr>,
         position: &PositionState,
     ) -> Self::State {
         (self.0)().hydrate::<FROM_SERVER>(cursor, position)

leptos/tests/ssr.rs

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

leptos_dom/src/helpers.rs

@@ -396,7 +396,8 @@ impl IntervalHandle {
     }
 }
 
-/// Repeatedly calls the given function, with a delay of the given duration between calls.
+/// Repeatedly calls the given function, with a delay of the given duration between calls,
+/// returning a cancelable handle.
 /// See [`setInterval()`](https://developer.mozilla.org/en-US/docs/Web/API/setInterval).
 #[cfg_attr(
   feature = "tracing",

leptos_macro/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "leptos_macro"
-version = "0.7.0-gamma"
+version = "0.7.0-beta4"
 authors = ["Greg Johnston"]
 license = "MIT"
 repository = "https://github.com/leptos-rs/leptos"
@@ -51,15 +51,7 @@ axum = ["server_fn_macro/axum"]
 
 [package.metadata.cargo-all-features]
 denylist = ["nightly", "tracing", "trace-component-props"]
-skip_feature_sets = [
-	["csr", "hydrate"],
-	["hydrate", "csr"],
-	["hydrate", "ssr"],
-	["actix", "axum"]
-]
+skip_feature_sets = [["csr", "hydrate"], ["hydrate", "csr"], ["hydrate", "ssr"]]
 
 [package.metadata.docs.rs]
 rustdoc-args = ["--generate-link-to-definition"]
-
-[lints.rust]
-unexpected_cfgs = { level = "warn", check-cfg = ['cfg(erase_components)'] }

leptos_macro/src/component.rs

@@ -18,8 +18,7 @@ use syn::{
 };
 
 pub struct Model {
-    is_transparent: bool,
-    island: Option<String>,
+    is_island: bool,
     docs: Docs,
     unknown_attrs: UnknownAttrs,
     vis: Visibility,
@@ -63,8 +62,7 @@ impl Parse for Model {
         });
 
         Ok(Self {
-            is_transparent: false,
-            island: None,
+            is_island: false,
             docs,
             unknown_attrs,
             vis: item.vis.clone(),
@@ -104,8 +102,7 @@ pub fn convert_from_snake_case(name: &Ident) -> Ident {
 impl ToTokens for Model {
     fn to_tokens(&self, tokens: &mut TokenStream) {
         let Self {
-            is_transparent,
-            island,
+            is_island,
             docs,
             unknown_attrs,
             vis,
@@ -114,27 +111,24 @@ impl ToTokens for Model {
             body,
             ret,
         } = self;
-        let is_island = island.is_some();
 
         let no_props = props.is_empty();
 
         // check for components that end ;
-        if !is_transparent {
-            let ends_semi =
-                body.block.stmts.iter().last().and_then(|stmt| match stmt {
-                    Stmt::Item(Item::Macro(mac)) => mac.semi_token.as_ref(),
-                    _ => None,
-                });
-            if let Some(semi) = ends_semi {
-                proc_macro_error2::emit_error!(
-                    semi.span(),
-                    "A component that ends with a `view!` macro followed by a \
-                     semicolon will return (), an empty view. This is usually \
-                     an accident, not intentional, so we prevent it. If you’d \
-                     like to return (), you can do it it explicitly by \
-                     returning () as the last item from the component."
-                );
-            }
+        let ends_semi =
+            body.block.stmts.iter().last().and_then(|stmt| match stmt {
+                Stmt::Item(Item::Macro(mac)) => mac.semi_token.as_ref(),
+                _ => None,
+            });
+        if let Some(semi) = ends_semi {
+            proc_macro_error2::emit_error!(
+                semi.span(),
+                "A component that ends with a `view!` macro followed by a \
+                 semicolon will return (), an empty view. This is usually an \
+                 accident, not intentional, so we prevent it. If you’d like \
+                 to return (), you can do it it explicitly by returning () as \
+                 the last item from the component."
+            );
         }
 
         //body.sig.ident = format_ident!("__{}", body.sig.ident);
@@ -152,9 +146,9 @@ impl ToTokens for Model {
         #[cfg(feature = "tracing")]
         let trace_name = format!("<{name} />");
 
-        let is_island_with_children =
-            is_island && props.iter().any(|prop| prop.name.ident == "children");
-        let is_island_with_other_props = is_island
+        let is_island_with_children = *is_island
+            && props.iter().any(|prop| prop.name.ident == "children");
+        let is_island_with_other_props = *is_island
             && ((is_island_with_children && props.len() > 1)
                 || (!is_island_with_children && !props.is_empty()));
 
@@ -210,11 +204,11 @@ impl ToTokens for Model {
                         )]
                     },
                     quote! {
-                        let __span = ::leptos::tracing::Span::current();
+                        let span = ::leptos::tracing::Span::current();
                     },
                     quote! {
                         #[cfg(debug_assertions)]
-                        let _guard = __span.entered();
+                        let _guard = span.entered();
                     },
                     if no_props || !cfg!(feature = "trace-component-props") {
                         quote!()
@@ -236,8 +230,9 @@ impl ToTokens for Model {
         let hydrate_fn_name = is_island.then(|| {
             use std::hash::{Hash, Hasher};
 
+            let span = format!("{:?}", name.span());
             let mut hasher = DefaultHasher::new();
-            island.hash(&mut hasher);
+            span.hash(&mut hasher);
             let caller = hasher.finish() as usize;
             Ident::new(&format!("{component_id}_{caller:?}"), name.span())
         });
@@ -258,9 +253,9 @@ impl ToTokens for Model {
         };
 
         let body_name = unmodified_fn_name_from_fn_name(&body_name);
-        let body_expr = if is_island {
+        let body_expr = if *is_island {
             quote! {
-                ::leptos::reactive::owner::Owner::with_hydration(move || {
+                ::leptos::reactive_graph::owner::Owner::with_hydration(move || {
                     #body_name(#prop_names)
                 })
             }
@@ -270,38 +265,22 @@ impl ToTokens for Model {
             }
         };
 
-        let component = if *is_transparent {
-            body_expr
-        } else if cfg!(erase_components) {
-            quote! {
-                ::leptos::prelude::IntoAny::into_any(
-                    ::leptos::prelude::untrack(
-                        move || {
-                            #tracing_guard_expr
-                            #tracing_props_expr
-                            #body_expr
-                        }
-                    )
-                )
-            }
-        } else {
-            quote! {
-                ::leptos::prelude::untrack(
-                    move || {
-                        #tracing_guard_expr
-                        #tracing_props_expr
-                        #body_expr
-                    }
-                )
-            }
+        let component = quote! {
+            ::leptos::reactive_graph::untrack(
+                move || {
+                    #tracing_guard_expr
+                    #tracing_props_expr
+                    #body_expr
+                }
+            )
         };
 
         // add island wrapper if island
-        let component = if is_island {
+        let component = if *is_island {
             let hydrate_fn_name = hydrate_fn_name.as_ref().unwrap();
             quote! {
                 {
-                    if ::leptos::reactive::owner::Owner::current_shared_context()
+                    if ::leptos::reactive_graph::owner::Owner::current_shared_context()
                         .map(|sc| sc.get_is_hydrating())
                         .unwrap_or(false) {
                         ::leptos::either::Either::Left(
@@ -337,9 +316,9 @@ impl ToTokens for Model {
                 quote! {
                     use leptos::tachys::view::any_view::IntoAny;
                     let children = Box::new(|| {
-                        let sc = ::leptos::reactive::owner::Owner::current_shared_context().unwrap();
+                        let sc = ::leptos::reactive_graph::owner::Owner::current_shared_context().unwrap();
                         let prev = sc.get_is_hydrating();
-                        let value = ::leptos::reactive::owner::Owner::with_no_hydration(||
+                        let value = ::leptos::reactive_graph::owner::Owner::with_no_hydration(||
                             ::leptos::tachys::html::islands::IslandChildren::new(children()).into_any()
                         );
                         sc.set_is_hydrating(prev);
@@ -364,64 +343,45 @@ impl ToTokens for Model {
             #component
         };
 
-        let binding = if is_island {
+        let binding = if *is_island {
             let island_props = if is_island_with_children
                 || is_island_with_other_props
             {
-                let (destructure, prop_builders, optional_props) =
-                    if is_island_with_other_props {
-                        let prop_names = props
-                            .iter()
-                            .filter_map(|prop| {
-                                if prop.name.ident == "children" {
-                                    None
-                                } else {
-                                    let name = &prop.name.ident;
-                                    Some(quote! { #name, })
-                                }
-                            })
-                            .collect::<TokenStream>();
-                        let destructure = quote! {
-                            let #props_serialized_name {
-                                #prop_names
-                            } = props;
-                        };
-                        let prop_builders = props
-                            .iter()
-                            .filter_map(|prop| {
-                                if prop.name.ident == "children"
-                                    || prop.prop_opts.optional
-                                {
-                                    None
-                                } else {
-                                    let name = &prop.name.ident;
-                                    Some(quote! {
-                                        .#name(#name)
-                                    })
-                                }
-                            })
-                            .collect::<TokenStream>();
-                        let optional_props = props
-                            .iter()
-                            .filter_map(|prop| {
-                                if prop.name.ident == "children"
-                                    || !prop.prop_opts.optional
-                                {
-                                    None
-                                } else {
-                                    let name = &prop.name.ident;
-                                    Some(quote! {
-                                        if let Some(#name) = #name {
-                                            props.#name = Some(#name)
-                                        }
-                                    })
-                                }
-                            })
-                            .collect::<TokenStream>();
-                        (destructure, prop_builders, optional_props)
-                    } else {
-                        (quote! {}, quote! {}, quote! {})
+                let (destructure, prop_builders) = if is_island_with_other_props
+                {
+                    let prop_names = props
+                        .iter()
+                        .filter_map(|prop| {
+                            if prop.name.ident == "children" {
+                                None
+                            } else {
+                                let name = &prop.name.ident;
+                                Some(quote! { #name, })
+                            }
+                        })
+                        .collect::<TokenStream>();
+                    let destructure = quote! {
+                        let #props_serialized_name {
+                            #prop_names
+                        } = props;
                     };
+                    let prop_builders = props
+                        .iter()
+                        .filter_map(|prop| {
+                            if prop.name.ident == "children" {
+                                None
+                            } else {
+                                let name = &prop.name.ident;
+                                Some(quote! {
+                                    .#name(#name)
+                                })
+                            }
+                        })
+                        .collect::<TokenStream>();
+                    (destructure, prop_builders)
+                } else {
+                    (quote! {}, quote! {})
+                };
                 let children = if is_island_with_children {
                     quote! {
                         .children({Box::new(|| {
@@ -445,14 +405,10 @@ impl ToTokens for Model {
 
                 quote! {{
                     #destructure
-                    let mut props = #props_name::builder()
+                    #props_name::builder()
                         #prop_builders
                         #children
-                        .build();
-
-                    #optional_props
-
-                    props
+                        .build()
                 }}
             } else {
                 quote! {}
@@ -542,15 +498,8 @@ impl ToTokens for Model {
 
 impl Model {
     #[allow(clippy::wrong_self_convention)]
-    pub fn is_transparent(mut self, is_transparent: bool) -> Self {
-        self.is_transparent = is_transparent;
-
-        self
-    }
-
-    #[allow(clippy::wrong_self_convention)]
-    pub fn with_island(mut self, island: Option<String>) -> Self {
-        self.island = island;
+    pub fn is_island(mut self, is_island: bool) -> Self {
+        self.is_island = is_island;
 
         self
     }

leptos_macro/src/lib.rs

@@ -266,21 +266,6 @@ mod slot;
 #[proc_macro]
 #[cfg_attr(feature = "tracing", tracing::instrument(level = "trace", skip_all))]
 pub fn view(tokens: TokenStream) -> TokenStream {
-    view_macro_impl(tokens, false)
-}
-
-/// The `template` macro behaves like [`view`], except that it wraps the entire tree in a
-/// [`ViewTemplate`](leptos::prelude::ViewTemplate). This optimizes creation speed by rendering
-/// most of the view into a `<template>` tag with HTML rendered at compile time, then hydrating it.
-/// In exchange, there is a small binary size overhead.
-#[proc_macro_error2::proc_macro_error]
-#[proc_macro]
-#[cfg_attr(feature = "tracing", tracing::instrument(level = "trace", skip_all))]
-pub fn template(tokens: TokenStream) -> TokenStream {
-    view_macro_impl(tokens, true)
-}
-
-fn view_macro_impl(tokens: TokenStream, template: bool) -> TokenStream {
     let tokens: proc_macro2::TokenStream = tokens.into();
     let mut tokens = tokens.into_iter();
 
@@ -317,19 +302,18 @@ fn view_macro_impl(tokens: TokenStream, template: bool) -> TokenStream {
     };
     let config = rstml::ParserConfig::default().recover_block(true);
     let parser = rstml::Parser::new(config);
-    let (mut nodes, errors) = parser.parse_recoverable(tokens).split_vec();
+    let (nodes, errors) = parser.parse_recoverable(tokens).split_vec();
     let errors = errors.into_iter().map(|e| e.emit_as_expr_tokens());
     let nodes_output = view::render_view(
-        &mut nodes,
+        &nodes,
         global_class.as_ref(),
         normalized_call_site(proc_macro::Span::call_site()),
-        template,
     );
 
     // The allow lint needs to be put here instead of at the expansion of
     // view::attribute_value(). Adding this next to the expanded expression
     // seems to break rust-analyzer, but it works when the allow is put here.
-    let output = quote! {
+    quote! {
         {
             #[allow(unused_braces)]
             {
@@ -337,14 +321,6 @@ fn view_macro_impl(tokens: TokenStream, template: bool) -> TokenStream {
                 #nodes_output
             }
         }
-    };
-
-    if template {
-        quote! {
-            ::leptos::prelude::ViewTemplate::new(#output)
-        }
-    } else {
-        output
     }
     .into()
 }
@@ -535,24 +511,11 @@ pub fn include_view(tokens: TokenStream) -> TokenStream {
 /// ```
 #[proc_macro_error2::proc_macro_error]
 #[proc_macro_attribute]
-pub fn component(args: proc_macro::TokenStream, s: TokenStream) -> TokenStream {
-    let is_transparent = if !args.is_empty() {
-        let transparent = parse_macro_input!(args as syn::Ident);
-
-        if transparent != "transparent" {
-            abort!(
-                transparent,
-                "only `transparent` is supported";
-                help = "try `#[component(transparent)]` or `#[component]`"
-            );
-        }
-
-        true
-    } else {
-        false
-    };
-
-    component_macro(s, is_transparent, None)
+pub fn component(
+    _args: proc_macro::TokenStream,
+    s: TokenStream,
+) -> TokenStream {
+    component_macro(s, false)
 }
 
 /// Defines a component as an interactive island when you are using the
@@ -628,37 +591,16 @@ pub fn component(args: proc_macro::TokenStream, s: TokenStream) -> TokenStream {
 /// ```
 #[proc_macro_error2::proc_macro_error]
 #[proc_macro_attribute]
-pub fn island(args: proc_macro::TokenStream, s: TokenStream) -> TokenStream {
-    let is_transparent = if !args.is_empty() {
-        let transparent = parse_macro_input!(args as syn::Ident);
-
-        if transparent != "transparent" {
-            abort!(
-                transparent,
-                "only `transparent` is supported";
-                help = "try `#[component(transparent)]` or `#[component]`"
-            );
-        }
-
-        true
-    } else {
-        false
-    };
-
-    let island_src = s.to_string();
-    component_macro(s, is_transparent, Some(island_src))
+pub fn island(_args: proc_macro::TokenStream, s: TokenStream) -> TokenStream {
+    component_macro(s, true)
 }
 
-fn component_macro(
-    s: TokenStream,
-    is_transparent: bool,
-    island: Option<String>,
-) -> TokenStream {
+fn component_macro(s: TokenStream, island: bool) -> TokenStream {
     let mut dummy = syn::parse::<DummyModel>(s.clone());
     let parse_result = syn::parse::<component::Model>(s);
 
     if let (Ok(ref mut unexpanded), Ok(model)) = (&mut dummy, parse_result) {
-        let expanded = model.is_transparent(is_transparent).with_island(island).into_token_stream();
+        let expanded = model.is_island(island).into_token_stream();
         if !matches!(unexpanded.vis, Visibility::Public(_)) {
             unexpanded.vis = Visibility::Public(Pub {
                 span: unexpanded.vis.span(),

leptos_macro/src/memo.rs

@@ -40,9 +40,9 @@ impl ToTokens for MemoMacroInput {
         let path = &self.path;
 
         tokens.extend(quote! {
-            ::leptos::reactive::computed::Memo::new(
+            ::leptos::reactive_graph::computed::Memo::new(
                 move |_| {
-                    use ::leptos::reactive::traits::With;
+                    use ::leptos::reactive_graph::traits::With;
                     #root.with(|st: _| st.#path.clone())
                 }
             )

leptos_macro/src/slice.rs

@@ -40,7 +40,7 @@ impl ToTokens for SliceMacroInput {
         let path = &self.path;
 
         tokens.extend(quote! {
-            ::leptos::reactive::computed::create_slice(
+            ::leptos::reactive_graph::computed::create_slice(
                 #root,
                 |st: &_| st.#path.clone(),
                 |st: &mut _, n| st.#path = n

leptos_macro/src/view/component_builder.rs

@@ -1,5 +1,5 @@
 use super::{fragment_to_tokens, TagType};
-use crate::view::{attribute_absolute, utils::filter_prefixed_attrs};
+use crate::view::attribute_absolute;
 use proc_macro2::{Ident, TokenStream, TokenTree};
 use quote::{format_ident, quote, quote_spanned};
 use rstml::node::{
@@ -10,10 +10,11 @@ use std::collections::HashMap;
 use syn::{spanned::Spanned, Expr, ExprPath, ExprRange, RangeLimits, Stmt};
 
 pub(crate) fn component_to_tokens(
-    node: &mut NodeElement<impl CustomNode>,
+    node: &NodeElement<impl CustomNode>,
     global_class: Option<&TokenTree>,
-    disable_inert_html: bool,
 ) -> TokenStream {
+    let name = node.name();
+
     #[allow(unused)] // TODO this is used by hot-reloading
     #[cfg(debug_assertions)]
     let component_name = super::ident_from_tag_name(node.name());
@@ -44,21 +45,16 @@ pub(crate) fn component_to_tokens(
         })
         .unwrap_or_else(|| node.attributes().len());
 
-    let attrs = node
-        .attributes()
-        .iter()
-        .filter_map(|node| {
-            if let NodeAttribute::Attribute(node) = node {
-                Some(node)
-            } else {
-                None
-            }
-        })
-        .cloned()
-        .collect::<Vec<_>>();
+    let attrs = node.attributes().iter().filter_map(|node| {
+        if let NodeAttribute::Attribute(node) = node {
+            Some(node)
+        } else {
+            None
+        }
+    });
 
     let props = attrs
-        .iter()
+        .clone()
         .enumerate()
         .filter(|(idx, attr)| {
             idx < &spread_marker && {
@@ -89,7 +85,7 @@ pub(crate) fn component_to_tokens(
         });
 
     let items_to_bind = attrs
-        .iter()
+        .clone()
         .filter_map(|attr| {
             if !is_attr_let(&attr.key) {
                 return None;
@@ -105,13 +101,20 @@ pub(crate) fn component_to_tokens(
                     return None;
                 }
             };
-
             let inputs = &binding.inputs;
             Some(quote! { #inputs })
         })
         .collect::<Vec<_>>();
 
-    let items_to_clone = filter_prefixed_attrs(attrs.iter(), "clone:");
+    let items_to_clone = attrs
+        .clone()
+        .filter_map(|attr| {
+            attr.key
+                .to_string()
+                .strip_prefix("clone:")
+                .map(|ident| format_ident!("{ident}", span = attr.key.span()))
+        })
+        .collect::<Vec<_>>();
 
     // include all attribute that are either
     // 1) blocks ({..attrs} or {attrs}),
@@ -180,12 +183,11 @@ pub(crate) fn component_to_tokens(
         quote! {}
     } else {
         let children = fragment_to_tokens(
-            &mut node.children,
+            &node.children,
             TagType::Unknown,
             Some(&mut slots),
             global_class,
             None,
-            disable_inert_html,
         );
 
         // TODO view marker for hot-reloading
@@ -259,7 +261,6 @@ pub(crate) fn component_to_tokens(
         quote! {}
     };
 
-    let name = node.name();
     #[allow(unused_mut)] // used in debug
     let mut component = quote! {
         {

leptos_macro/src/view/mod.rs

@@ -1,27 +1,19 @@
 mod component_builder;
 mod slot_helper;
-mod utils;
-
 use self::{
     component_builder::component_to_tokens,
     slot_helper::{get_slot, slot_to_tokens},
 };
-use convert_case::{
-    Case::{Snake, UpperCamel},
-    Casing,
-};
+use convert_case::{Case::Snake, Casing};
 use leptos_hot_reload::parsing::{is_component_node, value_to_string};
 use proc_macro2::{Ident, Span, TokenStream, TokenTree};
 use proc_macro_error2::abort;
-use quote::{format_ident, quote, quote_spanned, ToTokens};
+use quote::{quote, quote_spanned, ToTokens};
 use rstml::node::{
     CustomNode, KVAttributeValue, KeyedAttribute, Node, NodeAttribute,
     NodeBlock, NodeElement, NodeName, NodeNameFragment,
 };
-use std::{
-    cmp::Ordering,
-    collections::{HashMap, HashSet, VecDeque},
-};
+use std::collections::{HashMap, HashSet};
 use syn::{
     spanned::Spanned, Expr, Expr::Tuple, ExprLit, ExprRange, Lit, LitStr,
     RangeLimits, Stmt,
@@ -36,10 +28,9 @@ pub(crate) enum TagType {
 }
 
 pub fn render_view(
-    nodes: &mut [Node],
+    nodes: &[Node],
     global_class: Option<&TokenTree>,
     view_marker: Option<String>,
-    disable_inert_html: bool,
 ) -> Option<TokenStream> {
     let (base, should_add_view) = match nodes.len() {
         0 => {
@@ -53,13 +44,11 @@ pub fn render_view(
         }
         1 => (
             node_to_tokens(
-                &mut nodes[0],
+                &nodes[0],
                 TagType::Unknown,
                 None,
                 global_class,
                 view_marker.as_deref(),
-                true,
-                disable_inert_html,
             ),
             // only add View wrapper and view marker to a regular HTML
             // element or component, not to a <{..} /> attribute list
@@ -75,7 +64,6 @@ pub fn render_view(
                 None,
                 global_class,
                 view_marker.as_deref(),
-                disable_inert_html,
             ),
             true,
         ),
@@ -100,306 +88,12 @@ pub fn render_view(
     })
 }
 
-fn is_inert_element(orig_node: &Node<impl CustomNode>) -> bool {
-    // do not use this if the top-level node is not an Element,
-    // or if it's an element with no children and no attrs
-    match orig_node {
-        Node::Element(el) => {
-            if el.attributes().is_empty() && el.children.is_empty() {
-                return false;
-            }
-
-            // also doesn't work if the top-level element is an SVG/MathML element
-            let el_name = el.name().to_string();
-            if is_svg_element(&el_name) || is_math_ml_element(&el_name) {
-                return false;
-            }
-        }
-        _ => return false,
-    }
-
-    // otherwise, walk over all the nodes to make sure everything is inert
-    let mut nodes = VecDeque::from([orig_node]);
-
-    while let Some(current_element) = nodes.pop_front() {
-        match current_element {
-            Node::Text(_) | Node::RawText(_) => {}
-            Node::Element(node) => {
-                if is_component_node(node) {
-                    return false;
-                }
-                if is_spread_marker(node) {
-                    return false;
-                }
-
-                match node.name() {
-                    NodeName::Block(_) => return false,
-                    _ => {
-                        // check all attributes
-                        for attr in node.attributes() {
-                            match attr {
-                                NodeAttribute::Block(_) => return false,
-                                NodeAttribute::Attribute(attr) => {
-                                    let static_key =
-                                        !matches!(attr.key, NodeName::Block(_));
-
-                                    let static_value = match attr
-                                        .possible_value
-                                        .to_value()
-                                    {
-                                        None => true,
-                                        Some(value) => {
-                                            matches!(&value.value, KVAttributeValue::Expr(expr) if {
-                                                if let Expr::Lit(lit) = expr {
-                                                    matches!(&lit.lit, Lit::Str(_))
-                                                } else {
-                                                    false
-                                                }
-                                            })
-                                        }
-                                    };
-
-                                    if !static_key || !static_value {
-                                        return false;
-                                    }
-                                }
-                            }
-                        }
-
-                        // check all children
-                        nodes.extend(&node.children);
-                    }
-                }
-            }
-            _ => return false,
-        }
-    }
-
-    true
-}
-
-enum Item<'a, T> {
-    Node(&'a Node<T>, bool),
-    ClosingTag(String),
-}
-
-enum InertElementBuilder<'a> {
-    GlobalClass {
-        global_class: &'a TokenTree,
-        strs: Vec<GlobalClassItem<'a>>,
-        buffer: String,
-    },
-    NoGlobalClass {
-        buffer: String,
-    },
-}
-
-impl<'a> ToTokens for InertElementBuilder<'a> {
-    fn to_tokens(&self, tokens: &mut TokenStream) {
-        match self {
-            InertElementBuilder::GlobalClass { strs, .. } => {
-                tokens.extend(quote! {
-                    [#(#strs),*].join("")
-                });
-            }
-            InertElementBuilder::NoGlobalClass { buffer } => {
-                tokens.extend(quote! {
-                    #buffer
-                })
-            }
-        }
-    }
-}
-
-enum GlobalClassItem<'a> {
-    Global(&'a TokenTree),
-    String(String),
-}
-
-impl<'a> ToTokens for GlobalClassItem<'a> {
-    fn to_tokens(&self, tokens: &mut TokenStream) {
-        let addl_tokens = match self {
-            GlobalClassItem::Global(v) => v.to_token_stream(),
-            GlobalClassItem::String(v) => v.to_token_stream(),
-        };
-        tokens.extend(addl_tokens);
-    }
-}
-
-impl<'a> InertElementBuilder<'a> {
-    fn new(global_class: Option<&'a TokenTree>) -> Self {
-        match global_class {
-            None => Self::NoGlobalClass {
-                buffer: String::new(),
-            },
-            Some(global_class) => Self::GlobalClass {
-                global_class,
-                strs: Vec::new(),
-                buffer: String::new(),
-            },
-        }
-    }
-
-    fn push(&mut self, c: char) {
-        match self {
-            InertElementBuilder::GlobalClass { buffer, .. } => buffer.push(c),
-            InertElementBuilder::NoGlobalClass { buffer } => buffer.push(c),
-        }
-    }
-
-    fn push_str(&mut self, s: &str) {
-        match self {
-            InertElementBuilder::GlobalClass { buffer, .. } => {
-                buffer.push_str(s)
-            }
-            InertElementBuilder::NoGlobalClass { buffer } => buffer.push_str(s),
-        }
-    }
-
-    fn push_class(&mut self, class: &str) {
-        match self {
-            InertElementBuilder::GlobalClass {
-                global_class,
-                strs,
-                buffer,
-            } => {
-                buffer.push_str(" class=\"");
-                strs.push(GlobalClassItem::String(std::mem::take(buffer)));
-                strs.push(GlobalClassItem::Global(global_class));
-                buffer.push(' ');
-                buffer.push_str(class);
-                buffer.push('"');
-            }
-            InertElementBuilder::NoGlobalClass { buffer } => {
-                buffer.push_str(" class=\"");
-                buffer.push_str(class);
-                buffer.push('"');
-            }
-        }
-    }
-
-    fn finish(&mut self) {
-        match self {
-            InertElementBuilder::GlobalClass { strs, buffer, .. } => {
-                strs.push(GlobalClassItem::String(std::mem::take(buffer)));
-            }
-            InertElementBuilder::NoGlobalClass { .. } => {}
-        }
-    }
-}
-
-fn inert_element_to_tokens(
-    node: &Node<impl CustomNode>,
-    escape_text: bool,
-    global_class: Option<&TokenTree>,
-) -> Option<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();
-
-    Some(quote! {
-        ::leptos::tachys::html::InertElement::new(#html)
-    })
-}
-
 fn element_children_to_tokens(
-    nodes: &mut [Node<impl CustomNode>],
+    nodes: &[Node<impl CustomNode>],
     parent_type: TagType,
     parent_slots: Option<&mut HashMap<String, Vec<TokenStream>>>,
     global_class: Option<&TokenTree>,
     view_marker: Option<&str>,
-    disable_inert_html: bool,
 ) -> Option<TokenStream> {
     let children = children_to_tokens(
         nodes,
@@ -407,8 +101,6 @@ fn element_children_to_tokens(
         parent_slots,
         global_class,
         view_marker,
-        false,
-        disable_inert_html,
     );
     if children.is_empty() {
         None
@@ -445,12 +137,11 @@ fn element_children_to_tokens(
 }
 
 fn fragment_to_tokens(
-    nodes: &mut [Node<impl CustomNode>],
+    nodes: &[Node<impl CustomNode>],
     parent_type: TagType,
     parent_slots: Option<&mut HashMap<String, Vec<TokenStream>>>,
     global_class: Option<&TokenTree>,
     view_marker: Option<&str>,
-    disable_inert_html: bool,
 ) -> Option<TokenStream> {
     let children = children_to_tokens(
         nodes,
@@ -458,8 +149,6 @@ fn fragment_to_tokens(
         parent_slots,
         global_class,
         view_marker,
-        true,
-        disable_inert_html,
     );
     if children.is_empty() {
         None
@@ -486,23 +175,19 @@ fn fragment_to_tokens(
 }
 
 fn children_to_tokens(
-    nodes: &mut [Node<impl CustomNode>],
+    nodes: &[Node<impl CustomNode>],
     parent_type: TagType,
     parent_slots: Option<&mut HashMap<String, Vec<TokenStream>>>,
     global_class: Option<&TokenTree>,
     view_marker: Option<&str>,
-    top_level: bool,
-    disable_inert_html: bool,
 ) -> Vec<TokenStream> {
     if nodes.len() == 1 {
         match node_to_tokens(
-            &mut nodes[0],
+            &nodes[0],
             parent_type,
             parent_slots,
             global_class,
             view_marker,
-            top_level,
-            disable_inert_html,
         ) {
             Some(tokens) => vec![tokens],
             None => vec![],
@@ -510,7 +195,7 @@ fn children_to_tokens(
     } else {
         let mut slots = HashMap::new();
         let nodes = nodes
-            .iter_mut()
+            .iter()
             .filter_map(|node| {
                 node_to_tokens(
                     node,
@@ -518,8 +203,6 @@ fn children_to_tokens(
                     Some(&mut slots),
                     global_class,
                     view_marker,
-                    top_level,
-                    disable_inert_html,
                 )
             })
             .collect();
@@ -536,16 +219,12 @@ fn children_to_tokens(
 }
 
 fn node_to_tokens(
-    node: &mut Node<impl CustomNode>,
+    node: &Node<impl CustomNode>,
     parent_type: TagType,
     parent_slots: Option<&mut HashMap<String, Vec<TokenStream>>>,
     global_class: Option<&TokenTree>,
     view_marker: Option<&str>,
-    top_level: bool,
-    disable_inert_html: bool,
 ) -> Option<TokenStream> {
-    let is_inert = !disable_inert_html && is_inert_element(node);
-
     match node {
         Node::Comment(_) => None,
         Node::Doctype(node) => {
@@ -553,40 +232,26 @@ fn node_to_tokens(
             Some(quote! { ::leptos::tachys::html::doctype(#value) })
         }
         Node::Fragment(fragment) => fragment_to_tokens(
-            &mut fragment.children,
+            &fragment.children,
             parent_type,
             parent_slots,
             global_class,
             view_marker,
-            disable_inert_html,
         ),
-        Node::Block(block) => {
-            Some(quote! { ::leptos::prelude::IntoRender::into_render(#block) })
-        }
+        Node::Block(block) => Some(quote! { #block }),
         Node::Text(text) => Some(text_to_tokens(&text.value)),
         Node::RawText(raw) => {
             let text = raw.to_string_best();
             let text = syn::LitStr::new(&text, raw.span());
             Some(text_to_tokens(&text))
         }
-        Node::Element(el_node) => {
-            if !top_level && is_inert {
-                let el_name = el_node.name().to_string();
-                let escape = el_name != "script"
-                    && el_name != "style"
-                    && el_name != "textarea";
-                inert_element_to_tokens(node, escape, global_class)
-            } else {
-                element_to_tokens(
-                    el_node,
-                    parent_type,
-                    parent_slots,
-                    global_class,
-                    view_marker,
-                    disable_inert_html,
-                )
-            }
-        }
+        Node::Element(node) => element_to_tokens(
+            node,
+            parent_type,
+            parent_slots,
+            global_class,
+            view_marker,
+        ),
         Node::Custom(node) => Some(node.to_token_stream()),
     }
 }
@@ -605,57 +270,12 @@ fn text_to_tokens(text: &LitStr) -> TokenStream {
 }
 
 pub(crate) fn element_to_tokens(
-    node: &mut NodeElement<impl CustomNode>,
+    node: &NodeElement<impl CustomNode>,
     mut parent_type: TagType,
     parent_slots: Option<&mut HashMap<String, Vec<TokenStream>>>,
     global_class: Option<&TokenTree>,
     view_marker: Option<&str>,
-    disable_inert_html: bool,
 ) -> Option<TokenStream> {
-    // attribute sorting:
-    //
-    // the `class` and `style` attributes overwrite individual `class:` and `style:` attributes
-    // when they are set. as a result, we're going to sort the attributes so that `class` and
-    // `style` always come before all other attributes.
-
-    // if there's a spread marker, we don't want to move `class` or `style` before it
-    // so let's only sort attributes that come *before* a spread marker
-    let spread_position = node
-        .attributes()
-        .iter()
-        .position(|n| match n {
-            NodeAttribute::Block(node) => as_spread_attr(node).is_some(),
-            _ => false,
-        })
-        .unwrap_or_else(|| node.attributes().len());
-
-    // now, sort the attributes
-    node.attributes_mut()[0..spread_position].sort_by(|a, b| {
-        let key_a = match a {
-            NodeAttribute::Attribute(attr) => match &attr.key {
-                NodeName::Path(attr) => {
-                    attr.path.segments.first().map(|n| n.ident.to_string())
-                }
-                _ => None,
-            },
-            _ => None,
-        };
-        let key_b = match b {
-            NodeAttribute::Attribute(attr) => match &attr.key {
-                NodeName::Path(attr) => {
-                    attr.path.segments.first().map(|n| n.ident.to_string())
-                }
-                _ => None,
-            },
-            _ => None,
-        };
-        match (key_a.as_deref(), key_b.as_deref()) {
-            (Some("class"), _) | (Some("style"), _) => Ordering::Less,
-            (_, Some("class")) | (_, Some("style")) => Ordering::Greater,
-            _ => Ordering::Equal,
-        }
-    });
-
     // check for duplicate attribute names and emit an error for all subsequent ones
     let mut names = HashSet::new();
     for attr in node.attributes() {
@@ -679,17 +299,10 @@ pub(crate) fn element_to_tokens(
     let name = node.name();
     if is_component_node(node) {
         if let Some(slot) = get_slot(node) {
-            let slot = slot.clone();
-            slot_to_tokens(
-                node,
-                &slot,
-                parent_slots,
-                global_class,
-                disable_inert_html,
-            );
+            slot_to_tokens(node, slot, parent_slots, global_class);
             None
         } else {
-            Some(component_to_tokens(node, global_class, disable_inert_html))
+            Some(component_to_tokens(node, global_class))
         }
     } else if is_spread_marker(node) {
         let mut attributes = Vec::new();
@@ -743,11 +356,6 @@ pub(crate) fn element_to_tokens(
             quote! { ::leptos::tachys::html::element::#custom(#name) }
         } else if is_svg_element(&tag) {
             parent_type = TagType::Svg;
-            let name = if tag == "use" || tag == "use_" {
-                Ident::new_raw("use", name.span()).to_token_stream()
-            } else {
-                name.to_token_stream()
-            };
             quote! { ::leptos::tachys::svg::#name() }
         } else if is_math_ml_element(&tag) {
             parent_type = TagType::Math;
@@ -806,12 +414,11 @@ pub(crate) fn element_to_tokens(
         let self_closing = is_self_closing(node);
         let children = if !self_closing {
             element_children_to_tokens(
-                &mut node.children,
+                &node.children,
                 parent_type,
                 parent_slots,
                 global_class,
                 view_marker,
-                disable_inert_html,
             )
         } else {
             if !node.children.is_empty() {
@@ -856,25 +463,6 @@ fn is_spread_marker(node: &NodeElement<impl CustomNode>) -> bool {
     }
 }
 
-fn as_spread_attr(node: &NodeBlock) -> Option<Option<&Expr>> {
-    if let NodeBlock::ValidBlock(block) = node {
-        match block.stmts.first() {
-            Some(Stmt::Expr(
-                Expr::Range(ExprRange {
-                    start: None,
-                    limits: RangeLimits::HalfOpen(_),
-                    end,
-                    ..
-                }),
-                _,
-            )) => Some(end.as_deref()),
-            _ => None,
-        }
-    } else {
-        None
-    }
-}
-
 fn attribute_to_tokens(
     tag_type: TagType,
     node: &NodeAttribute,
@@ -882,18 +470,29 @@ fn attribute_to_tokens(
     is_custom: bool,
 ) -> TokenStream {
     match node {
-        NodeAttribute::Block(node) => as_spread_attr(node)
-            .flatten()
-            .map(|end| {
-                quote! {
-                    .add_any_attr(#end)
+        NodeAttribute::Block(node) => {
+            let dotted = if let NodeBlock::ValidBlock(block) = node {
+                match block.stmts.first() {
+                    Some(Stmt::Expr(
+                        Expr::Range(ExprRange {
+                            start: None,
+                            limits: RangeLimits::HalfOpen(_),
+                            end: Some(end),
+                            ..
+                        }),
+                        _,
+                    )) => Some(quote! { .add_any_attr(#end) }),
+                    _ => None,
                 }
-            })
-            .unwrap_or_else(|| {
+            } else {
+                None
+            };
+            dotted.unwrap_or_else(|| {
                 quote! {
                     .add_any_attr(#[allow(unused_braces)] { #node })
                 }
-            }),
+            })
+        }
         NodeAttribute::Attribute(node) => {
             let name = node.key.to_string();
             if name == "node_ref" {
@@ -901,7 +500,7 @@ fn attribute_to_tokens(
                     NodeName::Path(path) => path.path.get_ident(),
                     _ => unreachable!(),
                 };
-                let value = attribute_value(node, false);
+                let value = attribute_value(node);
                 quote! {
                     .#node_ref(#value)
                 }
@@ -909,8 +508,6 @@ fn attribute_to_tokens(
                 directive_call_from_attribute_node(node, name)
             } else if let Some(name) = name.strip_prefix("on:") {
                 event_to_tokens(name, node)
-            } else if let Some(name) = name.strip_prefix("bind:") {
-                two_way_binding_to_tokens(name, node)
             } else if let Some(name) = name.strip_prefix("class:") {
                 let class = match &node.key {
                     NodeName::Punctuated(parts) => &parts[0],
@@ -951,13 +548,13 @@ fn attribute_to_tokens(
                 // we don't provide statically-checked methods for SVG attributes
                 || (tag_type == TagType::Svg && name != "inner_html")
             {
-                let value = attribute_value(node, true);
+                let value = attribute_value(node);
                 quote! {
                     .attr(#name, #value)
                 }
             } else {
                 let key = attribute_name(&node.key);
-                let value = attribute_value(node, true);
+                let value = attribute_value(node);
 
                 // special case of global_class and class attribute
                 if &node.key.to_string() == "class"
@@ -994,11 +591,11 @@ pub(crate) fn attribute_absolute(
                 let id = &parts[0];
                 match id {
                     NodeNameFragment::Ident(id) => {
+                        let value = attribute_value(node);
                         // ignore `let:` and `clone:`
                         if id == "let" || id == "clone" {
                             None
                         } else if id == "attr" {
-                        let value = attribute_value(node, true);
                             let key = &parts[1];
                             let key_name = key.to_string();
                             if key_name == "class" || key_name == "style" {
@@ -1006,7 +603,6 @@ pub(crate) fn attribute_absolute(
                                     quote! { ::leptos::tachys::html::#key::#key(#value) },
                                 )
                             } else if key_name == "aria" {
-                                let value = attribute_value(node, true);
                                 let mut parts_iter = parts.iter();
                                 parts_iter.next();
                                 let fn_name = parts_iter.map(|p| p.to_string()).collect::<Vec<String>>().join("_");
@@ -1035,7 +631,6 @@ pub(crate) fn attribute_absolute(
                                 },
                             )
                         } else if id == "style" || id == "class" {
-                            let value = attribute_value(node, false);
                             let key = &node.key.to_string();
                             let key = key
                                 .replacen("style:", "", 1)
@@ -1044,7 +639,6 @@ pub(crate) fn attribute_absolute(
                                 quote! { ::leptos::tachys::html::#id::#id((#key, #value)) },
                             )
                         } else if id == "prop" {
-                            let value = attribute_value(node, false);
                             let key = &node.key.to_string();
                             let key = key.replacen("prop:", "", 1);
                             Some(
@@ -1097,20 +691,6 @@ pub(crate) fn attribute_absolute(
     }
 }
 
-pub(crate) fn two_way_binding_to_tokens(
-    name: &str,
-    node: &KeyedAttribute,
-) -> TokenStream {
-    let value = attribute_value(node, false);
-
-    let ident =
-        format_ident!("{}", name.to_case(UpperCamel), span = node.key.span());
-
-    quote! {
-        .bind(::leptos::attr::#ident, #value)
-    }
-}
-
 pub(crate) fn event_to_tokens(
     name: &str,
     node: &KeyedAttribute,
@@ -1126,7 +706,7 @@ pub(crate) fn event_type_and_handler(
     name: &str,
     node: &KeyedAttribute,
 ) -> (TokenStream, TokenStream, TokenStream) {
-    let handler = attribute_value(node, false);
+    let handler = attribute_value(node);
 
     let (event_type, is_custom, is_force_undelegated, is_targeted) =
         parse_event_name(name);
@@ -1183,7 +763,7 @@ fn class_to_tokens(
     class: TokenStream,
     class_name: Option<&str>,
 ) -> TokenStream {
-    let value = attribute_value(node, false);
+    let value = attribute_value(node);
     if let Some(class_name) = class_name {
         quote! {
             .#class((#class_name, #value))
@@ -1200,7 +780,7 @@ fn style_to_tokens(
     style: TokenStream,
     style_name: Option<&str>,
 ) -> TokenStream {
-    let value = attribute_value(node, false);
+    let value = attribute_value(node);
     if let Some(style_name) = style_name {
         quote! {
             .#style((#style_name, #value))
@@ -1217,7 +797,7 @@ fn prop_to_tokens(
     prop: TokenStream,
     key: &str,
 ) -> TokenStream {
-    let value = attribute_value(node, false);
+    let value = attribute_value(node);
     quote! {
         .#prop(#key, #value)
     }
@@ -1374,10 +954,7 @@ fn attribute_name(name: &NodeName) -> TokenStream {
     }
 }
 
-fn attribute_value(
-    attr: &KeyedAttribute,
-    is_attribute_proper: bool,
-) -> TokenStream {
+fn attribute_value(attr: &KeyedAttribute) -> TokenStream {
     match attr.possible_value.to_value() {
         None => quote! { true },
         Some(value) => match &value.value {
@@ -1392,26 +969,14 @@ fn attribute_value(
                     }
                 }
 
-                if matches!(expr, Expr::Lit(_)) || !is_attribute_proper {
-                    quote! {
-                        #expr
-                    }
-                } else {
-                    quote! {
-                        ::leptos::prelude::IntoAttributeValue::into_attribute_value(#expr)
-                    }
+                quote! {
+                    {#expr}
                 }
             }
             // any value in braces: expand as-is to give proper r-a support
             KVAttributeValue::InvalidBraced(block) => {
-                if is_attribute_proper {
-                    quote! {
-                        ::leptos::prelude::IntoAttributeValue::into_attribute_value(#block)
-                    }
-                } else {
-                    quote! {
-                        #block
-                    }
+                quote! {
+                    #block
                 }
             }
         },

leptos_macro/src/view/slot_helper.rs

@@ -1,17 +1,16 @@
 use super::{convert_to_snake_case, ident_from_tag_name};
-use crate::view::{fragment_to_tokens, utils::filter_prefixed_attrs, TagType};
+use crate::view::{fragment_to_tokens, TagType};
 use proc_macro2::{Ident, TokenStream, TokenTree};
-use quote::{quote, quote_spanned};
+use quote::{format_ident, quote, quote_spanned};
 use rstml::node::{CustomNode, KeyedAttribute, NodeAttribute, NodeElement};
 use std::collections::HashMap;
 use syn::spanned::Spanned;
 
 pub(crate) fn slot_to_tokens(
-    node: &mut NodeElement<impl CustomNode>,
+    node: &NodeElement<impl CustomNode>,
     slot: &KeyedAttribute,
     parent_slots: Option<&mut HashMap<String, Vec<TokenStream>>>,
     global_class: Option<&TokenTree>,
-    disable_inert_html: bool,
 ) {
     let name = slot.key.to_string();
     let name = name.trim();
@@ -31,25 +30,20 @@ pub(crate) fn slot_to_tokens(
         return;
     };
 
-    let attrs = node
-        .attributes()
-        .iter()
-        .filter_map(|node| {
-            if let NodeAttribute::Attribute(node) = node {
-                if is_slot(node) {
-                    None
-                } else {
-                    Some(node)
-                }
-            } else {
+    let attrs = node.attributes().iter().filter_map(|node| {
+        if let NodeAttribute::Attribute(node) = node {
+            if is_slot(node) {
                 None
+            } else {
+                Some(node)
             }
-        })
-        .cloned()
-        .collect::<Vec<_>>();
+        } else {
+            None
+        }
+    });
 
     let props = attrs
-        .iter()
+        .clone()
         .filter(|attr| {
             !attr.key.to_string().starts_with("let:")
                 && !attr.key.to_string().starts_with("clone:")
@@ -70,12 +64,27 @@ pub(crate) fn slot_to_tokens(
             }
         });
 
-    let items_to_bind = filter_prefixed_attrs(attrs.iter(), "let:");
+    let items_to_bind = attrs
+        .clone()
+        .filter_map(|attr| {
+            attr.key
+                .to_string()
+                .strip_prefix("let:")
+                .map(|ident| format_ident!("{ident}", span = attr.key.span()))
+        })
+        .collect::<Vec<_>>();
 
-    let items_to_clone = filter_prefixed_attrs(attrs.iter(), "clone:");
+    let items_to_clone = attrs
+        .clone()
+        .filter_map(|attr| {
+            attr.key
+                .to_string()
+                .strip_prefix("clone:")
+                .map(|ident| format_ident!("{ident}", span = attr.key.span()))
+        })
+        .collect::<Vec<_>>();
 
     let dyn_attrs = attrs
-        .iter()
         .filter(|attr| attr.key.to_string().starts_with("attr:"))
         .filter_map(|attr| {
             let name = &attr.key.to_string();
@@ -98,12 +107,11 @@ pub(crate) fn slot_to_tokens(
         quote! {}
     } else {
         let children = fragment_to_tokens(
-            &mut node.children,
+            &node.children,
             TagType::Unknown,
             Some(&mut slots),
             global_class,
             None,
-            disable_inert_html,
         );
 
         // TODO view markers for hot-reloading

leptos_macro/src/view/utils.rs

@@ -1,19 +0,0 @@
-use proc_macro2::Ident;
-use quote::format_ident;
-use rstml::node::KeyedAttribute;
-use syn::spanned::Spanned;
-
-pub fn filter_prefixed_attrs<'a, A>(attrs: A, prefix: &str) -> Vec<Ident>
-where
-    A: IntoIterator<Item = &'a KeyedAttribute> + Clone,
-{
-    attrs
-        .into_iter()
-        .filter_map(|attr| {
-            attr.key
-                .to_string()
-                .strip_prefix(prefix)
-                .map(|ident| format_ident!("{ident}", span = attr.key.span()))
-        })
-        .collect()
-}

leptos_macro/tests/ui.rs

@@ -1,4 +1,3 @@
-#[cfg(not(erase_components))]
 #[test]
 fn ui() {
     let t = trybuild::TestCases::new();

leptos_server/Cargo.toml

@@ -19,7 +19,6 @@ tracing = { version = "0.1.40", optional = true }
 futures = "0.3.30"
 
 any_spawner = { workspace = true }
-or_poisoned = { workspace = true }
 tachys = { workspace = true, optional = true, features = ["reactive_graph"] }
 send_wrapper = "0.6"
 

leptos_server/src/lib.rs

@@ -8,8 +8,6 @@ mod local_resource;
 pub use local_resource::*;
 mod multi_action;
 pub use multi_action::*;
-mod once_resource;
-pub use once_resource::*;
 mod resource;
 pub use resource::*;
 mod shared;
@@ -190,18 +188,20 @@ mod view_implementations {
         html::attribute::Attribute,
         hydration::Cursor,
         reactive_graph::{RenderEffectState, Suspend, SuspendState},
+        renderer::Renderer,
         ssr::StreamBuilder,
         view::{
             add_attr::AddAnyAttr, Position, PositionState, Render, RenderHtml,
         },
     };
 
-    impl<T, Ser> Render for Resource<T, Ser>
+    impl<T, R, Ser> Render<R> for Resource<T, Ser>
     where
-        T: Render + Send + Sync + Clone,
+        T: Render<R> + Send + Sync + Clone,
         Ser: Send + 'static,
+        R: Renderer,
     {
-        type State = RenderEffectState<SuspendState<T>>;
+        type State = RenderEffectState<SuspendState<T, R>>;
 
         fn build(self) -> Self::State {
             (move || Suspend::new(async move { self.await })).build()
@@ -212,18 +212,19 @@ mod view_implementations {
         }
     }
 
-    impl<T, Ser> AddAnyAttr for Resource<T, Ser>
+    impl<T, R, Ser> AddAnyAttr<R> for Resource<T, Ser>
     where
-        T: RenderHtml + Send + Sync + Clone,
+        T: RenderHtml<R> + Send + Sync + Clone,
         Ser: Send + 'static,
+        R: Renderer,
     {
-        type Output<SomeNewAttr: Attribute> = Box<
+        type Output<SomeNewAttr: Attribute<R>> = Box<
             dyn FnMut() -> Suspend<
                     Pin<
                         Box<
                             dyn Future<
-                                    Output = <T as AddAnyAttr>::Output<
-                                        <SomeNewAttr::CloneableOwned as Attribute>::CloneableOwned,
+                                    Output = <T as AddAnyAttr<R>>::Output<
+                                        <SomeNewAttr::CloneableOwned as Attribute<R>>::CloneableOwned,
                                     >,
                                 > + Send,
                         >,
@@ -231,21 +232,22 @@ mod view_implementations {
                 > + Send,
         >;
 
-        fn add_any_attr<NewAttr: Attribute>(
+        fn add_any_attr<NewAttr: Attribute<R>>(
             self,
             attr: NewAttr,
         ) -> Self::Output<NewAttr>
         where
-            Self::Output<NewAttr>: RenderHtml,
+            Self::Output<NewAttr>: RenderHtml<R>,
         {
             (move || Suspend::new(async move { self.await })).add_any_attr(attr)
         }
     }
 
-    impl<T, Ser> RenderHtml for Resource<T, Ser>
+    impl<T, R, Ser> RenderHtml<R> for Resource<T, Ser>
     where
-        T: RenderHtml + Send + Sync + Clone,
+        T: RenderHtml<R> + Send + Sync + Clone,
         Ser: Send + 'static,
+        R: Renderer,
     {
         type AsyncOutput = Option<T>;
 
@@ -294,7 +296,7 @@ mod view_implementations {
 
         fn hydrate<const FROM_SERVER: bool>(
             self,
-            cursor: &Cursor,
+            cursor: &Cursor<R>,
             position: &PositionState,
         ) -> Self::State {
             (move || Suspend::new(async move { self.await }))

leptos_server/src/local_resource.rs

@@ -9,7 +9,7 @@ use reactive_graph::{
     },
     owner::use_context,
     signal::guards::{AsyncPlain, ReadGuard},
-    traits::{DefinedAt, IsDisposed, ReadUntracked},
+    traits::{DefinedAt, ReadUntracked},
 };
 use send_wrapper::SendWrapper;
 use std::{
@@ -35,10 +35,10 @@ impl<T> Clone for ArcLocalResource<T> {
 
 impl<T> ArcLocalResource<T> {
     #[track_caller]
-    pub fn new<Fut>(fetcher: impl Fn() -> Fut + 'static) -> Self
+    pub fn new<Fut>(fetcher: impl Fn() -> Fut + Send + Sync + 'static) -> Self
     where
-        T: 'static,
-        Fut: Future<Output = T> + 'static,
+        T: Send + Sync + 'static,
+        Fut: Future<Output = T> + Send + 'static,
     {
         let fetcher = move || {
             let fut = fetcher();
@@ -60,7 +60,7 @@ impl<T> ArcLocalResource<T> {
             }
         };
         Self {
-            data: ArcAsyncDerived::new_unsync(fetcher),
+            data: ArcAsyncDerived::new(fetcher),
             #[cfg(debug_assertions)]
             defined_at: Location::caller(),
         }
@@ -103,7 +103,7 @@ impl<T> DefinedAt for ArcLocalResource<T> {
 
 impl<T> ReadUntracked for ArcLocalResource<T>
 where
-    T: 'static,
+    T: Send + Sync + 'static,
 {
     type Value = ReadGuard<Option<T>, AsyncPlain<Option<T>>>;
 
@@ -121,13 +121,6 @@ where
     }
 }
 
-impl<T: 'static> IsDisposed for ArcLocalResource<T> {
-    #[inline(always)]
-    fn is_disposed(&self) -> bool {
-        false
-    }
-}
-
 impl<T: 'static> ToAnySource for ArcLocalResource<T> {
     fn to_any_source(&self) -> AnySource {
         self.data.to_any_source()
@@ -201,7 +194,7 @@ impl<T> LocalResource<T> {
     pub fn new<Fut>(fetcher: impl Fn() -> Fut + 'static) -> Self
     where
         T: 'static,
-        Fut: Future<Output = T> + 'static,
+        Fut: Future<Output = T> + Send + 'static,
     {
         let fetcher = move || {
             let fut = fetcher();
@@ -230,7 +223,7 @@ impl<T> LocalResource<T> {
                 let fetcher = SendWrapper::new(fetcher);
                 AsyncDerived::new(move || {
                     let fut = fetcher();
-                    SendWrapper::new(async move { SendWrapper::new(fut.await) })
+                    async move { SendWrapper::new(fut.await) }
                 })
             },
             #[cfg(debug_assertions)]
@@ -280,7 +273,7 @@ impl<T> DefinedAt for LocalResource<T> {
 
 impl<T> ReadUntracked for LocalResource<T>
 where
-    T: 'static,
+    T: Send + Sync + 'static,
 {
     type Value =
         ReadGuard<Option<SendWrapper<T>>, AsyncPlain<Option<SendWrapper<T>>>>;
@@ -299,15 +292,9 @@ where
     }
 }
 
-impl<T: 'static> IsDisposed for LocalResource<T> {
-    fn is_disposed(&self) -> bool {
-        self.data.is_disposed()
-    }
-}
-
 impl<T: 'static> ToAnySource for LocalResource<T>
 where
-    T: 'static,
+    T: Send + Sync + 'static,
 {
     fn to_any_source(&self) -> AnySource {
         self.data.to_any_source()
@@ -316,7 +303,7 @@ where
 
 impl<T: 'static> ToAnySubscriber for LocalResource<T>
 where
-    T: 'static,
+    T: Send + Sync + 'static,
 {
     fn to_any_subscriber(&self) -> AnySubscriber {
         self.data.to_any_subscriber()
@@ -325,7 +312,7 @@ where
 
 impl<T> Source for LocalResource<T>
 where
-    T: 'static,
+    T: Send + Sync + 'static,
 {
     fn add_subscriber(&self, subscriber: AnySubscriber) {
         self.data.add_subscriber(subscriber)
@@ -342,7 +329,7 @@ where
 
 impl<T> ReactiveNode for LocalResource<T>
 where
-    T: 'static,
+    T: Send + Sync + 'static,
 {
     fn mark_dirty(&self) {
         self.data.mark_dirty();
@@ -363,7 +350,7 @@ where
 
 impl<T> Subscriber for LocalResource<T>
 where
-    T: 'static,
+    T: Send + Sync + 'static,
 {
     fn add_source(&self, source: AnySource) {
         self.data.add_source(source);

leptos_server/src/once_resource.rs

@@ -1,708 +0,0 @@
-use crate::{
-    initial_value, FromEncodedStr, IntoEncodedString,
-    IS_SUPPRESSING_RESOURCE_LOAD,
-};
-#[cfg(feature = "rkyv")]
-use codee::binary::RkyvCodec;
-#[cfg(feature = "serde-wasm-bindgen")]
-use codee::string::JsonSerdeWasmCodec;
-#[cfg(feature = "miniserde")]
-use codee::string::MiniserdeCodec;
-#[cfg(feature = "serde-lite")]
-use codee::SerdeLite;
-use codee::{
-    string::{FromToStringCodec, JsonSerdeCodec},
-    Decoder, Encoder,
-};
-use core::{fmt::Debug, marker::PhantomData};
-use futures::Future;
-use or_poisoned::OrPoisoned;
-use reactive_graph::{
-    computed::{
-        suspense::SuspenseContext, AsyncDerivedReadyFuture, ScopedFuture,
-    },
-    diagnostics::{SpecialNonReactiveFuture, SpecialNonReactiveZone},
-    graph::{AnySource, ToAnySource},
-    owner::{use_context, ArenaItem, Owner},
-    prelude::*,
-    signal::{
-        guards::{Plain, ReadGuard},
-        ArcTrigger,
-    },
-    unwrap_signal,
-};
-use std::{
-    future::IntoFuture,
-    mem,
-    panic::Location,
-    pin::Pin,
-    sync::{
-        atomic::{AtomicBool, Ordering},
-        Arc, RwLock,
-    },
-    task::{Context, Poll, Waker},
-};
-
-#[derive(Debug)]
-pub struct ArcOnceResource<T, Ser = JsonSerdeCodec> {
-    trigger: ArcTrigger,
-    value: Arc<RwLock<Option<T>>>,
-    wakers: Arc<RwLock<Vec<Waker>>>,
-    suspenses: Arc<RwLock<Vec<SuspenseContext>>>,
-    loading: Arc<AtomicBool>,
-    ser: PhantomData<fn() -> Ser>,
-    #[cfg(debug_assertions)]
-    defined_at: &'static Location<'static>,
-}
-
-impl<T, Ser> Clone for ArcOnceResource<T, Ser> {
-    fn clone(&self) -> Self {
-        Self {
-            trigger: self.trigger.clone(),
-            value: self.value.clone(),
-            wakers: self.wakers.clone(),
-            suspenses: self.suspenses.clone(),
-            loading: self.loading.clone(),
-            ser: self.ser,
-            #[cfg(debug_assertions)]
-            defined_at: self.defined_at,
-        }
-    }
-}
-
-impl<T, Ser> ArcOnceResource<T, Ser>
-where
-    T: Send + Sync + 'static,
-    Ser: Encoder<T> + Decoder<T>,
-    <Ser as Encoder<T>>::Error: Debug,
-    <Ser as Decoder<T>>::Error: Debug,
-    <<Ser as Decoder<T>>::Encoded as FromEncodedStr>::DecodingError: Debug,
-    <Ser as Encoder<T>>::Encoded: IntoEncodedString,
-    <Ser as Decoder<T>>::Encoded: FromEncodedStr,
-{
-    #[track_caller]
-    pub fn new_with_options(
-        fut: impl Future<Output = T> + Send + 'static,
-        #[allow(unused)] // this is used with `feature = "ssr"`
-        blocking: bool,
-    ) -> Self {
-        let shared_context = Owner::current_shared_context();
-        let id = shared_context
-            .as_ref()
-            .map(|sc| sc.next_id())
-            .unwrap_or_default();
-
-        let initial = initial_value::<T, Ser>(&id, shared_context.as_ref());
-        let is_ready = initial.is_some();
-        let value = Arc::new(RwLock::new(initial));
-        let wakers = Arc::new(RwLock::new(Vec::<Waker>::new()));
-        let suspenses = Arc::new(RwLock::new(Vec::<SuspenseContext>::new()));
-        let loading = Arc::new(AtomicBool::new(!is_ready));
-        let trigger = ArcTrigger::new();
-
-        let fut = ScopedFuture::new(fut);
-
-        if !is_ready && !IS_SUPPRESSING_RESOURCE_LOAD.load(Ordering::Relaxed) {
-            let value = Arc::clone(&value);
-            let wakers = Arc::clone(&wakers);
-            let loading = Arc::clone(&loading);
-            let trigger = trigger.clone();
-            reactive_graph::spawn(async move {
-                let loaded = fut.await;
-                *value.write().or_poisoned() = Some(loaded);
-                loading.store(false, Ordering::Relaxed);
-                for waker in mem::take(&mut *wakers.write().or_poisoned()) {
-                    waker.wake();
-                }
-                trigger.notify();
-            });
-        }
-
-        let data = Self {
-            trigger,
-            value: value.clone(),
-            loading,
-            wakers,
-            suspenses,
-            ser: PhantomData,
-            #[cfg(debug_assertions)]
-            defined_at: Location::caller(),
-        };
-
-        #[cfg(feature = "ssr")]
-        if let Some(shared_context) = shared_context {
-            let value = Arc::clone(&value);
-            let ready_fut = data.ready();
-
-            if blocking {
-                shared_context.defer_stream(Box::pin(data.ready()));
-            }
-
-            if shared_context.get_is_hydrating() {
-                shared_context.write_async(
-                    id,
-                    Box::pin(async move {
-                        ready_fut.await;
-                        let value = value.read().or_poisoned();
-                        let value = value.as_ref().unwrap();
-                        Ser::encode(value).unwrap().into_encoded_string()
-                    }),
-                );
-            }
-        }
-
-        data
-    }
-}
-
-impl<T, Ser> ArcOnceResource<T, Ser> {
-    /// Returns a `Future` that is ready when this resource has next finished loading.
-    pub fn ready(&self) -> AsyncDerivedReadyFuture {
-        AsyncDerivedReadyFuture::new(
-            self.to_any_source(),
-            &self.loading,
-            &self.wakers,
-        )
-    }
-}
-
-impl<T, Ser> DefinedAt for ArcOnceResource<T, Ser> {
-    fn defined_at(&self) -> Option<&'static Location<'static>> {
-        #[cfg(not(debug_assertions))]
-        {
-            None
-        }
-        #[cfg(debug_assertions)]
-        {
-            Some(self.defined_at)
-        }
-    }
-}
-
-impl<T, Ser> IsDisposed for ArcOnceResource<T, Ser> {
-    #[inline(always)]
-    fn is_disposed(&self) -> bool {
-        false
-    }
-}
-
-impl<T, Ser> ToAnySource for ArcOnceResource<T, Ser> {
-    fn to_any_source(&self) -> AnySource {
-        self.trigger.to_any_source()
-    }
-}
-
-impl<T, Ser> Track for ArcOnceResource<T, Ser> {
-    fn track(&self) {
-        self.trigger.track();
-    }
-}
-
-impl<T, Ser> ReadUntracked for ArcOnceResource<T, Ser>
-where
-    T: 'static,
-{
-    type Value = ReadGuard<Option<T>, Plain<Option<T>>>;
-
-    fn try_read_untracked(&self) -> Option<Self::Value> {
-        if let Some(suspense_context) = use_context::<SuspenseContext>() {
-            if self.value.read().or_poisoned().is_none() {
-                let handle = suspense_context.task_id();
-                let ready = SpecialNonReactiveFuture::new(self.ready());
-                reactive_graph::spawn(async move {
-                    ready.await;
-                    drop(handle);
-                });
-                self.suspenses.write().or_poisoned().push(suspense_context);
-            }
-        }
-        Plain::try_new(Arc::clone(&self.value)).map(ReadGuard::new)
-    }
-}
-
-impl<T, Ser> IntoFuture for ArcOnceResource<T, Ser>
-where
-    T: Clone + 'static,
-{
-    type Output = T;
-    type IntoFuture = OnceResourceFuture<T>;
-
-    fn into_future(self) -> Self::IntoFuture {
-        OnceResourceFuture {
-            source: self.to_any_source(),
-            value: Arc::clone(&self.value),
-            loading: Arc::clone(&self.loading),
-            wakers: Arc::clone(&self.wakers),
-            suspenses: Arc::clone(&self.suspenses),
-        }
-    }
-}
-
-/// A [`Future`] that is ready when an [`ArcAsyncDerived`] is finished loading or reloading,
-/// and contains its value. `.await`ing this clones the value `T`.
-pub struct OnceResourceFuture<T> {
-    source: AnySource,
-    value: Arc<RwLock<Option<T>>>,
-    loading: Arc<AtomicBool>,
-    wakers: Arc<RwLock<Vec<Waker>>>,
-    suspenses: Arc<RwLock<Vec<SuspenseContext>>>,
-}
-
-impl<T> Future for OnceResourceFuture<T>
-where
-    T: Clone + 'static,
-{
-    type Output = T;
-
-    #[track_caller]
-    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        #[cfg(debug_assertions)]
-        let _guard = SpecialNonReactiveZone::enter();
-        let waker = cx.waker();
-        self.source.track();
-
-        if let Some(suspense_context) = use_context::<SuspenseContext>() {
-            self.suspenses.write().or_poisoned().push(suspense_context);
-        }
-
-        if self.loading.load(Ordering::Relaxed) {
-            self.wakers.write().or_poisoned().push(waker.clone());
-            Poll::Pending
-        } else {
-            Poll::Ready(
-                self.value.read().or_poisoned().as_ref().unwrap().clone(),
-            )
-        }
-    }
-}
-
-impl<T> ArcOnceResource<T, JsonSerdeCodec>
-where
-    T: Send + Sync + 'static,
-    JsonSerdeCodec: Encoder<T> + Decoder<T>,
-    <JsonSerdeCodec as Encoder<T>>::Error: Debug,
-    <JsonSerdeCodec as Decoder<T>>::Error: Debug,
-    <<JsonSerdeCodec as Decoder<T>>::Encoded as FromEncodedStr>::DecodingError:
-        Debug,
-    <JsonSerdeCodec as Encoder<T>>::Encoded: IntoEncodedString,
-    <JsonSerdeCodec as Decoder<T>>::Encoded: FromEncodedStr,
-{
-    #[track_caller]
-    pub fn new(fut: impl Future<Output = T> + Send + 'static) -> Self {
-        ArcOnceResource::new_with_options(fut, false)
-    }
-
-    #[track_caller]
-    pub fn new_blocking(fut: impl Future<Output = T> + Send + 'static) -> Self {
-        ArcOnceResource::new_with_options(fut, true)
-    }
-}
-
-impl<T> ArcOnceResource<T, FromToStringCodec>
-where
-T: Send + Sync + 'static,
-    FromToStringCodec: Encoder<T> + Decoder<T>,
-    <FromToStringCodec as Encoder<T>>::Error: Debug, <FromToStringCodec as Decoder<T>>::Error: Debug,
-    <<FromToStringCodec as Decoder<T>>::Encoded as FromEncodedStr>::DecodingError: Debug,
-    <FromToStringCodec as Encoder<T>>::Encoded: IntoEncodedString,
-    <FromToStringCodec as Decoder<T>>::Encoded: FromEncodedStr,
-{
-    pub fn new_str(
-        fut: impl Future<Output = T> + Send + 'static
-    ) -> Self
-    {
-        ArcOnceResource::new_with_options(fut, false)
-    }
-
-    pub fn new_str_blocking(
-        fut: impl Future<Output = T> + Send + 'static
-    ) -> Self
-    {
-        ArcOnceResource::new_with_options(fut, true)
-    }
-}
-
-#[cfg(feature = "serde-wasm-bindgen")]
-impl<T> ArcOnceResource<T, JsonSerdeWasmCodec>
-where
-T: Send + Sync + 'static,
-    JsonSerdeWasmCodec: Encoder<T> + Decoder<T>,
-    <JsonSerdeWasmCodec as Encoder<T>>::Error: Debug, <JsonSerdeWasmCodec as Decoder<T>>::Error: Debug,
-    <<JsonSerdeWasmCodec as Decoder<T>>::Encoded as FromEncodedStr>::DecodingError: Debug,
-    <JsonSerdeWasmCodec as Encoder<T>>::Encoded: IntoEncodedString,
-    <JsonSerdeWasmCodec as Decoder<T>>::Encoded: FromEncodedStr,
-{
-    #[track_caller]
-    pub fn new_serde_wb(
-fut: impl Future<Output = T> + Send + 'static
-    ) -> Self
-    {
-        ArcOnceResource::new_with_options(fut, false)
-    }
-
-    #[track_caller]
-    pub fn new_serde_wb_blocking(
-fut: impl Future<Output = T> + Send + 'static
-    ) -> Self
-    {
-        ArcOnceResource::new_with_options(fut, true)
-    }
-}
-#[cfg(feature = "miniserde")]
-impl<T> ArcOnceResource<T, MiniserdeCodec>
-where
-    T: Send + Sync + 'static,
-    MiniserdeCodec: Encoder<T> + Decoder<T>,
-    <MiniserdeCodec as Encoder<T>>::Error: Debug,
-    <MiniserdeCodec as Decoder<T>>::Error: Debug,
-    <<MiniserdeCodec as Decoder<T>>::Encoded as FromEncodedStr>::DecodingError:
-        Debug,
-    <MiniserdeCodec as Encoder<T>>::Encoded: IntoEncodedString,
-    <MiniserdeCodec as Decoder<T>>::Encoded: FromEncodedStr,
-{
-    #[track_caller]
-    pub fn new_miniserde(
-        fut: impl Future<Output = T> + Send + 'static,
-    ) -> Self {
-        ArcOnceResource::new_with_options(fut, false)
-    }
-
-    #[track_caller]
-    pub fn new_miniserde_blocking(
-        fut: impl Future<Output = T> + Send + 'static,
-    ) -> Self {
-        ArcOnceResource::new_with_options(fut, true)
-    }
-}
-
-#[cfg(feature = "serde-lite")]
-impl<T> ArcOnceResource<T, SerdeLite<JsonSerdeCodec>>
-where
-T: Send + Sync + 'static,
-    SerdeLite<JsonSerdeCodec>: Encoder<T> + Decoder<T>,
-    <SerdeLite<JsonSerdeCodec> as Encoder<T>>::Error: Debug, <SerdeLite<JsonSerdeCodec> as Decoder<T>>::Error: Debug,
-    <<SerdeLite<JsonSerdeCodec> as Decoder<T>>::Encoded as FromEncodedStr>::DecodingError: Debug,
-    <SerdeLite<JsonSerdeCodec> as Encoder<T>>::Encoded: IntoEncodedString,
-    <SerdeLite<JsonSerdeCodec> as Decoder<T>>::Encoded: FromEncodedStr,
-{
-    #[track_caller]
-    pub fn new_serde_lite(
-fut: impl Future<Output = T> + Send + 'static
-    ) -> Self
-    {
-        ArcOnceResource::new_with_options(fut, false)
-    }
-
-    #[track_caller]
-    pub fn new_serde_lite_blocking(
-fut: impl Future<Output = T> + Send + 'static
-    ) -> Self
-    {
-        ArcOnceResource::new_with_options(fut, true)
-    }
-}
-
-#[cfg(feature = "rkyv")]
-impl<T> ArcOnceResource<T, RkyvCodec>
-where
-    T: Send + Sync + 'static,
-    RkyvCodec: Encoder<T> + Decoder<T>,
-    <RkyvCodec as Encoder<T>>::Error: Debug,
-    <RkyvCodec as Decoder<T>>::Error: Debug,
-    <<RkyvCodec as Decoder<T>>::Encoded as FromEncodedStr>::DecodingError:
-        Debug,
-    <RkyvCodec as Encoder<T>>::Encoded: IntoEncodedString,
-    <RkyvCodec as Decoder<T>>::Encoded: FromEncodedStr,
-{
-    #[track_caller]
-    pub fn new_rkyv(fut: impl Future<Output = T> + Send + 'static) -> Self {
-        ArcOnceResource::new_with_options(fut, false)
-    }
-
-    #[track_caller]
-    pub fn new_rkyv_blocking(
-        fut: impl Future<Output = T> + Send + 'static,
-    ) -> Self {
-        ArcOnceResource::new_with_options(fut, true)
-    }
-}
-
-#[derive(Debug)]
-pub struct OnceResource<T, Ser = JsonSerdeCodec> {
-    inner: ArenaItem<ArcOnceResource<T, Ser>>,
-    #[cfg(debug_assertions)]
-    defined_at: &'static Location<'static>,
-}
-
-impl<T, Ser> Clone for OnceResource<T, Ser> {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-
-impl<T, Ser> Copy for OnceResource<T, Ser> {}
-
-impl<T, Ser> OnceResource<T, Ser>
-where
-    T: Send + Sync + 'static,
-    Ser: Encoder<T> + Decoder<T>,
-    <Ser as Encoder<T>>::Error: Debug,
-    <Ser as Decoder<T>>::Error: Debug,
-    <<Ser as Decoder<T>>::Encoded as FromEncodedStr>::DecodingError: Debug,
-    <Ser as Encoder<T>>::Encoded: IntoEncodedString,
-    <Ser as Decoder<T>>::Encoded: FromEncodedStr,
-{
-    #[track_caller]
-    pub fn new_with_options(
-        fut: impl Future<Output = T> + Send + 'static,
-        blocking: bool,
-    ) -> Self {
-        #[cfg(debug_assertions)]
-        let defined_at = Location::caller();
-        Self {
-            inner: ArenaItem::new(ArcOnceResource::new_with_options(
-                fut, blocking,
-            )),
-            #[cfg(debug_assertions)]
-            defined_at,
-        }
-    }
-}
-
-impl<T, Ser> OnceResource<T, Ser>
-where
-    T: Send + Sync + 'static,
-    Ser: 'static,
-{
-    /// Returns a `Future` that is ready when this resource has next finished loading.
-    pub fn ready(&self) -> AsyncDerivedReadyFuture {
-        self.inner
-            .try_with_value(|inner| inner.ready())
-            .unwrap_or_else(unwrap_signal!(self))
-    }
-}
-
-impl<T, Ser> DefinedAt for OnceResource<T, Ser> {
-    fn defined_at(&self) -> Option<&'static Location<'static>> {
-        #[cfg(not(debug_assertions))]
-        {
-            None
-        }
-        #[cfg(debug_assertions)]
-        {
-            Some(self.defined_at)
-        }
-    }
-}
-
-impl<T, Ser> IsDisposed for OnceResource<T, Ser> {
-    #[inline(always)]
-    fn is_disposed(&self) -> bool {
-        false
-    }
-}
-
-impl<T, Ser> ToAnySource for OnceResource<T, Ser>
-where
-    T: Send + Sync + 'static,
-    Ser: 'static,
-{
-    fn to_any_source(&self) -> AnySource {
-        self.inner
-            .try_with_value(|inner| inner.to_any_source())
-            .unwrap_or_else(unwrap_signal!(self))
-    }
-}
-
-impl<T, Ser> Track for OnceResource<T, Ser>
-where
-    T: Send + Sync + 'static,
-    Ser: 'static,
-{
-    fn track(&self) {
-        if let Some(inner) = self.inner.try_get_value() {
-            inner.track();
-        }
-    }
-}
-
-impl<T, Ser> ReadUntracked for OnceResource<T, Ser>
-where
-    T: Send + Sync + 'static,
-    Ser: 'static,
-{
-    type Value = ReadGuard<Option<T>, Plain<Option<T>>>;
-
-    fn try_read_untracked(&self) -> Option<Self::Value> {
-        self.inner
-            .try_with_value(|inner| inner.try_read_untracked())
-            .flatten()
-    }
-}
-
-impl<T, Ser> IntoFuture for OnceResource<T, Ser>
-where
-    T: Clone + Send + Sync + 'static,
-    Ser: 'static,
-{
-    type Output = T;
-    type IntoFuture = OnceResourceFuture<T>;
-
-    fn into_future(self) -> Self::IntoFuture {
-        self.inner
-            .try_get_value()
-            .unwrap_or_else(unwrap_signal!(self))
-            .into_future()
-    }
-}
-
-impl<T> OnceResource<T, JsonSerdeCodec>
-where
-    T: Send + Sync + 'static,
-    JsonSerdeCodec: Encoder<T> + Decoder<T>,
-    <JsonSerdeCodec as Encoder<T>>::Error: Debug,
-    <JsonSerdeCodec as Decoder<T>>::Error: Debug,
-    <<JsonSerdeCodec as Decoder<T>>::Encoded as FromEncodedStr>::DecodingError:
-        Debug,
-    <JsonSerdeCodec as Encoder<T>>::Encoded: IntoEncodedString,
-    <JsonSerdeCodec as Decoder<T>>::Encoded: FromEncodedStr,
-{
-    #[track_caller]
-    pub fn new(fut: impl Future<Output = T> + Send + 'static) -> Self {
-        OnceResource::new_with_options(fut, false)
-    }
-
-    #[track_caller]
-    pub fn new_blocking(fut: impl Future<Output = T> + Send + 'static) -> Self {
-        OnceResource::new_with_options(fut, true)
-    }
-}
-
-impl<T> OnceResource<T, FromToStringCodec>
-where
-T: Send + Sync + 'static,
-    FromToStringCodec: Encoder<T> + Decoder<T>,
-    <FromToStringCodec as Encoder<T>>::Error: Debug, <FromToStringCodec as Decoder<T>>::Error: Debug,
-    <<FromToStringCodec as Decoder<T>>::Encoded as FromEncodedStr>::DecodingError: Debug,
-    <FromToStringCodec as Encoder<T>>::Encoded: IntoEncodedString,
-    <FromToStringCodec as Decoder<T>>::Encoded: FromEncodedStr,
-{
-    pub fn new_str(
-        fut: impl Future<Output = T> + Send + 'static
-    ) -> Self
-    {
-        OnceResource::new_with_options(fut, false)
-    }
-
-    pub fn new_str_blocking(
-        fut: impl Future<Output = T> + Send + 'static
-    ) -> Self
-    {
-        OnceResource::new_with_options(fut, true)
-    }
-}
-
-#[cfg(feature = "serde-wasm-bindgen")]
-impl<T> OnceResource<T, JsonSerdeWasmCodec>
-where
-T: Send + Sync + 'static,
-    JsonSerdeWasmCodec: Encoder<T> + Decoder<T>,
-    <JsonSerdeWasmCodec as Encoder<T>>::Error: Debug, <JsonSerdeWasmCodec as Decoder<T>>::Error: Debug,
-    <<JsonSerdeWasmCodec as Decoder<T>>::Encoded as FromEncodedStr>::DecodingError: Debug,
-    <JsonSerdeWasmCodec as Encoder<T>>::Encoded: IntoEncodedString,
-    <JsonSerdeWasmCodec as Decoder<T>>::Encoded: FromEncodedStr,
-{
-    #[track_caller]
-    pub fn new_serde_wb(
-fut: impl Future<Output = T> + Send + 'static
-    ) -> Self
-    {
-        OnceResource::new_with_options(fut, false)
-    }
-
-    #[track_caller]
-    pub fn new_serde_wb_blocking(
-fut: impl Future<Output = T> + Send + 'static
-    ) -> Self
-    {
-        OnceResource::new_with_options(fut, true)
-    }
-}
-#[cfg(feature = "miniserde")]
-impl<T> OnceResource<T, MiniserdeCodec>
-where
-    T: Send + Sync + 'static,
-    MiniserdeCodec: Encoder<T> + Decoder<T>,
-    <MiniserdeCodec as Encoder<T>>::Error: Debug,
-    <MiniserdeCodec as Decoder<T>>::Error: Debug,
-    <<MiniserdeCodec as Decoder<T>>::Encoded as FromEncodedStr>::DecodingError:
-        Debug,
-    <MiniserdeCodec as Encoder<T>>::Encoded: IntoEncodedString,
-    <MiniserdeCodec as Decoder<T>>::Encoded: FromEncodedStr,
-{
-    #[track_caller]
-    pub fn new_miniserde(
-        fut: impl Future<Output = T> + Send + 'static,
-    ) -> Self {
-        OnceResource::new_with_options(fut, false)
-    }
-
-    #[track_caller]
-    pub fn new_miniserde_blocking(
-        fut: impl Future<Output = T> + Send + 'static,
-    ) -> Self {
-        OnceResource::new_with_options(fut, true)
-    }
-}
-
-#[cfg(feature = "serde-lite")]
-impl<T> OnceResource<T, SerdeLite<JsonSerdeCodec>>
-where
-T: Send + Sync + 'static,
-    SerdeLite<JsonSerdeCodec>: Encoder<T> + Decoder<T>,
-    <SerdeLite<JsonSerdeCodec> as Encoder<T>>::Error: Debug, <SerdeLite<JsonSerdeCodec> as Decoder<T>>::Error: Debug,
-    <<SerdeLite<JsonSerdeCodec> as Decoder<T>>::Encoded as FromEncodedStr>::DecodingError: Debug,
-    <SerdeLite<JsonSerdeCodec> as Encoder<T>>::Encoded: IntoEncodedString,
-    <SerdeLite<JsonSerdeCodec> as Decoder<T>>::Encoded: FromEncodedStr,
-{
-    #[track_caller]
-    pub fn new_serde_lite(
-fut: impl Future<Output = T> + Send + 'static
-    ) -> Self
-    {
-        OnceResource::new_with_options(fut, false)
-    }
-
-    #[track_caller]
-    pub fn new_serde_lite_blocking(
-fut: impl Future<Output = T> + Send + 'static
-    ) -> Self
-    {
-        OnceResource::new_with_options(fut, true)
-    }
-}
-
-#[cfg(feature = "rkyv")]
-impl<T> OnceResource<T, RkyvCodec>
-where
-    T: Send + Sync + 'static,
-    RkyvCodec: Encoder<T> + Decoder<T>,
-    <RkyvCodec as Encoder<T>>::Error: Debug,
-    <RkyvCodec as Decoder<T>>::Error: Debug,
-    <<RkyvCodec as Decoder<T>>::Encoded as FromEncodedStr>::DecodingError:
-        Debug,
-    <RkyvCodec as Encoder<T>>::Encoded: IntoEncodedString,
-    <RkyvCodec as Decoder<T>>::Encoded: FromEncodedStr,
-{
-    #[track_caller]
-    pub fn new_rkyv(fut: impl Future<Output = T> + Send + 'static) -> Self {
-        OnceResource::new_with_options(fut, false)
-    }
-
-    #[track_caller]
-    pub fn new_rkyv_blocking(
-        fut: impl Future<Output = T> + Send + 'static,
-    ) -> Self {
-        OnceResource::new_with_options(fut, true)
-    }
-}

leptos_server/src/resource.rs

@@ -13,7 +13,7 @@ use codee::{
 };
 use core::{fmt::Debug, marker::PhantomData};
 use futures::Future;
-use hydration_context::{SerializedDataId, SharedContext};
+use hydration_context::SerializedDataId;
 use reactive_graph::{
     computed::{
         ArcAsyncDerived, ArcMemo, AsyncDerived, AsyncDerivedFuture,
@@ -24,69 +24,12 @@ use reactive_graph::{
     prelude::*,
     signal::{ArcRwSignal, RwSignal},
 };
-use std::{
-    future::{pending, IntoFuture},
-    ops::Deref,
-    panic::Location,
-    sync::{
-        atomic::{AtomicBool, Ordering},
-        Arc,
-    },
-};
-
-pub(crate) static IS_SUPPRESSING_RESOURCE_LOAD: AtomicBool =
-    AtomicBool::new(false);
-
-pub struct SuppressResourceLoad;
-
-impl SuppressResourceLoad {
-    pub fn new() -> Self {
-        IS_SUPPRESSING_RESOURCE_LOAD.store(true, Ordering::Relaxed);
-        Self
-    }
-}
-
-impl Default for SuppressResourceLoad {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-impl Drop for SuppressResourceLoad {
-    fn drop(&mut self) {
-        IS_SUPPRESSING_RESOURCE_LOAD.store(false, Ordering::Relaxed);
-    }
-}
+use std::{future::IntoFuture, ops::Deref};
 
 pub struct ArcResource<T, Ser = JsonSerdeCodec> {
     ser: PhantomData<Ser>,
     refetch: ArcRwSignal<usize>,
     data: ArcAsyncDerived<T>,
-    #[cfg(debug_assertions)]
-    defined_at: &'static Location<'static>,
-}
-
-impl<T, Ser> Debug for ArcResource<T, Ser> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        let mut d = f.debug_struct("ArcResource");
-        d.field("ser", &self.ser).field("data", &self.data);
-        #[cfg(debug_assertions)]
-        d.field("defined_at", self.defined_at);
-        d.finish_non_exhaustive()
-    }
-}
-
-impl<T, Ser> DefinedAt for ArcResource<T, Ser> {
-    fn defined_at(&self) -> Option<&'static Location<'static>> {
-        #[cfg(debug_assertions)]
-        {
-            Some(self.defined_at)
-        }
-        #[cfg(not(debug_assertions))]
-        {
-            None
-        }
-    }
 }
 
 impl<T, Ser> Clone for ArcResource<T, Ser> {
@@ -95,8 +38,6 @@ impl<T, Ser> Clone for ArcResource<T, Ser> {
             ser: self.ser,
             refetch: self.refetch.clone(),
             data: self.data.clone(),
-            #[cfg(debug_assertions)]
-            defined_at: self.defined_at,
         }
     }
 }
@@ -109,49 +50,6 @@ impl<T, Ser> Deref for ArcResource<T, Ser> {
     }
 }
 
-impl<T, Ser> Track for ArcResource<T, Ser>
-where
-    T: 'static,
-{
-    fn track(&self) {
-        self.data.track();
-    }
-}
-
-impl<T, Ser> ReadUntracked for ArcResource<T, Ser>
-where
-    T: 'static,
-{
-    type Value = <ArcAsyncDerived<T> as ReadUntracked>::Value;
-
-    #[track_caller]
-    fn try_read_untracked(&self) -> Option<Self::Value> {
-        #[cfg(all(feature = "hydration", debug_assertions))]
-        {
-            use reactive_graph::{
-                computed::suspense::SuspenseContext, owner::use_context,
-            };
-            let suspense = use_context::<SuspenseContext>();
-            if suspense.is_none() {
-                let location = std::panic::Location::caller();
-                reactive_graph::log_warning(format_args!(
-                    "At {location}, you are reading a resource in `hydrate` \
-                     mode outside a <Suspense/> or <Transition/>. This can \
-                     cause hydration mismatch errors and loses out on a \
-                     significant performance optimization. To fix this issue, \
-                     you can either: \n1. Wrap the place where you read the \
-                     resource in a <Suspense/> or <Transition/> component, or \
-                     \n2. Switch to using ArcLocalResource::new(), which will \
-                     wait to load the resource until the app is hydrated on \
-                     the client side. (This will have worse performance in \
-                     most cases.)",
-                ));
-            }
-        }
-        self.data.try_read_untracked()
-    }
-}
-
 impl<T, Ser> ArcResource<T, Ser>
 where
     Ser: Encoder<T> + Decoder<T>,
@@ -179,26 +77,17 @@ where
             .map(|sc| sc.next_id())
             .unwrap_or_default();
 
-        let initial = initial_value::<T, Ser>(&id, shared_context.as_ref());
+        let initial = Self::initial_value(&id);
         let is_ready = initial.is_some();
 
         let refetch = ArcRwSignal::new(0);
-        let source = ArcMemo::new({
-            let refetch = refetch.clone();
-            move |_| (refetch.get(), source())
-        });
+        let source = ArcMemo::new(move |_| source());
         let fun = {
             let source = source.clone();
+            let refetch = refetch.clone();
             move || {
-                let (_, source) = source.get();
-                let fut = fetcher(source);
-                async move {
-                    if IS_SUPPRESSING_RESOURCE_LOAD.load(Ordering::Relaxed) {
-                        pending().await
-                    } else {
-                        fut.await
-                    }
-                }
+                refetch.track();
+                fetcher(source.get())
             }
         };
 
@@ -240,8 +129,6 @@ where
             ser: PhantomData,
             data,
             refetch,
-            #[cfg(debug_assertions)]
-            defined_at: Location::caller(),
         }
     }
 
@@ -257,53 +144,43 @@ where
     pub fn refetch(&self) {
         *self.refetch.write() += 1;
     }
-}
 
-#[inline(always)]
-#[allow(unused)]
-pub(crate) fn initial_value<T, Ser>(
-    id: &SerializedDataId,
-    shared_context: Option<&Arc<dyn SharedContext + Send + Sync>>,
-) -> Option<T>
-where
-    Ser: Encoder<T> + Decoder<T>,
-    <Ser as Encoder<T>>::Error: Debug,
-    <Ser as Decoder<T>>::Error: Debug,
-    <<Ser as Decoder<T>>::Encoded as FromEncodedStr>::DecodingError: Debug,
-    <Ser as Encoder<T>>::Encoded: IntoEncodedString,
-    <Ser as Decoder<T>>::Encoded: FromEncodedStr,
-{
-    #[cfg(feature = "hydration")]
-    {
-        use std::borrow::Borrow;
+    #[inline(always)]
+    #[allow(unused)]
+    fn initial_value(id: &SerializedDataId) -> Option<T> {
+        #[cfg(feature = "hydration")]
+        {
+            use std::borrow::Borrow;
 
-        let shared_context = Owner::current_shared_context();
-        if let Some(shared_context) = shared_context {
-            let value = shared_context.read_data(id);
-            if let Some(value) = value {
-                let encoded =
-                    match <Ser as Decoder<T>>::Encoded::from_encoded_str(&value)
-                    {
-                        Ok(value) => value,
+            let shared_context = Owner::current_shared_context();
+            if let Some(shared_context) = shared_context {
+                let value = shared_context.read_data(id);
+                if let Some(value) = value {
+                    let encoded =
+                        match <Ser as Decoder<T>>::Encoded::from_encoded_str(
+                            &value,
+                        ) {
+                            Ok(value) => value,
+                            Err(e) => {
+                                #[cfg(feature = "tracing")]
+                                tracing::error!("couldn't deserialize: {e:?}");
+                                return None;
+                            }
+                        };
+                    let encoded = encoded.borrow();
+                    match Ser::decode(encoded) {
+                        Ok(value) => return Some(value),
+                        #[allow(unused)]
                         Err(e) => {
                             #[cfg(feature = "tracing")]
                             tracing::error!("couldn't deserialize: {e:?}");
-                            return None;
                         }
-                    };
-                let encoded = encoded.borrow();
-                match Ser::decode(encoded) {
-                    Ok(value) => return Some(value),
-                    #[allow(unused)]
-                    Err(e) => {
-                        #[cfg(feature = "tracing")]
-                        tracing::error!("couldn't deserialize: {e:?}");
                     }
                 }
             }
         }
+        None
     }
-    None
 }
 
 impl<T, E, Ser> ArcResource<Result<T, E>, Ser>
@@ -569,37 +446,6 @@ where
     ser: PhantomData<Ser>,
     data: AsyncDerived<T>,
     refetch: RwSignal<usize>,
-    #[cfg(debug_assertions)]
-    defined_at: &'static Location<'static>,
-}
-
-impl<T, Ser> Debug for Resource<T, Ser>
-where
-    T: Send + Sync + 'static,
-{
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        let mut d = f.debug_struct("ArcResource");
-        d.field("ser", &self.ser).field("data", &self.data);
-        #[cfg(debug_assertions)]
-        d.field("defined_at", self.defined_at);
-        d.finish_non_exhaustive()
-    }
-}
-
-impl<T, Ser> DefinedAt for Resource<T, Ser>
-where
-    T: Send + Sync + 'static,
-{
-    fn defined_at(&self) -> Option<&'static Location<'static>> {
-        #[cfg(debug_assertions)]
-        {
-            Some(self.defined_at)
-        }
-        #[cfg(not(debug_assertions))]
-        {
-            None
-        }
-    }
 }
 
 impl<T: Send + Sync + 'static, Ser> Copy for Resource<T, Ser> {}
@@ -621,49 +467,6 @@ where
     }
 }
 
-impl<T, Ser> Track for Resource<T, Ser>
-where
-    T: Send + Sync + 'static,
-{
-    fn track(&self) {
-        self.data.track();
-    }
-}
-
-impl<T, Ser> ReadUntracked for Resource<T, Ser>
-where
-    T: Send + Sync + 'static,
-{
-    type Value = <AsyncDerived<T> as ReadUntracked>::Value;
-
-    #[track_caller]
-    fn try_read_untracked(&self) -> Option<Self::Value> {
-        #[cfg(all(feature = "hydration", debug_assertions))]
-        {
-            use reactive_graph::{
-                computed::suspense::SuspenseContext, owner::use_context,
-            };
-            let suspense = use_context::<SuspenseContext>();
-            if suspense.is_none() {
-                let location = std::panic::Location::caller();
-                reactive_graph::log_warning(format_args!(
-                    "At {location}, you are reading a resource in `hydrate` \
-                     mode outside a <Suspense/> or <Transition/>. This can \
-                     cause hydration mismatch errors and loses out on a \
-                     significant performance optimization. To fix this issue, \
-                     you can either: \n1. Wrap the place where you read the \
-                     resource in a <Suspense/> or <Transition/> component, or \
-                     \n2. Switch to using LocalResource::new(), which will \
-                     wait to load the resource until the app is hydrated on \
-                     the client side. (This will have worse performance in \
-                     most cases.)",
-                ));
-            }
-        }
-        self.data.try_read_untracked()
-    }
-}
-
 impl<T> Resource<T, FromToStringCodec>
 where
     FromToStringCodec: Encoder<T> + Decoder<T>,
@@ -898,8 +701,6 @@ where
             ser: PhantomData,
             data: data.into(),
             refetch: refetch.into(),
-            #[cfg(debug_assertions)]
-            defined_at: Location::caller(),
         }
     }
 

meta/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "leptos_meta"
-version = "0.7.0-gamma"
+version = "0.7.0-beta4"
 authors = ["Greg Johnston"]
 license = "MIT"
 repository = "https://github.com/leptos-rs/leptos"

meta/src/body.rs

@@ -2,11 +2,12 @@ use crate::ServerMetaContext;
 use leptos::{
     attr::NextAttribute,
     component, html,
-    reactive::owner::use_context,
+    reactive_graph::owner::use_context,
     tachys::{
         dom::document,
         html::attribute::Attribute,
         hydration::Cursor,
+        renderer::{dom::Dom, Renderer},
         view::{
             add_attr::AddAnyAttr, Mountable, Position, PositionState, Render,
             RenderHtml,
@@ -28,7 +29,7 @@ use leptos::{
 /// #[component]
 /// fn MyApp() -> impl IntoView {
 ///     provide_meta_context();
-///     let (prefers_dark, set_prefers_dark) = signal(false);
+///     let (prefers_dark, set_prefers_dark) = create_signal(false);
 ///     let body_class = move || {
 ///         if prefers_dark.get() {
 ///             "dark".to_string()
@@ -55,14 +56,14 @@ struct BodyView<At> {
 
 struct BodyViewState<At>
 where
-    At: Attribute,
+    At: Attribute<Dom>,
 {
     attributes: At::State,
 }
 
-impl<At> Render for BodyView<At>
+impl<At> Render<Dom> for BodyView<At>
 where
-    At: Attribute,
+    At: Attribute<Dom>,
 {
     type State = BodyViewState<At>;
 
@@ -78,19 +79,19 @@ where
     }
 }
 
-impl<At> AddAnyAttr for BodyView<At>
+impl<At> AddAnyAttr<Dom> for BodyView<At>
 where
-    At: Attribute,
+    At: Attribute<Dom>,
 {
-    type Output<SomeNewAttr: Attribute> =
-        BodyView<<At as NextAttribute>::Output<SomeNewAttr>>;
+    type Output<SomeNewAttr: Attribute<Dom>> =
+        BodyView<<At as NextAttribute<Dom>>::Output<SomeNewAttr>>;
 
-    fn add_any_attr<NewAttr: Attribute>(
+    fn add_any_attr<NewAttr: Attribute<Dom>>(
         self,
         attr: NewAttr,
     ) -> Self::Output<NewAttr>
     where
-        Self::Output<NewAttr>: RenderHtml,
+        Self::Output<NewAttr>: RenderHtml<Dom>,
     {
         BodyView {
             attributes: self.attributes.add_any_attr(attr),
@@ -98,9 +99,9 @@ where
     }
 }
 
-impl<At> RenderHtml for BodyView<At>
+impl<At> RenderHtml<Dom> for BodyView<At>
 where
-    At: Attribute,
+    At: Attribute<Dom>,
 {
     type AsyncOutput = BodyView<At::AsyncOutput>;
 
@@ -134,7 +135,7 @@ where
 
     fn hydrate<const FROM_SERVER: bool>(
         self,
-        _cursor: &Cursor,
+        _cursor: &Cursor<Dom>,
         _position: &PositionState,
     ) -> Self::State {
         let el = document().body().expect("there to be a <body> element");
@@ -144,20 +145,20 @@ where
     }
 }
 
-impl<At> Mountable for BodyViewState<At>
+impl<At> Mountable<Dom> for BodyViewState<At>
 where
-    At: Attribute,
+    At: Attribute<Dom>,
 {
     fn unmount(&mut self) {}
 
     fn mount(
         &mut self,
-        _parent: &leptos::tachys::renderer::types::Element,
-        _marker: Option<&leptos::tachys::renderer::types::Node>,
+        _parent: &<Dom as Renderer>::Element,
+        _marker: Option<&<Dom as Renderer>::Node>,
     ) {
     }
 
-    fn insert_before_this(&self, _child: &mut dyn Mountable) -> bool {
+    fn insert_before_this(&self, _child: &mut dyn Mountable<Dom>) -> bool {
         false
     }
 }

meta/src/html.rs

@@ -2,11 +2,12 @@ use crate::ServerMetaContext;
 use leptos::{
     attr::NextAttribute,
     component, html,
-    reactive::owner::use_context,
+    reactive_graph::owner::use_context,
     tachys::{
         dom::document,
         html::attribute::Attribute,
         hydration::Cursor,
+        renderer::{dom::Dom, Renderer},
         view::{
             add_attr::AddAnyAttr, Mountable, Position, PositionState, Render,
             RenderHtml,
@@ -52,14 +53,14 @@ struct HtmlView<At> {
 
 struct HtmlViewState<At>
 where
-    At: Attribute,
+    At: Attribute<Dom>,
 {
     attributes: At::State,
 }
 
-impl<At> Render for HtmlView<At>
+impl<At> Render<Dom> for HtmlView<At>
 where
-    At: Attribute,
+    At: Attribute<Dom>,
 {
     type State = HtmlViewState<At>;
 
@@ -78,19 +79,19 @@ where
     }
 }
 
-impl<At> AddAnyAttr for HtmlView<At>
+impl<At> AddAnyAttr<Dom> for HtmlView<At>
 where
-    At: Attribute,
+    At: Attribute<Dom>,
 {
-    type Output<SomeNewAttr: Attribute> =
-        HtmlView<<At as NextAttribute>::Output<SomeNewAttr>>;
+    type Output<SomeNewAttr: Attribute<Dom>> =
+        HtmlView<<At as NextAttribute<Dom>>::Output<SomeNewAttr>>;
 
-    fn add_any_attr<NewAttr: Attribute>(
+    fn add_any_attr<NewAttr: Attribute<Dom>>(
         self,
         attr: NewAttr,
     ) -> Self::Output<NewAttr>
     where
-        Self::Output<NewAttr>: RenderHtml,
+        Self::Output<NewAttr>: RenderHtml<Dom>,
     {
         HtmlView {
             attributes: self.attributes.add_any_attr(attr),
@@ -98,9 +99,9 @@ where
     }
 }
 
-impl<At> RenderHtml for HtmlView<At>
+impl<At> RenderHtml<Dom> for HtmlView<At>
 where
-    At: Attribute,
+    At: Attribute<Dom>,
 {
     type AsyncOutput = HtmlView<At::AsyncOutput>;
 
@@ -134,7 +135,7 @@ where
 
     fn hydrate<const FROM_SERVER: bool>(
         self,
-        _cursor: &Cursor,
+        _cursor: &Cursor<Dom>,
         _position: &PositionState,
     ) -> Self::State {
         let el = document()
@@ -147,22 +148,22 @@ where
     }
 }
 
-impl<At> Mountable for HtmlViewState<At>
+impl<At> Mountable<Dom> for HtmlViewState<At>
 where
-    At: Attribute,
+    At: Attribute<Dom>,
 {
     fn unmount(&mut self) {}
 
     fn mount(
         &mut self,
-        _parent: &leptos::tachys::renderer::types::Element,
-        _marker: Option<&leptos::tachys::renderer::types::Node>,
+        _parent: &<Dom as Renderer>::Element,
+        _marker: Option<&<Dom as Renderer>::Node>,
     ) {
         // <Html> only sets attributes
         // the <html> tag doesn't need to be mounted anywhere, of course
     }
 
-    fn insert_before_this(&self, _child: &mut dyn Mountable) -> bool {
+    fn insert_before_this(&self, _child: &mut dyn Mountable<Dom>) -> bool {
         false
     }
 }

meta/src/lib.rs

@@ -52,14 +52,15 @@ use leptos::{
     attr::NextAttribute,
     component,
     logging::debug_warn,
-    reactive::owner::{provide_context, use_context},
+    reactive_graph::owner::{provide_context, use_context},
     tachys::{
         dom::document,
         html::{
             attribute::Attribute,
-            element::{ElementType, HtmlElement},
+            element::{CreateElement, ElementType, HtmlElement},
         },
         hydration::Cursor,
+        renderer::{dom::Dom, Renderer},
         view::{
             add_attr::AddAnyAttr, Mountable, Position, PositionState, Render,
             RenderHtml,
@@ -105,7 +106,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<Lazy<SendWrapper<Cursor<Dom>>>>,
 }
 
 impl MetaContext {
@@ -122,7 +123,7 @@ const COMMENT_NODE: u16 = 8;
 
 impl Default for MetaContext {
     fn default() -> Self {
-        let build_cursor: fn() -> SendWrapper<Cursor> = || {
+        let build_cursor: fn() -> SendWrapper<Cursor<Dom>> = || {
             let head = document().head().expect("missing <head> element");
             let mut cursor = None;
             let mut child = head.first_child();
@@ -322,10 +323,10 @@ pub fn use_head() -> MetaContext {
 }
 
 pub(crate) fn register<E, At, Ch>(
-    el: HtmlElement<E, At, Ch>,
+    el: HtmlElement<E, At, Ch, Dom>,
 ) -> RegisteredMetaTag<E, At, Ch>
 where
-    HtmlElement<E, At, Ch>: RenderHtml,
+    HtmlElement<E, At, Ch, Dom>: RenderHtml<Dom>,
 {
     #[allow(unused_mut)] // used for `ssr`
     let mut el = Some(el);
@@ -357,19 +358,19 @@ where
 struct RegisteredMetaTag<E, At, Ch> {
     // this is `None` if we've already taken it out to render to HTML on the server
     // we don't render it in place in RenderHtml, so it's fine
-    el: Option<HtmlElement<E, At, Ch>>,
+    el: Option<HtmlElement<E, At, Ch, Dom>>,
 }
 
 struct RegisteredMetaTagState<E, At, Ch>
 where
-    HtmlElement<E, At, Ch>: Render,
+    HtmlElement<E, At, Ch, Dom>: Render<Dom>,
 {
-    state: <HtmlElement<E, At, Ch> as Render>::State,
+    state: <HtmlElement<E, At, Ch, Dom> as Render<Dom>>::State,
 }
 
 impl<E, At, Ch> Drop for RegisteredMetaTagState<E, At, Ch>
 where
-    HtmlElement<E, At, Ch>: Render,
+    HtmlElement<E, At, Ch, Dom>: Render<Dom>,
 {
     fn drop(&mut self) {
         self.state.unmount();
@@ -386,11 +387,11 @@ fn document_head() -> HtmlHeadElement {
     })
 }
 
-impl<E, At, Ch> Render for RegisteredMetaTag<E, At, Ch>
+impl<E, At, Ch> Render<Dom> for RegisteredMetaTag<E, At, Ch>
 where
-    E: ElementType,
-    At: Attribute,
-    Ch: Render,
+    E: ElementType + CreateElement<Dom>,
+    At: Attribute<Dom>,
+    Ch: Render<Dom>,
 {
     type State = RegisteredMetaTagState<E, At, Ch>;
 
@@ -404,21 +405,24 @@ where
     }
 }
 
-impl<E, At, Ch> AddAnyAttr for RegisteredMetaTag<E, At, Ch>
+impl<E, At, Ch> AddAnyAttr<Dom> for RegisteredMetaTag<E, At, Ch>
 where
-    E: ElementType + Send,
-    At: Attribute + Send,
-    Ch: RenderHtml + Send,
+    E: ElementType + CreateElement<Dom> + Send,
+    At: Attribute<Dom> + Send,
+    Ch: RenderHtml<Dom> + Send,
 {
-    type Output<SomeNewAttr: Attribute> =
-        RegisteredMetaTag<E, <At as NextAttribute>::Output<SomeNewAttr>, Ch>;
+    type Output<SomeNewAttr: Attribute<Dom>> = RegisteredMetaTag<
+        E,
+        <At as NextAttribute<Dom>>::Output<SomeNewAttr>,
+        Ch,
+    >;
 
-    fn add_any_attr<NewAttr: Attribute>(
+    fn add_any_attr<NewAttr: Attribute<Dom>>(
         self,
         attr: NewAttr,
     ) -> Self::Output<NewAttr>
     where
-        Self::Output<NewAttr>: RenderHtml,
+        Self::Output<NewAttr>: RenderHtml<Dom>,
     {
         RegisteredMetaTag {
             el: self.el.map(|inner| inner.add_any_attr(attr)),
@@ -426,11 +430,11 @@ where
     }
 }
 
-impl<E, At, Ch> RenderHtml for RegisteredMetaTag<E, At, Ch>
+impl<E, At, Ch> RenderHtml<Dom> for RegisteredMetaTag<E, At, Ch>
 where
-    E: ElementType,
-    At: Attribute,
-    Ch: RenderHtml + Send,
+    E: ElementType + CreateElement<Dom>,
+    At: Attribute<Dom>,
+    Ch: RenderHtml<Dom> + Send,
 {
     type AsyncOutput = Self;
 
@@ -457,7 +461,7 @@ where
 
     fn hydrate<const FROM_SERVER: bool>(
         self,
-        _cursor: &Cursor,
+        _cursor: &Cursor<Dom>,
         _position: &PositionState,
     ) -> Self::State {
         let cursor = use_context::<MetaContext>()
@@ -467,18 +471,18 @@ where
             )
             .cursor;
         let state = self.el.unwrap().hydrate::<FROM_SERVER>(
-            &cursor,
+            &*cursor,
             &PositionState::new(Position::NextChild),
         );
         RegisteredMetaTagState { state }
     }
 }
 
-impl<E, At, Ch> Mountable for RegisteredMetaTagState<E, At, Ch>
+impl<E, At, Ch> Mountable<Dom> for RegisteredMetaTagState<E, At, Ch>
 where
-    E: ElementType,
-    At: Attribute,
-    Ch: Render,
+    E: ElementType + CreateElement<Dom>,
+    At: Attribute<Dom>,
+    Ch: Render<Dom>,
 {
     fn unmount(&mut self) {
         self.state.unmount();
@@ -486,8 +490,8 @@ where
 
     fn mount(
         &mut self,
-        _parent: &leptos::tachys::renderer::types::Element,
-        _marker: Option<&leptos::tachys::renderer::types::Node>,
+        _parent: &<Dom as Renderer>::Element,
+        _marker: Option<&<Dom as Renderer>::Node>,
     ) {
         // we always mount this to the <head>, which is the whole point
         // but this shouldn't warn about the parent being a regular element or being unused
@@ -496,7 +500,7 @@ where
         self.state.mount(&document_head(), None);
     }
 
-    fn insert_before_this(&self, _child: &mut dyn Mountable) -> bool {
+    fn insert_before_this(&self, _child: &mut dyn Mountable<Dom>) -> bool {
         // Registered meta tags will be mounted in the <head>, but *seem* to be mounted somewhere
         // else in the DOM. We should never tell the renderer that we have successfully mounted
         // something before this, because if e.g., a <Meta/> is the first item in an Either, then
@@ -521,7 +525,7 @@ struct MetaTagsView;
 // rendering HTML for all the tags that will be injected into the `<head>`
 //
 // client-side rendering is handled by the individual components
-impl Render for MetaTagsView {
+impl Render<Dom> for MetaTagsView {
     type State = ();
 
     fn build(self) -> Self::State {}
@@ -529,21 +533,21 @@ impl Render for MetaTagsView {
     fn rebuild(self, _state: &mut Self::State) {}
 }
 
-impl AddAnyAttr for MetaTagsView {
-    type Output<SomeNewAttr: Attribute> = MetaTagsView;
+impl AddAnyAttr<Dom> for MetaTagsView {
+    type Output<SomeNewAttr: Attribute<Dom>> = MetaTagsView;
 
-    fn add_any_attr<NewAttr: Attribute>(
+    fn add_any_attr<NewAttr: Attribute<Dom>>(
         self,
         _attr: NewAttr,
     ) -> Self::Output<NewAttr>
     where
-        Self::Output<NewAttr>: RenderHtml,
+        Self::Output<NewAttr>: RenderHtml<Dom>,
     {
         self
     }
 }
 
-impl RenderHtml for MetaTagsView {
+impl RenderHtml<Dom> for MetaTagsView {
     type AsyncOutput = Self;
 
     const MIN_LENGTH: usize = 0;
@@ -566,7 +570,7 @@ impl RenderHtml for MetaTagsView {
 
     fn hydrate<const FROM_SERVER: bool>(
         self,
-        _cursor: &Cursor,
+        _cursor: &Cursor<Dom>,
         _position: &PositionState,
     ) -> Self::State {
     }

meta/src/title.rs

@@ -3,13 +3,14 @@ use leptos::{
     attr::Attribute,
     component,
     oco::Oco,
-    reactive::{
+    reactive_graph::{
         effect::RenderEffect,
         owner::{use_context, Owner},
     },
     tachys::{
         dom::document,
         hydration::Cursor,
+        renderer::{dom::Dom, Renderer},
         view::{
             add_attr::AddAnyAttr, Mountable, Position, PositionState, Render,
             RenderHtml,
@@ -186,7 +187,7 @@ struct TitleViewState {
     effect: RenderEffect<Oco<'static, str>>,
 }
 
-impl Render for TitleView {
+impl Render<Dom> for TitleView {
     type State = TitleViewState;
 
     fn build(mut self) -> Self::State {
@@ -218,21 +219,21 @@ impl Render for TitleView {
     }
 }
 
-impl AddAnyAttr for TitleView {
-    type Output<SomeNewAttr: Attribute> = TitleView;
+impl AddAnyAttr<Dom> for TitleView {
+    type Output<SomeNewAttr: Attribute<Dom>> = TitleView;
 
-    fn add_any_attr<NewAttr: Attribute>(
+    fn add_any_attr<NewAttr: Attribute<Dom>>(
         self,
         _attr: NewAttr,
     ) -> Self::Output<NewAttr>
     where
-        Self::Output<NewAttr>: RenderHtml,
+        Self::Output<NewAttr>: RenderHtml<Dom>,
     {
         self
     }
 }
 
-impl RenderHtml for TitleView {
+impl RenderHtml<Dom> for TitleView {
     type AsyncOutput = Self;
 
     const MIN_LENGTH: usize = 0;
@@ -256,7 +257,7 @@ impl RenderHtml for TitleView {
 
     fn hydrate<const FROM_SERVER: bool>(
         mut self,
-        _cursor: &Cursor,
+        _cursor: &Cursor<Dom>,
         _position: &PositionState,
     ) -> Self::State {
         let el = self.el();
@@ -284,19 +285,19 @@ impl RenderHtml for TitleView {
     }
 }
 
-impl Mountable for TitleViewState {
+impl Mountable<Dom> for TitleViewState {
     fn unmount(&mut self) {}
 
     fn mount(
         &mut self,
-        _parent: &leptos::tachys::renderer::types::Element,
-        _marker: Option<&leptos::tachys::renderer::types::Node>,
+        _parent: &<Dom as Renderer>::Element,
+        _marker: Option<&<Dom as Renderer>::Node>,
     ) {
         // <title> doesn't need to be mounted
         // TitleView::el() guarantees that there is a <title> in the <head>
     }
 
-    fn insert_before_this(&self, _child: &mut dyn Mountable) -> bool {
+    fn insert_before_this(&self, _child: &mut dyn Mountable<Dom>) -> bool {
         false
     }
 }

next_tuple/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "next_tuple"
-version = "0.1.0-gamma"
+version = "0.1.0-beta4"
 authors = ["Greg Johnston"]
 license = "MIT"
 readme = "../README.md"

projects/session_auth_axum/Cargo.toml

@@ -30,21 +30,23 @@ 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 }
+axum_session_auth = { version = "0.14.0", features = [
+  "sqlite-rustls",
+], optional = true }
+axum_session = { version = "0.14.0", features = [
+  "sqlite-rustls",
+], optional = true }
 bcrypt = { version = "0.15.0", optional = true }
 async-trait = { version = "0.1.0", optional = true }
 
 [features]
 default = ["ssr"]
-hydrate = ["leptos/hydrate"]
+hydrate = ["leptos/hydrate", "leptos_meta/hydrate", "leptos_router/hydrate"]
 ssr = [
   "dep:axum",
   "dep:tower",
   "dep:tower-http",
   "dep:tokio",
-  "dep:axum_session_sqlx",
   "dep:axum_session_auth",
   "dep:axum_session",
   "dep:async-trait",

projects/session_auth_axum/src/auth.rs

@@ -28,8 +28,9 @@ impl Default for User {
 #[cfg(feature = "ssr")]
 pub mod ssr {
     pub use super::{User, UserPasshash};
-    pub use axum_session_auth::{Authentication, HasPermission};
-    use axum_session_sqlx::SessionSqlitePool;
+    pub use axum_session_auth::{
+        Authentication, HasPermission, SessionSqlitePool,
+    };
     pub use sqlx::SqlitePool;
     pub use std::collections::HashSet;
     pub type AuthSession = axum_session_auth::AuthSession<

projects/session_auth_axum/src/error_template.rs

@@ -8,10 +8,10 @@ use leptos_axum::ResponseOptions;
 #[component]
 pub fn ErrorTemplate(
     #[prop(optional)] outside_errors: Option<Errors>,
-    #[prop(optional)] errors: Option<ArcRwSignal<Errors>>,
+    #[prop(optional)] errors: Option<RwSignal<Errors>>,
 ) -> impl IntoView {
     let errors = match outside_errors {
-        Some(e) => ArcRwSignal::new(e),
+        Some(e) => RwSignal::new(e),
         None => match errors {
             Some(e) => e,
             None => panic!("No Errors found and we expected errors!"),

projects/session_auth_axum/src/fallback.rs

@@ -0,0 +1,50 @@
+use crate::{error_template::ErrorTemplate, errors::TodoAppError};
+use axum::{
+    body::Body,
+    extract::State,
+    http::{Request, Response, StatusCode, Uri},
+    response::{IntoResponse, Response as AxumResponse},
+};
+use leptos::{view, Errors, LeptosOptions};
+use tower::ServiceExt;
+use tower_http::services::ServeDir;
+
+pub async fn file_and_error_handler(
+    uri: Uri,
+    State(options): State<LeptosOptions>,
+    req: Request<Body>,
+) -> AxumResponse {
+    let root = options.site_root.clone();
+    let res = get_static_file(uri.clone(), &root).await.unwrap();
+
+    if res.status() == StatusCode::OK {
+        res.into_response()
+    } else {
+        let mut errors = Errors::default();
+        errors.insert_with_default_key(TodoAppError::NotFound);
+        let handler = leptos_axum::render_app_to_stream(
+            options.to_owned(),
+            move || view! {<ErrorTemplate outside_errors=errors.clone()/>},
+        );
+        handler(req).await.into_response()
+    }
+}
+
+async fn get_static_file(
+    uri: Uri,
+    root: &str,
+) -> Result<Response<Body>, (StatusCode, String)> {
+    let req = Request::builder()
+        .uri(uri.clone())
+        .body(Body::empty())
+        .unwrap();
+    // `ServeDir` implements `tower::Service` so we can call it with `tower::ServiceExt::oneshot`
+    // This path is relative to the cargo root
+    match ServeDir::new(root).oneshot(req).await {
+        Ok(res) => Ok(res.into_response()),
+        Err(err) => Err((
+            StatusCode::INTERNAL_SERVER_ERROR,
+            format!("Something went wrong: {err}"),
+        )),
+    }
+}

projects/session_auth_axum/src/lib.rs

@@ -2,6 +2,8 @@ pub mod auth;
 pub mod error_template;
 pub mod errors;
 #[cfg(feature = "ssr")]
+pub mod fallback;
+#[cfg(feature = "ssr")]
 pub mod state;
 pub mod todo;
 
@@ -12,5 +14,5 @@ pub fn hydrate() {
     _ = console_log::init_with_level(log::Level::Debug);
     console_error_panic_hook::set_once();
 
-    leptos::mount::hydrate_body(TodoApp);
+    leptos::mount_to_body(TodoApp);
 }

projects/session_auth_axum/src/main.rs

@@ -7,16 +7,14 @@ 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 axum_session_auth::{AuthConfig, AuthSessionLayer, SessionSqlitePool};
+use leptos::{get_configuration, logging::log, provide_context};
 use leptos_axum::{
     generate_route_list, handle_server_fns_with_context, LeptosRoutes,
 };
 use session_auth_axum::{
     auth::{ssr::AuthSession, User},
+    fallback::file_and_error_handler,
     state::AppState,
     todo::*,
 };
@@ -42,19 +40,19 @@ async fn server_fn_handler(
 
 async fn leptos_routes_handler(
     auth_session: AuthSession,
-    state: State<AppState>,
+    State(app_state): State<AppState>,
     req: Request<AxumBody>,
 ) -> Response {
-    let State(app_state) = state.clone();
     let handler = leptos_axum::render_route_with_context(
+        app_state.leptos_options.clone(),
         app_state.routes.clone(),
         move || {
             provide_context(auth_session.clone());
             provide_context(app_state.pool.clone());
         },
-        move || shell(app_state.leptos_options.clone()),
+        TodoApp,
     );
-    handler(state, req).await.into_response()
+    handler(req).await.into_response()
 }
 
 #[tokio::main]
@@ -113,7 +111,7 @@ async fn main() {
             get(server_fn_handler).post(server_fn_handler),
         )
         .leptos_routes_with_handler(routes, get(leptos_routes_handler))
-        .fallback(leptos_axum::file_and_error_handler::<AppState, _>(shell))
+        .fallback(file_and_error_handler)
         .layer(
             AuthSessionLayer::<User, i64, SessionSqlitePool, SqlitePool>::new(
                 Some(pool.clone()),

projects/session_auth_axum/src/state.rs

@@ -1,6 +1,6 @@
 use axum::extract::FromRef;
-use leptos::prelude::LeptosOptions;
-use leptos_axum::AxumRouteListing;
+use leptos::LeptosOptions;
+use leptos_router::RouteListing;
 use sqlx::SqlitePool;
 
 /// This takes advantage of Axum's SubStates feature by deriving FromRef. This is the only way to have more than one
@@ -9,5 +9,5 @@ use sqlx::SqlitePool;
 pub struct AppState {
     pub leptos_options: LeptosOptions,
     pub pool: SqlitePool,
-    pub routes: Vec<AxumRouteListing>,
+    pub routes: Vec<RouteListing>,
 }

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::*;
 use serde::{Deserialize, Serialize};
 
 #[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
@@ -109,33 +109,13 @@ pub async fn delete_todo(id: u16) -> Result<(), ServerFnError> {
         .map(|_| ())?)
 }
 
-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/>
-                <link rel="stylesheet" id="leptos" href="/pkg/session_auth_axum.css"/>
-                <link rel="shortcut icon" type="image/ico" href="/favicon.ico"/>
-                <MetaTags/>
-            </head>
-            <body>
-                <TodoApp/>
-            </body>
-        </html>
-    }
-}
-
 #[component]
 pub fn TodoApp() -> impl IntoView {
-    let login = ServerAction::<Login>::new();
-    let logout = ServerAction::<Logout>::new();
-    let signup = ServerAction::<Signup>::new();
+    let login = create_server_action::<Login>();
+    let logout = create_server_action::<Logout>();
+    let signup = create_server_action::<Signup>();
 
-    let user = Resource::new(
+    let user = create_resource(
         move || {
             (
                 login.version().get(),
@@ -148,6 +128,8 @@ pub fn TodoApp() -> impl IntoView {
     provide_meta_context();
 
     view! {
+        <Link rel="shortcut icon" type_="image/ico" href="/favicon.ico"/>
+        <Stylesheet id="leptos" href="/pkg/session_auth_axum.css"/>
         <Router>
             <header>
                 <A href="/">
@@ -167,7 +149,7 @@ pub fn TodoApp() -> impl IntoView {
                                         ", "
                                         <span>{format!("Login error: {}", e)}</span>
                                     }
-                                        .into_any()
+                                        .into_view()
                                 }
                                 Ok(None) => {
                                     view! {
@@ -177,7 +159,7 @@ pub fn TodoApp() -> impl IntoView {
                                         ", "
                                         <span>"Logged out."</span>
                                     }
-                                        .into_any()
+                                        .into_view()
                                 }
                                 Ok(Some(user)) => {
                                     view! {
@@ -187,7 +169,7 @@ pub fn TodoApp() -> impl IntoView {
                                             {format!("Logged in as: {} ({})", user.username, user.id)}
                                         </span>
                                     }
-                                        .into_any()
+                                        .into_view()
                                 }
                             })
                     }}
@@ -196,15 +178,13 @@ pub fn TodoApp() -> impl IntoView {
             </header>
             <hr/>
             <main>
-                <FlatRoutes fallback=|| "Not found.">
+                <Routes>
                     // Route
-                    <Route path=path!("") view=Todos/>
-                    <Route path=path!("signup") view=move || view! { <Signup action=signup/> }/>
-                    <Route path=path!("login") view=move || view! { <Login action=login/> }/>
-                    <ProtectedRoute
-                        path=path!("settings")
-                        condition=move || user.get().map(|r| r.ok().flatten().is_some())
-                        redirect_path=|| "/"
+                    <Route path="" view=Todos/>
+                    <Route path="signup" view=move || view! { <Signup action=signup/> }/>
+                    <Route path="login" view=move || view! { <Login action=login/> }/>
+                    <Route
+                        path="settings"
                         view=move || {
                             view! {
                                 <h1>"Settings"</h1>
@@ -213,7 +193,7 @@ pub fn TodoApp() -> impl IntoView {
                         }
                     />
 
-                </FlatRoutes>
+                </Routes>
             </main>
         </Router>
     }
@@ -221,12 +201,12 @@ pub fn TodoApp() -> impl IntoView {
 
 #[component]
 pub fn Todos() -> impl IntoView {
-    let add_todo = ServerMultiAction::<AddTodo>::new();
-    let delete_todo = ServerAction::<DeleteTodo>::new();
+    let add_todo = create_server_multi_action::<AddTodo>();
+    let delete_todo = create_server_action::<DeleteTodo>();
     let submissions = add_todo.submissions();
 
     // list of todos is loaded from the server in reaction to changes
-    let todos = Resource::new(
+    let todos = create_resource(
         move || (add_todo.version().get(), delete_todo.version().get()),
         move |_| get_todos(),
     );
@@ -251,11 +231,11 @@ pub fn Todos() -> impl IntoView {
                                             view! {
                                                 <pre class="error">"Server Error: " {e.to_string()}</pre>
                                             }
-                                                .into_any()
+                                                .into_view()
                                         }
                                         Ok(todos) => {
                                             if todos.is_empty() {
-                                                view! { <p>"No tasks were found."</p> }.into_any()
+                                                view! { <p>"No tasks were found."</p> }.into_view()
                                             } else {
                                                 todos
                                                     .into_iter()
@@ -272,11 +252,10 @@ pub fn Todos() -> impl IntoView {
                                                         }
                                                     })
                                                     .collect_view()
-                                                    .into_any()
                                             }
                                         }
                                     })
-                                    .unwrap_or(().into_any())
+                                    .unwrap_or_default()
                             }
                         };
                         let pending_todos = move || {
@@ -287,7 +266,7 @@ pub fn Todos() -> impl IntoView {
                                 .map(|submission| {
                                     view! {
                                         <li class="pending">
-                                            {move || submission.input().get().map(|data| data.title)}
+                                            {move || submission.input.get().map(|data| data.title)}
                                         </li>
                                     }
                                 })
@@ -303,7 +282,9 @@ pub fn Todos() -> impl IntoView {
 }
 
 #[component]
-pub fn Login(action: ServerAction<Login>) -> impl IntoView {
+pub fn Login(
+    action: Action<Login, Result<(), ServerFnError>>,
+) -> impl IntoView {
     view! {
         <ActionForm action=action>
             <h1>"Log In"</h1>
@@ -336,7 +317,9 @@ pub fn Login(action: ServerAction<Login>) -> impl IntoView {
 }
 
 #[component]
-pub fn Signup(action: ServerAction<Signup>) -> impl IntoView {
+pub fn Signup(
+    action: Action<Signup, Result<(), ServerFnError>>,
+) -> impl IntoView {
     view! {
         <ActionForm action=action>
             <h1>"Sign Up"</h1>
@@ -379,7 +362,9 @@ pub fn Signup(action: ServerAction<Signup>) -> impl IntoView {
 }
 
 #[component]
-pub fn Logout(action: ServerAction<Logout>) -> impl IntoView {
+pub fn Logout(
+    action: Action<Logout, Result<(), ServerFnError>>,
+) -> impl IntoView {
     view! {
         <div id="loginbox">
             <ActionForm action=action>

reactive_graph/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "reactive_graph"
-version = "0.1.0-gamma"
+version = "0.1.0-beta4"
 authors = ["Greg Johnston"]
 license = "MIT"
 readme = "../README.md"

reactive_graph/src/actions/action.rs

@@ -1,12 +1,9 @@
 use crate::{
     computed::{ArcMemo, Memo},
     diagnostics::is_suppressing_resource_load,
-    owner::{
-        ArcStoredValue, ArenaItem, FromLocal, LocalStorage, Storage,
-        SyncStorage,
-    },
+    owner::{FromLocal, LocalStorage, Storage, StoredValue, SyncStorage},
     signal::{ArcRwSignal, RwSignal},
-    traits::{DefinedAt, Dispose, Get, GetUntracked, GetValue, Update},
+    traits::{DefinedAt, Dispose, Get, GetUntracked, Update},
     unwrap_signal,
 };
 use any_spawner::Executor;
@@ -27,7 +24,7 @@ use std::{future::Future, panic::Location, pin::Pin, sync::Arc};
 /// # use reactive_graph::actions::*;
 /// # use reactive_graph::prelude::*;
 /// # tokio_test::block_on(async move {
-/// # any_spawner::Executor::init_tokio(); let owner = reactive_graph::owner::Owner::new(); owner.set();
+/// # any_spawner::Executor::init_tokio();
 /// # let _guard = reactive_graph::diagnostics::SpecialNonReactiveZone::enter();
 /// async fn send_new_todo_to_api(task: String) -> usize {
 ///     // do something...
@@ -96,7 +93,6 @@ pub struct ArcAction<I, O> {
     input: ArcRwSignal<Option<I>>,
     value: ArcRwSignal<Option<O>>,
     version: ArcRwSignal<usize>,
-    dispatched: ArcStoredValue<usize>,
     #[allow(clippy::complexity)]
     action_fn: Arc<
         dyn Fn(&I) -> Pin<Box<dyn Future<Output = O> + Send>> + Send + Sync,
@@ -112,7 +108,6 @@ impl<I, O> Clone for ArcAction<I, O> {
             input: self.input.clone(),
             value: self.value.clone(),
             version: self.version.clone(),
-            dispatched: self.dispatched.clone(),
             action_fn: self.action_fn.clone(),
             #[cfg(debug_assertions)]
             defined_at: self.defined_at,
@@ -140,7 +135,7 @@ where
     /// # use reactive_graph::actions::*;
     /// # use reactive_graph::prelude::*;
     /// # tokio_test::block_on(async move {
-    /// # any_spawner::Executor::init_tokio(); let owner = reactive_graph::owner::Owner::new(); owner.set();
+    /// # any_spawner::Executor::init_tokio();
     /// # let _guard = reactive_graph::diagnostics::SpecialNonReactiveZone::enter();
     /// let act = ArcAction::new(|n: &u8| {
     ///     let n = n.to_owned();
@@ -196,7 +191,6 @@ where
             input: Default::default(),
             value: ArcRwSignal::new(value),
             version: Default::default(),
-            dispatched: Default::default(),
             action_fn: Arc::new(move |input| Box::pin(action_fn(input))),
             #[cfg(debug_assertions)]
             defined_at: Location::caller(),
@@ -236,14 +230,14 @@ where
 
             // Update the state before loading
             self.in_flight.update(|n| *n += 1);
-            let current_version = self.dispatched.get_value();
+            let current_version =
+                self.version.try_get_untracked().unwrap_or_default();
             self.input.try_update(|inp| *inp = Some(input));
 
             // Spawn the task
-            crate::spawn({
+            Executor::spawn({
                 let input = self.input.clone();
                 let version = self.version.clone();
-                let dispatched = self.dispatched.clone();
                 let value = self.value.clone();
                 let in_flight = self.in_flight.clone();
                 async move {
@@ -255,7 +249,7 @@ where
                         // otherwise, update the value
                         result = fut => {
                             in_flight.update(|n| *n = n.saturating_sub(1));
-                            let is_latest = dispatched.get_value() <= current_version;
+                            let is_latest = version.get_untracked() <= current_version;
                             if is_latest {
                                 version.update(|n| *n += 1);
                                 value.update(|n| *n = Some(result));
@@ -288,7 +282,8 @@ where
 
             // Update the state before loading
             self.in_flight.update(|n| *n += 1);
-            let current_version = self.dispatched.get_value();
+            let current_version =
+                self.version.try_get_untracked().unwrap_or_default();
             self.input.try_update(|inp| *inp = Some(input));
 
             // Spawn the task
@@ -296,7 +291,6 @@ where
                 let input = self.input.clone();
                 let version = self.version.clone();
                 let value = self.value.clone();
-                let dispatched = self.dispatched.clone();
                 let in_flight = self.in_flight.clone();
                 async move {
                     select! {
@@ -307,7 +301,7 @@ where
                         // otherwise, update the value
                         result = fut => {
                             in_flight.update(|n| *n = n.saturating_sub(1));
-                            let is_latest = dispatched.get_value() <= current_version;
+                            let is_latest = version.get_untracked() <= current_version;
                             if is_latest {
                                 version.update(|n| *n += 1);
                                 value.update(|n| *n = Some(result));
@@ -357,7 +351,6 @@ where
             input: Default::default(),
             value: ArcRwSignal::new(value),
             version: Default::default(),
-            dispatched: Default::default(),
             action_fn: Arc::new(move |input| {
                 Box::pin(SendWrapper::new(action_fn(input)))
             }),
@@ -374,7 +367,7 @@ impl<I, O> ArcAction<I, O> {
     /// # use reactive_graph::actions::*;
     /// # use reactive_graph::prelude::*;
     /// # tokio_test::block_on(async move {
-    /// # any_spawner::Executor::init_tokio(); let owner = reactive_graph::owner::Owner::new(); owner.set();
+    /// # any_spawner::Executor::init_tokio();
     /// # let _guard = reactive_graph::diagnostics::SpecialNonReactiveZone::enter();
     /// let act = ArcAction::new(|n: &u8| {
     ///     let n = n.to_owned();
@@ -402,7 +395,7 @@ impl<I, O> ArcAction<I, O> {
     /// # use reactive_graph::actions::*;
     /// # use reactive_graph::prelude::*;
     /// # tokio_test::block_on(async move {
-    /// # any_spawner::Executor::init_tokio(); let owner = reactive_graph::owner::Owner::new(); owner.set();
+    /// # any_spawner::Executor::init_tokio();
     /// # let _guard = reactive_graph::diagnostics::SpecialNonReactiveZone::enter();
     /// let act = ArcAction::new(|n: &u8| {
     ///     let n = n.to_owned();
@@ -432,7 +425,7 @@ impl<I, O> ArcAction<I, O> {
     /// # use reactive_graph::actions::*;
     /// # use reactive_graph::prelude::*;
     /// # tokio_test::block_on(async move {
-    /// # any_spawner::Executor::init_tokio(); let owner = reactive_graph::owner::Owner::new(); owner.set();
+    /// # any_spawner::Executor::init_tokio();
     /// # let _guard = reactive_graph::diagnostics::SpecialNonReactiveZone::enter();
     /// let act = ArcAction::new(|n: &u8| {
     ///     let n = n.to_owned();
@@ -463,7 +456,7 @@ impl<I, O> ArcAction<I, O> {
     /// # use reactive_graph::actions::*;
     /// # use reactive_graph::prelude::*;
     /// # tokio_test::block_on(async move {
-    /// # any_spawner::Executor::init_tokio(); let owner = reactive_graph::owner::Owner::new(); owner.set();
+    /// # any_spawner::Executor::init_tokio();
     /// # let _guard = reactive_graph::diagnostics::SpecialNonReactiveZone::enter();
     /// let act = ArcAction::new(|n: &u8| {
     ///     let n = n.to_owned();
@@ -517,7 +510,7 @@ where
 /// # use reactive_graph::actions::*;
 /// # use reactive_graph::prelude::*;
 /// # tokio_test::block_on(async move {
-/// # any_spawner::Executor::init_tokio(); let owner = reactive_graph::owner::Owner::new(); owner.set();
+/// # any_spawner::Executor::init_tokio();
 /// # let _guard = reactive_graph::diagnostics::SpecialNonReactiveZone::enter();
 /// async fn send_new_todo_to_api(task: String) -> usize {
 ///     // do something...
@@ -568,7 +561,7 @@ where
 /// function, because it is stored in [Action::input] as well.
 ///
 /// ```rust
-/// # use reactive_graph::actions::*; let owner = reactive_graph::owner::Owner::new(); owner.set();
+/// # use reactive_graph::actions::*;
 /// // if there's a single argument, just use that
 /// let action1 = Action::new(|input: &String| {
 ///     let input = input.clone();
@@ -582,7 +575,7 @@ where
 /// let action3 = Action::new(|input: &(usize, String)| async { todo!() });
 /// ```
 pub struct Action<I, O, S = SyncStorage> {
-    inner: ArenaItem<ArcAction<I, O>, S>,
+    inner: StoredValue<ArcAction<I, O>, S>,
     #[cfg(debug_assertions)]
     defined_at: &'static Location<'static>,
 }
@@ -614,7 +607,7 @@ where
     /// # use reactive_graph::actions::*;
     /// # use reactive_graph::prelude::*;
     /// # tokio_test::block_on(async move {
-    /// # any_spawner::Executor::init_tokio(); let owner = reactive_graph::owner::Owner::new(); owner.set();
+    /// # any_spawner::Executor::init_tokio();
     /// # let _guard = reactive_graph::diagnostics::SpecialNonReactiveZone::enter();
     /// let act = Action::new(|n: &u8| {
     ///     let n = n.to_owned();
@@ -646,7 +639,7 @@ where
         Fu: Future<Output = O> + Send + 'static,
     {
         Self {
-            inner: ArenaItem::new(ArcAction::new(action_fn)),
+            inner: StoredValue::new(ArcAction::new(action_fn)),
             #[cfg(debug_assertions)]
             defined_at: Location::caller(),
         }
@@ -671,7 +664,9 @@ where
         Fu: Future<Output = O> + Send + 'static,
     {
         Self {
-            inner: ArenaItem::new(ArcAction::new_with_value(value, action_fn)),
+            inner: StoredValue::new(ArcAction::new_with_value(
+                value, action_fn,
+            )),
             #[cfg(debug_assertions)]
             defined_at: Location::caller(),
         }
@@ -693,7 +688,7 @@ where
         Fu: Future<Output = O> + Send + 'static,
     {
         Self {
-            inner: ArenaItem::new_local(ArcAction::new_unsync(action_fn)),
+            inner: StoredValue::new_local(ArcAction::new_unsync(action_fn)),
             #[cfg(debug_assertions)]
             defined_at: Location::caller(),
         }
@@ -709,7 +704,7 @@ where
         Fu: Future<Output = O> + Send + 'static,
     {
         Self {
-            inner: ArenaItem::new_local(ArcAction::new_unsync_with_value(
+            inner: StoredValue::new_local(ArcAction::new_unsync_with_value(
                 value, action_fn,
             )),
             #[cfg(debug_assertions)]
@@ -728,7 +723,7 @@ where
     /// # use reactive_graph::actions::*;
     /// # use reactive_graph::prelude::*;
     /// # tokio_test::block_on(async move {
-    /// # any_spawner::Executor::init_tokio(); let owner = reactive_graph::owner::Owner::new(); owner.set();
+    /// # any_spawner::Executor::init_tokio();
     /// # let _guard = reactive_graph::diagnostics::SpecialNonReactiveZone::enter();
     /// let act = Action::new(|n: &u8| {
     ///     let n = n.to_owned();
@@ -759,7 +754,7 @@ where
     /// # use reactive_graph::actions::*;
     /// # use reactive_graph::prelude::*;
     /// # tokio_test::block_on(async move {
-    /// # any_spawner::Executor::init_tokio(); let owner = reactive_graph::owner::Owner::new(); owner.set();
+    /// # any_spawner::Executor::init_tokio();
     /// # let _guard = reactive_graph::diagnostics::SpecialNonReactiveZone::enter();
     /// let act = Action::new(|n: &u8| {
     ///     let n = n.to_owned();
@@ -798,7 +793,7 @@ where
     /// # use reactive_graph::actions::*;
     /// # use reactive_graph::prelude::*;
     /// # tokio_test::block_on(async move {
-    /// # any_spawner::Executor::init_tokio(); let owner = reactive_graph::owner::Owner::new(); owner.set();
+    /// # any_spawner::Executor::init_tokio();
     /// # let _guard = reactive_graph::diagnostics::SpecialNonReactiveZone::enter();
     /// let act = ArcAction::new(|n: &u8| {
     ///     let n = n.to_owned();
@@ -854,7 +849,7 @@ where
     /// # use reactive_graph::actions::*;
     /// # use reactive_graph::prelude::*;
     /// # tokio_test::block_on(async move {
-    /// # any_spawner::Executor::init_tokio(); let owner = reactive_graph::owner::Owner::new(); owner.set();
+    /// # any_spawner::Executor::init_tokio();
     /// # let _guard = reactive_graph::diagnostics::SpecialNonReactiveZone::enter();
     /// let act = Action::new(|n: &u8| {
     ///     let n = n.to_owned();
@@ -913,9 +908,7 @@ where
     /// Calls the `async` function with a reference to the input type as its argument.
     #[track_caller]
     pub fn dispatch(&self, input: I) -> ActionAbortHandle {
-        self.inner
-            .try_with_value(|inner| inner.dispatch(input))
-            .unwrap_or_else(unwrap_signal!(self))
+        self.inner.with_value(|inner| inner.dispatch(input))
     }
 }
 
@@ -928,9 +921,7 @@ where
     /// Calls the `async` function with a reference to the input type as its argument.
     #[track_caller]
     pub fn dispatch_local(&self, input: I) -> ActionAbortHandle {
-        self.inner
-            .try_with_value(|inner| inner.dispatch_local(input))
-            .unwrap_or_else(unwrap_signal!(self))
+        self.inner.with_value(|inner| inner.dispatch_local(input))
     }
 }
 
@@ -951,7 +942,7 @@ where
         Fu: Future<Output = O> + 'static,
     {
         Self {
-            inner: ArenaItem::new_with_storage(ArcAction::new_unsync(
+            inner: StoredValue::new_with_storage(ArcAction::new_unsync(
                 action_fn,
             )),
             #[cfg(debug_assertions)]
@@ -970,7 +961,7 @@ where
         Fu: Future<Output = O> + 'static,
     {
         Self {
-            inner: ArenaItem::new_with_storage(
+            inner: StoredValue::new_with_storage(
                 ArcAction::new_unsync_with_value(value, action_fn),
             ),
             #[cfg(debug_assertions)]
@@ -1016,7 +1007,7 @@ impl<I, O, S> Copy for Action<I, O, S> {}
 /// # use reactive_graph::actions::*;
 /// # use reactive_graph::prelude::*;
 /// # tokio_test::block_on(async move {
-/// # any_spawner::Executor::init_tokio(); let owner = reactive_graph::owner::Owner::new(); owner.set();
+/// # any_spawner::Executor::init_tokio();
 /// # let _guard = reactive_graph::diagnostics::SpecialNonReactiveZone::enter();
 /// let act = create_action(|n: &u8| {
 ///     let n = n.to_owned();

reactive_graph/src/actions/multi_action.rs

@@ -1,10 +1,11 @@
 use crate::{
     diagnostics::is_suppressing_resource_load,
-    owner::{ArenaItem, FromLocal, LocalStorage, Storage, SyncStorage},
+    owner::{FromLocal, LocalStorage, Storage, StoredValue, SyncStorage},
     signal::{ArcReadSignal, ArcRwSignal, ReadSignal, RwSignal},
     traits::{DefinedAt, Dispose, GetUntracked, Set, Update},
     unwrap_signal,
 };
+use any_spawner::Executor;
 use std::{fmt::Debug, future::Future, panic::Location, pin::Pin, sync::Arc};
 
 /// An action that synchronizes multiple imperative `async` calls to the reactive system,
@@ -24,7 +25,7 @@ use std::{fmt::Debug, future::Future, panic::Location, pin::Pin, sync::Arc};
 /// # use reactive_graph::actions::*;
 /// # use reactive_graph::prelude::*;
 /// # tokio_test::block_on(async move {
-/// # any_spawner::Executor::init_tokio(); let owner = reactive_graph::owner::Owner::new(); owner.set();
+/// # any_spawner::Executor::init_tokio();
 /// # let _guard = reactive_graph::diagnostics::SpecialNonReactiveZone::enter();
 /// async fn send_new_todo_to_api(task: String) -> usize {
 ///   // do something...
@@ -45,7 +46,7 @@ use std::{fmt::Debug, future::Future, panic::Location, pin::Pin, sync::Arc};
 /// # });
 /// ```
 pub struct MultiAction<I, O, S = SyncStorage> {
-    inner: ArenaItem<ArcMultiAction<I, O>, S>,
+    inner: StoredValue<ArcMultiAction<I, O>, S>,
     #[cfg(debug_assertions)]
     defined_at: &'static Location<'static>,
 }
@@ -105,7 +106,7 @@ where
     /// # use reactive_graph::actions::*;
     /// # use reactive_graph::prelude::*;
     /// # tokio_test::block_on(async move {
-    /// # any_spawner::Executor::init_tokio(); let owner = reactive_graph::owner::Owner::new(); owner.set();
+    /// # any_spawner::Executor::init_tokio();
     /// # let _guard = reactive_graph::diagnostics::SpecialNonReactiveZone::enter();
     /// // if there's a single argument, just use that
     /// let action1 = MultiAction::new(|input: &String| {
@@ -129,7 +130,9 @@ where
         Fut: Future<Output = O> + Send + 'static,
     {
         Self {
-            inner: ArenaItem::new_with_storage(ArcMultiAction::new(action_fn)),
+            inner: StoredValue::new_with_storage(ArcMultiAction::new(
+                action_fn,
+            )),
             #[cfg(debug_assertions)]
             defined_at: Location::caller(),
         }
@@ -151,7 +154,7 @@ where
     /// # use reactive_graph::actions::*;
     /// # use reactive_graph::prelude::*;
     /// # tokio_test::block_on(async move {
-    /// # any_spawner::Executor::init_tokio(); let owner = reactive_graph::owner::Owner::new(); owner.set();
+    /// # any_spawner::Executor::init_tokio();
     /// # let _guard = reactive_graph::diagnostics::SpecialNonReactiveZone::enter();
     /// async fn send_new_todo_to_api(task: String) -> usize {
     ///   // do something...
@@ -187,7 +190,7 @@ where
     /// ```
     pub fn dispatch(&self, input: I) {
         if !is_suppressing_resource_load() {
-            self.inner.try_with_value(|inner| inner.dispatch(input));
+            self.inner.with_value(|inner| inner.dispatch(input));
         }
     }
 
@@ -202,7 +205,7 @@ where
     /// # use reactive_graph::actions::*;
     /// # use reactive_graph::prelude::*;
     /// # tokio_test::block_on(async move {
-    /// # any_spawner::Executor::init_tokio(); let owner = reactive_graph::owner::Owner::new(); owner.set();
+    /// # any_spawner::Executor::init_tokio();
     /// # let _guard = reactive_graph::diagnostics::SpecialNonReactiveZone::enter();
     /// async fn send_new_todo_to_api(task: String) -> usize {
     ///   // do something...
@@ -230,8 +233,7 @@ where
     /// # });
     /// ```
     pub fn dispatch_sync(&self, value: O) {
-        self.inner
-            .try_with_value(|inner| inner.dispatch_sync(value));
+        self.inner.with_value(|inner| inner.dispatch_sync(value));
     }
 }
 
@@ -245,7 +247,7 @@ where
     /// # use reactive_graph::actions::*;
     /// # use reactive_graph::prelude::*;
     /// # tokio_test::block_on(async move {
-    /// # any_spawner::Executor::init_tokio(); let owner = reactive_graph::owner::Owner::new(); owner.set();
+    /// # any_spawner::Executor::init_tokio();
     /// # let _guard = reactive_graph::diagnostics::SpecialNonReactiveZone::enter();
     /// async fn send_new_todo_to_api(task: String) -> usize {
     ///   // do something...
@@ -286,7 +288,7 @@ where
     /// # use reactive_graph::actions::*;
     /// # use reactive_graph::prelude::*;
     /// # tokio_test::block_on(async move {
-    /// # any_spawner::Executor::init_tokio(); let owner = reactive_graph::owner::Owner::new(); owner.set();
+    /// # any_spawner::Executor::init_tokio();
     /// # let _guard = reactive_graph::diagnostics::SpecialNonReactiveZone::enter();
     /// async fn send_new_todo_to_api(task: String) -> usize {
     ///   // do something...
@@ -336,7 +338,7 @@ where
 /// # use reactive_graph::actions::*;
 /// # use reactive_graph::prelude::*;
 /// # tokio_test::block_on(async move {
-/// # any_spawner::Executor::init_tokio(); let owner = reactive_graph::owner::Owner::new(); owner.set();
+/// # any_spawner::Executor::init_tokio();
 /// # let _guard = reactive_graph::diagnostics::SpecialNonReactiveZone::enter();
 /// async fn send_new_todo_to_api(task: String) -> usize {
 ///   // do something...
@@ -403,7 +405,7 @@ impl<I, O> ArcMultiAction<I, O> {
     /// # use reactive_graph::actions::*;
     /// # use reactive_graph::prelude::*;
     /// # tokio_test::block_on(async move {
-    /// # any_spawner::Executor::init_tokio(); let owner = reactive_graph::owner::Owner::new(); owner.set();
+    /// # any_spawner::Executor::init_tokio();
     /// # let _guard = reactive_graph::diagnostics::SpecialNonReactiveZone::enter();
     /// // if there's a single argument, just use that
     /// let action1 = ArcMultiAction::new(|input: &String| {
@@ -452,7 +454,7 @@ where
     /// # use reactive_graph::actions::*;
     /// # use reactive_graph::prelude::*;
     /// # tokio_test::block_on(async move {
-    /// # any_spawner::Executor::init_tokio(); let owner = reactive_graph::owner::Owner::new(); owner.set();
+    /// # any_spawner::Executor::init_tokio();
     /// # let _guard = reactive_graph::diagnostics::SpecialNonReactiveZone::enter();
     /// async fn send_new_todo_to_api(task: String) -> usize {
     ///   // do something...
@@ -505,7 +507,7 @@ where
 
             let version = self.version.clone();
 
-            crate::spawn(async move {
+            Executor::spawn(async move {
                 let new_value = fut.await;
                 let canceled = submission.canceled.get_untracked();
                 if !canceled {
@@ -529,7 +531,7 @@ where
     /// # use reactive_graph::actions::*;
     /// # use reactive_graph::prelude::*;
     /// # tokio_test::block_on(async move {
-    /// # any_spawner::Executor::init_tokio(); let owner = reactive_graph::owner::Owner::new(); owner.set();
+    /// # any_spawner::Executor::init_tokio();
     /// # let _guard = reactive_graph::diagnostics::SpecialNonReactiveZone::enter();
     /// async fn send_new_todo_to_api(task: String) -> usize {
     ///   // do something...
@@ -579,7 +581,7 @@ impl<I, O> ArcMultiAction<I, O> {
     /// # use reactive_graph::actions::*;
     /// # use reactive_graph::prelude::*;
     /// # tokio_test::block_on(async move {
-    /// # any_spawner::Executor::init_tokio(); let owner = reactive_graph::owner::Owner::new(); owner.set();
+    /// # any_spawner::Executor::init_tokio();
     /// # let _guard = reactive_graph::diagnostics::SpecialNonReactiveZone::enter();
     /// async fn send_new_todo_to_api(task: String) -> usize {
     ///   // do something...
@@ -609,7 +611,7 @@ impl<I, O> ArcMultiAction<I, O> {
     /// # use reactive_graph::actions::*;
     /// # use reactive_graph::prelude::*;
     /// # tokio_test::block_on(async move {
-    /// # any_spawner::Executor::init_tokio(); let owner = reactive_graph::owner::Owner::new(); owner.set();
+    /// # any_spawner::Executor::init_tokio();
     /// # let _guard = reactive_graph::diagnostics::SpecialNonReactiveZone::enter();
     /// async fn send_new_todo_to_api(task: String) -> usize {
     ///   // do something...