docs: clarify SSR/WASM binary size comments

.github/ISSUE_TEMPLATE/bug_report.md

@@ -1,43 +0,0 @@
----
-name: Bug report
-about: Create a report to help us improve
-title: ''
-labels: ''
-assignees: ''
-
----
-
-**Describe the bug**
-A clear and concise description of what the bug is.
-
-**Leptos Dependencies**
-
-Please copy and paste the Leptos dependencies and features from your `Cargo.toml`.
-
-For example:
-```toml
-leptos = { version = "0.3", features = ["serde"] }
-leptos_axum = { version = "0.3", optional = true }
-leptos_meta = { version = "0.3"}
-leptos_router = { version = "0.3"}
-```
-
-**To Reproduce**
-Steps to reproduce the behavior:
-1. Go to '...'
-2. Click on '....'
-3. Scroll down to '....'
-4. See error
-
-**Screenshots**
-If applicable, add screenshots to help explain your problem.
-
-**Next Steps**
-
-- [ ] I will make a PR
-- [ ] I would like to make a PR, but need help getting started
-- [ ] I want someone else to take the time to fix this
-- [ ] This is a low priority for me and is just shared for your information
-
-**Additional context**
-Add any other context about the problem here.

.github/ISSUE_TEMPLATE/config.yml

@@ -1,7 +0,0 @@
-contact_links:
-  - name: Support or Question
-    url: https://github.com/leptos-rs/leptos/discussions/new?category=q-a
-    about: Do you need help figuring out how to do something, or want some help troubleshooting a bug? You can ask in our Discussions section.
-  - name: Discord Discussions
-    url: https://discord.gg/YdRAhS7eQB
-    about: For more informal, real-time conversation and support, you can join our Discord server.

.github/ISSUE_TEMPLATE/feature_request.md

@@ -1,20 +0,0 @@
----
-name: Feature request
-about: Suggest an idea for this project
-title: ''
-labels: ''
-assignees: ''
-
----
-
-**Is your feature request related to a problem? Please describe.**
-A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
-
-**Describe the solution you'd like**
-A clear and concise description of what you want to happen.
-
-**Describe alternatives you've considered**
-A clear and concise description of any alternative solutions or features you've considered.
-
-**Additional context**
-Add any other context or screenshots about the feature request here.

.github/dependabot.yml

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

.github/workflows/autofix.yml

@@ -1,40 +0,0 @@
-name: autofix.ci
-on:
-  pull_request:
-  # Running this workflow on main branch pushes requires write permission to apply changes.
-  # Leave it alone for future uses.
-  # push:
-  #   branches: ["main"]
-permissions:
-  contents: read
-concurrency:
-  group: ${{ github.workflow }}-${{ github.ref }}
-  cancel-in-progress: true
-env:
-  CARGO_TERM_COLOR: always
-  RUST_BACKTRACE: 1
-  DEBIAN_FRONTEND: noninteractive
-jobs:
-  autofix:
-    runs-on: ubuntu-latest
-    timeout-minutes: 30
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions-rust-lang/setup-rust-toolchain@v1
-        with: {toolchain: "nightly-2025-04-16", components: "rustfmt, clippy", target: "wasm32-unknown-unknown", rustflags: ""}
-      - name: Install Glib
-        run: |
-          sudo apt-get update
-          sudo apt-get install -y libglib2.0-dev
-      - name: Install cargo-all-features
-        run: cargo install --git https://github.com/sabify/cargo-all-features --branch arbitrary-command-support
-      - name: Install jq
-        run: sudo apt-get install jq
-      - name: Format the workspace
-        run: cargo fmt --all
-      - name: Clippy the workspace
-        run: cargo all-features clippy --allow-dirty --fix --lib --no-deps
-      - uses: autofix-ci/action@v1.3.1
-        if: ${{ always() }}
-        with:
-          fail-fast: false

.github/workflows/check-examples.yml

@@ -0,0 +1,45 @@
+name: Test
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+env:
+  CARGO_TERM_COLOR: always
+
+jobs:
+  test:
+    name: Check examples ${{ matrix.os }} (using rustc ${{ matrix.rust }})
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        rust:
+          - nightly
+        os:
+          - ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Setup Rust
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: ${{ matrix.rust }}
+          override: true
+          components: rustfmt
+
+      - 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: Run cargo check on all examples
+        run: cargo make check-examples

.github/workflows/check-stable.yml

@@ -0,0 +1,45 @@
+name: Test
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+env:
+  CARGO_TERM_COLOR: always
+
+jobs:
+  test:
+    name: Check examples ${{ matrix.os }} (using rustc ${{ matrix.rust }})
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        rust:
+          - stable
+        os:
+          - ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Setup Rust
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: ${{ matrix.rust }}
+          override: true
+          components: rustfmt
+
+      - 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: Run cargo check on all examples
+        run: cargo make --profile=github-actions check-stable

.github/workflows/check.yml

@@ -0,0 +1,45 @@
+name: Test
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+env:
+  CARGO_TERM_COLOR: always
+
+jobs:
+  test:
+    name: Run `cargo check` ${{ matrix.os }} (using rustc ${{ matrix.rust }})
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        rust:
+          - nightly
+        os:
+          - ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Setup Rust
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: ${{ matrix.rust }}
+          override: true
+          components: rustfmt
+
+      - 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: Run cargo check on all libraries
+        run: cargo make --profile=github-actions check

.github/workflows/ci.yml

@@ -1,68 +0,0 @@
-name: CI
-on:
-  push:
-    branches:
-      - main
-      - leptos_0.6
-      - leptos_0.8
-  pull_request:
-    branches:
-      - main
-      - leptos_0.6
-      - leptos_0.8
-concurrency:
-  group: ${{ github.workflow }}-${{ github.ref }}
-  cancel-in-progress: true
-jobs:
-  get-leptos-changed:
-    uses: ./.github/workflows/get-leptos-changed.yml
-  get-leptos-matrix:
-    uses: ./.github/workflows/get-leptos-matrix.yml
-  get-example-changed:
-    uses: ./.github/workflows/get-example-changed.yml
-  get-examples-matrix:
-    uses: ./.github/workflows/get-examples-matrix.yml
-  test-members:
-    name: CI (members)
-    needs: [get-leptos-changed, get-leptos-matrix]
-    if: needs.get-leptos-changed.outputs.leptos_changed == 'true'
-    strategy:
-      matrix: ${{ fromJSON(needs.get-leptos-matrix.outputs.matrix) }}
-      fail-fast: false
-    uses: ./.github/workflows/run-cargo-make-task.yml
-    with:
-      directory: ${{ matrix.directory }}
-  test-examples:
-    name: CI (examples)
-    needs: [test-members, get-examples-matrix]
-    if: ${{ success() }}
-    strategy:
-      matrix: ${{ fromJSON(needs.get-examples-matrix.outputs.matrix) }}
-      fail-fast: false
-    uses: ./.github/workflows/run-cargo-make-task.yml
-    with:
-      directory: ${{ matrix.directory }}
-  test-only-examples:
-    name: CI (examples)
-    needs: [get-leptos-changed, get-example-changed]
-    if: needs.get-leptos-changed.outputs.leptos_changed != 'true' && needs.get-example-changed.outputs.example_changed == 'true'
-    strategy:
-      matrix: ${{ fromJSON(needs.get-example-changed.outputs.matrix) }}
-      fail-fast: false
-    uses: ./.github/workflows/run-cargo-make-task.yml
-    with:
-      directory: ${{ matrix.directory }}
-  semver-check:
-    name: SemVer check (stable)
-    needs: [get-leptos-changed, test-members, test-examples]
-    if: ${{ success() && needs.get-leptos-changed.outputs.leptos_changed == 'true' && !contains(github.event.pull_request.labels.*.name, 'breaking') }}
-    runs-on: ubuntu-latest
-    steps:
-      - name: Install Glib
-        run: |
-          sudo apt-get update
-          sudo apt-get install -y libglib2.0-dev
-      - name: Checkout
-        uses: actions/checkout@v4
-      - name: Semver Checks
-        uses: obi1kenobi/cargo-semver-checks-action@v2

.github/workflows/fmt.yml

@@ -0,0 +1,34 @@
+name: Test
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+env:
+  CARGO_TERM_COLOR: always
+
+jobs:
+  test:
+    name: Run rustfmt
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        rust:
+          - nightly
+        os:
+          - ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Setup Rust
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: ${{ matrix.rust }}
+          override: true
+          components: rustfmt
+
+      - name: Run Rustfmt
+        run: cargo fmt -- --check

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

@@ -1,43 +0,0 @@
-name: Examples Changed Call
-on:
-  workflow_call:
-    outputs:
-      example_changed:
-        description: "Example Changed"
-        value: ${{ jobs.get-example-changed.outputs.example_changed }}
-      # This is for test-only-examples workflow in ci.yml
-      matrix:
-        description: "Example Changed Directories"
-        value: ${{ jobs.get-example-changed.outputs.matrix }}
-jobs:
-  get-example-changed:
-    name: Get Example Changed
-    runs-on: ubuntu-latest
-    outputs:
-      example_changed: ${{ steps.set-example-changed.outputs.example_changed }}
-      # This is for test-only-examples workflow in ci.yml
-      matrix: ${{ steps.set-example-changed.outputs.matrix }}
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-      - name: Get example files that changed
-        id: changed-files
-        uses: tj-actions/changed-files@v46
-        with:
-          files: |
-            examples/**
-            !examples/cargo-make/**
-            !examples/Makefile.toml
-            !examples/*.md
-      - name: List example files that changed
-        run: echo '${{ steps.changed-files.outputs.all_changed_files }}'
-      - name: Install jq
-        run: sudo apt-get install jq
-      - name: Set example_changed
-        id: set-example-changed
-        run: |
-          echo "example_changed=${{ steps.changed-files.outputs.any_changed }}" >> "$GITHUB_OUTPUT"
-          # This is for test-only-examples workflow in ci.yml
-          echo "matrix={\"directory\": $(echo '${{ steps.changed-files.outputs.all_changed_files }}' | tr ' ' '\n' | awk -F'/' '{print $1 "/" $2}'| sort -u | jq -R -s -c 'split("\n") | .[:-1]')}" >> "$GITHUB_OUTPUT"

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

@@ -1,36 +0,0 @@
-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/\/$//' |
-          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 }}"
-          pwd
-          ls | sort -u

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

@@ -1,35 +0,0 @@
-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
-    runs-on: ubuntu-latest
-    outputs:
-      leptos_changed: ${{ steps.set-source-changed.outputs.leptos_changed }}
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-      - name: Get source files that changed
-        id: changed-source
-        uses: tj-actions/changed-files@v46
-        with:
-          files_ignore: |
-            .*/**/*
-            cargo-make/**/*
-            examples/**/*
-            projects/**/*
-            benchmarks/**/*
-            docs/**/*
-      - name: List source files that changed
-        run: echo '${{ steps.changed-source.outputs.all_changed_files }}'
-      - name: Set leptos_changed
-        id: set-source-changed
-        run: |
-          echo "leptos_changed=${{ steps.changed-source.outputs.any_changed }}" >> "$GITHUB_OUTPUT"

.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/publish-book.yml

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

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

@@ -1,186 +0,0 @@
-name: Run Task
-on:
-  workflow_call:
-    inputs:
-      directory:
-        required: true
-        type: string
-env:
-  CARGO_TERM_COLOR: always
-  CARGO_REGISTRIES_CRATES_IO_PROTOCOL: sparse
-  DEBIAN_FRONTEND: noninteractive
-  RUSTFLAGS: ${{ inputs.erased_mode && '--cfg erase_components' || '' }}
-  LEPTOS_TAILWIND_VERSION: v4.0.14
-  LEPTOS_SASS_VERSION: 1.86.0
-jobs:
-  test:
-    name: "Run (${{ matrix.toolchain }}) (erased_mode: ${{ matrix.erased_mode && 'enabled' || 'disabled' }})"
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        toolchain: [stable, nightly-2025-04-16]
-        erased_mode: [true, false]
-    steps:
-      - name: Free Disk Space
-        run: |
-          echo "Disk space before cleanup:"
-          df -h
-          sudo rm -rf /usr/local/.ghcup
-          sudo rm -rf /opt/hostedtoolcache/CodeQL
-          sudo rm -rf /usr/local/lib/android
-          sudo rm -rf /usr/share/dotnet
-          sudo rm -rf /opt/ghc
-          sudo rm -rf /usr/local/share/boost
-          sudo rm -rf /usr/local/lib/node_modules
-
-          # following lines currenly not needed as it takes too much time
-          # the new isolated CI doesn't need much space to test libraries
-          #
-          # uncommet only if nneded
-          #
-          # sudo apt-get clean
-          # sudo apt-get purge -y '^ghc-.*' '^dotnet-.*' '^llvm-.*' '^mono-.*' '^php.*' '^ruby.*'
-          # sudo apt-get autoremove -y
-          # sudo apt-get clean
-          # sudo rm -rf "$AGENT_TOOLSDIRECTORY"
-          # docker system prune -af
-          # docker image prune -af
-          # docker volume prune -f
-          echo "Disk space after cleanup:"
-          df -h
-      # Setup environment
-      - name: Install Glib
-        run: |
-          sudo apt-get update
-          sudo apt-get install -y libglib2.0-dev
-      - uses: actions/checkout@v4
-      - name: Setup Rust
-        uses: dtolnay/rust-toolchain@master
-        with:
-          toolchain: ${{ matrix.toolchain }}
-          targets: wasm32-unknown-unknown
-          components: clippy,rustfmt
-      - 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 --locked --no-confirm
-      - name: Install cargo-make
-        run: cargo binstall cargo-make --no-confirm
-      - name: Install nextest
-        run: cargo binstall cargo-nextest --no-confirm
-      - name: Install cargo-all-features
-        run: cargo install --git https://github.com/sabify/cargo-all-features --branch arbitrary-command-support
-      # Part of direct-minimal-versions check
-      - name: Install cargo-hack
-        if: contains(matrix.toolchain, 'nightly')
-        uses: taiki-e/install-action@cargo-hack
-      # Part of direct-minimal-versions check
-      - name: Install cargo-minimal-versions
-        if: contains(matrix.toolchain, 'nightly')
-        uses: taiki-e/install-action@cargo-minimal-versions
-      - name: Install Trunk
-        if: contains(inputs.directory, 'examples')
-        run: cargo binstall trunk --no-confirm
-      - name: Print Trunk Version
-        if: contains(inputs.directory, 'examples')
-        run: trunk --version
-      - name: Install Node.js
-        if: contains(inputs.directory, 'examples')
-        uses: actions/setup-node@v4
-        with:
-          node-version: 20
-      - uses: pnpm/action-setup@v4
-        name: Install pnpm
-        if: contains(inputs.directory, 'examples')
-        id: pnpm-install
-        with:
-          version: 8
-          run_install: false
-      - name: Get pnpm store directory
-        if: contains(inputs.directory, 'examples')
-        id: pnpm-cache
-        run: |
-          echo "STORE_PATH=$(pnpm store path)" >> $GITHUB_OUTPUT
-      - uses: actions/cache@v4
-        if: contains(inputs.directory, 'examples')
-        name: Setup pnpm cache
-        with:
-          path: ${{ steps.pnpm-cache.outputs.STORE_PATH }}
-          key: ${{ runner.os }}-pnpm-store-${{ hashFiles('**/pnpm-lock.yaml') }}
-          restore-keys: |
-            ${{ runner.os }}-pnpm-store-
-      - name: Maybe install chromedriver
-        if: contains(inputs.directory, 'examples')
-        run: |
-          project_makefile='${{inputs.directory}}/Makefile.toml'
-          webdriver_count=$(cat $project_makefile | grep "cargo-make/webdriver.toml" | wc -l)
-          if [ $webdriver_count -eq 1 ]; then
-              if ! command -v chromedriver &>/dev/null; then
-                  echo chromedriver required
-                  sudo apt-get update
-                  sudo apt-get install chromium-chromedriver
-              else
-                  echo chromedriver is already installed
-              fi
-          else
-              echo chromedriver is not required
-          fi
-      - name: Maybe install playwright browser dependencies
-        if: contains(inputs.directory, 'examples')
-        run: |
-          for pw_path in $(find '${{inputs.directory}}' -name playwright.config.ts)
-          do
-            pw_dir=$(dirname $pw_path)
-            if [ ! -v $pw_dir ]; then
-              echo "Playwright required in $pw_dir"
-              cd $pw_dir
-              pnpm dlx playwright install --with-deps
-            else
-              echo Playwright is not required
-            fi
-          done
-      - name: Install Deno
-        if: contains(inputs.directory, 'examples')
-        uses: denoland/setup-deno@v2
-        with:
-          deno-version: v1.x
-      - name: Maybe install gtk-rs dependencies
-        if: contains(inputs.directory, 'gtk')
-        run: |
-          sudo apt-get install -y libglib2.0-dev libgio2.0-cil-dev libgraphene-1.0-dev libcairo2-dev libpango1.0-dev libgtk-4-dev
-      - name: Install Tailwind and Sass dependencies
-        if: contains(inputs.directory, 'examples')
-        run: |
-          cd '${{ inputs.directory }}'
-          tailwindcss_version=$(echo "$LEPTOS_TAILWIND_VERSION" | sed 's/^v//')
-          sass_version="$LEPTOS_SASS_VERSION"
-          pnpm add "tailwindcss@$tailwindcss_version" "@tailwindcss/cli@$tailwindcss_version" "sass@$sass_version"
-
-          echo "Tailwind CSS version:"
-          ./node_modules/.bin/tailwindcss --version
-
-          echo "Sass version:"
-          ./node_modules/.bin/sass --version
-      # Run Cargo Make Task
-      - name: ${{ inputs.cargo_make_task }}
-        run: |
-          cd '${{ inputs.directory }}'
-          cargo make --no-workspace --profile=github-actions ci
-          # check the direct-minimal-versions on release
-          if [[ "${{ github.ref_name }}" =~ ^v[0-9]+\.[0-9]+\.[0-9]+$ ]]; then
-            cargo make --no-workspace --profile=github-actions check-minimal-versions
-          fi
-      # Check if the counter_isomorphic can be built with leptos_debuginfo cfg flag in release mode
-      - name: ${{ inputs.cargo_make_task }} with --cfg=leptos_debuginfo
-        if: contains(inputs.directory, 'counter_isomorphic')
-        run: |
-          cd '${{ inputs.directory }}'
-          RUSTFLAGS="$RUSTFLAGS --cfg leptos_debuginfo" cargo leptos build --release
-      - name: Clean up ${{ inputs.directory }}
-        if: always()
-        run: |
-          cd '${{ inputs.directory }}'
-          cargo clean || true
-          rm -rf node_modules || true

.github/workflows/test.yml

@@ -0,0 +1,45 @@
+name: Test
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+env:
+  CARGO_TERM_COLOR: always
+
+jobs:
+  test:
+    name: Run tests ${{ matrix.os }} (using rustc ${{ matrix.rust }})
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        rust:
+          - nightly
+        os:
+          - ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v3
+
+      - name: Setup Rust
+        uses: actions-rs/toolchain@v1
+        with:
+          toolchain: ${{ matrix.rust }}
+          override: true
+          components: rustfmt
+
+      - 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: Run tests with all features
+        run: cargo make --profile=github-actions test

.gitignore

@@ -3,15 +3,9 @@ dist
 pkg
 comparisons
 blob.rs
-**/projects/**/Cargo.lock
-**/examples/**/Cargo.lock
-**/benchmarks/**/Cargo.lock
+Cargo.lock
 **/*.rs.bk
 .DS_Store
 .idea
 .direnv
 .envrc
-
-.vscode
-vendor
-hash.txt

ARCHITECTURE.md

@@ -1,231 +0,0 @@
-# Architecture
-
-The goal of this document is to make it easier for contributors (and anyone
-who’s interested!) to understand the architecture of the framework.
-
-The whole Leptos framework is built from a series of layers. Each of these layers
-depends on the one below it, but each can be used independently from the ones
-built on top of it. While running a command like `cargo leptos new --git 
-leptos-rs/start` pulls in the whole framework, it’s important to remember that
-none of this is magic: each layer of that onion can be stripped away and
-reimplemented, configured, or adapted as needed, incrementally.
-
-> Everything that follows will assume you have a good working understanding
-> of the framework. There will be explanations of how some parts of it work
-> or fit together, but these are not docs. They assume you know what I’m
-> talking about.
-
-## The Reactive System: `leptos_reactive`
-
-The reactive system allows you to define dynamic values (signals),
-the relationships between them (derived signals and memos), and the side effects
-that run in response to them (effects).
-
-These concepts are completely independent of the DOM and can be used to drive
-any kind of reactive updates. The reactive system is based on the assumption
-that data is relatively cheap, and side effects are relatively expensive. Its
-goal is to minimize those side effects (like updating the DOM or making a network
-requests) as infrequently as possible.
-
-The reactive system is implemented as a single data structure that exists at
-runtime. In exchange for giving ownership over a value to the reactive system
-(by creating a signal), you receive a `Copy + 'static` identifier for its
-location in the reactive system. This enables most of the ergonomics of storing
-and sharing state, the use of callback closures without lifetime issues, etc.
-This is implemented by storing signals in a slotmap arena. The signal, memo,
-and scope types that are exposed to users simply carry around an index into that
-slotmap.
-
-> Items owned by the reactive system are dropped when the corresponding reactive
-> scope is dropped, i.e., when the component or section of the UI they’re
-> created in is removed. In a sense, Leptos implements a “garbage collector”
-> in which the lifetime of data is tied to the lifetime of the UI, not Rust’s
-> lexical scopes.
-
-## The DOM Renderer: `leptos_dom`
-
-The reactive system can be used to drive any kinds of side effects. One very
-common side effect is calling an imperative method, for example to update the
-DOM.
-
-The entire DOM renderer is built on top of the reactive system. It provides
-a builder pattern that can be used to create DOM elements dynamically.
-
-The renderer assumes, as a convention, that dynamic attributes, classes,
-styles, and children are defined by being passed a `Fn() -> T`, where their
-static equivalents just receive `T`. There’s nothing about this that is
-divinely ordained, but it’s a useful convention because it allows us to use
-zero-overhead derived signals as one of several ways to indicate dynamic
-content.
-
-`leptos_dom` also contains code for server-side rendering of the same
-UI views to HTML, either for out-of-order streaming (`src/ssr.rs`) or
-in-order streaming/async rendering (`src/ssr_in_order.rs`).
-
-## The Macros: `leptos_macro`
-
-It’s entirely possible to write Leptos code with no macros at all. The
-`view` and `component` macros, the most common, can be replaced by
-the builder syntax and simple functions (see the `counter_without_macros`
-example). But the macros enable a JSX-like syntax for describing views.
-
-This package also contains the `Params` derive macro used for typed
-queries and route params in the router.
-
-### Macro-based Optimizations
-
-Leptos 0.0.x was built much more heavily on macros. Taking its cues  
-from SolidJS, the `view` macro emitted different code for CSR, SSR, and
-hydration, optimizing each. The CSR/hydrate versions worked by compiling
-the view to an HTML template string, cloning that `<template>`, and
-traversing the DOM to set up reactivity. The SSR version worked similarly
-by compiling the static parts of the view to strings at compile time,
-reducing the amount of work that needed to be done on each request.
-
-Proc macros are hard, and this system was brittle. 0.1 introduced a
-more robust renderer, including the builder syntax, and rebuilt the `view`
-macro to use that builder syntax instead. It moved the optimized-but-buggy
-CSR version of the macro to a more-limited `template` macro.
-
-The `view` macro now separately optimizes SSR to use the same static-string
-optimizations, which (by our benchmarks) makes Leptos about 3-4x faster
-than similar Rust frontend frameworks in its HTML rendering.
-
-> The optimization is pretty straightforward. Consider the following view:
->
-> ```rust
-> view! { cx,
->   <main class="text-center">
->     <div class="flex-col">
->       <button>"Click me."</button>
->       <p class="italic">"Text."</p>
->     </div>
->   </main>
-> }
-> ```
->
-> Internally, with the builder this is something like
->
-> ```rust
-> Element {
->   tag: "main",
->   attrs: vec![("class", "text-center")],
->   children: vec![
-> 	  Element {
-> 		tag: "div",
-> 		attrs: vec![("class", "flex-col")],
->       children: vec![
->         Element {
-> 	        tag: "button",
-> 			attrs: vec![],
-> 			children: vec!["Click me"]
->         },
->         Element {
-> 	        tag: "p",
-> 			attrs: vec![("class", "italic")],
-> 			children: vec!["Text"]
->         }
->       ]
-> 	  }
->   ]
-> }
-> ```
->
-> This is a _bunch_ of small allocations and separate strings,
-> and in early 0.1 versions we used a `SmallVec` for children and
-> attributes and actually caused some stack overflows.
->
-> But if you look at the view itself you can see that none of this
-> will _ever_ change. So we can actually optimize it at compile
-> time to a single `&'static str`:
->
-> ```rust
-> r#"<main class="text-center">
->     <div class="flex-col">
->       <button>"Click me."</button>
->       <p class="italic">"Text."</p>
->     </div>
->   </main>"#
-> ```
-
-## Server Functions (`leptos_server`, `server_fn`, and `server_fn_macro`)
-
-Server functions are a framework-agnostic shorthand for converting
-a function, whose body can only be run on the server, into an ad hoc
-REST API endpoint, and then generating code on the client to call that
-endpoint when you call the function.
-
-These are inspired by Solid/Bling’s `server$` functions, and there’s
-similar work being done in a number of other JavaScript frameworks.
-
-RPC is not a new idea, but these kinds of server functions may be.
-Specifically, by using web standards (defaulting to `POST`/`GET` requests
-with URL-encoded form data) they allow easy graceful degradation and the
-use of the `<form>` element.
-
-This function is split across three packages so that `server_fn` and
-`server_fn_macro` can be used by other frameworks. `leptos_server`
-includes some Leptos-specific reactive functionality (like actions).
-
-## `leptos`
-
-This package is built on and reexports most of the layers already
-mentioned, and implements a number of control-flow components (`<Show/>`,
-`<ErrorBoundary/>`, `<For/>`, `<Suspense/>`, `<Transition/>`) that use
-public APIs of the other packages.
-
-This is the main entrypoint for users, but is relatively light itself.
-
-## `leptos_meta`
-
-This package exists to allow you to work with tags normally found in
-the `<head>`, from within your components.
-
-It is implemented as a distinct package, rather than part of
-`leptos_dom`, on the principle that “what can be implemented in userland,
-should be.” The framework can be used without it, so it’s not in core.
-
-## `leptos_router`
-
-The router originates as a direct port of `solid-router`, which is the
-origin of most of its terminology, architecture, and route-matching logic.
-
-Subsequent developments (like animated routing, and managing route transitions
-given the lack of `useTransition` in Leptos) have caused it to diverge
-slightly from Solid’s exact code, but it is still very closely related.
-
-The core principle here is “nested routing,” dividing a single page
-into independently-rendered parts. This is described in some detail in the docs.
-
-Like `leptos_meta`, it is implemented as a distinct package, because it
-can be replaced with another router or with none. The framework can be used
-without it, so it’s not in core.
-
-## Server Integrations
-
-The server integrations are the most “frameworky” layer of the whole framework.
-These **do** assume the use of `leptos`, `leptos_router`, and `leptos_meta`.
-They specifically draw routing data from `leptos_router`, and inject the
-metadata from `leptos_meta` into the `<head>` appropriately.
-
-But of course, if you one day create `leptos-helmet` and `leptos-better-router`,
-you can create new server integrations that plug them into the SSR rendering
-methods from `leptos_dom` instead. Everything involved is quite modular.
-
-These packages essentially provide helpers that save the templates and user apps
-from including a huge amount of boilerplate to connect the various other packages
-correctly. Again, early versions of the framework examples are illustrative here
-for reference: they include large amounts of manual SSR route handling, etc.
-
-## `cargo-leptos` helpers
-
-`leptos_config` and `leptos_hot_reload` exist to support two different features
-of `cargo-leptos`, namely its configuration and its view-patching/hot-reloading 
-features.
-
-It’s important to say that the main feature `cargo-leptos` remains its ability
-to conveniently tie together different build tooling, compiling your app to
-WASM for the browser, building the server version, pulling in SASS and
-Tailwind, etc. It is an extremely good build tool, not a magic formula. Each
-of the examples includes instructions for how to run the examples without
-`cargo-leptos`.

CODE_OF_CONDUCT.md

@@ -2,7 +2,7 @@
 
 _This Code of Conduct is based on the [Rust Code of Conduct](https://www.rust-lang.org/policies/code-of-conduct)
 and the [Bevy Code of Conduct](https://raw.githubusercontent.com/bevyengine/bevy/main/CODE_OF_CONDUCT.md),
-which are adapted from the [Node.js Policy on Trolling](http://blog.izs.me/post/30036893703/policy-on-trolling)
+which are adapted from the [Node.js Policy on Trolling](http://blog.izs.me/post/30036893703/policy-on-trolling) 
 and the [Contributor Covenant](https://www.contributor-covenant.org)._
 
 ## Our Pledge

CONTRIBUTING.md

@@ -1,101 +0,0 @@
-# Contributing to Leptos
-
-Thanks for your interesting in contributing to Leptos! This is a truly
-community-driven framework, and while we have a central maintainer (@gbj)
-large parts of the renderer, reactive system, and server integrations have
-all been written by other contributors. Contributions are always welcome.
-
-Participation in this community is governed by a [Code of Conduct](./CODE_OF_CONDUCT.md).
-Some of the most active conversations around development take place on our
-[Discord server](https://discord.gg/YdRAhS7eQB).
-
-This guide seeks to
-
-- describe some of the framework’s values (in a technical, not an ethical, sense)
-- provide a high-level overview of how the pieces of the framework fit together
-- orient you to the organization of this repository
-
-## Values
-
-Leptos, as a framework, reflects certain technical values:
-
-- **Expose primitives rather than imposing patterns.** Provide building blocks
-  that users can combine together to build up more complex behavior, rather than
-  requiring users follow certain templates, file formats, etc. e.g., components
-  are defined as functions, rather than a bespoke single-file component format.
-  The reactive system feeds into the rendering system, rather than being defined
-  by it.
-- **Bottom-up over top-down.** If you envision a user’s application as a tree
-  (like an HTML document), push meaning toward the leaves of the tree. e.g., If data
-  needs to be loaded, load it in a granular primitive (resources) rather than a
-  route- or page-level data structure.
-- **Performance by default.** When possible, users should only pay for what they
-  use. e.g., we don’t make all component props reactive by default. This is
-  because doing so would force the overhead of a reactive prop onto props that don’t
-  need to be reactive.
-- **Full-stack performance.** Performance can’t be limited to a single metric,
-  whether that’s a DOM rendering benchmark, WASM binary size, or server response
-  time. Use methods like HTTP streaming and progressive enhancement to enable
-  applications to load, become interactive, and respond as quickly as possible.
-- **Use safe Rust.** There’s no need for `unsafe` Rust in the framework, and
-  avoiding it at all costs reduces the maintenance and testing burden significantly.
-- **Embrace Rust semantics.** Especially in things like UI templating, use Rust
-  semantics or extend them in a predictable way with control-flow components
-  rather than overloading the meaning of Rust terms like `if` or `for` in a
-  framework-specific way.
-- **Enhance ergonomics without obfuscating what’s happening.** This is by far
-  the hardest to achieve. It’s often the case that adding additional layers to
-  improve DX (like a custom build tool and starter templates) comes across as
-  “too magic” to some people who haven’t had to build the same things manually.
-  When possible, make it easier to see how the pieces fit together, without
-  sacrificing the improved DX.
-
-## Processes
-
-We do not have PR templates or formal processes for approving PRs. But there
-are a few guidelines that will make it a better experience for everyone:
-
-- Run `cargo fmt` before submitting your code.
-- Keep PRs limited to addressing one feature or one issue, in general. In some
-  cases (e.g., “reduce allocations in the reactive system”) this may touch a number
-  of different areas, but is still conceptually one thing.
-- If it’s an unsolicited PR not linked to an open issue, please include a
-  specific explanation for what it’s trying to achieve. For example: “When I
-  was trying to deploy my app under _circumstances X_, I found that the way
-  _function Y_ was implemented caused _issue Z_. This PR should fix that by
-  _solution._”
-- Our CI tests every PR against all the existing examples, sometimes requiring
-  compilation for both server and client side, etc. It’s thorough but slow. If
-  you want to run CI locally to reduce frustration, you can do that by installing
-  `cargo-make` and using `cargo make check && cargo make test && cargo make
-check-examples`.
-
-## Before Submitting a PR
-
-We have a fairly extensive CI setup that runs both lints (like `rustfmt` and `clippy`)
-and tests on PRs. You can run most of these locally if you have `cargo-make` installed.
-
-Note that some of the `rustfmt` settings used require usage of the nightly compiler.
-Formatting the code using the stable toolchain may result in a wrong code format and
-subsequently CI errors.
-Run `cargo +nightly fmt` if you want to keep the stable toolchain active.
-You may want to let your IDE automatically use the `+nightly` parameter when a
-"format on save" action is used.
-
-If you added an example, make sure to add it to the list in `examples/Makefile.toml`.
-
-From the root directory of the repo, run
-- `cargo +nightly fmt`
-- `cargo +nightly make check`
-- `cargo +nightly make test`
-- `cargo +nightly make check-examples`
-- `cargo +nightly make --profile=github-actions ci`
-
-If you modified an example:
-- `cd examples/your_example`
-- `cargo +nightly fmt -- --config-path ../..`
-- `cargo +nightly make --profile=github-actions verify-flow`
-
-## Architecture
-
-See [ARCHITECTURE.md](./ARCHITECTURE.md).

Cargo.toml

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

Makefile.toml

@@ -3,37 +3,118 @@
 #     cargo install --force cargo-make
 ############
 
-[env]
-CARGO_MAKE_EXTEND_WORKSPACE_MAKEFILE = true
+[config]
+# make tasks run at the workspace root
+default_to_workspace = false
 
-[tasks.check-stable]
-workspace = false
+[tasks.check]
 clear = true
 dependencies = [
-  { name = "lint", path = "examples/counter_without_macros" },
-  { name = "lint", path = "examples/counters_stable" },
+	"check-all",
+	"check-wasm",
+	"check-all-release",
+	"check-wasm-release",
 ]
 
-[tasks.ci-examples]
-workspace = false
-cwd = "examples"
+[tasks.check-all]
 command = "cargo"
-args = ["make", "ci-clean"]
+args = ["+nightly", "check-all-features"]
+install_crate = "cargo-all-features"
+
+[tasks.check-wasm]
+clear = true
+dependencies = [{ name = "check-wasm", path = "leptos" }]
+
+[tasks.check-all-release]
+command = "cargo"
+args = ["+nightly", "check-all-features"]
+install_crate = "cargo-all-features"
+
+[tasks.check-wasm-release]
+clear = true
+dependencies = [{ name = "check-wasm-release", path = "leptos" }]
 
 [tasks.check-examples]
-workspace = false
-cwd = "examples"
-command = "cargo"
-args = ["make", "check-clean"]
+clear = true
+dependencies = [
+	{ name = "check", path = "examples/counter" },
+	{ name = "check", path = "examples/counter_isomorphic" },
+	{ name = "check", path = "examples/counters" },
+	{ name = "check", path = "examples/error_boundary" },
+	{ name = "check", path = "examples/errors_axum" },
+	{ name = "check", path = "examples/fetch" },
+	{ name = "check", path = "examples/hackernews" },
+	{ name = "check", path = "examples/hackernews_axum" },
+	{ name = "check", path = "examples/login_with_token_csr_only" },
+	{ name = "check", path = "examples/parent_child" },
+	{ name = "check", path = "examples/router" },
+	{ name = "check", path = "examples/session_auth_axum" },
+	{ name = "check", path = "examples/slots" },
+	{ name = "check", path = "examples/ssr_modes" },
+	{ name = "check", path = "examples/ssr_modes_axum" },
+	{ name = "check", path = "examples/tailwind" },
+	{ name = "check", path = "examples/tailwind_csr_trunk" },
+	{ name = "check", path = "examples/todo_app_sqlite" },
+	{ name = "check", path = "examples/todo_app_sqlite_axum" },
+	{ name = "check", path = "examples/todo_app_sqlite_viz" },
+	{ name = "check", path = "examples/todomvc" },
+]
 
-[tasks.build-examples]
-workspace = false
+[tasks.check-stable]
+clear = true
+dependencies = [
+	{ name = "check", path = "examples/counter_without_macros" },
+	{ name = "check", path = "examples/counters_stable" },
+]
+
+[tasks.test]
+clear = true
+dependencies = [
+	"test-all",
+	"test-leptos_macro-example",
+	"doc-leptos_macro-example",
+]
+
+[tasks.test-all]
+command = "cargo"
+args = ["+nightly", "test-all-features"]
+install_crate = "cargo-all-features"
+
+[tasks.test-leptos_macro-example]
+description = "Tests the leptos_macro/example to check if macro handles doc comments correctly"
+command = "cargo"
+args = ["+nightly", "test", "--doc"]
+cwd = "leptos_macro/example"
+install_crate = false
+
+[tasks.doc-leptos_macro-example]
+description = "Docs the leptos_macro/example to check if macro handles doc comments correctly"
+command = "cargo"
+args = ["+nightly", "doc"]
+cwd = "leptos_macro/example"
+install_crate = false
+
+[tasks.test-examples]
+description = "Run all unit and web tests for examples"
 cwd = "examples"
 command = "cargo"
-args = ["make", "build-clean"]
+args = ["make", "test-unit-and-web"]
+
+[tasks.verify-examples]
+description = "Run all quality checks and tests for examples"
+cwd = "examples"
+command = "cargo"
+args = ["make", "verify-flow"]
 
 [tasks.clean-examples]
-workspace = false
+description = "Clean all example projects"
 cwd = "examples"
 command = "cargo"
-args = ["make", "clean"]
+args = ["make", "clean-all"]
+
+[env]
+RUSTFLAGS = ""
+LEPTOS_OUTPUT_NAME = "ci" # allows examples to check/build without cargo-leptos
+
+[env.github-actions]
+RUSTFLAGS = "-D warnings"

README.md

@@ -5,23 +5,18 @@
 
 [![crates.io](https://img.shields.io/crates/v/leptos.svg)](https://crates.io/crates/leptos)
 [![docs.rs](https://docs.rs/leptos/badge.svg)](https://docs.rs/leptos)
-![Crates.io MSRV](https://img.shields.io/crates/msrv/leptos)
 [![Discord](https://img.shields.io/discord/1031524867910148188?color=%237289DA&label=discord)](https://discord.gg/YdRAhS7eQB)
 [![Matrix](https://img.shields.io/badge/Matrix-leptos-grey?logo=matrix&labelColor=white&logoColor=black)](https://matrix.to/#/#leptos:matrix.org)
 
-[Website](https://leptos.dev) | [Book](https://leptos-rs.github.io/leptos/) | [Docs.rs](https://docs.rs/leptos/latest/leptos/) | [Playground](https://codesandbox.io/p/sandbox/leptos-rtfggt?file=%2Fsrc%2Fmain.rs%3A1%2C1) | [Discord](https://discord.gg/YdRAhS7eQB)
-
-You can find a list of useful libraries and example projects at [`awesome-leptos`](https://github.com/leptos-rs/awesome-leptos).
-
 # Leptos
 
 ```rust
 use leptos::*;
 
 #[component]
-pub fn SimpleCounter(initial_value: i32) -> impl IntoView {
+pub fn SimpleCounter(cx: Scope, initial_value: i32) -> impl IntoView {
     // create a reactive signal with the initial value
-    let (value, set_value) = signal(initial_value);
+    let (value, set_value) = create_signal(cx, initial_value);
 
     // create event handlers for our buttons
     // note that `value` and `set_value` are `Copy`, so it's super easy to move them into closures
@@ -30,42 +25,21 @@ pub fn SimpleCounter(initial_value: i32) -> impl IntoView {
     let increment = move |_| set_value.update(|value| *value += 1);
 
     // create user interfaces with the declarative `view!` macro
-    view! {
+    view! { cx,
         <div>
-            <button on:click=clear>Clear</button>
-            <button on:click=decrement>-1</button>
-            // text nodes can be quoted or unquoted
+            <button on:click=clear>"Clear"</button>
+            <button on:click=decrement>"-1"</button>
             <span>"Value: " {value} "!"</span>
-            <button on:click=increment>+1</button>
+            <button on:click=increment>"+1"</button>
         </div>
     }
 }
 
-// we also support a builder syntax rather than the JSX-like `view` macro
-#[component]
-pub fn SimpleCounterWithBuilder(initial_value: i32) -> impl IntoView {
-    use leptos::html::*;
-
-    let (value, set_value) = signal(initial_value);
-    let clear = move |_| set_value(0);
-    let decrement = move |_| set_value.update(|value| *value -= 1);
-    let increment = move |_| set_value.update(|value| *value += 1);
-
-    // the `view` macro above expands to this builder syntax
-    div().child((
-        button().on(ev::click, clear).child("Clear"),
-        button().on(ev::click, decrement).child("-1"),
-        span().child(("Value: ", value, "!")),
-        button().on(ev::click, increment).child("+1")
-    ))
-}
-
 // Easy to use with Trunk (trunkrs.dev) or with a simple wasm-bindgen setup
 pub fn main() {
-    mount_to_body(|| view! {
-        <SimpleCounter initial_value=3 />
-    })
+    mount_to_body(|cx| view! { cx,  <SimpleCounter initial_value=3 /> })
 }
+
 ```
 
 ## About the Framework
@@ -92,7 +66,7 @@ Here are some resources for learning more about Leptos:
 
 ## `nightly` Note
 
-Most of the examples assume you’re using `nightly` version of Rust and the `nightly` feature of Leptos. To use `nightly` Rust, you can either set your toolchain globally or on per-project basis.
+Most of the examples assume you’re using `nightly` version of Rust. For this, you can either set your toolchain globally or on per-project basis.
 
 To set `nightly` as a default toolchain for all projects (and add the ability to compile Rust to WebAssembly, if you haven’t already):
 
@@ -110,7 +84,13 @@ channel = "nightly"
 targets = ["wasm32-unknown-unknown"]
 ```
 
-The `nightly` feature enables the function call syntax for accessing and setting signals, as opposed to `.get()` and `.set()`. This leads to a consistent mental model in which accessing a reactive value of any kind (a signal, memo, or derived signal) is always represented as a function call. This is only possible with nightly Rust and the `nightly` feature.
+If you’re on `stable`, note the following:
+
+1. You need to enable the `"stable"` flag in `Cargo.toml`: `leptos = { version = "0.2", features = ["stable"] }`
+2. `nightly` enables the function call syntax for accessing and setting signals. If you’re using `stable`,
+   you’ll just call `.get()`, `.set()`, or `.update()` manually. Check out the
+   [`counters_stable` example](https://github.com/leptos-rs/leptos/blob/main/examples/counters_stable/src/main.rs)
+   for examples of the correct API.
 
 ## `cargo-leptos`
 
@@ -129,7 +109,7 @@ Open browser to [http://localhost:3000/](http://localhost:3000/).
 
 ### What’s up with the name?
 
-_Leptos_ (λεπτός) is an ancient Greek word meaning “thin, light, refined, fine-grained.” To me, a classicist and not a dog owner, it evokes the lightweight reactive system that powers the framework. I've since learned the same word is at the root of the medical term “leptospirosis,” a blood infection that affects humans and animals... My bad. No dogs were harmed in the creation of this framework.
+_Leptos_ (λεπτός) is an ancient Greek word meaning “thin, light, refine, fine-grained.” To me, a classicist and not a dog owner, it evokes the lightweight reactive system that powers the framework. I've since learned the same word is at the root of the medical term “leptospirosis,” a blood infection that affects humans and animals... My bad. No dogs were harmed in the creation of this framework.
 
 ### Is it production ready?
 
@@ -137,7 +117,7 @@ People usually mean one of three things by this question.
 
 1. **Are the APIs stable?** i.e., will I have to rewrite my whole app from Leptos 0.1 to 0.2 to 0.3 to 0.4, or can I write it now and benefit from new features and updates as new versions come?
 
-The APIs are basically settled. We’re adding new features, but we’re very happy with where the type system and patterns have landed. I would not expect major breaking changes to your code to adapt to future releases, in terms of architecture.
+The APIs are basically settled. We’re adding new features, but we’re very happy with where the type system and patterns have landed. I would not expect major breaking changes to your code to adapt to future releases. The sorts of breaking changes that we discuss are things like “Oh yeah, that function should probably take `cx` as its argument...” not major changes to the way you write your application.
 
 2. **Are there bugs?**
 
@@ -151,34 +131,44 @@ There are several people in the community using Leptos right now for internal ap
 
 ### Can I use this for native GUI?
 
-Sure! Obviously the `view` macro is for generating DOM nodes but you can use the reactive system to drive any native GUI toolkit that uses the same kind of object-oriented, event-callback-based framework as the DOM pretty easily. The principles are the same:
+Sure! Obviously the `view` macro is for generating DOM nodes but you can use the reactive system to drive native any GUI toolkit that uses the same kind of object-oriented, event-callback-based framework as the DOM pretty easily. The principles are the same:
 
 - Use signals, derived signals, and memos to create your reactive system
 - Create GUI widgets
 - Use event listeners to update signals
 - Create effects to update the UI
 
-The 0.7 update originally set out to create a "generic rendering" approach that would allow us to reuse most of the same view logic to do all of the above. Unfortunately, this has had to be shelved for now due to difficulties encountered by the Rust compiler when building larger-scale applications with the number of generics spread throughout the codebase that this required. It's an approach I'm looking forward to exploring again in the future; feel free to reach out if you're interested in this kind of work.
+I've put together a [very simple GTK example](https://github.com/leptos-rs/leptos/blob/main/examples/gtk/src/main.rs) so you can see what I mean.
 
-### How is this different from Yew?
+### How is this different from Yew/Dioxus?
 
-Yew is the most-used library for Rust web UI development, but there are several differences between Yew and Leptos, in philosophy, approach, and performance.
+On the surface level, these libraries may seem similar. Yew is, of course, the most mature Rust library for web UI development and has a huge ecosystem. Dioxus is similar in many ways, being heavily inspired by React. Here are some conceptual differences between Leptos and these frameworks:
 
 - **VDOM vs. fine-grained:** Yew is built on the virtual DOM (VDOM) model: state changes cause components to re-render, generating a new virtual DOM tree. Yew diffs this against the previous VDOM, and applies those patches to the actual DOM. Component functions rerun whenever state changes. Leptos takes an entirely different approach. Components run once, creating (and returning) actual DOM nodes and setting up a reactive system to update those DOM nodes.
-- **Performance:** This has huge performance implications: Leptos is simply much faster at both creating and updating the UI than Yew is.
-- **Server integration:** Yew was created in an era in which browser-rendered single-page apps (SPAs) were the dominant paradigm. While Leptos supports client-side rendering, it also focuses on integrating with the server side of your application via server functions and multiple modes of serving HTML, including out-of-order streaming.
-
-### How is this different from Dioxus?
-
-Like Leptos, Dioxus is a framework for building UIs using web technologies. However, there are significant differences in approach and features.
-
-- **VDOM vs. fine-grained:** While Dioxus has a performant virtual DOM (VDOM), it still uses coarse-grained/component-scoped reactivity: changing a stateful value reruns the component function and diffs the old UI against the new one. Leptos components use a different mental model, creating (and returning) actual DOM nodes and setting up a reactive system to update those DOM nodes.
-- **Web vs. desktop priorities:** Dioxus uses Leptos server functions in its fullstack mode, but does not have the same `<Suspense>`-based support for things like streaming HTML rendering, or share the same focus on holistic web performance. Leptos tends to prioritize holistic web performance (streaming HTML rendering, smaller WASM binary sizes, etc.), whereas Dioxus has an unparalleled experience when building desktop apps, because your application logic runs as a native Rust binary.
+- **Performance:** This has huge performance implications: Leptos is simply much faster at both creating and updating the UI than Yew is. (Dioxus has made huge advances in performance with its recent 0.3 release, and is now roughly on par with Leptos.)
+- **Mental model:** Adopting fine-grained reactivity also tends to simplify the mental model. There are no surprising component re-renders because there are no re-renders. You can call functions, create timeouts, etc. within the body of your component functions because they won’t be re-run. You don’t need to think about manual dependency tracking for effects; fine-grained reactivity tracks dependencies automatically.
 
 ### How is this different from Sycamore?
 
-Sycamore and Leptos are both heavily influenced by SolidJS. At this point, Leptos has a larger community and ecosystem and is more actively developed. Other differences:
+Conceptually, these two frameworks are very similar: because both are built on fine-grained reactivity, most apps will end up looking very similar between the two, and Sycamore or Leptos apps will both look a lot like SolidJS apps, in the same way that Yew or Dioxus can look a lot like React.
 
-- **Templating DSLs:** Sycamore uses a custom templating language for its views, while Leptos uses a JSX-like template format.
-- **`'static` signals:** One of Leptos’s main innovations was the creation of `Copy + 'static` signals, which have excellent ergonomics. Sycamore is in the process of adopting the same pattern, but this is not yet released.
-- **Perseus vs. server functions:** The Perseus metaframework provides an opinionated way to build Sycamore apps that include server functionality. Leptos instead provides primitives like server functions in the core of the framework.
+There are some practical differences that make a significant difference:
+
+- **Templating:** Leptos uses a JSX-like template format (built on [syn-rsx](https://github.com/stoically/syn-rsx)) for its `view` macro. Sycamore offers the choice of its own templating DSL or a builder syntax.
+- **Server integration:** Leptos provides primitives that encourage HTML streaming and allow for easy async integration and RPC calls, even without WASM enabled, making it easy to opt into integrations between your frontend and backend code without pushing you toward any particular metaframework patterns.
+- **Read-write segregation:** Leptos, like Solid, encourages read-write segregation between signal getters and setters, so you end up accessing signals with tuples like `let (count, set_count) = create_signal(cx, 0);` _(If you prefer or if it's more convenient for your API, you can use [`create_rw_signal`](https://docs.rs/leptos/latest/leptos/fn.create_rw_signal.html) to give a unified read/write signal.)_
+- **Signals are functions:** In Leptos, you can call a signal to access it rather than calling a specific method (so, `count()` instead of `count.get()`) This creates a more consistent mental model: accessing a reactive value is always a matter of calling a function. For example:
+
+  ```rust
+  let (count, set_count) = create_signal(cx, 0); // a signal
+  let double_count = move || count() * 2; // a derived signal
+  let memoized_count = create_memo(cx, move |_| count() * 3); // a memo
+  // all are accessed by calling them
+  assert_eq!(count(), 0);
+  assert_eq!(double_count(), 0);
+  assert_eq!(memoized_count(), 0);
+  // this function can accept any of those signals
+  fn do_work_on_signal(my_signal: impl Fn() -> i32) { ... }
+  ```
+
+- **Signals and scopes are `'static`:** Both Leptos and Sycamore ease the pain of moving signals in closures (in particular, event listeners) by making them `Copy`, to avoid the `{ let count = count.clone(); move |_| ... }` that's very familiar in Rust UI code. Sycamore does this by using bump allocation to tie the lifetimes of its signals to its scopes: since references are `Copy`, `&'a Signal<T>` can be moved into a closure. Leptos does this by using arena allocation and passing around indices: types like `ReadSignal<T>`, `WriteSignal<T>`, and `Memo<T>` are actually wrappers for indices into an arena. This means that both scopes and signals are both `Copy` and `'static` in Leptos, which means that they can be moved easily into closures without adding lifetime complexity.

SECURITY.md

@@ -1,13 +0,0 @@
-# Security Policy
-
-## Reporting a Vulnerability
-
-To report a suspected security issue, please contact security@leptos.dev rather than opening
-a public issue.
-
-## Supported Versions
-
-The most-recently-released version of the library is supported with security updates.
-For example, if a security issue is discovered that affects 0.3.2 and all later releases,
-a 0.4.x patch will be released but a new 0.3.x patch release will not be made. You should 
-plan to update to the latest version to receive any new features or bugfixes of any kind.

TODO.md

@@ -1,40 +0,0 @@
-- core examples
-    - [x] counter
-    - [x] counters
-    - [x] fetch
-    - [x] todomvc 
-    - [x] error_boundary
-    - [x] parent\_child
-        - [x] on: on components
-    - [ ] router
-    - [ ] slots 
-    - [ ] hackernews
-    - [ ] counter\_isomorphic
-    - [ ] todo\_app\_sqlite
-- other ssr examples
-    - [ ] error boundary SSR
-- reactivity 
-    - Signal wrappers
-    - SignalDispose implementations on all Copy types
-    - untracked access warnings
-- ErrorBoundary
-    - [ ] RenderHtml implementation 
-    - [ ] Separate component?
-- Suspense/Transition components?
-- callbacks
-    - unsync StoredValue
-- SSR
-    - escaping HTML correctly (attributes + text nodes)
-- router
-    - nested routes
-    - trailing slashes
-- \_meta package (and use in hackernews)
-- integrations
-- update tests
-- hackernews example
-  - TODOs
-  - Suspense/Transition/Await components
-  - nicer routing components
-  - async routing (waiting for data to load before navigation)
-  - `<A>` component
-  - figure out rebuilding issues: list (needs new signal IDs) vs. regular rebuild

any_error/Cargo.toml

@@ -1,13 +0,0 @@
-[package]
-name = "throw_error"
-version = "0.3.0"
-authors = ["Greg Johnston"]
-license = "MIT"
-readme = "../README.md"
-repository = "https://github.com/leptos-rs/leptos"
-description = "Utilities for wrapping, throwing, and catching errors."
-rust-version.workspace = true
-edition.workspace = true
-
-[dependencies]
-pin-project-lite = { workspace = true, default-features = true }

any_error/Makefile.toml

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

any_error/README.md

@@ -1,2 +0,0 @@
-A utility library for wrapping arbitrary errors, and for “throwing” errors in a way
-that can be caught by user-defined error hooks.

any_error/src/lib.rs

@@ -1,160 +0,0 @@
-#![forbid(unsafe_code)]
-#![deny(missing_docs)]
-
-//! A utility library for wrapping arbitrary errors, and for “throwing” errors in a way
-//! that can be caught by user-defined error hooks.
-
-use std::{
-    cell::RefCell,
-    error,
-    fmt::{self, Display},
-    future::Future,
-    ops,
-    pin::Pin,
-    sync::Arc,
-    task::{Context, Poll},
-};
-
-/* Wrapper Types */
-
-/// A generic wrapper for any error.
-#[derive(Debug, Clone)]
-#[repr(transparent)]
-pub struct Error(Arc<dyn error::Error + Send + Sync>);
-
-impl Error {
-    /// Converts the wrapper into the inner reference-counted error.
-    pub fn into_inner(self) -> Arc<dyn error::Error + Send + Sync> {
-        Arc::clone(&self.0)
-    }
-}
-
-impl ops::Deref for Error {
-    type Target = Arc<dyn error::Error + Send + Sync>;
-
-    fn deref(&self) -> &Self::Target {
-        &self.0
-    }
-}
-
-impl fmt::Display for Error {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{}", self.0)
-    }
-}
-
-impl<T> From<T> for Error
-where
-    T: error::Error + Send + Sync + 'static,
-{
-    fn from(value: T) -> Self {
-        Error(Arc::new(value))
-    }
-}
-
-/// Implements behavior that allows for global or scoped error handling.
-///
-/// This allows for both "throwing" errors to register them, and "clearing" errors when they are no
-/// longer valid. This is useful for something like a user interface, in which an error can be
-/// "thrown" on some invalid user input, and later "cleared" if the user corrects the input.
-/// Keeping a unique identifier for each error allows the UI to be updated accordingly.
-pub trait ErrorHook: Send + Sync {
-    /// Handles the given error, returning a unique identifier.
-    fn throw(&self, error: Error) -> ErrorId;
-
-    /// Clears the error associated with the given identifier.
-    fn clear(&self, id: &ErrorId);
-}
-
-/// A unique identifier for an error. This is returned when you call [`throw`], which calls a
-/// global error handler.
-#[derive(Debug, PartialEq, Eq, Hash, Clone, Default)]
-pub struct ErrorId(usize);
-
-impl Display for ErrorId {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        Display::fmt(&self.0, f)
-    }
-}
-
-impl From<usize> for ErrorId {
-    fn from(value: usize) -> Self {
-        Self(value)
-    }
-}
-
-thread_local! {
-    static ERROR_HOOK: RefCell<Option<Arc<dyn ErrorHook>>> = RefCell::new(None);
-}
-
-/// Resets the error hook to its previous state when dropped.
-pub struct ResetErrorHookOnDrop(Option<Arc<dyn ErrorHook>>);
-
-impl Drop for ResetErrorHookOnDrop {
-    fn drop(&mut self) {
-        ERROR_HOOK.with_borrow_mut(|this| *this = self.0.take())
-    }
-}
-
-/// Returns the current error hook.
-pub fn get_error_hook() -> Option<Arc<dyn ErrorHook>> {
-    ERROR_HOOK.with_borrow(Clone::clone)
-}
-
-/// Sets the current thread-local error hook, which will be invoked when [`throw`] is called.
-pub fn set_error_hook(hook: Arc<dyn ErrorHook>) -> ResetErrorHookOnDrop {
-    ResetErrorHookOnDrop(
-        ERROR_HOOK.with_borrow_mut(|this| Option::replace(this, hook)),
-    )
-}
-
-/// Invokes the error hook set by [`set_error_hook`] with the given error.
-pub fn throw(error: impl Into<Error>) -> ErrorId {
-    ERROR_HOOK
-        .with_borrow(|hook| hook.as_ref().map(|hook| hook.throw(error.into())))
-        .unwrap_or_default()
-}
-
-/// Clears the given error from the current error hook.
-pub fn clear(id: &ErrorId) {
-    ERROR_HOOK
-        .with_borrow(|hook| hook.as_ref().map(|hook| hook.clear(id)))
-        .unwrap_or_default()
-}
-
-pin_project_lite::pin_project! {
-    /// A [`Future`] that reads the error hook that is set when it is created, and sets this as the
-    /// current error hook whenever it is polled.
-    pub struct ErrorHookFuture<Fut> {
-        hook: Option<Arc<dyn ErrorHook>>,
-        #[pin]
-        inner: Fut
-    }
-}
-
-impl<Fut> ErrorHookFuture<Fut> {
-    /// Reads the current hook and wraps the given [`Future`], returning a new `Future` that will
-    /// set the error hook whenever it is polled.
-    pub fn new(inner: Fut) -> Self {
-        Self {
-            hook: ERROR_HOOK.with_borrow(Clone::clone),
-            inner,
-        }
-    }
-}
-
-impl<Fut> Future for ErrorHookFuture<Fut>
-where
-    Fut: Future,
-{
-    type Output = Fut::Output;
-
-    fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
-        let this = self.project();
-        let _hook = this
-            .hook
-            .as_ref()
-            .map(|hook| set_error_hook(Arc::clone(hook)));
-        this.inner.poll(cx)
-    }
-}

any_spawner/Cargo.toml

@@ -1,47 +0,0 @@
-[package]
-name = "any_spawner"
-version = "0.3.0"
-authors = ["Greg Johnston"]
-license = "MIT"
-readme = "../README.md"
-repository = "https://github.com/leptos-rs/leptos"
-description = "Spawn asynchronous tasks in an executor-independent way."
-edition.workspace = true
-
-[dependencies]
-async-executor = { optional = true , workspace = true, default-features = true }
-futures = { workspace = true, default-features = true }
-glib = { optional = true , workspace = true, default-features = true }
-thiserror = { workspace = true , default-features = true }
-tokio = { optional = true, default-features = false, features = [
-  "rt",
-] , workspace = true }
-tracing = { optional = true , workspace = true, default-features = true }
-wasm-bindgen-futures = { optional = true , workspace = true, default-features = true }
-
-[dev-dependencies]
-futures-lite = { default-features = false , workspace = true }
-tokio = { default-features = false, features = [
-  "rt",
-  "macros",
-  "time",
-] , workspace = true }
-wasm-bindgen-test = { workspace = true, default-features = true }
-serial_test = { workspace = true, default-features = true }
-
-[features]
-async-executor = ["dep:async-executor"]
-tracing = ["dep:tracing"]
-tokio = ["dep:tokio"]
-glib = ["dep:glib"]
-wasm-bindgen = ["dep:wasm-bindgen-futures"]
-futures-executor = ["futures/thread-pool", "futures/executor"]
-
-
-[package.metadata.docs.rs]
-all-features = true
-rustdoc-args = ["--cfg", "docsrs"]
-
-[package.metadata.cargo-all-features]
-denylist = ["tracing"]
-max_combination_size = 2

any_spawner/Makefile.toml

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

any_spawner/README.md

@@ -1,26 +0,0 @@
-This crate makes it easier to write asynchronous code that is executor-agnostic, by providing a
-utility that can be used to spawn tasks in a variety of executors.
-
-It only supports single executor per program, but that executor can be set at runtime, anywhere
-in your crate (or an application that depends on it).
-
-This can be extended to support any executor or runtime that supports spawning [`Future`]s.
-
-This is a least common denominator implementation in many ways. Limitations include:
-
-- setting an executor is a one-time, global action
-- no "join handle" or other result is returned from the spawn
-- the `Future` must output `()`
-
-```rust
-use any_spawner::Executor;
-
-Executor::init_futures_executor()
-    .expect("executor should only be initialized once");
-
-// spawn a thread-safe Future
-Executor::spawn(async { /* ... */ });
-
-// spawn a Future that is !Send
-Executor::spawn_local(async { /* ... */ });
-```

any_spawner/src/lib.rs

@@ -1,514 +0,0 @@
-//! This crate makes it easier to write asynchronous code that is executor-agnostic, by providing a
-//! utility that can be used to spawn tasks in a variety of executors.
-//!
-//! It only supports single executor per program, but that executor can be set at runtime, anywhere
-//! in your crate (or an application that depends on it).
-//!
-//! This can be extended to support any executor or runtime that supports spawning [`Future`]s.
-//!
-//! This is a least common denominator implementation in many ways. Limitations include:
-//! - setting an executor is a one-time, global action
-//! - no "join handle" or other result is returned from the spawn
-//! - the `Future` must output `()`
-//!
-//! ```no_run
-//! use any_spawner::Executor;
-//!
-//! // make sure an Executor has been initialized with one of the init_ functions
-//!
-//! // spawn a thread-safe Future
-//! Executor::spawn(async { /* ... */ });
-//!
-//! // spawn a Future that is !Send
-//! Executor::spawn_local(async { /* ... */ });
-//! ```
-
-#![forbid(unsafe_code)]
-#![deny(missing_docs)]
-#![cfg_attr(docsrs, feature(doc_cfg))]
-
-use std::{future::Future, pin::Pin, sync::OnceLock};
-use thiserror::Error;
-
-/// A future that has been pinned.
-pub type PinnedFuture<T> = Pin<Box<dyn Future<Output = T> + Send>>;
-/// A future that has been pinned.
-pub type PinnedLocalFuture<T> = Pin<Box<dyn Future<Output = T>>>;
-
-// Type alias for the spawn function pointer.
-type SpawnFn = fn(PinnedFuture<()>);
-// Type alias for the spawn_local function pointer.
-type SpawnLocalFn = fn(PinnedLocalFuture<()>);
-// Type alias for the poll_local function pointer.
-type PollLocalFn = fn();
-
-/// Holds the function pointers for the current global executor.
-#[derive(Clone, Copy)]
-struct ExecutorFns {
-    spawn: SpawnFn,
-    spawn_local: SpawnLocalFn,
-    poll_local: PollLocalFn,
-}
-
-// Use a single OnceLock to ensure atomic initialization of all functions.
-static EXECUTOR_FNS: OnceLock<ExecutorFns> = OnceLock::new();
-
-// No-op functions to use when an executor doesn't support a specific operation.
-#[cfg(any(feature = "tokio", feature = "wasm-bindgen", feature = "glib"))]
-#[cold]
-#[inline(never)]
-fn no_op_poll() {}
-
-#[cfg(all(not(feature = "wasm-bindgen"), not(debug_assertions)))]
-#[cold]
-#[inline(never)]
-fn no_op_spawn(_: PinnedFuture<()>) {
-    #[cfg(debug_assertions)]
-    eprintln!(
-        "Warning: Executor::spawn called, but no global 'spawn' function is \
-         configured (perhaps only spawn_local is supported, e.g., on wasm \
-         without threading?)."
-    );
-}
-
-// Wasm panics if you spawn without an executor
-#[cfg(feature = "wasm-bindgen")]
-#[cold]
-#[inline(never)]
-fn no_op_spawn(_: PinnedFuture<()>) {
-    panic!(
-        "Executor::spawn called, but no global 'spawn' function is configured."
-    );
-}
-
-#[cfg(not(debug_assertions))]
-#[cold]
-#[inline(never)]
-fn no_op_spawn_local(_: PinnedLocalFuture<()>) {
-    panic!(
-        "Executor::spawn_local called, but no global 'spawn_local' function \
-         is configured."
-    );
-}
-
-/// Errors that can occur when using the executor.
-#[derive(Error, Debug)]
-pub enum ExecutorError {
-    /// The executor has already been set.
-    #[error("Global executor has already been set.")]
-    AlreadySet,
-}
-
-/// A global async executor that can spawn tasks.
-pub struct Executor;
-
-impl Executor {
-    /// Spawns a thread-safe [`Future`].
-    ///
-    /// Uses the globally configured executor.
-    /// Panics if no global executor has been initialized.
-    #[inline(always)]
-    #[track_caller]
-    pub fn spawn(fut: impl Future<Output = ()> + Send + 'static) {
-        let pinned_fut = Box::pin(fut);
-
-        if let Some(fns) = EXECUTOR_FNS.get() {
-            (fns.spawn)(pinned_fut)
-        } else {
-            // No global executor set.
-            handle_uninitialized_spawn(pinned_fut);
-        }
-    }
-
-    /// Spawns a [`Future`] that cannot be sent across threads.
-    ///
-    /// Uses the globally configured executor.
-    /// Panics if no global executor has been initialized.
-    #[inline(always)]
-    #[track_caller]
-    pub fn spawn_local(fut: impl Future<Output = ()> + 'static) {
-        let pinned_fut = Box::pin(fut);
-
-        if let Some(fns) = EXECUTOR_FNS.get() {
-            (fns.spawn_local)(pinned_fut)
-        } else {
-            // No global executor set.
-            handle_uninitialized_spawn_local(pinned_fut);
-        }
-    }
-
-    /// Waits until the next "tick" of the current async executor.
-    /// Respects the global executor.
-    #[inline(always)]
-    pub async fn tick() {
-        let (tx, rx) = futures::channel::oneshot::channel();
-        #[cfg(not(all(feature = "wasm-bindgen", target_family = "wasm")))]
-        Executor::spawn(async move {
-            _ = tx.send(());
-        });
-        #[cfg(all(feature = "wasm-bindgen", target_family = "wasm"))]
-        Executor::spawn_local(async move {
-            _ = tx.send(());
-        });
-
-        _ = rx.await;
-    }
-
-    /// Polls the global async executor.
-    ///
-    /// Uses the globally configured executor.
-    /// Does nothing if the global executor does not support polling.
-    #[inline(always)]
-    pub fn poll_local() {
-        if let Some(fns) = EXECUTOR_FNS.get() {
-            (fns.poll_local)()
-        }
-        // If not initialized or doesn't support polling, do nothing gracefully.
-    }
-}
-
-impl Executor {
-    /// Globally sets the [`tokio`] runtime as the executor used to spawn tasks.
-    ///
-    /// Returns `Err(_)` if a global executor has already been set.
-    ///
-    /// Requires the `tokio` feature to be activated on this crate.
-    #[cfg(feature = "tokio")]
-    #[cfg_attr(docsrs, doc(cfg(feature = "tokio")))]
-    pub fn init_tokio() -> Result<(), ExecutorError> {
-        let executor_impl = ExecutorFns {
-            spawn: |fut| {
-                tokio::spawn(fut);
-            },
-            spawn_local: |fut| {
-                tokio::task::spawn_local(fut);
-            },
-            // Tokio doesn't have an explicit global poll function like LocalPool::run_until_stalled
-            poll_local: no_op_poll,
-        };
-        EXECUTOR_FNS
-            .set(executor_impl)
-            .map_err(|_| ExecutorError::AlreadySet)
-    }
-
-    /// Globally sets the [`wasm-bindgen-futures`] runtime as the executor used to spawn tasks.
-    ///
-    /// Returns `Err(_)` if a global executor has already been set.
-    ///
-    /// Requires the `wasm-bindgen` feature to be activated on this crate.
-    #[cfg(feature = "wasm-bindgen")]
-    #[cfg_attr(docsrs, doc(cfg(feature = "wasm-bindgen")))]
-    pub fn init_wasm_bindgen() -> Result<(), ExecutorError> {
-        let executor_impl = ExecutorFns {
-            // wasm-bindgen-futures only supports spawn_local
-            spawn: no_op_spawn,
-            spawn_local: |fut| {
-                wasm_bindgen_futures::spawn_local(fut);
-            },
-            poll_local: no_op_poll,
-        };
-        EXECUTOR_FNS
-            .set(executor_impl)
-            .map_err(|_| ExecutorError::AlreadySet)
-    }
-
-    /// Globally sets the [`glib`] runtime as the executor used to spawn tasks.
-    ///
-    /// Returns `Err(_)` if a global executor has already been set.
-    ///
-    /// Requires the `glib` feature to be activated on this crate.
-    #[cfg(feature = "glib")]
-    #[cfg_attr(docsrs, doc(cfg(feature = "glib")))]
-    pub fn init_glib() -> Result<(), ExecutorError> {
-        let executor_impl = ExecutorFns {
-            spawn: |fut| {
-                let main_context = glib::MainContext::default();
-                main_context.spawn(fut);
-            },
-            spawn_local: |fut| {
-                let main_context = glib::MainContext::default();
-                main_context.spawn_local(fut);
-            },
-            // Glib needs event loop integration, explicit polling isn't the standard model here.
-            poll_local: no_op_poll,
-        };
-        EXECUTOR_FNS
-            .set(executor_impl)
-            .map_err(|_| ExecutorError::AlreadySet)
-    }
-
-    /// Globally sets the [`futures`] executor as the executor used to spawn tasks,
-    /// lazily creating a thread pool to spawn tasks into.
-    ///
-    /// Returns `Err(_)` if a global executor has already been set.
-    ///
-    /// Requires the `futures-executor` feature to be activated on this crate.
-    #[cfg(feature = "futures-executor")]
-    #[cfg_attr(docsrs, doc(cfg(feature = "futures-executor")))]
-    pub fn init_futures_executor() -> Result<(), ExecutorError> {
-        use futures::{
-            executor::{LocalPool, LocalSpawner, ThreadPool},
-            task::{LocalSpawnExt, SpawnExt},
-        };
-        use std::cell::RefCell;
-
-        // Keep the lazy-init ThreadPool and thread-local LocalPool for spawn_local impl
-        static THREAD_POOL: OnceLock<ThreadPool> = OnceLock::new();
-        thread_local! {
-            static LOCAL_POOL: RefCell<LocalPool> = RefCell::new(LocalPool::new());
-            // SPAWNER is derived from LOCAL_POOL, keep it for efficiency inside the closure
-            static SPAWNER: LocalSpawner = LOCAL_POOL.with(|pool| pool.borrow().spawner());
-        }
-
-        fn get_thread_pool() -> &'static ThreadPool {
-            THREAD_POOL.get_or_init(|| {
-                ThreadPool::new()
-                    .expect("could not create futures executor ThreadPool")
-            })
-        }
-
-        let executor_impl = ExecutorFns {
-            spawn: |fut| {
-                get_thread_pool()
-                    .spawn(fut)
-                    .expect("failed to spawn future on ThreadPool");
-            },
-            spawn_local: |fut| {
-                // Use the thread_local SPAWNER derived from LOCAL_POOL
-                SPAWNER.with(|spawner| {
-                    spawner
-                        .spawn_local(fut)
-                        .expect("failed to spawn local future");
-                });
-            },
-            poll_local: || {
-                // Use the thread_local LOCAL_POOL
-                LOCAL_POOL.with(|pool| {
-                    // Use try_borrow_mut to prevent panic during re-entrant calls
-                    if let Ok(mut pool) = pool.try_borrow_mut() {
-                        pool.run_until_stalled();
-                    }
-                    // If already borrowed, we're likely in a nested poll, so do nothing.
-                });
-            },
-        };
-
-        EXECUTOR_FNS
-            .set(executor_impl)
-            .map_err(|_| ExecutorError::AlreadySet)
-    }
-
-    /// Globally sets the [`async_executor`] executor as the executor used to spawn tasks,
-    /// lazily creating a thread pool to spawn tasks into.
-    ///
-    /// Returns `Err(_)` if a global executor has already been set.
-    ///
-    /// Requires the `async-executor` feature to be activated on this crate.
-    #[cfg(feature = "async-executor")]
-    #[cfg_attr(docsrs, doc(cfg(feature = "async-executor")))]
-    pub fn init_async_executor() -> Result<(), ExecutorError> {
-        use async_executor::{Executor as AsyncExecutor, LocalExecutor};
-
-        // Keep the lazy-init global Executor and thread-local LocalExecutor for spawn_local impl
-        static ASYNC_EXECUTOR: OnceLock<AsyncExecutor<'static>> =
-            OnceLock::new();
-        thread_local! {
-            static LOCAL_EXECUTOR_POOL: LocalExecutor<'static> = const { LocalExecutor::new() };
-        }
-
-        fn get_async_executor() -> &'static AsyncExecutor<'static> {
-            ASYNC_EXECUTOR.get_or_init(AsyncExecutor::new)
-        }
-
-        let executor_impl = ExecutorFns {
-            spawn: |fut| {
-                get_async_executor().spawn(fut).detach();
-            },
-            spawn_local: |fut| {
-                LOCAL_EXECUTOR_POOL.with(|pool| pool.spawn(fut).detach());
-            },
-            poll_local: || {
-                LOCAL_EXECUTOR_POOL.with(|pool| {
-                    // try_tick polls the local executor without blocking
-                    // This prevents issues if called recursively or from within a task.
-                    pool.try_tick();
-                });
-            },
-        };
-        EXECUTOR_FNS
-            .set(executor_impl)
-            .map_err(|_| ExecutorError::AlreadySet)
-    }
-
-    /// Globally sets a custom executor as the executor used to spawn tasks.
-    ///
-    /// Requires the custom executor to be `Send + Sync` as it will be stored statically.
-    ///
-    /// Returns `Err(_)` if a global executor has already been set.
-    pub fn init_custom_executor(
-        custom_executor: impl CustomExecutor + Send + Sync + 'static,
-    ) -> Result<(), ExecutorError> {
-        // Store the custom executor instance itself to call its methods.
-        // Use Box for dynamic dispatch.
-        static CUSTOM_EXECUTOR_INSTANCE: OnceLock<
-            Box<dyn CustomExecutor + Send + Sync>,
-        > = OnceLock::new();
-
-        CUSTOM_EXECUTOR_INSTANCE
-            .set(Box::new(custom_executor))
-            .map_err(|_| ExecutorError::AlreadySet)?;
-
-        // Now set the ExecutorFns using the stored instance
-        let executor_impl = ExecutorFns {
-            spawn: |fut| {
-                // Unwrap is safe because we just set it successfully or returned Err.
-                CUSTOM_EXECUTOR_INSTANCE.get().unwrap().spawn(fut);
-            },
-            spawn_local: |fut| {
-                CUSTOM_EXECUTOR_INSTANCE.get().unwrap().spawn_local(fut);
-            },
-            poll_local: || {
-                CUSTOM_EXECUTOR_INSTANCE.get().unwrap().poll_local();
-            },
-        };
-
-        EXECUTOR_FNS
-            .set(executor_impl)
-            .map_err(|_| ExecutorError::AlreadySet)
-        // If setting EXECUTOR_FNS fails (extremely unlikely race if called *concurrently*
-        // with another init_* after CUSTOM_EXECUTOR_INSTANCE was set), we technically
-        // leave CUSTOM_EXECUTOR_INSTANCE set but EXECUTOR_FNS not. This is an edge case,
-        // but the primary race condition is solved.
-    }
-
-    /// Sets a custom executor *for the current thread only*.
-    ///
-    /// This overrides the global executor for calls to `spawn`, `spawn_local`, and `poll_local`
-    /// made *from the current thread*. It does not affect other threads or the global state.
-    ///
-    /// The provided `custom_executor` must implement [`CustomExecutor`] and `'static`, but does
-    /// **not** need to be `Send` or `Sync`.
-    ///
-    /// Returns `Err(ExecutorError::AlreadySet)` if a *local* executor has already been set
-    /// *for this thread*.
-    pub fn init_local_custom_executor(
-        custom_executor: impl CustomExecutor + 'static,
-    ) -> Result<(), ExecutorError> {
-        // Store the custom executor instance itself to call its methods.
-        // Use Box for dynamic dispatch.
-        thread_local! {
-            static CUSTOM_EXECUTOR_INSTANCE: OnceLock<
-                Box<dyn CustomExecutor>,
-            > = OnceLock::new();
-        };
-
-        CUSTOM_EXECUTOR_INSTANCE.with(|this| {
-            this.set(Box::new(custom_executor))
-                .map_err(|_| ExecutorError::AlreadySet)
-        })?;
-
-        // Now set the ExecutorFns using the stored instance
-        let executor_impl = ExecutorFns {
-            spawn: |fut| {
-                // Unwrap is safe because we just set it successfully or returned Err.
-                CUSTOM_EXECUTOR_INSTANCE
-                    .with(|this| this.get().unwrap().spawn(fut));
-            },
-            spawn_local: |fut| {
-                CUSTOM_EXECUTOR_INSTANCE
-                    .with(|this| this.get().unwrap().spawn_local(fut));
-            },
-            poll_local: || {
-                CUSTOM_EXECUTOR_INSTANCE
-                    .with(|this| this.get().unwrap().poll_local());
-            },
-        };
-
-        EXECUTOR_FNS
-            .set(executor_impl)
-            .map_err(|_| ExecutorError::AlreadySet)
-    }
-}
-
-/// A trait for custom executors.
-/// Custom executors can be used to integrate with any executor that supports spawning futures.
-///
-/// If used with `init_custom_executor`, the implementation must be `Send + Sync + 'static`.
-///
-/// All methods can be called recursively. Implementors should be mindful of potential
-/// deadlocks or excessive resource consumption if recursive calls are not handled carefully
-/// (e.g., using `try_borrow_mut` or non-blocking polls within implementations).
-pub trait CustomExecutor {
-    /// Spawns a future, usually on a thread pool.
-    fn spawn(&self, fut: PinnedFuture<()>);
-    /// Spawns a local future. May require calling `poll_local` to make progress.
-    fn spawn_local(&self, fut: PinnedLocalFuture<()>);
-    /// Polls the executor, if it supports polling. Implementations should ideally be
-    /// non-blocking or use mechanisms like `try_tick` or `try_borrow_mut` to handle
-    /// re-entrant calls safely.
-    fn poll_local(&self);
-}
-
-// Ensure CustomExecutor is object-safe
-#[allow(dead_code)]
-fn test_object_safety(_: Box<dyn CustomExecutor + Send + Sync>) {} // Added Send + Sync constraint here for global usage
-
-/// Handles the case where `Executor::spawn` is called without an initialized executor.
-#[cold] // Less likely path
-#[inline(never)]
-#[track_caller]
-fn handle_uninitialized_spawn(_fut: PinnedFuture<()>) {
-    let caller = std::panic::Location::caller();
-    #[cfg(all(debug_assertions, feature = "tracing"))]
-    {
-        tracing::error!(
-            target: "any_spawner",
-            spawn_caller=%caller,
-            "Executor::spawn called before a global executor was initialized. Task dropped."
-        );
-        // Drop the future implicitly after logging
-        drop(_fut);
-    }
-    #[cfg(all(debug_assertions, not(feature = "tracing")))]
-    {
-        panic!(
-            "At {caller}, tried to spawn a Future with Executor::spawn() \
-             before a global executor was initialized."
-        );
-    }
-    // In release builds (without tracing), call the specific no-op function.
-    #[cfg(not(debug_assertions))]
-    {
-        no_op_spawn(_fut);
-    }
-}
-
-/// Handles the case where `Executor::spawn_local` is called without an initialized executor.
-#[cold] // Less likely path
-#[inline(never)]
-#[track_caller]
-fn handle_uninitialized_spawn_local(_fut: PinnedLocalFuture<()>) {
-    let caller = std::panic::Location::caller();
-    #[cfg(all(debug_assertions, feature = "tracing"))]
-    {
-        tracing::error!(
-            target: "any_spawner",
-            spawn_caller=%caller,
-            "Executor::spawn_local called before a global executor was initialized. \
-            Task likely dropped or panicked."
-        );
-        // Fall through to panic or no-op depending on build/target
-    }
-    #[cfg(all(debug_assertions, not(feature = "tracing")))]
-    {
-        panic!(
-            "At {caller}, tried to spawn a Future with \
-             Executor::spawn_local() before a global executor was initialized."
-        );
-    }
-    // In release builds (without tracing), call the specific no-op function (which usually panics).
-    #[cfg(not(debug_assertions))]
-    {
-        no_op_spawn_local(_fut);
-    }
-}

any_spawner/tests/already_set_error.rs

@@ -1,24 +0,0 @@
-use any_spawner::{Executor, ExecutorError};
-
-#[test]
-fn test_already_set_error() {
-    struct SimpleExecutor;
-
-    impl any_spawner::CustomExecutor for SimpleExecutor {
-        fn spawn(&self, _fut: any_spawner::PinnedFuture<()>) {}
-        fn spawn_local(&self, _fut: any_spawner::PinnedLocalFuture<()>) {}
-        fn poll_local(&self) {}
-    }
-
-    // First initialization should succeed
-    Executor::init_custom_executor(SimpleExecutor)
-        .expect("First initialization failed");
-
-    // Second initialization should fail with AlreadySet error
-    let result = Executor::init_custom_executor(SimpleExecutor);
-    assert!(matches!(result, Err(ExecutorError::AlreadySet)));
-
-    // First local initialization should fail
-    let result = Executor::init_local_custom_executor(SimpleExecutor);
-    assert!(matches!(result, Err(ExecutorError::AlreadySet)));
-}

any_spawner/tests/async_executor.rs

@@ -1,74 +0,0 @@
-#![cfg(feature = "async-executor")]
-
-use std::{
-    future::Future,
-    pin::Pin,
-    sync::{Arc, Mutex},
-};
-
-// A simple async executor for testing
-struct TestExecutor {
-    tasks: Mutex<Vec<Pin<Box<dyn Future<Output = ()> + Send + 'static>>>>,
-}
-
-impl TestExecutor {
-    fn new() -> Self {
-        TestExecutor {
-            tasks: Mutex::new(Vec::new()),
-        }
-    }
-
-    fn spawn<F>(&self, future: F)
-    where
-        F: Future<Output = ()> + Send + 'static,
-    {
-        self.tasks.lock().unwrap().push(Box::pin(future));
-    }
-
-    fn run_all(&self) {
-        // Take all tasks out to process them
-        let tasks = self.tasks.lock().unwrap().drain(..).collect::<Vec<_>>();
-
-        // Use a basic future executor to run each task to completion
-        for mut task in tasks {
-            // Use futures-lite's block_on to complete the future
-            futures::executor::block_on(async {
-                unsafe {
-                    let task_mut = Pin::new_unchecked(&mut task);
-                    let _ = std::future::Future::poll(
-                        task_mut,
-                        &mut std::task::Context::from_waker(
-                            futures::task::noop_waker_ref(),
-                        ),
-                    );
-                }
-            });
-        }
-    }
-}
-
-#[test]
-fn test_async_executor() {
-    let executor = Arc::new(TestExecutor::new());
-    let executor_clone = executor.clone();
-
-    // Create a spawner function that will use our test executor
-    let spawner = move |future| {
-        executor_clone.spawn(future);
-    };
-
-    // Prepare test data
-    let counter = Arc::new(Mutex::new(0));
-    let counter_clone = counter.clone();
-
-    // Use the spawner to spawn a task
-    spawner(async move {
-        *counter_clone.lock().unwrap() += 1;
-    });
-
-    // Run all tasks
-    executor.run_all();
-
-    // Check if the task completed correctly
-    assert_eq!(*counter.lock().unwrap(), 1);
-}

any_spawner/tests/custom_executor.rs

@@ -1,63 +0,0 @@
-use any_spawner::Executor;
-use std::sync::{
-    atomic::{AtomicBool, Ordering},
-    Arc,
-};
-
-#[test]
-fn test_custom_executor() {
-    // Define a simple custom executor
-    struct TestExecutor {
-        spawn_called: Arc<AtomicBool>,
-        spawn_local_called: Arc<AtomicBool>,
-        poll_local_called: Arc<AtomicBool>,
-    }
-
-    impl any_spawner::CustomExecutor for TestExecutor {
-        fn spawn(&self, fut: any_spawner::PinnedFuture<()>) {
-            self.spawn_called.store(true, Ordering::SeqCst);
-            // Execute the future immediately (this works for simple test futures)
-            futures::executor::block_on(fut);
-        }
-
-        fn spawn_local(&self, fut: any_spawner::PinnedLocalFuture<()>) {
-            self.spawn_local_called.store(true, Ordering::SeqCst);
-            // Execute the future immediately
-            futures::executor::block_on(fut);
-        }
-
-        fn poll_local(&self) {
-            self.poll_local_called.store(true, Ordering::SeqCst);
-        }
-    }
-
-    let spawn_called = Arc::new(AtomicBool::new(false));
-    let spawn_local_called = Arc::new(AtomicBool::new(false));
-    let poll_local_called = Arc::new(AtomicBool::new(false));
-
-    let executor = TestExecutor {
-        spawn_called: spawn_called.clone(),
-        spawn_local_called: spawn_local_called.clone(),
-        poll_local_called: poll_local_called.clone(),
-    };
-
-    // Initialize with our custom executor
-    Executor::init_custom_executor(executor)
-        .expect("Failed to initialize custom executor");
-
-    // Test spawn
-    Executor::spawn(async {
-        // Simple task
-    });
-    assert!(spawn_called.load(Ordering::SeqCst));
-
-    // Test spawn_local
-    Executor::spawn_local(async {
-        // Simple local task
-    });
-    assert!(spawn_local_called.load(Ordering::SeqCst));
-
-    // Test poll_local
-    Executor::poll_local();
-    assert!(poll_local_called.load(Ordering::SeqCst));
-}

any_spawner/tests/custom_runtime.rs

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

any_spawner/tests/executor_tick.rs

@@ -1,28 +0,0 @@
-#![cfg(feature = "tokio")]
-
-use any_spawner::Executor;
-use std::{
-    sync::{Arc, Mutex},
-    time::Duration,
-};
-
-#[tokio::test]
-async fn test_executor_tick() {
-    // Initialize the tokio executor
-    Executor::init_tokio().expect("Failed to initialize tokio executor");
-
-    let value = Arc::new(Mutex::new(false));
-    let value_clone = value.clone();
-
-    // Spawn a task that sets the value after a tick
-    Executor::spawn(async move {
-        Executor::tick().await;
-        *value_clone.lock().unwrap() = true;
-    });
-
-    // Allow some time for the task to complete
-    tokio::time::sleep(Duration::from_millis(50)).await;
-
-    // Check that the value was set
-    assert!(*value.lock().unwrap());
-}

any_spawner/tests/futures_executor.rs

@@ -1,44 +0,0 @@
-#![cfg(feature = "futures-executor")]
-
-use any_spawner::Executor;
-use futures::channel::oneshot;
-use std::{
-    sync::{Arc, Mutex},
-    time::Duration,
-};
-
-#[test]
-fn test_futures_executor() {
-    // Initialize the futures executor
-    Executor::init_futures_executor()
-        .expect("Failed to initialize futures executor");
-
-    let (tx, rx) = oneshot::channel();
-    let result = Arc::new(Mutex::new(None));
-    let result_clone = result.clone();
-
-    // Spawn a task
-    Executor::spawn(async move {
-        tx.send(84).expect("Failed to send value");
-    });
-
-    // Spawn a task that waits for the result
-    Executor::spawn(async move {
-        match rx.await {
-            Ok(val) => *result_clone.lock().unwrap() = Some(val),
-            Err(_) => panic!("Failed to receive value"),
-        }
-    });
-
-    // Poll a few times to ensure the task completes
-    for _ in 0..10 {
-        Executor::poll_local();
-        std::thread::sleep(Duration::from_millis(10));
-
-        if result.lock().unwrap().is_some() {
-            break;
-        }
-    }
-
-    assert_eq!(*result.lock().unwrap(), Some(84));
-}

any_spawner/tests/futures_runtime.rs

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

any_spawner/tests/glib.rs

@@ -1,151 +0,0 @@
-#![cfg(feature = "glib")]
-
-use any_spawner::Executor;
-use glib::{MainContext, MainLoop};
-use serial_test::serial;
-use std::{
-    cell::Cell,
-    future::Future,
-    rc::Rc,
-    sync::{
-        atomic::{AtomicBool, Ordering},
-        Arc, Mutex,
-    },
-    time::Duration,
-};
-
-// Helper to run a future to completion on a dedicated glib MainContext.
-// Returns true if the future completed within the timeout, false otherwise.
-fn run_on_glib_context<F>(fut: F)
-where
-    F: Future<Output = ()> + Send + 'static,
-{
-    let _ = Executor::init_glib();
-
-    let context = MainContext::default();
-    let main_loop = MainLoop::new(Some(&context), false);
-    let main_loop_clone = main_loop.clone();
-
-    Executor::spawn(async move {
-        fut.await;
-        main_loop_clone.quit();
-    });
-
-    main_loop.run();
-}
-
-// Helper to run a local (!Send) future on the glib context.
-fn run_local_on_glib_context<F>(fut: F)
-where
-    F: Future<Output = ()> + 'static,
-{
-    let _ = Executor::init_glib();
-
-    let context = MainContext::default();
-    let main_loop = MainLoop::new(Some(&context), false);
-    let main_loop_clone = main_loop.clone();
-
-    Executor::spawn_local(async move {
-        fut.await;
-        main_loop_clone.quit();
-    });
-
-    main_loop.run();
-}
-
-// This test must run after a test that successfully initializes glib,
-// or within its own process.
-#[test]
-#[serial]
-fn test_glib_spawn() {
-    let success_flag = Arc::new(AtomicBool::new(false));
-    let flag_clone = success_flag.clone();
-
-    run_on_glib_context(async move {
-        // Simulate async work
-        futures_lite::future::yield_now().await;
-        flag_clone.store(true, Ordering::SeqCst);
-
-        // We need to give the spawned task time to run.
-        // The run_on_glib_context handles the main loop.
-        // We just need to ensure spawn happened correctly.
-        // Let's wait a tiny bit within the driving future to ensure spawn gets processed.
-        glib::timeout_future(Duration::from_millis(10)).await;
-    });
-
-    assert!(
-        success_flag.load(Ordering::SeqCst),
-        "Spawned future did not complete successfully"
-    );
-}
-
-// Similar conditions as test_glib_spawn regarding initialization state.
-#[test]
-#[serial]
-fn test_glib_spawn_local() {
-    let success_flag = Rc::new(Cell::new(false));
-    let flag_clone = success_flag.clone();
-
-    run_local_on_glib_context(async move {
-        // Use Rc to make the future !Send
-        let non_send_data = Rc::new(Cell::new(10));
-
-        let data = non_send_data.get();
-        assert_eq!(data, 10, "Rc data should be accessible");
-        non_send_data.set(20); // Modify non-Send data
-
-        // Simulate async work
-        futures_lite::future::yield_now().await;
-
-        assert_eq!(
-            non_send_data.get(),
-            20,
-            "Rc data should persist modification"
-        );
-        flag_clone.set(true);
-
-        // Wait a tiny bit
-        glib::timeout_future(Duration::from_millis(10)).await;
-    });
-
-    assert!(
-        success_flag.get(),
-        "Spawned local future did not complete successfully"
-    );
-}
-
-// Test Executor::tick with glib backend
-#[test]
-#[serial]
-fn test_glib_tick() {
-    run_on_glib_context(async {
-        let value = Arc::new(Mutex::new(false));
-        let value_clone = value.clone();
-
-        // Spawn a task that sets the value after a tick
-        Executor::spawn(async move {
-            Executor::tick().await;
-            *value_clone.lock().unwrap() = true;
-        });
-
-        // Allow some time for the task to complete
-        glib::timeout_future(Duration::from_millis(10)).await;
-
-        // Check that the value was set
-        assert!(*value.lock().unwrap());
-    });
-}
-
-// Test Executor::poll_local with glib backend (should be a no-op)
-#[test]
-#[serial]
-fn test_glib_poll_local_is_no_op() {
-    // Ensure glib executor is initialized
-    let _ = Executor::init_glib();
-    // poll_local for glib is configured as a no-op
-    // Calling it should not panic or cause issues.
-    Executor::poll_local();
-    Executor::poll_local();
-
-    println!("Executor::poll_local called successfully (expected no-op).");
-}

any_spawner/tests/local_custom_executor.rs

@@ -1,54 +0,0 @@
-use any_spawner::Executor;
-use std::sync::{
-    atomic::{AtomicBool, Ordering},
-    Arc,
-};
-
-#[test]
-fn test_local_custom_executor() {
-    // Define a thread-local custom executor
-    struct LocalTestExecutor {
-        spawn_called: Arc<AtomicBool>,
-        spawn_local_called: Arc<AtomicBool>,
-    }
-
-    impl any_spawner::CustomExecutor for LocalTestExecutor {
-        fn spawn(&self, fut: any_spawner::PinnedFuture<()>) {
-            self.spawn_called.store(true, Ordering::SeqCst);
-            futures::executor::block_on(fut);
-        }
-
-        fn spawn_local(&self, fut: any_spawner::PinnedLocalFuture<()>) {
-            self.spawn_local_called.store(true, Ordering::SeqCst);
-            futures::executor::block_on(fut);
-        }
-
-        fn poll_local(&self) {
-            // No-op for this test
-        }
-    }
-
-    let local_spawn_called = Arc::new(AtomicBool::new(false));
-    let local_spawn_local_called = Arc::new(AtomicBool::new(false));
-
-    let local_executor = LocalTestExecutor {
-        spawn_called: local_spawn_called.clone(),
-        spawn_local_called: local_spawn_local_called.clone(),
-    };
-
-    // Initialize a thread-local executor
-    Executor::init_local_custom_executor(local_executor)
-        .expect("Failed to initialize local custom executor");
-
-    // Test spawn - should use the thread-local executor
-    Executor::spawn(async {
-        // Simple task
-    });
-    assert!(local_spawn_called.load(Ordering::SeqCst));
-
-    // Test spawn_local - should use the thread-local executor
-    Executor::spawn_local(async {
-        // Simple local task
-    });
-    assert!(local_spawn_local_called.load(Ordering::SeqCst));
-}

any_spawner/tests/multiple_tasks.rs

@@ -1,35 +0,0 @@
-#![cfg(feature = "tokio")]
-
-use any_spawner::Executor;
-use futures::channel::oneshot;
-use std::sync::{Arc, Mutex};
-
-#[tokio::test]
-async fn test_multiple_tasks() {
-    Executor::init_tokio().expect("Failed to initialize tokio executor");
-
-    let counter = Arc::new(Mutex::new(0));
-    let tasks = 10;
-    let mut handles = Vec::new();
-
-    // Spawn multiple tasks that increment the counter
-    for _ in 0..tasks {
-        let counter_clone = counter.clone();
-        let (tx, rx) = oneshot::channel();
-
-        Executor::spawn(async move {
-            *counter_clone.lock().unwrap() += 1;
-            tx.send(()).expect("Failed to send completion signal");
-        });
-
-        handles.push(rx);
-    }
-
-    // Wait for all tasks to complete
-    for handle in handles {
-        handle.await.expect("Task failed");
-    }
-
-    // Verify that all tasks incremented the counter
-    assert_eq!(*counter.lock().unwrap(), tasks);
-}

any_spawner/tests/tokio_executor.rs

@@ -1,20 +0,0 @@
-#![cfg(feature = "tokio")]
-
-use any_spawner::Executor;
-use futures::channel::oneshot;
-
-#[tokio::test]
-async fn test_tokio_executor() {
-    // Initialize the tokio executor
-    Executor::init_tokio().expect("Failed to initialize tokio executor");
-
-    let (tx, rx) = oneshot::channel();
-
-    // Spawn a task that sends a value
-    Executor::spawn(async move {
-        tx.send(42).expect("Failed to send value");
-    });
-
-    // Wait for the spawned task to complete
-    assert_eq!(rx.await.unwrap(), 42);
-}

any_spawner/tests/wasm_bindgen_tests.rs

@@ -1,88 +0,0 @@
-#![cfg(all(feature = "wasm-bindgen", target_family = "wasm"))]
-
-use any_spawner::Executor;
-use futures::channel::oneshot;
-use std::sync::{
-    atomic::{AtomicBool, Ordering},
-    Arc,
-};
-use wasm_bindgen_test::*;
-
-wasm_bindgen_test_configure!(run_in_browser);
-
-#[wasm_bindgen_test]
-async fn test_wasm_bindgen_spawn_local() {
-    // Initialize the wasm-bindgen executor
-    let _ = Executor::init_wasm_bindgen();
-
-    // Create a channel to verify the task completes
-    let (tx, rx) = oneshot::channel();
-
-    // Spawn a local task (wasm doesn't support sending futures between threads)
-    Executor::spawn_local(async move {
-        // Simulate some async work
-        Executor::tick().await;
-        tx.send(42).expect("Failed to send result");
-    });
-
-    // Wait for the task to complete
-    let result = rx.await.expect("Failed to receive result");
-    assert_eq!(result, 42);
-}
-
-#[wasm_bindgen_test]
-async fn test_wasm_bindgen_tick() {
-    // Initialize the wasm-bindgen executor if not already initialized
-    let _ = Executor::init_wasm_bindgen();
-
-    let flag = Arc::new(AtomicBool::new(false));
-    let flag_clone = flag.clone();
-
-    // Spawn a task that will set the flag
-    Executor::spawn_local(async move {
-        flag_clone.store(true, Ordering::SeqCst);
-    });
-
-    // Wait for a tick, which should allow the spawned task to run
-    Executor::tick().await;
-
-    // Verify the flag was set
-    assert!(flag.load(Ordering::SeqCst));
-}
-
-#[wasm_bindgen_test]
-async fn test_multiple_wasm_bindgen_tasks() {
-    // Initialize once for all tests
-    let _ = Executor::init_wasm_bindgen();
-
-    // Create channels for multiple tasks
-    let (tx1, rx1) = oneshot::channel();
-    let (tx2, rx2) = oneshot::channel();
-
-    // Spawn multiple tasks
-    Executor::spawn_local(async move {
-        tx1.send("task1").expect("Failed to send from task1");
-    });
-
-    Executor::spawn_local(async move {
-        tx2.send("task2").expect("Failed to send from task2");
-    });
-
-    // Wait for both tasks to complete
-    let (result1, result2) = futures::join!(rx1, rx2);
-
-    assert_eq!(result1.unwrap(), "task1");
-    assert_eq!(result2.unwrap(), "task2");
-}
-
-// This test verifies that spawn (not local) fails on wasm as expected
-#[wasm_bindgen_test]
-#[should_panic]
-fn test_wasm_bindgen_spawn_errors() {
-    let _ = Executor::init_wasm_bindgen();
-
-    // Using should_panic to test that Executor::spawn panics in wasm
-    Executor::spawn(async {
-        // This should panic since wasm-bindgen doesn't support Send futures
-    });
-}

benchmarks/Cargo.toml

@@ -2,36 +2,26 @@
 name = "benchmarks"
 version = "0.1.0"
 edition = "2021"
-# std::sync::LazyLock is stabilized in Rust version 1.80.0
-rust-version = "1.80.0"
 
 [dependencies]
-l0410 = { package = "leptos", version = "0.4.10", features = [
-  "nightly",
-  "ssr",
-] }
-leptos = { path = "../leptos", features = ["ssr", "nightly"] }
-leptos_reactive = { path = "../leptos_reactive", features = ["ssr", "nightly"] }
-tachydom = { git = "https://github.com/gbj/tachys", features = [
-  "nightly",
-  "leptos",
-] }
-tachy_maccy = { git = "https://github.com/gbj/tachys", features = ["nightly"] }
-sycamore = { version = "0.8.0", features = ["ssr"] }
-yew = { version = "0.20.0", features = ["ssr"] }
-tokio-test = "0.4.0"
-miniserde = "0.1.0"
-gloo = "0.8.0"
-uuid = { version = "1.0", features = ["serde", "v4", "wasm-bindgen"] }
-wasm-bindgen = "0.2.100"
-lazy_static = "1.0"
-log = "0.4.0"
-strum = "0.24.0"
-strum_macros = "0.24.0"
-serde = { version = "1.0", features = ["derive", "rc"] }
-serde_json = "1.0"
-tera = "1.0"
+l021 = { package = "leptos", version = "0.2.1" }
+leptos = { path = "../leptos", default-features = false, features = ["ssr"] }
+sycamore = { version = "0.8", features = ["ssr"] }
+yew = { git = "https://github.com/yewstack/yew", features = ["ssr"] }
+tokio-test = "0.4"
+miniserde = "0.1"
+gloo = "0.8"
+uuid = { version = "1", features = ["serde", "v4", "wasm-bindgen"] }
+wasm-bindgen = "0.2"
+lazy_static = "1"
+log = "0.4"
+strum = "0.24"
+strum_macros = "0.24"
+serde = { version = "1", features = ["derive", "rc"] }
+serde_json = "1"
+tera = "1"
+reactive-signals = "0.1.0-alpha.4"
 
 [dependencies.web-sys]
-version = "0.3.0"
+version = "0.3"
 features = ["Window", "Document", "HtmlElement", "HtmlInputElement"]

benchmarks/src/lib.rs

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

benchmarks/src/reactive.rs

@@ -6,122 +6,13 @@ fn leptos_deep_creation(b: &mut Bencher) {
     use leptos::*;
     let runtime = create_runtime();
 
-    b.iter(|| {
-        let signal = create_rw_signal(0);
-        let mut memos = Vec::<Memo<usize>>::new();
-        for _ in 0..1000usize {
-            let prev = memos.last().copied();
-            if let Some(prev) = prev {
-                memos.push(create_memo(move |_| prev.get() + 1));
-            } else {
-                memos.push(create_memo(move |_| signal.get() + 1));
-            }
-        }
-    });
-
-    runtime.dispose();
-}
-
-#[bench]
-fn leptos_deep_update(b: &mut Bencher) {
-    use leptos::*;
-    let runtime = create_runtime();
-
-    b.iter(|| {
-        let signal = create_rw_signal(0);
-        let mut memos = Vec::<Memo<usize>>::new();
-        for _ in 0..1000usize {
-            if let Some(prev) = memos.last().copied() {
-                memos.push(create_memo(move |_| prev.get() + 1));
-            } else {
-                memos.push(create_memo(move |_| signal.get() + 1));
-            }
-        }
-        signal.set(1);
-        assert_eq!(memos[999].get(), 1001);
-    });
-
-    runtime.dispose();
-}
-
-#[bench]
-fn leptos_narrowing_down(b: &mut Bencher) {
-    use leptos::*;
-    let runtime = create_runtime();
-
-    b.iter(|| {
-        let sigs = (0..1000).map(|n| create_signal(n)).collect::<Vec<_>>();
-        let reads = sigs.iter().map(|(r, _)| *r).collect::<Vec<_>>();
-        let writes = sigs.iter().map(|(_, w)| *w).collect::<Vec<_>>();
-        let memo =
-            create_memo(move |_| reads.iter().map(|r| r.get()).sum::<i32>());
-        assert_eq!(memo(), 499500);
-    });
-
-    runtime.dispose();
-}
-
-#[bench]
-fn leptos_fanning_out(b: &mut Bencher) {
-    use leptos::*;
-    let runtime = create_runtime();
-
-    b.iter(|| {
-        let sig = create_rw_signal(0);
-        let memos = (0..1000)
-            .map(|_| create_memo(move |_| sig.get()))
-            .collect::<Vec<_>>();
-        assert_eq!(memos.iter().map(|m| m.get()).sum::<i32>(), 0);
-        sig.set(1);
-        assert_eq!(memos.iter().map(|m| m.get()).sum::<i32>(), 1000);
-    });
-
-    runtime.dispose();
-}
-
-#[bench]
-fn leptos_narrowing_update(b: &mut Bencher) {
-    use leptos::*;
-    let runtime = create_runtime();
-
-    b.iter(|| {
-        let acc = Rc::new(Cell::new(0));
-        let sigs = (0..1000).map(|n| create_signal(n)).collect::<Vec<_>>();
-        let reads = sigs.iter().map(|(r, _)| *r).collect::<Vec<_>>();
-        let writes = sigs.iter().map(|(_, w)| *w).collect::<Vec<_>>();
-        let memo =
-            create_memo(move |_| reads.iter().map(|r| r.get()).sum::<i32>());
-        assert_eq!(memo(), 499500);
-        create_isomorphic_effect({
-            let acc = Rc::clone(&acc);
-            move |_| {
-                acc.set(memo());
-            }
-        });
-        assert_eq!(acc.get(), 499500);
-
-        writes[1].update(|n| *n += 1);
-        writes[10].update(|n| *n += 1);
-        writes[100].update(|n| *n += 1);
-
-        assert_eq!(acc.get(), 499503);
-        assert_eq!(memo(), 499503);
-    });
-
-    runtime.dispose();
-}
-
-#[bench]
-fn l0410_deep_creation(b: &mut Bencher) {
-    use l0410::*;
-    let runtime = create_runtime();
-
     b.iter(|| {
         create_scope(runtime, |cx| {
             let signal = create_rw_signal(cx, 0);
             let mut memos = Vec::<Memo<usize>>::new();
             for _ in 0..1000usize {
-                if let Some(prev) = memos.last().copied() {
+                let prev = memos.last().copied();
+                if let Some(prev) = prev {
                     memos.push(create_memo(cx, move |_| prev.get() + 1));
                 } else {
                     memos.push(create_memo(cx, move |_| signal.get() + 1));
@@ -135,8 +26,8 @@ fn l0410_deep_creation(b: &mut Bencher) {
 }
 
 #[bench]
-fn l0410_deep_update(b: &mut Bencher) {
-    use l0410::*;
+fn leptos_deep_update(b: &mut Bencher) {
+    use leptos::*;
     let runtime = create_runtime();
 
     b.iter(|| {
@@ -160,8 +51,238 @@ fn l0410_deep_update(b: &mut Bencher) {
 }
 
 #[bench]
-fn l0410_narrowing_down(b: &mut Bencher) {
-    use l0410::*;
+fn leptos_narrowing_down(b: &mut Bencher) {
+    use leptos::*;
+    let runtime = create_runtime();
+
+    b.iter(|| {
+        create_scope(runtime, |cx| {
+            let sigs =
+                (0..1000).map(|n| create_signal(cx, n)).collect::<Vec<_>>();
+            let reads = sigs.iter().map(|(r, _)| *r).collect::<Vec<_>>();
+            let writes = sigs.iter().map(|(_, w)| *w).collect::<Vec<_>>();
+            let memo = create_memo(cx, move |_| {
+                reads.iter().map(|r| r.get()).sum::<i32>()
+            });
+            assert_eq!(memo(), 499500);
+        })
+        .dispose()
+    });
+
+    runtime.dispose();
+}
+
+#[bench]
+fn leptos_fanning_out(b: &mut Bencher) {
+    use leptos::*;
+    let runtime = create_runtime();
+
+    b.iter(|| {
+        create_scope(runtime, |cx| {
+            let sig = create_rw_signal(cx, 0);
+            let memos = (0..1000)
+                .map(|_| create_memo(cx, move |_| sig.get()))
+                .collect::<Vec<_>>();
+            assert_eq!(memos.iter().map(|m| m.get()).sum::<i32>(), 0);
+            sig.set(1);
+            assert_eq!(memos.iter().map(|m| m.get()).sum::<i32>(), 1000);
+        })
+        .dispose()
+    });
+
+    runtime.dispose();
+}
+
+#[bench]
+fn leptos_narrowing_update(b: &mut Bencher) {
+    use leptos::*;
+    let runtime = create_runtime();
+
+    b.iter(|| {
+        create_scope(runtime, |cx| {
+            let acc = Rc::new(Cell::new(0));
+            let sigs =
+                (0..1000).map(|n| create_signal(cx, n)).collect::<Vec<_>>();
+            let reads = sigs.iter().map(|(r, _)| *r).collect::<Vec<_>>();
+            let writes = sigs.iter().map(|(_, w)| *w).collect::<Vec<_>>();
+            let memo = create_memo(cx, move |_| {
+                reads.iter().map(|r| r.get()).sum::<i32>()
+            });
+            assert_eq!(memo(), 499500);
+            create_isomorphic_effect(cx, {
+                let acc = Rc::clone(&acc);
+                move |_| {
+                    acc.set(memo());
+                }
+            });
+            assert_eq!(acc.get(), 499500);
+
+            writes[1].update(|n| *n += 1);
+            writes[10].update(|n| *n += 1);
+            writes[100].update(|n| *n += 1);
+
+            assert_eq!(acc.get(), 499503);
+            assert_eq!(memo(), 499503);
+        })
+        .dispose()
+    });
+
+    runtime.dispose();
+}
+
+#[bench]
+fn leptos_scope_creation_and_disposal(b: &mut Bencher) {
+    use leptos::*;
+    let runtime = create_runtime();
+
+    b.iter(|| {
+        let acc = Rc::new(Cell::new(0));
+        let disposers = (0..1000)
+            .map(|_| {
+                create_scope(runtime, {
+                    let acc = Rc::clone(&acc);
+                    move |cx| {
+                        let (r, w) = create_signal(cx, 0);
+                        create_isomorphic_effect(cx, {
+                            move |_| {
+                                acc.set(r());
+                            }
+                        });
+                        w.update(|n| *n += 1);
+                    }
+                })
+            })
+            .collect::<Vec<_>>();
+        for disposer in disposers {
+            disposer.dispose();
+        }
+    });
+
+    runtime.dispose();
+}
+
+#[bench]
+fn rs_deep_update(b: &mut Bencher) {
+    use reactive_signals::{Scope, Signal, signal, runtimes::ClientRuntime, types::Func};
+
+    let sc = ClientRuntime::new_root_scope();
+    b.iter(|| {
+        let signal = signal!(sc, 0);
+        let mut memos = Vec::<Signal<Func<i32>, ClientRuntime>>::new();
+        for i in 0..1000usize {
+            let prev = memos.get(i.saturating_sub(1)).copied();
+            if let Some(prev) = prev {
+                memos.push(signal!(sc, move || prev.get() + 1))
+            } else {
+                memos.push(signal!(sc, move || signal.get() + 1))
+            }
+        }
+        signal.set(1);
+        assert_eq!(memos[999].get(), 1001);
+    });
+}
+
+#[bench]
+fn rs_fanning_out(b: &mut Bencher) {
+    use reactive_signals::{Scope, Signal, signal, runtimes::ClientRuntime, types::Func};
+    let cx = ClientRuntime::new_root_scope();
+
+    b.iter(|| {
+        let sig = signal!(cx, 0);
+        let memos = (0..1000)
+            .map(|_| signal!(cx, move || sig.get()))
+            .collect::<Vec<_>>();
+        assert_eq!(memos.iter().map(|m| m.get()).sum::<i32>(), 0);
+        sig.set(1);
+        assert_eq!(memos.iter().map(|m| m.get()).sum::<i32>(), 1000);
+    });
+}
+
+#[bench]
+fn rs_narrowing_update(b: &mut Bencher) {
+    use reactive_signals::{Scope, Signal, signal, runtimes::ClientRuntime, types::Func};
+    let cx = ClientRuntime::new_root_scope();
+
+    b.iter(|| {
+        let acc = Rc::new(Cell::new(0));
+        let sigs =
+            (0..1000).map(|n| signal!(cx, n)).collect::<Vec<_>>();
+        let memo = signal!(cx, {
+            let sigs = sigs.clone();
+            move || {
+                sigs.iter().map(|r| r.get()).sum::<i32>()
+            }
+        });
+        assert_eq!(memo.get(), 499500);
+        signal!(cx, {
+            let acc = Rc::clone(&acc);
+            move || {
+                acc.set(memo.get());
+            }
+        });
+
+        assert_eq!(acc.get(), 499500);
+
+        sigs[1].update(|n| *n += 1);
+        sigs[10].update(|n| *n += 1);
+        sigs[100].update(|n| *n += 1);
+
+        assert_eq!(acc.get(), 499503);
+        assert_eq!(memo.get(), 499503);
+    });
+}
+
+#[bench]
+fn l021_deep_creation(b: &mut Bencher) {
+    use l021::*;
+    let runtime = create_runtime();
+
+    b.iter(|| {
+        create_scope(runtime, |cx| {
+            let signal = create_rw_signal(cx, 0);
+            let mut memos = Vec::<Memo<usize>>::new();
+            for _ in 0..1000usize {
+                if let Some(prev) = memos.last().copied() {
+                    memos.push(create_memo(cx, move |_| prev.get() + 1));
+                } else {
+                    memos.push(create_memo(cx, move |_| signal.get() + 1));
+                }
+            }
+        })
+        .dispose()
+    });
+
+    runtime.dispose();
+}
+
+#[bench]
+fn l021_deep_update(b: &mut Bencher) {
+    use l021::*;
+    let runtime = create_runtime();
+
+    b.iter(|| {
+        create_scope(runtime, |cx| {
+            let signal = create_rw_signal(cx, 0);
+            let mut memos = Vec::<Memo<usize>>::new();
+            for _ in 0..1000usize {
+                if let Some(prev) = memos.last().copied() {
+                    memos.push(create_memo(cx, move |_| prev.get() + 1));
+                } else {
+                    memos.push(create_memo(cx, move |_| signal.get() + 1));
+                }
+            }
+            signal.set(1);
+            assert_eq!(memos[999].get(), 1001);
+        })
+        .dispose()
+    });
+
+    runtime.dispose();
+}
+
+#[bench]
+fn l021_narrowing_down(b: &mut Bencher) {
+    use l021::*;
     let runtime = create_runtime();
 
     b.iter(|| {
@@ -183,8 +304,8 @@ fn l0410_narrowing_down(b: &mut Bencher) {
 }
 
 #[bench]
-fn l0410_fanning_out(b: &mut Bencher) {
-    use l0410::*;
+fn l021_fanning_out(b: &mut Bencher) {
+    use leptos::*;
     let runtime = create_runtime();
 
     b.iter(|| {
@@ -203,8 +324,8 @@ fn l0410_fanning_out(b: &mut Bencher) {
     runtime.dispose();
 }
 #[bench]
-fn l0410_narrowing_update(b: &mut Bencher) {
-    use l0410::*;
+fn l021_narrowing_update(b: &mut Bencher) {
+    use l021::*;
     let runtime = create_runtime();
 
     b.iter(|| {
@@ -217,11 +338,11 @@ fn l0410_narrowing_update(b: &mut Bencher) {
             let memo = create_memo(cx, move |_| {
                 reads.iter().map(|r| r.get()).sum::<i32>()
             });
-            assert_eq!(memo.get(), 499500);
+            assert_eq!(memo(), 499500);
             create_isomorphic_effect(cx, {
                 let acc = Rc::clone(&acc);
                 move |_| {
-                    acc.set(memo.get());
+                    acc.set(memo());
                 }
             });
             assert_eq!(acc.get(), 499500);
@@ -231,7 +352,7 @@ fn l0410_narrowing_update(b: &mut Bencher) {
             writes[100].update(|n| *n += 1);
 
             assert_eq!(acc.get(), 499503);
-            assert_eq!(memo.get(), 499503);
+            assert_eq!(memo(), 499503);
         })
         .dispose()
     });
@@ -240,8 +361,8 @@ fn l0410_narrowing_update(b: &mut Bencher) {
 }
 
 #[bench]
-fn l0410_scope_creation_and_disposal(b: &mut Bencher) {
-    use l0410::*;
+fn l021_scope_creation_and_disposal(b: &mut Bencher) {
+    use l021::*;
     let runtime = create_runtime();
 
     b.iter(|| {
@@ -254,7 +375,7 @@ fn l0410_scope_creation_and_disposal(b: &mut Bencher) {
                         let (r, w) = create_signal(cx, 0);
                         create_isomorphic_effect(cx, {
                             move |_| {
-                                acc.set(r.get());
+                                acc.set(r());
                             }
                         });
                         w.update(|n| *n += 1);

benchmarks/src/ssr.rs

@@ -2,14 +2,15 @@ use test::Bencher;
 
 #[bench]
 fn leptos_ssr_bench(b: &mut Bencher) {
-	use leptos::*;
-	let r = create_runtime();
     b.iter(|| {
-			leptos::leptos_dom::HydrationCtx::reset_id();
+		use leptos::*;
+		leptos_dom::HydrationCtx::reset_id();
+		_ = create_scope(create_runtime(), |cx| {
 			#[component]
-			fn Counter(initial: i32) -> impl IntoView {
-				let (value, set_value) = create_signal(initial);
+			fn Counter(cx: Scope, initial: i32) -> impl IntoView {
+				let (value, set_value) = create_signal(cx, initial);
 				view! {
+					cx,
 					<div>
 						<button on:click=move |_| set_value.update(|value| *value -= 1)>"-1"</button>
 						<span>"Value: " {move || value().to_string()} "!"</span>
@@ -18,7 +19,8 @@ fn leptos_ssr_bench(b: &mut Bencher) {
 				}
 			}
 
-			let rendered = view! {
+			let rendered = view! { 
+				cx,
 				<main>
 					<h1>"Welcome to our benchmark page."</h1>
 					<p>"Here's some introductory text."</p>
@@ -26,53 +28,14 @@ fn leptos_ssr_bench(b: &mut Bencher) {
 					<Counter initial=2/>
 					<Counter initial=3/>
 				</main>
-			}.into_view().render_to_string();
+			}.into_view(cx).render_to_string(cx);
 
 			assert_eq!(
 				rendered,
-"<main data-hk=\"0-0-0-1\"><h1 data-hk=\"0-0-0-2\">Welcome to our benchmark page.</h1><p data-hk=\"0-0-0-3\">Here&#x27;s some introductory text.</p><div data-hk=\"0-0-0-5\"><button data-hk=\"0-0-0-6\">-1</button><span data-hk=\"0-0-0-7\">Value: <!>1<!--hk=0-0-0-8-->!</span><button data-hk=\"0-0-0-9\">+1</button></div><!--hk=0-0-0-4--><div data-hk=\"0-0-0-11\"><button data-hk=\"0-0-0-12\">-1</button><span data-hk=\"0-0-0-13\">Value: <!>2<!--hk=0-0-0-14-->!</span><button data-hk=\"0-0-0-15\">+1</button></div><!--hk=0-0-0-10--><div data-hk=\"0-0-0-17\"><button data-hk=\"0-0-0-18\">-1</button><span data-hk=\"0-0-0-19\">Value: <!>3<!--hk=0-0-0-20-->!</span><button data-hk=\"0-0-0-21\">+1</button></div><!--hk=0-0-0-16--></main>"			);
+				"<main id=\"_0-1\"><h1 id=\"_0-2\">Welcome to our benchmark page.</h1><p id=\"_0-3\">Here&#x27;s some introductory text.</p><div id=\"_0-3-1\"><button id=\"_0-3-2\">-1</button><span id=\"_0-3-3\">Value: <!>1<!--hk=_0-3-4-->!</span><button id=\"_0-3-5\">+1</button></div><!--hk=_0-3-0--><div id=\"_0-3-5-1\"><button id=\"_0-3-5-2\">-1</button><span id=\"_0-3-5-3\">Value: <!>2<!--hk=_0-3-5-4-->!</span><button id=\"_0-3-5-5\">+1</button></div><!--hk=_0-3-5-0--><div id=\"_0-3-5-5-1\"><button id=\"_0-3-5-5-2\">-1</button><span id=\"_0-3-5-5-3\">Value: <!>3<!--hk=_0-3-5-5-4-->!</span><button id=\"_0-3-5-5-5\">+1</button></div><!--hk=_0-3-5-5-0--></main>"
+			);
+		});
 	});
-	r.dispose();
-}
-
-#[bench]
-fn tachys_ssr_bench(b: &mut Bencher) {
-	use leptos::{create_runtime, create_signal, SignalGet, SignalUpdate};
-	use tachy_maccy::view;
-	use tachydom::view::{Render, RenderHtml};
-	use tachydom::html::element::ElementChild;
-	use tachydom::html::attribute::global::ClassAttribute;
-	use tachydom::html::attribute::global::GlobalAttributes;
-	use tachydom::html::attribute::global::OnAttribute;
-	use tachydom::renderer::dom::Dom;
-	let rt = create_runtime();
-    b.iter(|| {
-		fn counter(initial: i32) -> impl Render<Dom> + RenderHtml<Dom> {
-			let (value, set_value) = create_signal(initial);
-			view! {
-				<div>
-					<button on:click=move |_| set_value.update(|value| *value -= 1)>"-1"</button>
-					<span>"Value: " {move || value().to_string()} "!"</span>
-					<button on:click=move |_| set_value.update(|value| *value += 1)>"+1"</button>
-				</div>
-			}
-		}
-
-		let rendered = view! {
-			<main>
-				<h1>"Welcome to our benchmark page."</h1>
-				<p>"Here's some introductory text."</p>
-				{counter(1)}
-				{counter(2)}
-				{counter(3)}
-			</main>
-		}.to_html();
-		assert_eq!(
-			rendered,
-			"<main><h1>Welcome to our benchmark page.</h1><p>Here's some introductory text.</p><div><button>-1</button><span>Value: <!>1<!>!</span><button>+1</button></div><div><button>-1</button><span>Value: <!>2<!>!</span><button>+1</button></div><div><button>-1</button><span>Value: <!>3<!>!</span><button>+1</button></div></main>"
-		);
-	});
-	rt.dispose();
 }
 
 #[bench]
@@ -92,13 +55,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/leptos.rs

@@ -1,7 +1,7 @@
 pub use leptos::*;
 use miniserde::*;
-use wasm_bindgen::JsCast;
 use web_sys::HtmlInputElement;
+use wasm_bindgen::JsCast;
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Todos(pub Vec<Todo>);
@@ -9,13 +9,13 @@ pub struct Todos(pub Vec<Todo>);
 const STORAGE_KEY: &str = "todos-leptos";
 
 impl Todos {
-    pub fn new() -> Self {
+    pub fn new(cx: Scope) -> Self {
         Self(vec![])
     }
 
-    pub fn new_with_1000() -> Self {
+    pub fn new_with_1000(cx: Scope) -> Self {
         let todos = (0..1000)
-            .map(|id| Todo::new(id, format!("Todo #{id}")))
+            .map(|id| Todo::new(cx, id, format!("Todo #{id}")))
             .collect();
         Self(todos)
     }
@@ -72,17 +72,13 @@ pub struct Todo {
 }
 
 impl Todo {
-    pub fn new(id: usize, title: String) -> Self {
-        Self::new_with_completed(id, title, false)
+    pub fn new(cx: Scope, id: usize, title: String) -> Self {
+        Self::new_with_completed(cx, id, title, false)
     }
 
-    pub fn new_with_completed(
-        id: usize,
-        title: String,
-        completed: bool,
-    ) -> Self {
-        let (title, set_title) = create_signal(title);
-        let (completed, set_completed) = create_signal(completed);
+    pub fn new_with_completed(cx: Scope, id: usize, title: String, completed: bool) -> Self {
+        let (title, set_title) = create_signal(cx, title);
+        let (completed, set_completed) = create_signal(cx, completed);
         Self {
             id,
             title,
@@ -102,7 +98,7 @@ const ESCAPE_KEY: u32 = 27;
 const ENTER_KEY: u32 = 13;
 
 #[component]
-pub fn TodoMVC(todos: Todos) -> impl IntoView {
+pub fn TodoMVC(cx: Scope, todos: Todos) -> impl IntoView {
     let mut next_id = todos
         .0
         .iter()
@@ -111,10 +107,10 @@ pub fn TodoMVC(todos: Todos) -> impl IntoView {
         .map(|last| last + 1)
         .unwrap_or(0);
 
-    let (todos, set_todos) = create_signal(todos);
-    provide_context(set_todos);
+    let (todos, set_todos) = create_signal(cx, todos);
+    provide_context(cx, set_todos);
 
-    let (mode, set_mode) = create_signal(Mode::All);
+    let (mode, set_mode) = create_signal(cx, Mode::All);
 
     let add_todo = move |ev: web_sys::KeyboardEvent| {
         let target = event_target::<HtmlInputElement>(&ev);
@@ -124,7 +120,7 @@ pub fn TodoMVC(todos: Todos) -> impl IntoView {
             let title = event_target_value(&ev);
             let title = title.trim();
             if !title.is_empty() {
-                let new = Todo::new(next_id, title.to_string());
+                let new = Todo::new(cx, next_id, title.to_string());
                 set_todos.update(|t| t.add(new));
                 next_id += 1;
                 target.set_value("");
@@ -132,7 +128,7 @@ pub fn TodoMVC(todos: Todos) -> impl IntoView {
         }
     };
 
-    let filtered_todos = create_memo::<Vec<Todo>>(move |_| {
+    let filtered_todos = create_memo::<Vec<Todo>>(cx, move |_| {
         todos.with(|todos| match mode.get() {
             Mode::All => todos.0.to_vec(),
             Mode::Active => todos
@@ -152,7 +148,7 @@ pub fn TodoMVC(todos: Todos) -> impl IntoView {
 
     // effect to serialize to JSON
     // this does reactive reads, so it will automatically serialize on any relevant change
-    create_effect(move |_| {
+    create_effect(cx, move |_| {
         if let Ok(Some(storage)) = window().local_storage() {
             let objs = todos
                 .get()
@@ -167,7 +163,7 @@ pub fn TodoMVC(todos: Todos) -> impl IntoView {
         }
     });
 
-    view! { 
+    view! { cx,
         <main>
             <section class="todoapp">
                 <header class="header">
@@ -192,8 +188,8 @@ pub fn TodoMVC(todos: Todos) -> impl IntoView {
                         <For
                             each=filtered_todos
                             key=|todo| todo.id
-                            children=move |todo: Todo| {
-                                view! { <Todo todo=todo.clone()/> }
+                            view=move |cx, todo: Todo| {
+                                view! { cx, <Todo todo=todo.clone()/> }
                             }
                         />
                     </ul>
@@ -240,14 +236,14 @@ pub fn TodoMVC(todos: Todos) -> impl IntoView {
                 <p>"Part of " <a href="http://todomvc.com">"TodoMVC"</a></p>
             </footer>
         </main>
-    }.into_view()
+    }.into_view(cx)
 }
 
 #[component]
-pub fn Todo(todo: Todo) -> impl IntoView {
-    let (editing, set_editing) = create_signal(false);
-    let set_todos = use_context::<WriteSignal<Todos>>().unwrap();
-    //let input = NodeRef::new();
+pub fn Todo(cx: Scope, todo: Todo) -> impl IntoView {
+    let (editing, set_editing) = create_signal(cx, false);
+    let set_todos = use_context::<WriteSignal<Todos>>(cx).unwrap();
+    //let input = NodeRef::new(cx);
 
     let save = move |value: &str| {
         let value = value.trim();
@@ -259,7 +255,7 @@ pub fn Todo(todo: Todo) -> impl IntoView {
         set_editing(false);
     };
 
-    view! { 
+    view! { cx,
         <li class="todo" class:editing=editing class:completed=move || (todo.completed)()>
             <div class="view">
                 <input class="toggle" type="checkbox" prop:checked=move || (todo.completed)()/>
@@ -272,7 +268,7 @@ pub fn Todo(todo: Todo) -> impl IntoView {
             {move || {
                 editing()
                     .then(|| {
-                        view! { 
+                        view! { cx,
                             <input
                                 class="edit"
                                 class:hidden=move || !(editing)()
@@ -323,8 +319,8 @@ pub struct TodoSerialized {
 }
 
 impl TodoSerialized {
-    pub fn into_todo(self, ) -> Todo {
-        Todo::new_with_completed(self.id, self.title, self.completed)
+    pub fn into_todo(self, cx: Scope) -> Todo {
+        Todo::new_with_completed(cx, self.id, self.title, self.completed)
     }
 }
 

benchmarks/src/todomvc/mod.rs

@@ -2,7 +2,6 @@ use test::Bencher;
 
 mod leptos;
 mod sycamore;
-mod tachys;
 mod tera;
 mod yew;
 
@@ -13,34 +12,18 @@ fn leptos_todomvc_ssr(b: &mut Bencher) {
     b.iter(|| {
         use crate::todomvc::leptos::*;
 
-        let html = ::leptos::ssr::render_to_string(|| {
-            view! { <TodoMVC todos=Todos::new()/> }
+        let html = ::leptos::ssr::render_to_string(|cx| {
+            view! { cx, <TodoMVC todos=Todos::new(cx)/> }
         });
         assert!(html.len() > 1);
     });
-    runtime.dispose();
-}
-
-#[bench]
-fn tachys_todomvc_ssr(b: &mut Bencher) {
-    use ::leptos::*;
-    let runtime = create_runtime();
-    b.iter(|| {
-        use crate::todomvc::tachys::*;
-        use tachydom::view::{Render, RenderHtml};
-
-        let rendered = TodoMVC(Todos::new()).to_html();
-        assert_eq!(
-            rendered,
-"<main><section class=\"todoapp\"><header class=\"header\"><h1>todos</h1><input placeholder=\"What needs to be done?\" autofocus class=\"new-todo\"></header><section class=\"main hidden\"><input id=\"toggle-all\" type=\"checkbox\" class=\"toggle-all\"><label for=\"toggle-all\">Mark all as complete</label><ul class=\"todo-list\"></ul></section><footer class=\"footer hidden\"><span class=\"todo-count\"><strong>0</strong><!> items<!> left</span><ul class=\"filters\"><li><a href=\"#/\" class=\"selected selected\">All</a></li><li><a href=\"#/active\" class=\"\">Active</a></li><li><a href=\"#/completed\" class=\"\">Completed</a></li></ul><button class=\"clear-completed hidden hidden\">Clear completed</button></footer></section><footer class=\"info\"><p>Double-click to edit a todo</p><p>Created by <a href=\"http://todomvc.com\">Greg Johnston</a></p><p>Part of <a href=\"http://todomvc.com\">TodoMVC</a></p></footer></main>"        );
-    });
-    runtime.dispose();
 }
 
 #[bench]
 fn sycamore_todomvc_ssr(b: &mut Bencher) {
     use self::sycamore::*;
-    use ::sycamore::{prelude::*, *};
+    use ::sycamore::prelude::*;
+    use ::sycamore::*;
 
     b.iter(|| {
         _ = create_scope(|cx| {
@@ -59,7 +42,8 @@ fn sycamore_todomvc_ssr(b: &mut Bencher) {
 #[bench]
 fn yew_todomvc_ssr(b: &mut Bencher) {
     use self::yew::*;
-    use ::yew::{prelude::*, ServerRenderer};
+    use ::yew::prelude::*;
+    use ::yew::ServerRenderer;
 
     b.iter(|| {
         tokio_test::block_on(async {
@@ -76,33 +60,21 @@ fn leptos_todomvc_ssr_with_1000(b: &mut Bencher) {
         use self::leptos::*;
         use ::leptos::*;
 
-        let html = ::leptos::ssr::render_to_string(|| {
+        let html = ::leptos::ssr::render_to_string(|cx| {
             view! {
-                <TodoMVC todos=Todos::new_with_1000()/>
+                cx,
+                <TodoMVC todos=Todos::new_with_1000(cx)/>
             }
         });
         assert!(html.len() > 1);
     });
 }
 
-#[bench]
-fn tachys_todomvc_ssr_with_1000(b: &mut Bencher) {
-    use ::leptos::*;
-    let runtime = create_runtime();
-    b.iter(|| {
-        use crate::todomvc::tachys::*;
-        use tachydom::view::{Render, RenderHtml};
-
-        let rendered = TodoMVC(Todos::new_with_1000()).to_html();
-        assert!(rendered.len() > 20_000)
-    });
-    runtime.dispose();
-}
-
 #[bench]
 fn sycamore_todomvc_ssr_with_1000(b: &mut Bencher) {
     use self::sycamore::*;
-    use ::sycamore::{prelude::*, *};
+    use ::sycamore::prelude::*;
+    use ::sycamore::*;
 
     b.iter(|| {
         _ = create_scope(|cx| {
@@ -121,7 +93,8 @@ fn sycamore_todomvc_ssr_with_1000(b: &mut Bencher) {
 #[bench]
 fn yew_todomvc_ssr_with_1000(b: &mut Bencher) {
     use self::yew::*;
-    use ::yew::{prelude::*, ServerRenderer};
+    use ::yew::prelude::*;
+    use ::yew::ServerRenderer;
 
     b.iter(|| {
         tokio_test::block_on(async {
@@ -130,19 +103,4 @@ fn yew_todomvc_ssr_with_1000(b: &mut Bencher) {
             assert!(rendered.len() > 1);
         });
     });
-}
-
-#[bench]
-fn tera_todomvc_ssr(b: &mut Bencher) {
-    use ::leptos::*;
-    let runtime = create_runtime();
-    b.iter(|| {
-        use crate::todomvc::leptos::*;
-
-        let html = ::leptos::ssr::render_to_string(|| {
-            view! { <TodoMVC todos=Todos::new()/> }
-        });
-        assert!(html.len() > 1);
-    });
-    runtime.dispose();
-}
+}

benchmarks/src/todomvc/tachys.rs

@@ -1,333 +0,0 @@
-pub use leptos_reactive::*;
-use miniserde::*;
-use tachy_maccy::view;
-use tachydom::{
-    html::{
-        attribute::global::{ClassAttribute, GlobalAttributes, OnAttribute},
-        element::ElementChild,
-    },
-    renderer::dom::Dom,
-    view::{keyed::keyed, Render, RenderHtml},
-};
-use wasm_bindgen::JsCast;
-use web_sys::HtmlInputElement;
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct Todos(pub Vec<Todo>);
-
-const STORAGE_KEY: &str = "todos-leptos";
-
-impl Todos {
-    pub fn new() -> Self {
-        Self(vec![])
-    }
-
-    pub fn new_with_1000() -> Self {
-        let todos = (0..1000)
-            .map(|id| Todo::new(id, format!("Todo #{id}")))
-            .collect();
-        Self(todos)
-    }
-
-    pub fn is_empty(&self) -> bool {
-        self.0.is_empty()
-    }
-
-    pub fn add(&mut self, todo: Todo) {
-        self.0.push(todo);
-    }
-
-    pub fn remove(&mut self, id: usize) {
-        self.0.retain(|todo| todo.id != id);
-    }
-
-    pub fn remaining(&self) -> usize {
-        self.0.iter().filter(|todo| !(todo.completed)()).count()
-    }
-
-    pub fn completed(&self) -> usize {
-        self.0.iter().filter(|todo| (todo.completed)()).count()
-    }
-
-    pub fn toggle_all(&self) {
-        // if all are complete, mark them all active instead
-        if self.remaining() == 0 {
-            for todo in &self.0 {
-                if todo.completed.get() {
-                    (todo.set_completed)(false);
-                }
-            }
-        }
-        // otherwise, mark them all complete
-        else {
-            for todo in &self.0 {
-                (todo.set_completed)(true);
-            }
-        }
-    }
-
-    fn clear_completed(&mut self) {
-        self.0.retain(|todo| !todo.completed.get());
-    }
-}
-
-#[derive(Debug, PartialEq, Eq, Clone)]
-pub struct Todo {
-    pub id: usize,
-    pub title: ReadSignal<String>,
-    pub set_title: WriteSignal<String>,
-    pub completed: ReadSignal<bool>,
-    pub set_completed: WriteSignal<bool>,
-}
-
-impl Todo {
-    pub fn new(id: usize, title: String) -> Self {
-        Self::new_with_completed(id, title, false)
-    }
-
-    pub fn new_with_completed(
-        id: usize,
-        title: String,
-        completed: bool,
-    ) -> Self {
-        let (title, set_title) = create_signal(title);
-        let (completed, set_completed) = create_signal(completed);
-        Self {
-            id,
-            title,
-            set_title,
-            completed,
-            set_completed,
-        }
-    }
-
-    pub fn toggle(&self) {
-        self.set_completed
-            .update(|completed| *completed = !*completed);
-    }
-}
-
-const ESCAPE_KEY: u32 = 27;
-const ENTER_KEY: u32 = 13;
-
-pub fn TodoMVC(todos: Todos) -> impl Render<Dom> + RenderHtml<Dom> {
-    let mut next_id = todos
-        .0
-        .iter()
-        .map(|todo| todo.id)
-        .max()
-        .map(|last| last + 1)
-        .unwrap_or(0);
-
-    let (todos, set_todos) = create_signal(todos);
-    provide_context(set_todos);
-
-    let (mode, set_mode) = create_signal(Mode::All);
-
-    let add_todo = move |ev: web_sys::KeyboardEvent| {
-        todo!()
-        /* let target = event_target::<HtmlInputElement>(&ev);
-        ev.stop_propagation();
-        let key_code = ev.unchecked_ref::<web_sys::KeyboardEvent>().key_code();
-        if key_code == ENTER_KEY {
-            let title = event_target_value(&ev);
-            let title = title.trim();
-            if !title.is_empty() {
-                let new = Todo::new(next_id, title.to_string());
-                set_todos.update(|t| t.add(new));
-                next_id += 1;
-                target.set_value("");
-            }
-        } */
-    };
-
-    let filtered_todos = create_memo::<Vec<Todo>>(move |_| {
-        todos.with(|todos| match mode.get() {
-            Mode::All => todos.0.to_vec(),
-            Mode::Active => todos
-                .0
-                .iter()
-                .filter(|todo| !todo.completed.get())
-                .cloned()
-                .collect(),
-            Mode::Completed => todos
-                .0
-                .iter()
-                .filter(|todo| todo.completed.get())
-                .cloned()
-                .collect(),
-        })
-    });
-
-    // effect to serialize to JSON
-    // this does reactive reads, so it will automatically serialize on any relevant change
-    create_effect(move |_| {
-        ()
-        /* if let Ok(Some(storage)) = window().local_storage() {
-            let objs = todos
-                .get()
-                .0
-                .iter()
-                .map(TodoSerialized::from)
-                .collect::<Vec<_>>();
-            let json = json::to_string(&objs);
-            if storage.set_item(STORAGE_KEY, &json).is_err() {
-                log::error!("error while trying to set item in localStorage");
-            }
-        } */
-    });
-
-    view! {
-        <main>
-            <section class="todoapp">
-                <header class="header">
-                    <h1>"todos"</h1>
-                    <input
-                        class="new-todo"
-                        placeholder="What needs to be done?"
-                        autofocus
-                    />
-                </header>
-                <section class="main" class:hidden=move || todos.with(|t| t.is_empty())>
-                    <input
-                        id="toggle-all"
-                        class="toggle-all"
-                        r#type="checkbox"
-                        //prop:checked=move || todos.with(|t| t.remaining() > 0)
-                        on:input=move |_| set_todos.update(|t| t.toggle_all())
-                    />
-                    <label r#for="toggle-all">"Mark all as complete"</label>
-                    <ul class="todo-list">
-                        {move || {
-                            keyed(filtered_todos.get(), |todo| todo.id, Todo)
-                        }}
-                    </ul>
-                </section>
-                <footer class="footer" class:hidden=move || todos.with(|t| t.is_empty())>
-                    <span class="todo-count">
-                        <strong>{move || todos.with(|t| t.remaining().to_string())}</strong>
-                        {move || if todos.with(|t| t.remaining()) == 1 { " item" } else { " items" }}
-                        " left"
-                    </span>
-                    <ul class="filters">
-                        <li>
-                            <a
-                                href="#/"
-                                class="selected"
-                                class:selected=move || mode() == Mode::All
-                            >
-                                "All"
-                            </a>
-                        </li>
-                        <li>
-                            <a href="#/active" class:selected=move || mode() == Mode::Active>
-                                "Active"
-                            </a>
-                        </li>
-                        <li>
-                            <a href="#/completed" class:selected=move || mode() == Mode::Completed>
-                                "Completed"
-                            </a>
-                        </li>
-                    </ul>
-                    <button
-                        class="clear-completed hidden"
-                        class:hidden=move || todos.with(|t| t.completed() == 0)
-                        on:click=move |_| set_todos.update(|t| t.clear_completed())
-                    >
-                        "Clear completed"
-                    </button>
-                </footer>
-            </section>
-            <footer class="info">
-                <p>"Double-click to edit a todo"</p>
-                <p>"Created by " <a href="http://todomvc.com">"Greg Johnston"</a></p>
-                <p>"Part of " <a href="http://todomvc.com">"TodoMVC"</a></p>
-            </footer>
-        </main>
-    }
-}
-
-pub fn Todo(todo: Todo) -> impl Render<Dom> + RenderHtml<Dom> {
-    let (editing, set_editing) = create_signal(false);
-    let set_todos = use_context::<WriteSignal<Todos>>().unwrap();
-    //let input = NodeRef::new();
-
-    let save = move |value: &str| {
-        let value = value.trim();
-        if value.is_empty() {
-            set_todos.update(|t| t.remove(todo.id));
-        } else {
-            (todo.set_title)(value.to_string());
-        }
-        set_editing(false);
-    };
-
-    view! {
-        <li class="todo" class:editing=editing class:completed=move || (todo.completed)()>
-            /* <div class="view">
-                <input class="toggle" r#type="checkbox"/>
-                <label on:dblclick=move |_| set_editing(true)>{move || todo.title.get()}</label>
-                <button
-                    class="destroy"
-                    on:click=move |_| set_todos.update(|t| t.remove(todo.id))
-                ></button>
-            </div>
-            {move || {
-                editing()
-                    .then(|| {
-                        view! {
-                            <input
-                                class="edit"
-                                class:hidden=move || !(editing)()
-                            />
-                        }
-                    })
-            }} */
-        </li>
-    }
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum Mode {
-    Active,
-    Completed,
-    All,
-}
-
-impl Default for Mode {
-    fn default() -> Self {
-        Mode::All
-    }
-}
-
-pub fn route(hash: &str) -> Mode {
-    match hash {
-        "/active" => Mode::Active,
-        "/completed" => Mode::Completed,
-        _ => Mode::All,
-    }
-}
-
-#[derive(Serialize, Deserialize)]
-pub struct TodoSerialized {
-    pub id: usize,
-    pub title: String,
-    pub completed: bool,
-}
-
-impl TodoSerialized {
-    pub fn into_todo(self) -> Todo {
-        Todo::new_with_completed(self.id, self.title, self.completed)
-    }
-}
-
-impl From<&Todo> for TodoSerialized {
-    fn from(todo: &Todo) -> Self {
-        Self {
-            id: todo.id,
-            title: todo.title.get(),
-            completed: (todo.completed)(),
-        }
-    }
-}

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 %}
@@ -87,17 +87,17 @@ static TEMPLATE: &str = r#"<main>
         </main>"#;
 
 #[bench]
-fn tera_todomvc_ssr(b: &mut Bencher) {
+fn tera_todomvc(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 {
@@ -127,17 +127,17 @@ fn tera_todomvc_ssr(b: &mut Bencher) {
 }
 
 #[bench]
-fn tera_todomvc_ssr_1000(b: &mut Bencher) {
+fn tera_todomvc_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 {
@@ -174,4 +174,4 @@ fn tera_todomvc_ssr_1000(b: &mut Bencher) {
 
         let _ = TERA.render("template.html", &ctx).unwrap();
     });
-}
+}

cargo-make/check-minimal-versions.toml

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

cargo-make/lint.toml

@@ -1,20 +0,0 @@
-[tasks.lint]
-dependencies = ["check-format-flow", "clippy-each-feature"]
-
-[tasks.check-format]
-env = { LEPTOS_PROJECT_DIRECTORY = "../" }
-args = ["fmt", "--", "--check", "--config-path", "${LEPTOS_PROJECT_DIRECTORY}"]
-
-[tasks.clippy-each-feature]
-command = "cargo"
-args = [
-  "all-features",
-  "clippy",
-  "--no-deps",
-  "--",
-  "-D",
-  "clippy::print_stdout",
-]
-install_script = '''
-cargo install --git https://github.com/sabify/cargo-all-features --branch arbitrary-command-support
-'''

cargo-make/main.toml

@@ -1,15 +0,0 @@
-extend = [
-  { path = "./lint.toml" },
-  { path = "./test.toml" },
-  { path = "./check-minimal-versions.toml" },
-]
-
-[env]
-RUSTFLAGS = ""
-LEPTOS_OUTPUT_NAME = "ci" # allows examples to check/build without cargo-leptos
-
-[env.github-actions]
-RUSTFLAGS = "-D warnings"
-
-[tasks.ci]
-dependencies = ["lint", "test-each-feature", "doctests"]

cargo-make/test.toml

@@ -1,16 +0,0 @@
-[tasks.test-each-feature]
-env = { "NEXTEST_NO_TESTS" = "warn" }
-command = "cargo"
-args = ["all-features", "nextest", "run", "--all-targets"]
-install_script = '''
-cargo install --git https://github.com/sabify/cargo-all-features --branch arbitrary-command-support
-'''
-
-# This can be removed once doctests is supported in nextest
-# https://github.com/nextest-rs/nextest/issues/16
-[tasks.doctests]
-command = "cargo"
-args = ["all-features", "test", "--doc"]
-install_script = '''
-cargo install --git https://github.com/sabify/cargo-all-features --branch arbitrary-command-support
-'''

cargo-make/wasm-test.toml

@@ -1,7 +0,0 @@
-[tasks.post-test]
-dependencies = ["test-wasm"]
-
-[tasks.test-wasm]
-env = { CARGO_MAKE_WASM_TEST_ARGS = "--headless --chrome --features=wasm-bindgen" }
-command = "cargo"
-args = ["make", "wasm-pack-test"]

const_str_slice_concat/Cargo.toml

@@ -1,12 +0,0 @@
-[package]
-name = "const_str_slice_concat"
-version = "0.1.0"
-authors = ["Greg Johnston"]
-license = "MIT"
-readme = "../README.md"
-repository = "https://github.com/leptos-rs/leptos"
-description = "Utilities for const concatenation of string slices."
-rust-version.workspace = true
-edition.workspace = true
-
-[dependencies]

const_str_slice_concat/Makefile.toml

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

const_str_slice_concat/src/lib.rs

@@ -1,139 +0,0 @@
-#![no_std]
-#![forbid(unsafe_code)]
-#![deny(missing_docs)]
-
-//! Utilities for const concatenation of string slices.
-
-pub(crate) const MAX_TEMPLATE_SIZE: usize = 4096;
-
-/// Converts a zero-terminated buffer of bytes into a UTF-8 string.
-pub const fn str_from_buffer(buf: &[u8; MAX_TEMPLATE_SIZE]) -> &str {
-    match core::ffi::CStr::from_bytes_until_nul(buf) {
-        Ok(cstr) => match cstr.to_str() {
-            Ok(str) => str,
-            Err(_) => panic!("TEMPLATE FAILURE"),
-        },
-        Err(_) => panic!("TEMPLATE FAILURE"),
-    }
-}
-
-/// Concatenates any number of static strings into a single array.
-// credit to Rainer Stropek, "Constant fun," Rust Linz, June 2022
-pub const fn const_concat(
-    strs: &'static [&'static str],
-) -> [u8; MAX_TEMPLATE_SIZE] {
-    let mut buffer = [0; MAX_TEMPLATE_SIZE];
-    let mut position = 0;
-    let mut remaining = strs;
-
-    while let [current, tail @ ..] = remaining {
-        let x = current.as_bytes();
-        let mut i = 0;
-
-        // have it iterate over bytes manually, because, again,
-        // no mutable references in const fns
-        while i < x.len() {
-            buffer[position] = x[i];
-            position += 1;
-            i += 1;
-        }
-
-        remaining = tail;
-    }
-
-    buffer
-}
-
-/// Converts a zero-terminated buffer of bytes into a UTF-8 string with the given prefix.
-pub const fn const_concat_with_prefix(
-    strs: &'static [&'static str],
-    prefix: &'static str,
-    suffix: &'static str,
-) -> [u8; MAX_TEMPLATE_SIZE] {
-    let mut buffer = [0; MAX_TEMPLATE_SIZE];
-    let mut position = 0;
-    let mut remaining = strs;
-
-    while let [current, tail @ ..] = remaining {
-        let x = current.as_bytes();
-        let mut i = 0;
-
-        // have it iterate over bytes manually, because, again,
-        // no mutable references in const fns
-        while i < x.len() {
-            buffer[position] = x[i];
-            position += 1;
-            i += 1;
-        }
-
-        remaining = tail;
-    }
-
-    if buffer[0] == 0 {
-        buffer
-    } else {
-        let mut new_buf = [0; MAX_TEMPLATE_SIZE];
-        let prefix = prefix.as_bytes();
-        let suffix = suffix.as_bytes();
-        let mut position = 0;
-        let mut i = 0;
-        while i < prefix.len() {
-            new_buf[position] = prefix[i];
-            position += 1;
-            i += 1;
-        }
-        i = 0;
-        while i < buffer.len() {
-            if buffer[i] == 0 {
-                break;
-            }
-            new_buf[position] = buffer[i];
-            position += 1;
-            i += 1;
-        }
-        i = 0;
-        while i < suffix.len() {
-            new_buf[position] = suffix[i];
-            position += 1;
-            i += 1;
-        }
-
-        new_buf
-    }
-}
-
-/// Converts any number of strings into a UTF-8 string, separated by the given string.
-pub const fn const_concat_with_separator(
-    strs: &[&str],
-    separator: &'static str,
-) -> [u8; MAX_TEMPLATE_SIZE] {
-    let mut buffer = [0; MAX_TEMPLATE_SIZE];
-    let mut position = 0;
-    let mut remaining = strs;
-
-    while let [current, tail @ ..] = remaining {
-        let x = current.as_bytes();
-        let mut i = 0;
-
-        // have it iterate over bytes manually, because, again,
-        // no mutable references in const fns
-        while i < x.len() {
-            buffer[position] = x[i];
-            position += 1;
-            i += 1;
-        }
-        if !x.is_empty() {
-            let mut position = 0;
-            let separator = separator.as_bytes();
-            while i < separator.len() {
-                buffer[position] = separator[i];
-                position += 1;
-                i += 1;
-            }
-        }
-
-        remaining = tail;
-    }
-
-    buffer
-}

docs/COMMON_BUGS.md

@@ -9,10 +9,10 @@ This document is intended as a running list of common issues, with example code
 **Issue**: Sometimes you want to update a reactive signal in a way that depends on another signal.
 
 ```rust
-let (a, set_a) = create_signal(0);
-let (b, set_b) = create_signal(false);
+let (a, set_a) = create_signal(cx, 0);
+let (b, set_b) = create_signal(cx, false);
 
-create_effect(move |_| {
+create_effect(cx, move |_| {
 	if a() > 5 {
 		set_b(true);
 	}
@@ -24,7 +24,7 @@ This creates an inefficient chain of updates, and can easily lead to infinite lo
 **Solution**: Follow the rule, _What can be derived, should be derived._ In this case, this has the benefit of massively reducing the code size, too!
 
 ```rust
-let (a, set_a) = create_signal(0);
+let (a, set_a) = create_signal(cx, 0);
 let b = move || a () > 5;
 ```
 
@@ -34,19 +34,19 @@ Sometimes you have nested signals: for example, hash-map that can change over ti
 
 ```rust
 #[component]
-pub fn App() -> impl IntoView {
-    let resources = create_rw_signal(HashMap::new());
+pub fn App(cx: Scope) -> impl IntoView {
+    let resources = create_rw_signal(cx, HashMap::new());
 
     let update = move |id: usize| {
         resources.update(|resources| {
             resources
                 .entry(id)
-                .or_insert_with(|| create_rw_signal(0))
+                .or_insert_with(|| create_rw_signal(cx, 0))
                 .update(|amount| *amount += 1)
         })
     };
 
-    view! {
+    view! { cx,
         <div>
             <pre>{move || format!("{:#?}", resources.get().into_iter().map(|(id, resource)| (id, resource.get())).collect::<Vec<_>>())}</pre>
             <button on:click=move |_| update(1)>"+"</button>
@@ -55,17 +55,17 @@ pub fn App() -> impl IntoView {
 }
 ```
 
-Clicking the button twice will cause a panic, because of the nested signal _read_. Calling the `update` function on `resources` immediately takes out a mutable borrow on `resources`, then updates the `resource` signal—which re-runs the effect that reads from the signals, which tries to immutably access `resources` and panics. It's the nested update here which causes a problem, because the inner update triggers and effect that tries to read both signals while the outer is still updating.
+Clicking the button twice will cause a panic, because of the nested signal *read*. Calling the `update` function on `resources` immediately takes out a mutable borrow on `resources`, then updates the `resource` signal—which re-runs the effect that reads from the signals, which tries to immutably access `resources` and panics. It's the nested update here which causes a problem, because the inner update triggers and effect that tries to read both signals while the outer is still updating.
 
-You can fix this fairly easily by using the [`batch()`](https://docs.rs/leptos/latest/leptos/fn.batch.html) method:
+You can fix this fairly easily by using the [`Scope::batch()`](https://docs.rs/leptos/latest/leptos/struct.Scope.html#method.batch) method:
 
 ```rust
     let update = move |id: usize| {
-        batch(move || {
+        cx.batch(move || {
             resources.update(|resources| {
                 resources
                     .entry(id)
-                    .or_insert_with(|| create_rw_signal(0))
+                    .or_insert_with(|| create_rw_signal(cx, 0))
                     .update(|amount| *amount += 1)
             })
         });
@@ -83,11 +83,11 @@ Many DOM attributes can be updated either by setting an attribute on the DOM nod
 This means that in practice, attributes like `value` or `checked` on an `<input/>` element only update the _default_ value for the `<input/>`. If you want to reactively update the value, you should use `prop:value` instead to set the `value` property.
 
 ```rust
-let (a, set_a) = create_signal("Starting value".to_string());
+let (a, set_a) = create_signal(cx, "Starting value".to_string());
 let on_input = move |ev| set_a(event_target_value(&ev));
 
 view! {
-
+	cx,
 	// ❌ reactivity doesn't work as expected: typing only updates the default
 	//    of each input, so if you start typing in the second input, it won't
 	//    update the first one
@@ -97,11 +97,11 @@ view! {
 ```
 
 ```rust
-let (a, set_a) = create_signal("Starting value".to_string());
+let (a, set_a) = create_signal(cx, "Starting value".to_string());
 let on_input = move |ev| set_a(event_target_value(&ev));
 
 view! {
-
+	cx,
 	// ✅ works as intended by setting the value *property*
 	<input prop:value=a on:input=on_input />
 	<input prop:value=a on:input=on_input />

docs/book/README.md

@@ -1,3 +1,14 @@
-The Leptos book is now available at [https://book.leptos.dev](https://book.leptos.dev).
+This project contains the core of a new introductory guide to Leptos.
 
-The source code for the book has moved to [https://github.com/leptos-rs/book](https://github.com/leptos-rs/book). Please open issues or make PRs in that repository.
+It is built using `mdbook`. You can view a local copy by installing `mdbook`
+
+```bash
+cargo install mdbook
+```
+
+and run the book with
+```
+mdbook serve
+```
+
+It should be available at `http://localhost:3000`.

docs/book/book.toml

@@ -1,10 +0,0 @@
-[output.html]
-additional-css = ["./mdbook-admonish.css"]
-[output.html.playground]
-runnable = false
-
-[preprocessor]
-
-[preprocessor.admonish]
-command = "mdbook-admonish"
-assets_version = "3.0.1" # do not edit: managed by `mdbook-admonish install`

docs/book/mdbook-admonish.css

@@ -1,345 +0,0 @@
-@charset "UTF-8";
-:root {
-  --md-admonition-icon--admonish-note: url("data:image/svg+xml;charset=utf-8,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24'><path d='M20.71 7.04c.39-.39.39-1.04 0-1.41l-2.34-2.34c-.37-.39-1.02-.39-1.41 0l-1.84 1.83 3.75 3.75M3 17.25V21h3.75L17.81 9.93l-3.75-3.75L3 17.25z'/></svg>");
-  --md-admonition-icon--admonish-abstract: url("data:image/svg+xml;charset=utf-8,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24'><path d='M17 9H7V7h10m0 6H7v-2h10m-3 6H7v-2h7M12 3a1 1 0 0 1 1 1 1 1 0 0 1-1 1 1 1 0 0 1-1-1 1 1 0 0 1 1-1m7 0h-4.18C14.4 1.84 13.3 1 12 1c-1.3 0-2.4.84-2.82 2H5a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h14a2 2 0 0 0 2-2V5a2 2 0 0 0-2-2z'/></svg>");
-  --md-admonition-icon--admonish-info: url("data:image/svg+xml;charset=utf-8,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24'><path d='M13 9h-2V7h2m0 10h-2v-6h2m-1-9A10 10 0 0 0 2 12a10 10 0 0 0 10 10 10 10 0 0 0 10-10A10 10 0 0 0 12 2z'/></svg>");
-  --md-admonition-icon--admonish-tip: url("data:image/svg+xml;charset=utf-8,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24'><path d='M17.66 11.2c-.23-.3-.51-.56-.77-.82-.67-.6-1.43-1.03-2.07-1.66C13.33 7.26 13 4.85 13.95 3c-.95.23-1.78.75-2.49 1.32-2.59 2.08-3.61 5.75-2.39 8.9.04.1.08.2.08.33 0 .22-.15.42-.35.5-.23.1-.47.04-.66-.12a.58.58 0 0 1-.14-.17c-1.13-1.43-1.31-3.48-.55-5.12C5.78 10 4.87 12.3 5 14.47c.06.5.12 1 .29 1.5.14.6.41 1.2.71 1.73 1.08 1.73 2.95 2.97 4.96 3.22 2.14.27 4.43-.12 6.07-1.6 1.83-1.66 2.47-4.32 1.53-6.6l-.13-.26c-.21-.46-.77-1.26-.77-1.26m-3.16 6.3c-.28.24-.74.5-1.1.6-1.12.4-2.24-.16-2.9-.82 1.19-.28 1.9-1.16 2.11-2.05.17-.8-.15-1.46-.28-2.23-.12-.74-.1-1.37.17-2.06.19.38.39.76.63 1.06.77 1 1.98 1.44 2.24 2.8.04.14.06.28.06.43.03.82-.33 1.72-.93 2.27z'/></svg>");
-  --md-admonition-icon--admonish-success: url("data:image/svg+xml;charset=utf-8,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24'><path d='m9 20.42-6.21-6.21 2.83-2.83L9 14.77l9.88-9.89 2.83 2.83L9 20.42z'/></svg>");
-  --md-admonition-icon--admonish-question: url("data:image/svg+xml;charset=utf-8,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24'><path d='m15.07 11.25-.9.92C13.45 12.89 13 13.5 13 15h-2v-.5c0-1.11.45-2.11 1.17-2.83l1.24-1.26c.37-.36.59-.86.59-1.41a2 2 0 0 0-2-2 2 2 0 0 0-2 2H8a4 4 0 0 1 4-4 4 4 0 0 1 4 4 3.2 3.2 0 0 1-.93 2.25M13 19h-2v-2h2M12 2A10 10 0 0 0 2 12a10 10 0 0 0 10 10 10 10 0 0 0 10-10c0-5.53-4.5-10-10-10z'/></svg>");
-  --md-admonition-icon--admonish-warning: url("data:image/svg+xml;charset=utf-8,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24'><path d='M13 14h-2V9h2m0 9h-2v-2h2M1 21h22L12 2 1 21z'/></svg>");
-  --md-admonition-icon--admonish-failure: url("data:image/svg+xml;charset=utf-8,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24'><path d='M20 6.91 17.09 4 12 9.09 6.91 4 4 6.91 9.09 12 4 17.09 6.91 20 12 14.91 17.09 20 20 17.09 14.91 12 20 6.91z'/></svg>");
-  --md-admonition-icon--admonish-danger: url("data:image/svg+xml;charset=utf-8,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24'><path d='M11 15H6l7-14v8h5l-7 14v-8z'/></svg>");
-  --md-admonition-icon--admonish-bug: url("data:image/svg+xml;charset=utf-8,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24'><path d='M14 12h-4v-2h4m0 6h-4v-2h4m6-6h-2.81a5.985 5.985 0 0 0-1.82-1.96L17 4.41 15.59 3l-2.17 2.17a6.002 6.002 0 0 0-2.83 0L8.41 3 7 4.41l1.62 1.63C7.88 6.55 7.26 7.22 6.81 8H4v2h2.09c-.05.33-.09.66-.09 1v1H4v2h2v1c0 .34.04.67.09 1H4v2h2.81c1.04 1.79 2.97 3 5.19 3s4.15-1.21 5.19-3H20v-2h-2.09c.05-.33.09-.66.09-1v-1h2v-2h-2v-1c0-.34-.04-.67-.09-1H20V8z'/></svg>");
-  --md-admonition-icon--admonish-example: url("data:image/svg+xml;charset=utf-8,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24'><path d='M7 13v-2h14v2H7m0 6v-2h14v2H7M7 7V5h14v2H7M3 8V5H2V4h2v4H3m-1 9v-1h3v4H2v-1h2v-.5H3v-1h1V17H2m2.25-7a.75.75 0 0 1 .75.75c0 .2-.08.39-.21.52L3.12 13H5v1H2v-.92L4 11H2v-1h2.25z'/></svg>");
-  --md-admonition-icon--admonish-quote: url("data:image/svg+xml;charset=utf-8,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24'><path d='M14 17h3l2-4V7h-6v6h3M6 17h3l2-4V7H5v6h3l-2 4z'/></svg>");
-  --md-details-icon: url("data:image/svg+xml;charset=utf-8,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 24 24'><path d='M8.59 16.58 13.17 12 8.59 7.41 10 6l6 6-6 6-1.41-1.42Z'/></svg>");
-}
-
-:is(.admonition) {
-  display: flow-root;
-  margin: 1.5625em 0;
-  padding: 0 1.2rem;
-  color: var(--fg);
-  page-break-inside: avoid;
-  background-color: var(--bg);
-  border: 0 solid black;
-  border-inline-start-width: 0.4rem;
-  border-radius: 0.2rem;
-  box-shadow: 0 0.2rem 1rem rgba(0, 0, 0, 0.05), 0 0 0.1rem rgba(0, 0, 0, 0.1);
-}
-@media print {
-  :is(.admonition) {
-    box-shadow: none;
-  }
-}
-:is(.admonition) > * {
-  box-sizing: border-box;
-}
-:is(.admonition) :is(.admonition) {
-  margin-top: 1em;
-  margin-bottom: 1em;
-}
-:is(.admonition) > .tabbed-set:only-child {
-  margin-top: 0;
-}
-html :is(.admonition) > :last-child {
-  margin-bottom: 1.2rem;
-}
-
-a.admonition-anchor-link {
-  display: none;
-  position: absolute;
-  left: -1.2rem;
-  padding-right: 1rem;
-}
-a.admonition-anchor-link:link, a.admonition-anchor-link:visited {
-  color: var(--fg);
-}
-a.admonition-anchor-link:link:hover, a.admonition-anchor-link:visited:hover {
-  text-decoration: none;
-}
-a.admonition-anchor-link::before {
-  content: "§";
-}
-
-:is(.admonition-title, summary.admonition-title) {
-  position: relative;
-  min-height: 4rem;
-  margin-block: 0;
-  margin-inline: -1.6rem -1.2rem;
-  padding-block: 0.8rem;
-  padding-inline: 4.4rem 1.2rem;
-  font-weight: 700;
-  background-color: rgba(68, 138, 255, 0.1);
-  print-color-adjust: exact;
-  -webkit-print-color-adjust: exact;
-  display: flex;
-}
-:is(.admonition-title, summary.admonition-title) p {
-  margin: 0;
-}
-html :is(.admonition-title, summary.admonition-title):last-child {
-  margin-bottom: 0;
-}
-:is(.admonition-title, summary.admonition-title)::before {
-  position: absolute;
-  top: 0.625em;
-  inset-inline-start: 1.6rem;
-  width: 2rem;
-  height: 2rem;
-  background-color: #448aff;
-  print-color-adjust: exact;
-  -webkit-print-color-adjust: exact;
-  mask-image: url('data:image/svg+xml;charset=utf-8,<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"></svg>');
-  -webkit-mask-image: url('data:image/svg+xml;charset=utf-8,<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"></svg>');
-  mask-repeat: no-repeat;
-  -webkit-mask-repeat: no-repeat;
-  mask-size: contain;
-  -webkit-mask-size: contain;
-  content: "";
-}
-:is(.admonition-title, summary.admonition-title):hover a.admonition-anchor-link {
-  display: initial;
-}
-
-details.admonition > summary.admonition-title::after {
-  position: absolute;
-  top: 0.625em;
-  inset-inline-end: 1.6rem;
-  height: 2rem;
-  width: 2rem;
-  background-color: currentcolor;
-  mask-image: var(--md-details-icon);
-  -webkit-mask-image: var(--md-details-icon);
-  mask-repeat: no-repeat;
-  -webkit-mask-repeat: no-repeat;
-  mask-size: contain;
-  -webkit-mask-size: contain;
-  content: "";
-  transform: rotate(0deg);
-  transition: transform 0.25s;
-}
-details[open].admonition > summary.admonition-title::after {
-  transform: rotate(90deg);
-}
-
-:is(.admonition):is(.admonish-note) {
-  border-color: #448aff;
-}
-
-:is(.admonish-note) > :is(.admonition-title, summary.admonition-title) {
-  background-color: rgba(68, 138, 255, 0.1);
-}
-:is(.admonish-note) > :is(.admonition-title, summary.admonition-title)::before {
-  background-color: #448aff;
-  mask-image: var(--md-admonition-icon--admonish-note);
-  -webkit-mask-image: var(--md-admonition-icon--admonish-note);
-  mask-repeat: no-repeat;
-  -webkit-mask-repeat: no-repeat;
-  mask-size: contain;
-  -webkit-mask-repeat: no-repeat;
-}
-
-:is(.admonition):is(.admonish-abstract, .admonish-summary, .admonish-tldr) {
-  border-color: #00b0ff;
-}
-
-:is(.admonish-abstract, .admonish-summary, .admonish-tldr) > :is(.admonition-title, summary.admonition-title) {
-  background-color: rgba(0, 176, 255, 0.1);
-}
-:is(.admonish-abstract, .admonish-summary, .admonish-tldr) > :is(.admonition-title, summary.admonition-title)::before {
-  background-color: #00b0ff;
-  mask-image: var(--md-admonition-icon--admonish-abstract);
-  -webkit-mask-image: var(--md-admonition-icon--admonish-abstract);
-  mask-repeat: no-repeat;
-  -webkit-mask-repeat: no-repeat;
-  mask-size: contain;
-  -webkit-mask-repeat: no-repeat;
-}
-
-:is(.admonition):is(.admonish-info, .admonish-todo) {
-  border-color: #00b8d4;
-}
-
-:is(.admonish-info, .admonish-todo) > :is(.admonition-title, summary.admonition-title) {
-  background-color: rgba(0, 184, 212, 0.1);
-}
-:is(.admonish-info, .admonish-todo) > :is(.admonition-title, summary.admonition-title)::before {
-  background-color: #00b8d4;
-  mask-image: var(--md-admonition-icon--admonish-info);
-  -webkit-mask-image: var(--md-admonition-icon--admonish-info);
-  mask-repeat: no-repeat;
-  -webkit-mask-repeat: no-repeat;
-  mask-size: contain;
-  -webkit-mask-repeat: no-repeat;
-}
-
-:is(.admonition):is(.admonish-tip, .admonish-hint, .admonish-important) {
-  border-color: #00bfa5;
-}
-
-:is(.admonish-tip, .admonish-hint, .admonish-important) > :is(.admonition-title, summary.admonition-title) {
-  background-color: rgba(0, 191, 165, 0.1);
-}
-:is(.admonish-tip, .admonish-hint, .admonish-important) > :is(.admonition-title, summary.admonition-title)::before {
-  background-color: #00bfa5;
-  mask-image: var(--md-admonition-icon--admonish-tip);
-  -webkit-mask-image: var(--md-admonition-icon--admonish-tip);
-  mask-repeat: no-repeat;
-  -webkit-mask-repeat: no-repeat;
-  mask-size: contain;
-  -webkit-mask-repeat: no-repeat;
-}
-
-:is(.admonition):is(.admonish-success, .admonish-check, .admonish-done) {
-  border-color: #00c853;
-}
-
-:is(.admonish-success, .admonish-check, .admonish-done) > :is(.admonition-title, summary.admonition-title) {
-  background-color: rgba(0, 200, 83, 0.1);
-}
-:is(.admonish-success, .admonish-check, .admonish-done) > :is(.admonition-title, summary.admonition-title)::before {
-  background-color: #00c853;
-  mask-image: var(--md-admonition-icon--admonish-success);
-  -webkit-mask-image: var(--md-admonition-icon--admonish-success);
-  mask-repeat: no-repeat;
-  -webkit-mask-repeat: no-repeat;
-  mask-size: contain;
-  -webkit-mask-repeat: no-repeat;
-}
-
-:is(.admonition):is(.admonish-question, .admonish-help, .admonish-faq) {
-  border-color: #64dd17;
-}
-
-:is(.admonish-question, .admonish-help, .admonish-faq) > :is(.admonition-title, summary.admonition-title) {
-  background-color: rgba(100, 221, 23, 0.1);
-}
-:is(.admonish-question, .admonish-help, .admonish-faq) > :is(.admonition-title, summary.admonition-title)::before {
-  background-color: #64dd17;
-  mask-image: var(--md-admonition-icon--admonish-question);
-  -webkit-mask-image: var(--md-admonition-icon--admonish-question);
-  mask-repeat: no-repeat;
-  -webkit-mask-repeat: no-repeat;
-  mask-size: contain;
-  -webkit-mask-repeat: no-repeat;
-}
-
-:is(.admonition):is(.admonish-warning, .admonish-caution, .admonish-attention) {
-  border-color: #ff9100;
-}
-
-:is(.admonish-warning, .admonish-caution, .admonish-attention) > :is(.admonition-title, summary.admonition-title) {
-  background-color: rgba(255, 145, 0, 0.1);
-}
-:is(.admonish-warning, .admonish-caution, .admonish-attention) > :is(.admonition-title, summary.admonition-title)::before {
-  background-color: #ff9100;
-  mask-image: var(--md-admonition-icon--admonish-warning);
-  -webkit-mask-image: var(--md-admonition-icon--admonish-warning);
-  mask-repeat: no-repeat;
-  -webkit-mask-repeat: no-repeat;
-  mask-size: contain;
-  -webkit-mask-repeat: no-repeat;
-}
-
-:is(.admonition):is(.admonish-failure, .admonish-fail, .admonish-missing) {
-  border-color: #ff5252;
-}
-
-:is(.admonish-failure, .admonish-fail, .admonish-missing) > :is(.admonition-title, summary.admonition-title) {
-  background-color: rgba(255, 82, 82, 0.1);
-}
-:is(.admonish-failure, .admonish-fail, .admonish-missing) > :is(.admonition-title, summary.admonition-title)::before {
-  background-color: #ff5252;
-  mask-image: var(--md-admonition-icon--admonish-failure);
-  -webkit-mask-image: var(--md-admonition-icon--admonish-failure);
-  mask-repeat: no-repeat;
-  -webkit-mask-repeat: no-repeat;
-  mask-size: contain;
-  -webkit-mask-repeat: no-repeat;
-}
-
-:is(.admonition):is(.admonish-danger, .admonish-error) {
-  border-color: #ff1744;
-}
-
-:is(.admonish-danger, .admonish-error) > :is(.admonition-title, summary.admonition-title) {
-  background-color: rgba(255, 23, 68, 0.1);
-}
-:is(.admonish-danger, .admonish-error) > :is(.admonition-title, summary.admonition-title)::before {
-  background-color: #ff1744;
-  mask-image: var(--md-admonition-icon--admonish-danger);
-  -webkit-mask-image: var(--md-admonition-icon--admonish-danger);
-  mask-repeat: no-repeat;
-  -webkit-mask-repeat: no-repeat;
-  mask-size: contain;
-  -webkit-mask-repeat: no-repeat;
-}
-
-:is(.admonition):is(.admonish-bug) {
-  border-color: #f50057;
-}
-
-:is(.admonish-bug) > :is(.admonition-title, summary.admonition-title) {
-  background-color: rgba(245, 0, 87, 0.1);
-}
-:is(.admonish-bug) > :is(.admonition-title, summary.admonition-title)::before {
-  background-color: #f50057;
-  mask-image: var(--md-admonition-icon--admonish-bug);
-  -webkit-mask-image: var(--md-admonition-icon--admonish-bug);
-  mask-repeat: no-repeat;
-  -webkit-mask-repeat: no-repeat;
-  mask-size: contain;
-  -webkit-mask-repeat: no-repeat;
-}
-
-:is(.admonition):is(.admonish-example) {
-  border-color: #7c4dff;
-}
-
-:is(.admonish-example) > :is(.admonition-title, summary.admonition-title) {
-  background-color: rgba(124, 77, 255, 0.1);
-}
-:is(.admonish-example) > :is(.admonition-title, summary.admonition-title)::before {
-  background-color: #7c4dff;
-  mask-image: var(--md-admonition-icon--admonish-example);
-  -webkit-mask-image: var(--md-admonition-icon--admonish-example);
-  mask-repeat: no-repeat;
-  -webkit-mask-repeat: no-repeat;
-  mask-size: contain;
-  -webkit-mask-repeat: no-repeat;
-}
-
-:is(.admonition):is(.admonish-quote, .admonish-cite) {
-  border-color: #9e9e9e;
-}
-
-:is(.admonish-quote, .admonish-cite) > :is(.admonition-title, summary.admonition-title) {
-  background-color: rgba(158, 158, 158, 0.1);
-}
-:is(.admonish-quote, .admonish-cite) > :is(.admonition-title, summary.admonition-title)::before {
-  background-color: #9e9e9e;
-  mask-image: var(--md-admonition-icon--admonish-quote);
-  -webkit-mask-image: var(--md-admonition-icon--admonish-quote);
-  mask-repeat: no-repeat;
-  -webkit-mask-repeat: no-repeat;
-  mask-size: contain;
-  -webkit-mask-repeat: no-repeat;
-}
-
-.navy :is(.admonition) {
-  background-color: var(--sidebar-bg);
-}
-
-.ayu :is(.admonition),
-.coal :is(.admonition) {
-  background-color: var(--theme-hover);
-}
-
-.rust :is(.admonition) {
-  background-color: var(--sidebar-bg);
-  color: var(--sidebar-fg);
-}
-.rust .admonition-anchor-link:link, .rust .admonition-anchor-link:visited {
-  color: var(--sidebar-fg);
-}

docs/book/src/01_introduction.md

@@ -1,2 +1,20 @@
-<meta http-equiv="refresh" content="0; URL=https://book.leptos.dev/">
-<link rel="canonical" href="https://book.leptos.dev/">
+# Introduction
+
+This book is intended as an introduction to the [Leptos](https://github.com/leptos-rs/leptos) Web framework. 
+It will walk through the fundamental concepts you need to build applications, 
+beginning with a simple application rendered in the browser, and building toward a
+full-stack application with server-side rendering and hydration.
+
+The guide doesn’t assume you know anything about fine-grained reactivity or the 
+details of modern Web frameworks. It does assume you are familiar with the Rust 
+programming language, HTML, CSS, and the DOM and basic Web APIs.
+
+Leptos is most similar to frameworks like [Solid](https://www.solidjs.com) (JavaScript) 
+and [Sycamore](https://sycamore-rs.netlify.app/) (Rust). There are some similarities 
+to other frameworks like React (JavaScript), Svelte (JavaScript), Yew (Rust), and 
+Dioxus (Rust), so knowledge of one of those frameworks may also make it easier to 
+understand Leptos.
+
+You can find more detailed docs for each part of the API at [Docs.rs](https://docs.rs/leptos/latest/leptos/).
+
+**The guide is a work in progress.**

docs/book/src/02_getting_started.md

@@ -0,0 +1,70 @@
+# Getting Started
+
+There are two basic paths to getting started with Leptos:
+
+1. Client-side rendering with [Trunk](https://trunkrs.dev/)
+2. Full-stack rendering with [`cargo-leptos`](https://github.com/leptos-rs/cargo-leptos)
+
+For the early examples, it will be easiest to begin with Trunk. We’ll introduce
+`cargo-leptos` a little later in this series.
+
+If you don’t already have it installed, you can install Trunk by running
+
+```bash
+cargo install trunk
+```
+
+Create a basic Rust binary project
+
+```bash
+cargo init leptos-tutorial
+```
+
+> We recommend using `nightly` Rust, as it enables [a few nice features](https://github.com/leptos-rs/leptos#nightly-note). To use `nightly` Rust with WebAssembly, you can run
+>
+> ```bash
+> rustup toolchain install nightly
+> rustup default nightly
+> rustup target add wasm32-unknown-unknown
+> ```
+
+`cd` into your new `leptos-tutorial` project and add `leptos` as a dependency
+
+```bash
+cargo add leptos
+```
+
+Create a simple `index.html` in the root of the `leptos-tutorial` directory
+
+```html
+<!DOCTYPE html>
+<html>
+  <head></head>
+  <body></body>
+</html>
+```
+
+And add a simple “Hello, world!” to your `main.rs`
+
+```rust
+use leptos::*;
+
+fn main() {
+    mount_to_body(|cx| view! { cx,  <p>"Hello, world!"</p> })
+}
+```
+
+Your directory structure should now look something like this
+
+```
+leptos_tutorial
+├── src
+│   └── main.rs
+├── Cargo.toml
+├── index.html
+```
+
+Now run `trunk serve --open` from the root of the `leptos-tutorial` directory.
+Trunk should automatically compile your app and open it in your default browser.
+If you make edits to `main.rs`, Trunk will recompile your source code and
+live-reload the page.

docs/book/src/14_create_effect.md

@@ -0,0 +1,112 @@
+# Responding to Changes with `create_effect`
+
+Believe it or not, we’ve made it this far without having mentioned half of the reactive system: effects.
+
+Leptos is built on a fine-grained reactive system, which means that individual reactive values (“signals,” sometimes known as observables) trigger rerunning the code that reacts to them (“effects,” sometimes known as observers). These two halves of the reactive system are inter-dependent. Without effects, signals can change within the reactive system but never be observed in a way that interacts with the outside world. Without signals, effects run once but never again, as there’s no observable value to subscribe to.
+
+[`create_effect`](https://docs.rs/leptos_reactive/latest/leptos_reactive/fn.create_effect.html) takes a function as its argument. It immediately runs the function. If you access any reactive signal inside that function, it registers the fact that the effect depends on that signal with the reactive runtime. Whenever one of the signals that the effect depends on changes, the effect runs again.
+
+```rust
+let (a, set_a) = create_signal(cx, 0);
+let (b, set_b) = create_signal(cx, 0);
+
+create_effect(cx, move |_| {
+  // immediately prints "Value: 0" and subscribes to `a`
+  log::debug!("Value: {}", a());
+});
+```
+
+The effect function is called with an argument containing whatever value it returned the last time it ran. On the initial run, this is `None`.
+
+By default, effects **do not run on the server**. This means you can call browser-specific APIs within the effect function without causing issues. If you need an effect to run on the server, use [`create_isomorphic_effect`](https://docs.rs/leptos_reactive/latest/leptos_reactive/fn.create_isomorphic_effect.html).
+
+## Autotracking and Dynamic Dependencies
+
+If you’re familiar with a framework like React, you might notice one key difference. React and similar frameworks typically require you to pass a “dependency array,” an explicit set of variables that determine when the effect should rerun.
+
+Because Leptos comes from the tradition of synchronous reactive programming, we don’t need this explicit dependency list. Instead, we automatically track dependencies depending on which signals are accessed within the effect.
+
+This has two effects (no pun intended). Dependencies are
+
+1. **Automatic**: You don’t need to maintain a dependency list, or worry about what should or shouldn’t be included. The framework simply tracks which signals might cause the effect to rerun, and handles it for you.
+2. **Dynamic**: The dependency list is cleared and updated every time the effect runs. If your effect contains a conditional (for example), only signals that are used in the current branch are tracked. This means that effects rerun the absolute minimum number of times.
+
+> If this sounds like magic, and if you want a deep dive into how automatic dependency tracking works, [check out this video](https://www.youtube.com/watch?v=GWB3vTWeLd4). (Apologies for the low volume!)
+
+## Effects as Zero-Cost-ish Abstraction
+
+While they’re not a “zero-cost abstraction” in the most technical sense—they require some additional memory use, exist at runtime, etc.—at a higher level, from the perspective of whatever expensive API calls or other work you’re doing within them, effects are a zero-cost abstraction. They rerun the absolute minimum number of times necessary, given how you’ve described them.
+
+Imagine that I’m creating some kind of chat software, and I want people to be able to display their full name, or just their first name, and to notify the server whenever their name changes:
+
+```rust
+let (first, set_first) = create_signal(cx, String::new());
+let (last, set_last) = create_signal(cx, String::new());
+let (use_last, set_use_last) = create_signal(cx, true);
+
+// this will add the name to the log
+// any time one of the source signals changes
+create_effect(cx, move |_| {
+    log(
+        cx,
+        if use_last() {
+            format!("{} {}", first(), last())
+        } else {
+            first()
+        },
+    )
+});
+```
+
+If `use_last` is `true`, effect should rerun whenever `first`, `last`, or `use_last` changes. But if I toggle `use_last` to `false`, a change in `last` will never cause the full name to change. In fact, `last` will be removed from the dependency list until `use_last` toggles again. This saves us from sending multiple unnecessary requests to the API if I change `last` multiple times while `use_last` is still `false`.
+
+## To `create_effect`, or not to `create_effect`?
+
+Effects are intended to run _side-effects_ of the system, not to synchronize state _within_ the system. In other words: don’t write to signals within effects.
+
+If you need to define a signal that depends on the value of other signals, use a derived signal or [`create_memo`](https://docs.rs/leptos_reactive/latest/leptos_reactive/fn.create_memo.html).
+
+If you need to synchronize some reactive value with the non-reactive world outside—like a web API, the console, the filesystem, or the DOM—create an effect.
+
+> If you’re curious for more information about when you should and shouldn’t use `create_effect`, [check out this video](https://www.youtube.com/watch?v=aQOFJQ2JkvQ) for a more in-depth consideration!
+
+## Effects and Rendering
+
+We’ve managed to get this far without mentioning effects because they’re built into the Leptos DOM renderer. We’ve seen that you can create a signal and pass it into the `view` macro, and it will update the relevant DOM node whenever the signal changes:
+
+```rust
+let (count, set_count) = create_signal(cx, 0);
+
+view! { cx,
+    <p>{count}</p>
+}
+```
+
+This works because the framework essentially creates an effect wrapping this update. You can imagine Leptos translating this view into something like this:
+
+```rust
+let (count, set_count) = create_signal(cx, 0);
+
+// create a DOM element
+let p = create_element("p");
+
+// create an effect to reactively update the text
+create_effect(cx, move |prev_value| {
+    // first, access the signal’s value and convert it to a string
+    let text = count().to_string();
+
+    // if this is different from the previous value, update the node
+    if prev_value != Some(text) {
+        p.set_text_content(&text);
+    }
+
+    // return this value so we can memoize the next update
+    text
+});
+```
+
+Every time `count` is updated, this effect wil rerun. This is what allows reactive, fine-grained updates to the DOM.
+
+[Click to open CodeSandbox.](https://codesandbox.io/p/sandbox/serene-thompson-40974n?file=%2Fsrc%2Fmain.rs&selection=%5B%7B%22endColumn%22%3A1%2C%22endLineNumber%22%3A2%2C%22startColumn%22%3A1%2C%22startLineNumber%22%3A2%7D%5D)
+
+<iframe src="https://codesandbox.io/p/sandbox/serene-thompson-40974n?file=%2Fsrc%2Fmain.rs&selection=%5B%7B%22endColumn%22%3A1%2C%22endLineNumber%22%3A2%2C%22startColumn%22%3A1%2C%22startLineNumber%22%3A2%7D%5D" width="100%" height="1000px" style="max-height: 100vh"></iframe>

docs/book/src/15_global_state.md

@@ -1,2 +1,174 @@
-<meta http-equiv="refresh" content="0; URL=https://book.leptos.dev/15_global_state.html">
-<link rel="canonical" href="https://book.leptos.dev/15_global_state.html">
+# Global State Management
+
+So far, we've only been working with local state in components
+We've only seen how to communicate between parent and child components
+But there are also more general ways to manage global state
+
+The three best approaches to global state are
+
+1. Using the router to drive global state via the URL
+2. Passing signals through context
+3. Creating a global state struct and creating lenses into it with `create_slice`
+
+## Option #1: URL as Global State
+
+The next few sections of the tutorial will be about the router.
+So for now, we'll just look at options #2 and #3.
+
+## Option #2: Passing Signals through Context
+
+In virtual DOM libraries like React, using the Context API to manage global
+state is a bad idea: because the entire app exists in a tree, changing
+some value provided high up in the tree can cause the whole app to render.
+
+In fine-grained reactive libraries like Leptos, this is simply not the case.
+You can create a signal in the root of your app and pass it down to other
+components using provide_context(). Changing it will only cause rerendering
+in the specific places it is actually used, not the whole app.
+
+We start by creating a signal in the root of the app and providing it to
+all its children and descendants using `provide_context`.
+
+```rust
+#[component]
+fn App(cx: Scope) -> impl IntoView {
+    // here we create a signal in the root that can be consumed
+    // anywhere in the app.
+    let (count, set_count) = create_signal(cx, 0);
+    // we'll pass the setter to specific components,
+    // but provide the count itself to the whole app via context
+    provide_context(cx, count);
+
+    view! { cx,
+        // SetterButton is allowed to modify the count
+        <SetterButton set_count/>
+        // These consumers can only read from it
+        // But we could give them write access by passing `set_count` if we wanted
+        <FancyMath/>
+        <ListItems/>
+    }
+}
+```
+
+`<SetterButton/>` is the kind of counter we’ve written several times now.
+(See the sandbox below if you don’t understand what I mean.)
+
+`<FancyMath/>` and `<ListItems/>` both consume the signal we’re providing via
+`use_context` and do something with it.
+
+```rust
+/// A component that does some "fancy" math with the global count
+#[component]
+fn FancyMath(cx: Scope) -> impl IntoView {
+    // here we consume the global count signal with `use_context`
+    let count = use_context::<ReadSignal<u32>>(cx)
+        // we know we just provided this in the parent component
+        .expect("there to be a `count` signal provided");
+    let is_even = move || count() & 1 == 0;
+
+    view! { cx,
+        <div class="consumer blue">
+            "The number "
+            <strong>{count}</strong>
+            {move || if is_even() {
+                " is"
+            } else {
+                " is not"
+            }}
+            " even."
+        </div>
+    }
+}
+```
+
+This kind of “provide a signal in a parent, consume it in a child” should be familiar
+from the chapter on [parent-child interactions](./view/08_parent_child.md). The same
+pattern you use to communicate between parents and children works for grandparents and
+grandchildren, or any ancestors and descendants: in other words, between “global” state
+in the root component of your app and any other components anywhere else in the app.
+
+Because of the fine-grained nature of updates, this is usually all you need. However,
+in some cases with more complex state changes, you may want to use a slightly more
+structured approach to global state.
+
+## Option #3: Create a Global State Struct
+
+You can use this approach to build a single global data structure
+that holds the state for your whole app, and then access it by
+taking fine-grained slices using
+[`create_slice`](https://docs.rs/leptos/latest/leptos/fn.create_slice.html)
+or [`create_memo`](https://docs.rs/leptos/latest/leptos/fn.create_memo.html),
+so that changing one part of the state doesn't cause parts of your
+app that depend on other parts of the state to change.
+
+You can begin by defining a simple state struct:
+
+```rust
+#[derive(Default, Clone, Debug)]
+struct GlobalState {
+    count: u32,
+    name: String,
+}
+```
+
+Provide it in the root of your app so it’s available everywhere.
+
+```rust
+#[component]
+fn App(cx: Scope) -> impl IntoView {
+    // we'll provide a single signal that holds the whole state
+    // each component will be responsible for creating its own "lens" into it
+    let state = create_rw_signal(cx, GlobalState::default());
+    provide_context(cx, state);
+
+    // ...
+}
+```
+
+Then child components can access “slices” of that state with fine-grained
+updates via `create_slice`. Each slice signal only updates when the particular
+piece of the larger struct it accesses updates. This means you can create a single
+root signal, and then take independent, fine-grained slices of it in different
+components, each of which can update without notifying the others of changes.
+
+```rust
+/// A component that updates the count in the global state.
+#[component]
+fn GlobalStateCounter(cx: Scope) -> impl IntoView {
+    let state = use_context::<RwSignal<GlobalState>>(cx).expect("state to have been provided");
+
+    // `create_slice` lets us create a "lens" into the data
+    let (count, set_count) = create_slice(
+        cx,
+        // we take a slice *from* `state`
+        state,
+        // our getter returns a "slice" of the data
+        |state| state.count,
+        // our setter describes how to mutate that slice, given a new value
+        |state, n| state.count = n,
+    );
+
+    view! { cx,
+        <div class="consumer blue">
+            <button
+                on:click=move |_| {
+                    set_count(count() + 1);
+                }
+            >
+                "Increment Global Count"
+            </button>
+            <br/>
+            <span>"Count is: " {count}</span>
+        </div>
+    }
+}
+```
+
+Clicking this button only updates `state.count`, so if we create another slice
+somewhere else that only takes `state.name`, clicking the button won’t cause
+that other slice to update. This allows you to combine the benefits of a top-down
+data flow and of fine-grained reactive updates.
+
+[Click to open CodeSandbox.](https://codesandbox.io/p/sandbox/1-basic-component-forked-8bte19?selection=%5B%7B%22endColumn%22%3A1%2C%22endLineNumber%22%3A2%2C%22startColumn%22%3A1%2C%22startLineNumber%22%3A2%7D%5D&file=%2Fsrc%2Fmain.rs)
+
+<iframe src="https://codesandbox.io/p/sandbox/1-basic-component-forked-8bte19?selection=%5B%7B%22endColumn%22%3A1%2C%22endLineNumber%22%3A2%2C%22startColumn%22%3A1%2C%22startLineNumber%22%3A2%7D%5D&file=%2Fsrc%2Fmain.rs" width="100%" height="1000px" style="max-height: 100vh"></iframe>

docs/book/src/SUMMARY.md

@@ -1,25 +1,18 @@
 # Summary
 
 - [Introduction](./01_introduction.md)
-- [Getting Started](./getting_started/README.md)
-  - [Leptos DX](./getting_started/leptos_dx.md)
-  - [The Leptos Community and leptos-* Crates](./getting_started/community_crates.md)
-- [Part 1: Building User Interfaces](./view/README.md)
+- [Getting Started](./02_getting_started.md)
+- [Building User Interfaces](./view/README.md)
   - [A Basic Component](./view/01_basic_component.md)
   - [Dynamic Attributes](./view/02_dynamic_attributes.md)
   - [Components and Props](./view/03_components.md)
   - [Iteration](./view/04_iteration.md)
-  - [Iterating over More Complex Data](./view/04b_iteration.md)
   - [Forms and Inputs](./view/05_forms.md)
   - [Control Flow](./view/06_control_flow.md)
   - [Error Handling](./view/07_errors.md)
   - [Parent-Child Communication](./view/08_parent_child.md)
   - [Passing Children to Components](./view/09_component_children.md)
-  - [No Macros: The View Builder Syntax](./view/builder.md)
-- [Reactivity](./reactivity/README.md)
-  - [Working with Signals](./reactivity/working_with_signals.md)
-  - [Responding to Changes with `create_effect`](./reactivity/14_create_effect.md)
-  - [Interlude: Reactivity and Functions](./reactivity/interlude_functions.md)
+- [Interlude: Reactivity and Functions](./interlude_functions.md)
 - [Testing](./testing.md)
 - [Async](./async/README.md)
   - [Loading Data with Resources](./async/10_resources.md)
@@ -27,6 +20,7 @@
   - [Transition](./async/12_transition.md)
   - [Actions](./async/13_actions.md)
 - [Interlude: Projecting Children](./interlude_projecting_children.md)
+- [Responding to Changes with `create_effect`](./14_create_effect.md)
 - [Global State Management](./15_global_state.md)
 - [Router](./router/README.md)
   - [Defining `<Routes/>`](./router/16_routes.md)
@@ -35,22 +29,24 @@
   - [`<A/>`](./router/19_a.md)
   - [`<Form/>`](./router/20_form.md)
 - [Interlude: Styling](./interlude_styling.md)
-- [Metadata](./metadata.md)
-- [Client-Side Rendering: Wrapping Up](./csr_wrapping_up.md)
-- [Part 2: Server Side Rendering](./ssr/README.md)
+- [Metadata]()
+- [Server Side Rendering](./ssr/README.md)
   - [`cargo-leptos`](./ssr/21_cargo_leptos.md)
   - [The Life of a Page Load](./ssr/22_life_cycle.md)
   - [Async Rendering and SSR “Modes”](./ssr/23_ssr_modes.md)
   - [Hydration Bugs](./ssr/24_hydration_bugs.md)
 - [Working with the Server](./server/README.md)
   - [Server Functions](./server/25_server_functions.md)
-  - [Extractors](./server/26_extractors.md)
-  - [Responses and Redirects](./server/27_response.md)
-- [Progressive Enhancement and Graceful Degradation](./progressive_enhancement/README.md)
-  - [`<ActionForm/>`s](./progressive_enhancement/action_form.md)
-- [Deployment](./deployment/README.md)
-  - [Optimizing WASM Binary Size](./deployment/binary_size.md)
-- [Guide: Islands](./islands.md)
-
-- [Appendix: How Does the Reactive System Work?](./appendix_reactive_graph.md)
-
+  - [Request/Response]()
+  - [Extractors]()
+    - [Axum]()
+    - [Actix]()
+  - [Headers]()
+  - [Cookies]()
+- [Building Full-Stack Apps]()
+  - [Actions]()
+  - [Forms]()
+  - [`<ActionForm/>`s]()
+  - [Turning off WebAssembly: Progressive Enhancement and Graceful Degradation]()
+- [Advanced Reactivity]()
+- [Appendix: Optimizing WASM Binary Size](./appendix_binary_size.md)

docs/book/src/appendix_binary_size.md

@@ -0,0 +1,66 @@
+# Appendix: Optimizing WASM Binary Size
+
+One of the primary downsides of deploying a Rust/WebAssembly frontend app is that splitting a WASM file into smaller chunks to be dynamically loaded is significantly more difficult than splitting a JavaScript bundle. There have been experiments like [`wasm-split`](https://emscripten.org/docs/optimizing/Module-Splitting.html) in the Emscripten ecosystem but at present there’s no way to split and dynamically load a Rust/`wasm-bindgen` binary. This means that the whole WASM binary needs to be loaded before your app becomes interactive. Because the WASM format is designed for streaming compilation, WASM files are much faster to compile per kilobyte than JavaScript files. (For a deeper look, you can [read this great article from the Mozilla team](https://hacks.mozilla.org/2018/01/making-webassembly-even-faster-firefoxs-new-streaming-and-tiering-compiler/) on streaming WASM compilation.)
+
+Still, it’s important to ship the smallest WASM binary to users that you can, as it will reduce their network usage and make your app interactive as quickly as possible.
+
+So what are some practical steps?
+
+## Things to Do
+
+1. Make sure you’re looking at a release build. (Debug builds are much, much larger.)
+2. Add a release profile for WASM that optimizes for size, not speed.
+
+For a `cargo-leptos` project, for example, you can add this to your `Cargo.toml`:
+
+```toml
+[profile.wasm-release]
+inherits = "release"
+opt-level = 'z'
+lto = true
+codegen-units = 1
+
+# ....
+
+[package.metadata.leptos]
+# ....
+lib-profile-release = "wasm-release"
+```
+
+This will hyper-optimize the WASM for your release build for size, while keeping your server build optimized for speed. (For a pure client-rendered app without server considerations, just use the `[profile.wasm-release]` block as your `[profile.release]`.)
+
+3. Always serve compressed WASM in production. WASM tends to compress very well, typically shrinking to less than 50% its uncompressed size, and it’s trivial to enable compression for static files being served from Actix or Axum.
+
+4. If you’re using nightly Rust, you can rebuild the standard library with this same profile rather than the prebuilt standard library that’s distributed with the `wasm32-unknown-unknown` target.
+
+To do this, create a file in your project at `.cargo/config.toml`
+
+```toml
+[unstable]
+build-std = ["std", "panic_abort", "core", "alloc"]
+build-std-features = ["panic_immediate_abort"]
+```
+
+Note that if you're using this with SSR too, the same Cargo profile will be applied. You'll need to explicitly specify your target:
+```toml
+[build]
+target = "x86_64-unknown-linux-gnu" # or whatever
+```
+
+And you'll need to add `panic = "abort"` to `[profile.release]` in `Cargo.toml`. Note that this applies the same `build-std` and panic settings to your server binary, which may not be desirable. Some further exploration is probably needed here.
+
+5. One of the sources of binary size in WASM binaries can be `serde` serialization/deserialization code. Leptos uses `serde` by default to serialize and deserialize resources created with `create_resource`. You might try experimenting with the `miniserde` and `serde-lite` features, which allow you to use those crates for serialization and deserialization instead; each only implements a subset of `serde`’s functionality, but typically optimizes for size over speed.
+
+## Things to Avoid
+
+There are certain crates that tend to inflate binary sizes. For example, the `regex` crate with its default features adds about 500kb to a WASM binary (largely because it has to pull in Unicode table data!) In a size-conscious setting, you might consider avoiding regexes in general, or even dropping down and calling browser APIs to use the built-in regex engine instead. (This is what `leptos_router` does on the few occasions it needs a regular expression.)
+
+In general, Rust’s commitment to runtime performance is sometimes at odds with a commitment to a small binary. For example, Rust monomorphizes generic functions, meaning it creates a distinct copy of the function for each generic type it’s called with. This is significantly faster than dynamic dispatch, but increases binary size. Leptos tries to balance runtime performance with binary size considerations pretty carefully; but you might find that writing code that uses many generics tends to increase binary size. For example, if you have a generic component with a lot of code in its body and call it with four different types, remember that the compiler could include four copies of that same code. Refactoring to use a concrete inner function or helper can often maintain performance and ergonomics while reducing binary size.
+
+## A Final Thought
+
+Remember that in a server-rendered app, JS bundle size/WASM binary size affects only _one_ thing: time to interactivity on the first load. This is very important to a good user experience—nobody wants to click a button three times and have it do nothing because the interactive code is still loading—but it is not the only important measure.
+
+It’s especially worth remembering that streaming in a single WASM binary means all subsequent navigations are nearly instantaneous, depending only on any additional data loading. Precisely because your WASM binary is _not_ bundle split, navigating to a new route does not require loading additional JS/WASM, as it does in nearly every JavaScript framework. Is this copium? Maybe. Or maybe it’s just an honest trade-off between the two approaches!
+
+Always take the opportunity to optimize the low-hanging fruit in your application. And always test your app under real circumstances with real user network speeds and devices before making any heroic efforts.

docs/book/src/appendix_reactive_graph.md

@@ -1,2 +0,0 @@
-<meta http-equiv="refresh" content="0; URL=https://book.leptos.dev/appendix_reactive_graph.html">
-<link rel="canonical" href="https://book.leptos.dev/appendix_reactive_graph.html">

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

@@ -1,2 +1,55 @@
-<meta http-equiv="refresh" content="0; URL=https://book.leptos.dev/async/10_resources.html">
-<link rel="canonical" href="https://book.leptos.dev/async/10_resources.html">
+# Loading Data with Resources
+
+A [Resource](https://docs.rs/leptos/latest/leptos/struct.Resource.html) is a reactive data structure that reflects the current state of an asynchronous task, allowing you to integrate asynchronous `Future`s into the synchronous reactive system. Rather than waiting for its data to load with `.await`, you transform the `Future` into a signal that returns `Some(T)` if it has resolved, and `None` if it’s still pending.
+
+You do this by using the [`create_resource`](https://docs.rs/leptos/latest/leptos/fn.create_resource.html) function. This takes two arguments (other than the ubiquitous `cx`):
+
+1. a source signal, which will generate a new `Future` whenever it changes
+2. a fetcher function, which takes the data from that signal and returns a `Future`
+
+Here’s an example
+
+```rust
+// our source signal: some synchronous, local state
+let (count, set_count) = create_signal(cx, 0);
+
+// our resource
+let async_data = create_resource(cx,
+    count,
+    // every time `count` changes, this will run
+    |value| async move {
+        log!("loading data from API");
+        load_data(value).await
+    },
+);
+```
+
+To create a resource that simply runs once, you can pass a non-reactive, empty source signal:
+
+```rust
+let once = create_resource(cx, || (), |_| async move { load_data().await });
+```
+
+To access the value you can use `.read(cx)` or `.with(cx, |data| /* */)`. These work just like `.get()` and `.with()` on a signal—`read` clones the value and returns it, `with` applies a closure to it—but with two differences
+
+1. For any `Resource<_, T>`, they always return `Option<T>`, not `T`: because it’s always possible that your resource is still loading.
+2. They take a `Scope` argument. You’ll see why in the next chapter, on `<Suspense/>`.
+
+So, you can show the current state of a resource in your view:
+
+```rust
+let once = create_resource(cx, || (), |_| async move { load_data().await });
+view! { cx,
+    <h1>"My Data"</h1>
+    {move || match once.read(cx) {
+        None => view! { cx, <p>"Loading..."</p> }.into_view(cx),
+        Some(data) => view! { cx, <ShowData data/> }.into_view(cx)
+    }}
+}
+```
+
+Resources also provide a `refetch()` method that allows you to manually reload the data (for example, in response to a button click) and a `loading()` method that returns a `ReadSignal<bool>` indicating whether the resource is currently loading or not.
+
+[Click to open CodeSandbox.](https://codesandbox.io/p/sandbox/10-async-resources-4z0qt3?file=%2Fsrc%2Fmain.rs&selection=%5B%7B%22endColumn%22%3A1%2C%22endLineNumber%22%3A3%2C%22startColumn%22%3A1%2C%22startLineNumber%22%3A3%7D%5D)
+
+<iframe src="https://codesandbox.io/p/sandbox/10-async-resources-4z0qt3?file=%2Fsrc%2Fmain.rs&selection=%5B%7B%22endColumn%22%3A1%2C%22endLineNumber%22%3A3%2C%22startColumn%22%3A1%2C%22startLineNumber%22%3A3%7D%5D" width="100%" height="1000px" style="max-height: 100vh"></iframe>

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

@@ -1,2 +1,74 @@
-<meta http-equiv="refresh" content="0; URL=https://book.leptos.dev/async/11_suspense.html">
-<link rel="canonical" href="https://book.leptos.dev/async/11_suspense.html">
+# `<Suspense/>`
+
+In the previous chapter, we showed how you can create a simple loading screen to show some fallback while a resource is loading.
+
+```rust
+let (count, set_count) = create_signal(cx, 0);
+let a = create_resource(cx, count, |count| async move { load_a(count).await });
+
+view! { cx,
+    <h1>"My Data"</h1>
+    {move || match once.read(cx) {
+        None => view! { cx, <p>"Loading..."</p> }.into_view(cx),
+        Some(data) => view! { cx, <ShowData data/> }.into_view(cx)
+    }}
+}
+```
+
+But what if we have two resources, and want to wait for both of them?
+
+```rust
+let (count, set_count) = create_signal(cx, 0);
+let (count2, set_count2) = create_signal(cx, 0);
+let a = create_resource(cx, count, |count| async move { load_a(count).await });
+let b = create_resource(cx, count2, |count| async move { load_b(count).await });
+
+view! { cx,
+    <h1>"My Data"</h1>
+    {move || match (a.read(cx), b.read(cx)) {
+        (Some(a), Some(b)) => view! { cx,
+            <ShowA a/>
+            <ShowA b/>
+        }.into_view(cx),
+        _ => view! { cx, <p>"Loading..."</p> }.into_view(cx)
+    }}
+}
+```
+
+That’s not _so_ bad, but it’s kind of annoying. What if we could invert the flow of control?
+
+The [`<Suspense/>`](https://docs.rs/leptos/latest/leptos/fn.Suspense.html) component lets us do exactly that. You give it a `fallback` prop and children, one or more of which usually involves reading from a resource. Reading from a resource “under” a `<Suspense/>` (i.e., in one of its children) registers that resource with the `<Suspense/>`. If it’s still waiting for resources to load, it shows the `fallback`. When they’ve all loaded, it shows the children.
+
+```rust
+let (count, set_count) = create_signal(cx, 0);
+let (count2, set_count2) = create_signal(cx, 0);
+let a = create_resource(cx, count, |count| async move { load_a(count).await });
+let b = create_resource(cx, count2, |count| async move { load_b(count).await });
+
+view! { cx,
+    <h1>"My Data"</h1>
+    <Suspense
+        fallback=move || view! { cx, <p>"Loading..."</p> }
+    >
+        <h2>"My Data"</h2>
+        <h3>"A"</h3>
+        {move || {
+            a.read(cx)
+                .map(|a| view! { cx, <ShowA a/> })
+        }}
+        <h3>"B"</h3>
+        {move || {
+            b.read(cx)
+                .map(|b| view! { cx, <ShowB b/> })
+        }}
+    </Suspense>
+}
+```
+
+Every time one of the resources is reloading, the `"Loading..."` fallback will show again.
+
+This inversion of the flow of control makes it easier to add or remove individual resources, as you don’t need to handle the matching yourself. It also unlocks some massive performance improvements during server-side rendering, which we’ll talk about during a later chapter.
+
+[Click to open CodeSandbox.](https://codesandbox.io/p/sandbox/11-suspense-907niv?file=%2Fsrc%2Fmain.rs)
+
+<iframe src="https://codesandbox.io/p/sandbox/11-suspense-907niv?file=%2Fsrc%2Fmain.rs" width="100%" height="1000px" style="max-height: 100vh"></iframe>

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

@@ -1,2 +1,11 @@
-<meta http-equiv="refresh" content="0; URL=https://book.leptos.dev/async/12_transition.html">
-<link rel="canonical" href="https://book.leptos.dev/async/12_transition.html">
+# `<Transition/>`
+
+You’ll notice in the `<Suspense/>` example that if you keep reloading the data, it keeps flickering back to `"Loading..."`. Sometimes this is fine. For other times, there’s [`<Transition/>`](https://docs.rs/leptos/latest/leptos/fn.Suspense.html).
+
+`<Transition/>` behaves exactly the same as `<Suspense/>`, but instead of falling back every time, it only shows the fallback the first time. On all subsequent loads, it continues showing the old data until the new data are ready. This can be really handy to prevent the flickering effect, and to allow users to continue interacting with your application.
+
+This example shows how you can create a simple tabbed contact list with `<Transition/>`. When you select a new tab, it continues showing the current contact until the new data loads. This can be a much better user experience than constantly falling back to a loading message.
+
+[Click to open CodeSandbox.](https://codesandbox.io/p/sandbox/12-transition-sn38sd?selection=%5B%7B%22endColumn%22%3A15%2C%22endLineNumber%22%3A2%2C%22startColumn%22%3A15%2C%22startLineNumber%22%3A2%7D%5D&file=%2Fsrc%2Fmain.rs)
+
+<iframe src="https://codesandbox.io/p/sandbox/12-transition-sn38sd?selection=%5B%7B%22endColumn%22%3A15%2C%22endLineNumber%22%3A2%2C%22startColumn%22%3A15%2C%22startLineNumber%22%3A2%7D%5D&file=%2Fsrc%2Fmain.rs" width="100%" height="1000px" style="max-height: 100vh"></iframe>

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

@@ -1,2 +1,96 @@
-<meta http-equiv="refresh" content="0; URL=https://book.leptos.dev/async/13_action.html">
-<link rel="canonical" href="https://book.leptos.dev/async/13_action.html">
+# Mutating Data with Actions
+
+We’ve talked about how to load `async` data with resources. Resources immediately load data and work closely with `<Suspense/>` and `<Transition/>` components to show whether data is loading in your app. But what if you just want to call some arbitrary `async` function and keep track of what it’s doing?
+
+Well, you could always use [`spawn_local`](https://docs.rs/leptos/latest/leptos/fn.spawn_local.html). This allows you to just spawn an `async` task in a synchronous environment by handing the `Future` off to the browser (or, on the server, Tokio or whatever other runtime you’re using). But how do you know if it’s still pending? Well, you could just set a signal to show whether it’s loading, and another one to show the result...
+
+All of this is true. Or you could use the final `async` primitive: [`create_action`](https://docs.rs/leptos/latest/leptos/fn.create_action.html).
+
+Actions and resources seem similar, but they represent fundamentally different things. If you’re trying to load data by running an `async` function, either once or when some other value changes, you probably want to use `create_resource`. If you’re trying to occasionally run an `async` function in response to something like a user clicking a button, you probably want to use `create_action`.
+
+Say we have some `async` function we want to run.
+
+```rust
+async fn add_todo(new_title: &str) -> Uuid {
+    /* do some stuff on the server to add a new todo */
+}
+```
+
+`create_action` takes a reactive `Scope` and an `async` function that takes a reference to a single argument, which you could think of as its “input type.”
+
+> The input is always a single type. If you want to pass in multiple arguments, you can do it with a struct or tuple.
+>
+> ```rust
+> // if there's a single argument, just use that
+> let action1 = create_action(cx, |input: &String| {
+>    let input = input.clone();
+>    async move { todo!() }
+> });
+>
+> // if there are no arguments, use the unit type `()`
+> let action2 = create_action(cx, |input: &()| async { todo!() });
+>
+> // if there are multiple arguments, use a tuple
+> let action3 = create_action(cx,
+>   |input: &(usize, String)| async { todo!() }
+> );
+> ```
+>
+> Because the action function takes a reference but the `Future` needs to have a `'static` lifetime, you’ll usually need to clone the value to pass it into the `Future`. This is admittedly awkward but it unlocks some powerful features like optimistic UI. We’ll see a little more about that in future chapters.
+
+So in this case, all we need to do to create an action is
+
+```rust
+let add_todo = create_action(cx, |input: &String| {
+    let input = input.to_owned();
+    async move { add_todo(&input).await }
+});
+```
+
+Rather than calling `add_todo` directly, we’ll call it with `.dispatch()`, as in
+
+```rust
+add_todo.dispatch("Some value".to_string());
+```
+
+You can do this from an event listener, a timeout, or anywhere; because `.dispatch()` isn’t an `async` function, it can be called from a synchronous context.
+
+Actions provide access to a few signals that synchronize between the asynchronous action you’re calling and the synchronous reactive system:
+
+```rust
+let submitted = add_todo.input(); // RwSignal<Option<String>>
+let pending = add_todo.pending(); // ReadSignal<bool>
+let todo_id = add_todo.value(); // RwSignal<Option<Uuid>>
+```
+
+This makes it easy to track the current state of your request, show a loading indicator, or do “optimistic UI” based on the assumption that the submission will succeed.
+
+```rust
+let input_ref = create_node_ref::<Input>(cx);
+
+view! { cx,
+    <form
+        on:submit=move |ev| {
+            ev.prevent_default(); // don't reload the page...
+            let input = input_ref.get().expect("input to exist");
+            add_todo.dispatch(input.value());
+        }
+    >
+        <label>
+            "What do you need to do?"
+            <input type="text"
+                node_ref=input_ref
+            />
+        </label>
+        <button type="submit">"Add Todo"</button>
+    </form>
+    // use our loading state
+    <p>{move || pending().then("Loading...")}</p>
+}
+```
+
+Now, there’s a chance this all seems a little over-complicated, or maybe too restricted. I wanted to include actions here, alongside resources, as the missing piece of the puzzle. In a real Leptos app, you’ll actually most often use actions alongside server functions, [`create_server_action`](https://docs.rs/leptos/latest/leptos/fn.create_server_action.html), and the [`<ActionForm/>`](https://docs.rs/leptos_router/latest/leptos_router/fn.ActionForm.html) component to create really powerful progressively-enhanced forms. So if this primitive seems useless to you... Don’t worry! Maybe it will make sense later. (Or check out our [`todo_app_sqlite`](https://github.com/leptos-rs/leptos/blob/main/examples/todo_app_sqlite/src/todo.rs) example now.)
+
+[Click to open CodeSandbox.](https://codesandbox.io/p/sandbox/10-async-resources-forked-hgpfp0?selection=%5B%7B%22endColumn%22%3A1%2C%22endLineNumber%22%3A4%2C%22startColumn%22%3A1%2C%22startLineNumber%22%3A4%7D%5D&file=%2Fsrc%2Fmain.rs)
+
+<iframe src="https://codesandbox.io/p/sandbox/10-async-resources-forked-hgpfp0?selection=%5B%7B%22endColumn%22%3A1%2C%22endLineNumber%22%3A4%2C%22startColumn%22%3A1%2C%22startLineNumber%22%3A4%7D%5D&file=%2Fsrc%2Fmain.rs" width="100%" height="1000px" style="max-height: 100vh"></iframe>

docs/book/src/async/README.md

@@ -1,2 +1,9 @@
-<meta http-equiv="refresh" content="0; URL=https://book.leptos.dev/async/index.html">
-<link rel="canonical" href="https://book.leptos.dev/async/index.html">
+# Working with `async`
+
+So far we’ve only been working with synchronous users interfaces: You provide some input,
+the app immediately processes it and updates the interface. This is great, but is a tiny
+subset of what web applications do. In particular, most web apps have to deal with some kind of asynchronous data loading, usually loading something from an API.
+
+Asynchronous data is notoriously hard to integrate with the synchronous parts of your code. Leptos provides a cross-platform [`spawn_local`](https://docs.rs/leptos/latest/leptos/fn.spawn_local.html) function that makes it easy to run a `Future`, but there’s much more to it than that.
+
+In this chapter, we’ll see how Leptos helps smooth out that process for you.

docs/book/src/csr_wrapping_up.md

@@ -1,2 +0,0 @@
-<meta http-equiv="refresh" content="0; URL=https://book.leptos.dev/csr_wrapping_up.html">
-<link rel="canonical" href="https://book.leptos.dev/csr_wrapping_up.html">

docs/book/src/deployment/README.md

@@ -1,2 +0,0 @@
-<meta http-equiv="refresh" content="0; URL=https://book.leptos.dev/deployment/index.html">
-<link rel="canonical" href="https://book.leptos.dev/deployment/index.html">

docs/book/src/deployment/binary_size.md

@@ -1,2 +0,0 @@
-<meta http-equiv="refresh" content="0; URL=https://book.leptos.dev/deployment/binary_size.html">
-<link rel="canonical" href="https://book.leptos.dev/deployment/binary_size.html">

docs/book/src/getting_started/README.md

@@ -1,2 +0,0 @@
-<meta http-equiv="refresh" content="0; URL=https://book.leptos.dev/getting_started/index.html">
-<link rel="canonical" href="https://book.leptos.dev/getting_started/index.html">

docs/book/src/getting_started/community_crates.md

@@ -1,2 +0,0 @@
-<meta http-equiv="refresh" content="0; URL=https://book.leptos.dev/getting_started/community_crates.html">
-<link rel="canonical" href="https://book.leptos.dev/getting_started/community_crates.html">

docs/book/src/getting_started/leptos_dx.md

@@ -1,2 +0,0 @@
-<meta http-equiv="refresh" content="0; URL=https://book.leptos.dev/getting_started/leptos_dx.html">
-<link rel="canonical" href="https://book.leptos.dev/getting_started/leptos_dx.html">

docs/book/src/interlude_functions.md

@@ -0,0 +1,76 @@
+# Interlude: Reactivity and Functions
+
+One of our core contributors said to me recently: “I never used closures this often
+until I started using Leptos.” And it’s true. Closures are at the heart of any Leptos
+application. It sometimes looks a little silly:
+
+```rust
+// a signal holds a value, and can be updated
+let (count, set_count) = create_signal(cx, 0);
+
+// a derived signal is a function that accesses other signals
+let double_count = move || count() * 2;
+let count_is_odd = move || count() & 1 == 1;
+let text = move || if count_is_odd() {
+    "odd"
+} else {
+    "even"
+};
+
+// an effect automatically tracks the signals it depends on
+// and reruns when they change
+create_effect(cx, move |_| {
+    log!("text = {}", text());
+});
+
+view! { cx,
+    <p>{move || text().to_uppercase()}</p>
+}
+```
+
+Closures, closures everywhere!
+
+But why?
+
+## Functions and UI Frameworks
+
+Functions are at the heart of every UI framework. And this makes perfect sense. Creating a user interface is basically divided into two phases:
+
+1. initial rendering
+2. updates
+
+In a web framework, the framework does some kind of initial rendering. Then it hands control back over to the browser. When certain events fire (like a mouse click) or asynchronous tasks finish (like an HTTP request finishing), the browser wakes the framework back up to update something. The framework runs some kind of code to update your user interface, and goes back asleep until the browser wakes it up again.
+
+The key phrase here is “runs some kind of code.” The natural way to “run some kind of code” at an arbitrary point in time—in Rust or in any other programming language—is to call a function. And in fact every UI framework is based on rerunning some kind of function over and over:
+
+1. virtual DOM (VDOM) frameworks like React, Yew, or Dioxus rerun a component or render function over and over, to generate a virtual DOM tree that can be reconciled with the previous result to patch the DOM
+2. compiled frameworks like Angular and Svelte divide your component templates into “create” and “update” functions, rerunning the update function when they detect a change to the component’s state
+3. in fine-grained reactive frameworks like SolidJS, Sycamore, or Leptos, _you_ define the functions that rerun
+
+That’s what all our components are doing.
+
+Take our typical `<SimpleCounter/>` example in its simplest form:
+
+```rust
+#[component]
+pub fn SimpleCounter(cx: Scope) -> impl IntoView {
+    let (value, set_value) = create_signal(cx, 0);
+
+    let increment = move |_| set_value.update(|value| *value += 1);
+
+    view! { cx,
+        <button on:click=increment>
+            {value}
+        </button>
+    }
+}
+```
+
+The `SimpleCounter` function itself runs once. The `value` signal is created once. The framework hands off the `increment` function to the browser as an event listener. When you click the button, the browser calls `increment`, which updates `value` via `set_value`. And that updates the single text node represented in our view by `{value}`.
+
+Closures are key to reactivity. They provide the framework with the ability to rerun the smallest possible unit of your application in responsive to a change.
+
+So remember two things:
+
+1. Your component function is a setup function, not a render function: it only runs once.
+2. For values in your view template to be reactive, they must be functions: either signals (which implement the `Fn` traits) or closures.

docs/book/src/interlude_projecting_children.md

@@ -1,2 +1,177 @@
-<meta http-equiv="refresh" content="0; URL=https://book.leptos.dev/interlude_projecting_children.html">
-<link rel="canonical" href="https://book.leptos.dev/interlude_projecting_children.html">
+# Projecting Children
+
+As you build components you may occasionally find yourself wanting to “project” children through multiple layers of components.
+
+## The Problem
+
+Consider the following:
+
+```rust
+pub fn LoggedIn<F, IV>(cx: Scope, fallback: F, children: ChildrenFn) -> impl IntoView
+where
+    F: Fn(Scope) -> IV + 'static,
+    IV: IntoView,
+{
+    view! { cx,
+        <Suspense
+            fallback=|| ()
+        >
+            <Show
+				// check whether user is verified
+				// by reading from the resource
+                when=move || todo!()
+                fallback=fallback
+            >
+				{children(cx)}
+			</Show>
+        </Suspense>
+    }
+}
+```
+
+This is pretty straightforward: when the user is logged in, we want to show `children`. Until if the user is not logged in, we want to show `fallback`. And while we’re waiting to find out, we just render `()`, i.e., nothing.
+
+In other words, we want to pass the children of `<WhenLoaded/>` _through_ the `<Suspense/>` component to become the children of the `<Show/>`. This is what I mean by “projection.”
+
+This won’t compile.
+
+```
+error[E0507]: cannot move out of `fallback`, a captured variable in an `Fn` closure
+error[E0507]: cannot move out of `children`, a captured variable in an `Fn` closure
+```
+
+The problem here is that both `<Suspense/>` and `<Show/>` need to be able to construct their `children` multiple times. The first time you construct `<Suspense/>`’s children, it would take ownership of `fallback` and `children` to move them into the invocation of `<Show/>`, but then they're not available for future `<Suspense/>` children construction.
+
+## The Details
+
+> Feel free to skip ahead to the solution.
+
+If you want to really understand the issue here, it may help to look at the expanded `view` macro. Here’s a cleaned-up version:
+
+```rust
+Suspense(
+    cx,
+    ::leptos::component_props_builder(&Suspense)
+        .fallback(|| ())
+        .children({
+            // fallback and children are moved into this closure
+            Box::new(move |cx| {
+                {
+                    // fallback and children captured here
+                    leptos::Fragment::lazy(|| {
+                        vec![
+                            (Show(
+                                cx,
+                                ::leptos::component_props_builder(&Show)
+                                    .when(|| true)
+									// but fallback is moved into Show here
+                                    .fallback(fallback)
+									// and children is moved into Show here
+                                    .children(children)
+                                    .build(),
+                            )
+                            .into_view(cx)),
+                        ]
+                    })
+                }
+            })
+        })
+        .build(),
+)
+```
+
+All components own their props; so the `<Show/>` in this case can’t be called because it only has captured references to `fallback` and `children`.
+
+## Solution
+
+However, both `<Suspense/>` and `<Show/>` take `ChildrenFn`, i.e., their `children` should implement the `Fn` type so they can be called multiple times with only an immutable reference. This means we don’t need to own `children` or `fallback`; we just need to be able to pass `'static` references to them.
+
+We can solve this problem by using the [`store_value`](https://docs.rs/leptos/latest/leptos/fn.store_value.html) primitive. This essentially stores a value in the reactive system, handing ownership off to the framework in exchange for a reference that is, like signals, `Copy` and `'static`, which we can access or modify through certain methods.
+
+In this case, it’s really simple:
+
+```rust
+pub fn LoggedIn<F, IV>(cx: Scope, fallback: F, children: ChildrenFn) -> impl IntoView
+where
+    F: Fn(Scope) -> IV + 'static,
+    IV: IntoView,
+{
+    let fallback = store_value(cx, fallback);
+    let children = store_value(cx, children);
+    view! { cx,
+        <Suspense
+            fallback=|| ()
+        >
+            <Show
+                when=|| todo!()
+                fallback=move |cx| fallback.with_value(|fallback| fallback(cx))
+            >
+                {children.with_value(|children| children(cx))}
+            </Show>
+        </Suspense>
+    }
+}
+```
+
+At the top level, we store both `fallback` and `children` in the reactive scope owned by `LoggedIn`. Now we can simply move those references down through the other layers into the `<Show/>` component and call them there.
+
+## A Final Note
+
+Note that this works because `<Show/>` and `<Suspense/>` only need an immutable reference to their children (which `.with_value` can give it), not ownership.
+
+In other cases, you may need to project owned props through a function that takes `ChildrenFn` and therefore needs to be called more than once. In this case, you may find the `clone:` helper in the`view` macro helpful.
+
+Consider this example
+
+```rust
+#[component]
+pub fn App(cx: Scope) -> impl IntoView {
+    let name = "Alice".to_string();
+    view! { cx,
+        <Outer>
+            <Inner>
+                <Inmost name=name.clone()/>
+            </Inner>
+        </Outer>
+    }
+}
+
+#[component]
+pub fn Outer(cx: Scope, children: ChildrenFn) -> impl IntoView {
+    children(cx)
+}
+
+#[component]
+pub fn Inner(cx: Scope, children: ChildrenFn) -> impl IntoView {
+    children(cx)
+}
+
+#[component]
+pub fn Inmost(cx: Scope, name: String) -> impl IntoView {
+    view! { cx,
+        <p>{name}</p>
+    }
+}
+```
+
+Even with `name=name.clone()`, this gives the error
+
+```
+cannot move out of `name`, a captured variable in an `Fn` closure
+```
+
+It’s captured through multiple levels of children that need to run more than once, and there’s no obvious way to clone it _into_ the children.
+
+In this case, the `clone:` syntax comes in handy. Calling `clone:name` will clone `name` _before_ moving it into `<Inner/>`’s children, which solves our ownership issue.
+
+```rust
+view! { cx,
+	<Outer>
+		<Inner clone:name>
+			<Inmost name=name.clone()/>
+		</Inner>
+	</Outer>
+}
+```
+
+These issues can be a little tricky to understand or debug, because of the opacity of the `view` macro. But in general, they can always be solved.

docs/book/src/interlude_styling.md

@@ -1,2 +1,112 @@
-<meta http-equiv="refresh" content="0; URL=https://book.leptos.dev/interlude_styling.html">
-<link rel="canonical" href="https://book.leptos.dev/interlude_styling.html">
+# Interlude: Styling
+
+Anyone creating a website or application soon runs into the question of styling. For a small app, a single CSS file is probably plenty to style your user interface. But as an application grows, many developers find that plain CSS becomes increasingly hard to manage.
+
+Some frontend frameworks (like Angular, Vue, and Svelte) provide built-in ways to scope your CSS to particular components, making it easier to manage styles across a whole application without styles meant to modify one small component having a global effect. Other frameworks (like React or Solid) don’t provide built-in CSS scoping, but rely on libraries in the ecosystem to do it for them. Leptos is in this latter camp: the framework itself has no opinions about CSS at all, but provides a few tools and primitives that allow others to build styling libraries.
+
+Here are a few different approaches to styling your Leptos app, other than plain CSS.
+
+## TailwindCSS: Utility-first CSS
+
+[TailwindCSS](https://tailwindcss.com/) is a popular utility-first CSS library. It allows you to style your application by using inline utility classes, with a custom CLI tool that scans your files for Tailwind class names and bundles the necessary CSS.
+
+This allows you to write components like this:
+
+```rust
+#[component]
+fn Home(cx: Scope) -> impl IntoView {
+    let (count, set_count) = create_signal(cx, 0);
+
+    view! { cx,
+        <main class="my-0 mx-auto max-w-3xl text-center">
+            <h2 class="p-6 text-4xl">"Welcome to Leptos with Tailwind"</h2>
+            <p class="px-10 pb-10 text-left">"Tailwind will scan your Rust files for Tailwind class names and compile them into a CSS file."</p>
+            <button
+                class="bg-sky-600 hover:bg-sky-700 px-5 py-3 text-white rounded-lg"
+                on:click=move |_| set_count.update(|count| *count += 1)
+            >
+                {move || if count() == 0 {
+                    "Click me!".to_string()
+                } else {
+                    count().to_string()
+                }}
+            </button>
+        </main>
+    }
+}
+```
+
+It can be a little complicated to set up the Tailwind integration at first, but you can check out our two examples of how to use Tailwind with a [client-side-rendered `trunk` application](https://github.com/leptos-rs/leptos/tree/main/examples/tailwind_csr_trunk) or with a [server-rendered `cargo-leptos` application](https://github.com/leptos-rs/leptos/tree/main/examples/tailwind). `cargo-leptos` also has some [built-in Tailwind support](https://github.com/leptos-rs/cargo-leptos#site-parameters) that you can use as an alternative to Tailwind’s CLI.
+
+## Stylers: Compile-time CSS Extraction
+
+[Stylers](https://github.com/abishekatp/stylers) is a compile-time scoped CSS library that lets you declare scoped CSS in the body of your component. Stylers will extract this CSS at compile time into CSS files that you can then import into your app, which means that it doesn’t add anything to the WASM binary size of your application.
+
+This allows you to write components like this:
+
+```rust
+use stylers::style;
+
+#[component]
+pub fn App(cx: Scope) -> impl IntoView {
+    let styler_class = style! { "App",
+        #two{
+            color: blue;
+        }
+        div.one{
+            color: red;
+            content: raw_str(r#"\hello"#);
+            font: "1.3em/1.2" Arial, Helvetica, sans-serif;
+        }
+        div {
+            border: 1px solid black;
+            margin: 25px 50px 75px 100px;
+            background-color: lightblue;
+        }
+        h2 {
+            color: purple;
+        }
+        @media only screen and (max-width: 1000px) {
+            h3 {
+                background-color: lightblue;
+                color: blue
+            }
+        }
+    };
+
+    view! { cx, class = styler_class,
+        <div class="one">
+            <h1 id="two">"Hello"</h1>
+            <h2>"World"</h2>
+            <h2>"and"</h2>
+            <h3>"friends!"</h3>
+        </div>
+    }
+}
+```
+
+## Styled: Runtime CSS Scoping
+
+[Styled](https://github.com/eboody/styled) is a runtime scoped CSS library that integrates well with Leptos. It lets you declare scoped CSS in the body of your component function, and then applies those styles at runtime.
+
+```rust
+use styled::style;
+
+#[component]
+pub fn MyComponent(cx: Scope) -> impl IntoView {
+    let styles = style!(
+      div {
+        background-color: red;
+        color: white;
+      }
+    );
+
+    styled::view! { cx, styles,
+        <div>"This text should be red with white text."</div>
+    }
+}
+```
+
+## Contributions Welcome
+
+Leptos has no opinions on how you style your website or app, but we’re very happy to provide support to any tools you’re trying to create to make it easier. If you’re working on a CSS or styling approach that you’d like to add to this list, please let us know!

docs/book/src/islands.md

@@ -1,2 +0,0 @@
-<meta http-equiv="refresh" content="0; URL=https://book.leptos.dev/islands.html">
-<link rel="canonical" href="https://book.leptos.dev/islands.html">

docs/book/src/metadata.md

@@ -1,2 +0,0 @@
-<meta http-equiv="refresh" content="0; URL=https://book.leptos.dev/metadata.html">
-<link rel="canonical" href="https://book.leptos.dev/metadata.html">

docs/book/src/progressive_enhancement/README.md

@@ -1,2 +0,0 @@
-<meta http-equiv="refresh" content="0; URL=https://book.leptos.dev/progressive_enhancement/index.html">
-<link rel="canonical" href="https://book.leptos.dev/progressive_enhancement/index.html">

docs/book/src/progressive_enhancement/action_form.md

@@ -1,2 +0,0 @@
-<meta http-equiv="refresh" content="0; URL=https://book.leptos.dev/progressive_enhancement/action_form.html">
-<link rel="canonical" href="https://book.leptos.dev/progressive_enhancement/action_form.html">

docs/book/src/reactivity/14_create_effect.md

@@ -1,2 +0,0 @@
-<meta http-equiv="refresh" content="0; URL=https://book.leptos.dev/reactivity/14_create_effect.html">
-<link rel="canonical" href="https://book.leptos.dev/reactivity/14_create_effect.html">

docs/book/src/reactivity/README.md

@@ -1,2 +0,0 @@
-<meta http-equiv="refresh" content="0; URL=https://book.leptos.dev/reactivity/index.html">
-<link rel="canonical" href="https://book.leptos.dev/reactivity/index.html">

docs/book/src/reactivity/interlude_functions.md

@@ -1,2 +0,0 @@
-<meta http-equiv="refresh" content="0; URL=https://book.leptos.dev/reactivity/interlude_functions.html">
-<link rel="canonical" href="https://book.leptos.dev/reactivity/interlude_functions.html">

docs/book/src/reactivity/working_with_signals.md

@@ -1,2 +0,0 @@
-<meta http-equiv="refresh" content="0; URL=https://book.leptos.dev/reactivity/working_with_signals.html">
-<link rel="canonical" href="https://book.leptos.dev/reactivity/working_with_signals.html">

docs/book/src/router/16_routes.md

@@ -1,2 +1,101 @@
-<meta http-equiv="refresh" content="0; URL=https://book.leptos.dev/router/16_routes.html">
-<link rel="canonical" href="https://book.leptos.dev/router/16_routes.html">
+# Defining Routes
+
+## Getting Started
+
+It’s easy to get started with the router.
+
+First things first, make sure you’ve added the `leptos_router` package to your dependencies.
+
+> It’s important that the router is a separate package from `leptos` itself. This means that everything in the router can be defined in user-land code. If you want to create your own router, or use no router, you’re completely free to do that!
+
+And import the relevant types from the router, either with something like
+
+```rust
+use leptos_router::{Route, RouteProps, Router, RouterProps, Routes, RoutesProps};
+```
+
+or simply
+
+```rust
+use leptos_router::*;
+```
+
+## Providing the `<Router/>`
+
+Routing behavior is provided by the [`<Router/>`](https://docs.rs/leptos_router/latest/leptos_router/fn.Router.html) component. This should usually be somewhere near the root of your application, the rest of the app.
+
+> You shouldn’t try to use multiple `<Router/>`s in your app. Remember that the router drives global state: if you have multiple routers, which ones decides what to do when the URL changes?
+
+Let’s start with a simple `<App/>` component using the router:
+
+```rust
+use leptos::*;
+use leptos_router::*;
+
+#[component]
+pub fn App(cx: Scope) -> impl IntoView {
+  view! {
+    <Router>
+      <nav>
+        /* ... */
+      </nav>
+      <main>
+        /* ... */
+      </main>
+    </Router>
+  }
+}
+```
+
+## Defining `<Routes/>`
+
+The [`<Routes/>`](https://docs.rs/leptos_router/latest/leptos_router/fn.Routes.html) component is where you define all the routes to which a user can navigate in your application. Each possible route is defined by a [`<Route/>`](https://docs.rs/leptos_router/latest/leptos_router/fn.Route.html) component.
+
+You should place the `<Routes/>` component at the location within your app where you want routes to be rendered. Everything outside `<Routes/>` will be present on every page, so you can leave things like a navigation bar or menu outside the `<Routes/>`.
+
+```rust
+use leptos::*;
+use leptos_router::*;
+
+#[component]
+pub fn App(cx: Scope) -> impl IntoView {
+  view! {
+    <Router>
+      <nav>
+        /* ... */
+      </nav>
+      <main>
+        // all our routes will appear inside <main>
+        <Routes>
+          /* ... */
+        </Routes>
+      </main>
+    </Router>
+  }
+}
+```
+
+Individual routes are defined by providing children to `<Routes/>` with the `<Route/>` component. `<Route/>` takes a `path` and a `view`. When the current location matches `path`, the `view` will be created and displayed.
+
+The `path` can include
+
+- a static path (`/users`),
+- dynamic, named parameters beginning with a colon (`/:id`),
+- and/or a wildcard beginning with an asterisk (`/user/*any`)
+
+The `view` is a function that takes a `Scope` and returns a view.
+
+```rust
+<Routes>
+  <Route path="/" view=|cx| view! { cx, <Home/> }/>
+  <Route path="/users" view=|cx| view! { cx, <Users/> }/>
+  <Route path="/users/:id" view=|cx| view! { cx, <UserProfile/> }/>
+  <Route path="/*any" view=|cx| view! { cx, <NotFound/> }/>
+</Routes>
+```
+
+> The router scores each route to see how good a match it is, so you can define your routes in any order.
+
+Now if you navigate to `/` or to `/users` you’ll get the home page or the `<Users/>`. If you go to `/users/3` or `/blahblah` you’ll get a user profile or your 404 page (`<NotFound/>`). On every navigation, the router determines which `<Route/>` should be matched, and therefore what content should be displayed where the `<Routes/>` component is defined.
+
+Simple enough?

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

@@ -1,2 +1,172 @@
-<meta http-equiv="refresh" content="0; URL=https://book.leptos.dev/router/17_nested_routing.html">
-<link rel="canonical" href="https://book.leptos.dev/router/17_nested_routing.html">
+# Nested Routing
+
+We just defined the following set of routes:
+
+```rust
+<Routes>
+  <Route path="/" view=|cx| view! { cx, <Home /> }/>
+  <Route path="/users" view=|cx| view! { cx, <Users /> }/>
+  <Route path="/users/:id" view=|cx| view! { cx, <UserProfile /> }/>
+  <Route path="/*any" view=|cx| view! { cx, <NotFound /> }/>
+</Routes>
+```
+
+There’s a certain amount of duplication here: `/users` and `/users/:id`. This is fine for a small app, but you can probably already tell it won’t scale well. Wouldn’t it be nice if we could nest these routes?
+
+Well... you can!
+
+```rust
+<Routes>
+  <Route path="/" view=|cx| view! { cx, <Home /> }/>
+  <Route path="/users" view=|cx| view! { cx, <Users /> }>
+    <Route path=":id" view=|cx| view! { cx, <UserProfile /> }/>
+  </Route>
+  <Route path="/*any" view=|cx| view! { cx, <NotFound /> }/>
+</Routes>
+```
+
+But wait. We’ve just subtly changed what our application does.
+
+The next section is one of the most important in this entire routing section of the guide. Read it carefully, and feel free to ask questions if there’s anything you don’t understand.
+
+# Nested Routes as Layout
+
+Nested routes are a form of layout, not a method of route definition.
+
+Let me put that another way: The goal of defining nested routes is not primarily to avoid repeating yourself when typing out the paths in your route definitions. It is actually to tell the router to display multiple `<Route/>`s on the page at the same time, side by side.
+
+Let’s look back at our practical example.
+
+```rust
+<Routes>
+  <Route path="/users" view=|cx| view! { cx, <Users /> }/>
+  <Route path="/users/:id" view=|cx| view! { cx, <UserProfile /> }/>
+</Routes>
+```
+
+This means:
+
+- If I go to `/users`, I get the `<Users/>` component.
+- If I go to `/users/3`, I get the `<UserProfile/>` component (with the parameter `id` set to `3`; more on that later)
+
+Let’s say I use nested routes instead:
+
+```rust
+<Routes>
+  <Route path="/users" view=|cx| view! { cx, <Users /> }>
+    <Route path=":id" view=|cx| view! { cx, <UserProfile /> }/>
+  </Route>
+</Routes>
+```
+
+This means:
+
+- If I go to `/users/3`, the path matches two `<Route/>`s: `<Users/>` and `<UserProfile/>`.
+- If I go to `/users`, the path is not matched.
+
+I actually need to add a fallback route
+
+```rust
+<Routes>
+  <Route path="/users" view=|cx| view! { cx, <Users /> }>
+    <Route path=":id" view=|cx| view! { cx, <UserProfile /> }/>
+    <Route path="" view=|cx| view! { cx, <NoUser /> }/>
+  </Route>
+</Routes>
+```
+
+Now:
+
+- If I go to `/users/3`, the path matches `<Users/>` and `<UserProfile/>`.
+- If I go to `/users`, the path matches `<Users/>` and `<NoUser/>`.
+
+When I use nested routes, in other words, each **path** can match multiple **routes**: each URL can render the views provided by multiple `<Route/>` components, at the same time, on the same page.
+
+This may be counter-intuitive, but it’s very powerful, for reasons you’ll hopefully see in a few minutes.
+
+## Why Nested Routing?
+
+Why bother with this?
+
+Most web applications contain levels of navigation that correspond to different parts of the layout. For example, in an email app you might have a URL like `/contacts/greg`, which shows a list of contacts on the left of the screen, and contact details for Greg on the right of the screen. The contact list and the contact details should always appear on the screen at the same time. If there’s no contact selected, maybe you want to show a little instructional text.
+
+You can easily define this with nested routes
+
+```rust
+<Routes>
+  <Route path="/contacts" view=|cx| view! { cx, <ContactList/> }>
+    <Route path=":id" view=|cx| view! { cx, <ContactInfo/> }/>
+    <Route path="" view=|cx| view! { cx,
+      <p>"Select a contact to view more info."</p>
+    }/>
+  </Route>
+</Routes>
+```
+
+You can go even deeper. Say you want to have tabs for each contact’s address, email/phone, and your conversations with them. You can add _another_ set of nested routes inside `:id`:
+
+```rust
+<Routes>
+  <Route path="/contacts" view=|cx| view! { cx, <ContactList/> }>
+    <Route path=":id" view=|cx| view! { cx, <ContactInfo/> }>
+      <Route path="" view=|cx| view! { cx, <EmailAndPhone/> }/>
+      <Route path="address" view=|cx| view! { cx, <Address/> }/>
+      <Route path="messages" view=|cx| view! { cx, <Messages/> }/>
+    </Route>
+    <Route path="" view=|cx| view! { cx,
+      <p>"Select a contact to view more info."</p>
+    }/>
+  </Route>
+</Routes>
+```
+
+> The main page of the [Remix website](https://remix.run/), a React framework from the creators of React Router, has a great visual example if you scroll down, with three levels of nested routing: Sales > Invoices > an invoice.
+
+## `<Outlet/>`
+
+Parent routes do not automatically render their nested routes. After all, they are just components; they don’t know exactly where they should render their children, and “just stick at at the end of the parent component” is not a great answer.
+
+Instead, you tell a parent component where to render any nested components with an `<Outlet/>` component. The `<Outlet/>` simply renders one of two things:
+
+- if there is no nested route that has been matched, it shows nothing
+- if there is a nested route that has been matched, it shows its `view`
+
+That’s all! But it’s important to know and to remember, because it’s a common source of “Why isn’t this working?” frustration. If you don’t provide an `<Outlet/>`, the nested route won’t be displayed.
+
+```rust
+#[component]
+pub fn ContactList(cx: Scope) -> impl IntoView {
+  let contacts = todo!();
+
+  view! { cx,
+    <div style="display: flex">
+      // the contact list
+      <For each=contacts
+        key=|contact| contact.id
+        view=|cx, contact| todo!()
+      >
+      // the nested child, if any
+      // don’t forget this!
+      <Outlet/>
+    </div>
+  }
+}
+```
+
+## Nested Routing and Performance
+
+All of this is nice, conceptually, but again—what’s the big deal?
+
+Performance.
+
+In a fine-grained reactive library like Leptos, it’s always important to do the least amount of rendering work you can. Because we’re working with real DOM nodes and not diffing a virtual DOM, we want to “rerender” components as infrequently as possible. Nested routing makes this extremely easy.
+
+Imagine my contact list example. If I navigate from Greg to Alice to Bob and back to Greg, the contact information needs to change on each navigation. But the `<ContactList/>` should never be rerendered. Not only does this save on rendering performance, it also maintains state in the UI. For example, if I have a search bar at the top of `<ContactList/>`, navigating from Greg to Alice to Bob won’t clear the search.
+
+In fact, in this case, we don’t even need to rerender the `<Contact/>` component when moving between contacts. The router will just reactively update the `:id` parameter as we navigate, allowing us to make fine-grained updates. As we navigate between contacts, we’ll update single text nodes to change the contact’s name, address, and so on, without doing _any_ additional rerendering.
+
+> This sandbox includes a couple features (like nested routing) discussed in this section and the previous one, and a couple we’ll cover in the rest of this chapter. The router is such an integrated system that it makes sense to provide a single example, so don’t be surprised if there’s anything you don’t understand.
+
+[Click to open CodeSandbox.](https://codesandbox.io/p/sandbox/16-router-fy4tjv?file=%2Fsrc%2Fmain.rs&selection=%5B%7B%22endColumn%22%3A1%2C%22endLineNumber%22%3A3%2C%22startColumn%22%3A1%2C%22startLineNumber%22%3A3%7D%5D)
+
+<iframe src="https://codesandbox.io/p/sandbox/16-router-fy4tjv?file=%2Fsrc%2Fmain.rs&selection=%5B%7B%22endColumn%22%3A1%2C%22endLineNumber%22%3A3%2C%22startColumn%22%3A1%2C%22startLineNumber%22%3A3%7D%5D" width="100%" height="1000px" style="max-height: 100vh"></iframe>

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

@@ -1,2 +1,79 @@
-<meta http-equiv="refresh" content="0; URL=https://book.leptos.dev/router/18_params_and_queries.html">
-<link rel="canonical" href="https://book.leptos.dev/router/18_params_and_queries.html">
+# Params and Queries
+
+Static paths are useful for distinguishing between different pages, but almost every application wants to pass data through the URL at some point.
+
+There are two ways you can do this:
+
+1. named route **params** like `id` in `/users/:id`
+2. named route **queries** like `q` in `/search?q=Foo`
+
+Because of the way URLs are built, you can access the query from _any_ `<Route/>` view. You can access route params from the `<Route/>` that defines them or any of its nested children.
+
+Accessing params and queries is pretty simple with a couple of hooks:
+
+- [`use_query`](https://docs.rs/leptos_router/latest/leptos_router/fn.use_query.html) or [`use_query_map`](https://docs.rs/leptos_router/latest/leptos_router/fn.use_query_map.html)
+- [`use_params`](https://docs.rs/leptos_router/latest/leptos_router/fn.use_params.html) or [`use_params_map`](https://docs.rs/leptos_router/latest/leptos_router/fn.use_query_map.html)
+
+Each of these comes with a typed option (`use_query` and `use_params`) and an untyped option (`use_query_map` and `use_params_map`).
+
+The untyped versions hold a simple key-value map. To use the typed versions, derive the [`Params`](https://docs.rs/leptos_router/0.2.3/leptos_router/trait.Params.html) trait on a struct.
+
+> `Params` is a very lightweight trait to convert a flat key-value map of strings into a struct by applying `FromStr` to each field. Because of the flat structure of route params and URL queries, it’s significantly less flexible than something like `serde`; it also adds much less weight to your binary.
+
+```rust
+use leptos::*;
+use leptos_router::*;
+
+#[derive(Params)]
+struct ContactParams {
+	id: usize
+}
+
+#[derive(Params)]
+struct ContactSearch {
+	q: String
+}
+```
+
+> Note: The `Params` derive macro is located at `leptos::Params`, and the `Params` trait is at `leptos_router::Params`. If you avoid using glob imports like `use leptos::*;`, make sure you’re importing the right one for the derive macro.
+
+Now we can use them in a component. Imagine a URL that has both params and a query, like `/contacts/:id?q=Search`.
+
+The typed versions return `Memo<Result<T>, _>`. It’s a Memo so it reacts to changes in the URL. It’s a `Result` because the params or query need to be parsed from the URL, and may or may not be valid.
+
+```rust
+let params = use_params::<ContactParams>(cx);
+let query = use_query::<ContactSearch>(cx);
+
+// id: || -> usize
+let id = move || {
+	params.with(|params| {
+		params
+			.map(|params| params.id)
+			.unwrap_or_default()
+	})
+};
+```
+
+The untyped versions return `Memo<ParamsMap>`. Again, it’s memo to react to changes in the URL. [`ParamsMap`](https://docs.rs/leptos_router/0.2.3/leptos_router/struct.ParamsMap.html) behaves a lot like any other map type, with a `.get()` method that returns `Option<&String>`.
+
+```rust
+let params = use_params_map(cx);
+let query = use_query_map(cx);
+
+// id: || -> Option<String>
+let id = move || {
+	params.with(|params| params.get("id").cloned())
+};
+```
+
+This can get a little messy: deriving a signal that wraps an `Option<_>` or `Result<_>` can involve a couple steps. But it’s worth doing this for two reasons:
+
+1. It’s correct, i.e., it forces you to consider the cases, “What if the user doesn’t pass a value for this query field? What if they pass an invalid value?”
+2. It’s performant. Specifically, when you navigate between different paths that match the same `<Route/>` with only params or the query changing, you can get fine-grained updates to different parts of your app without rerendering. For example, navigating between different contacts in our contact-list example does a targeted update to the name field (and eventually contact info) without needing to replacing or rerender the wrapping `<Contact/>`. This is what fine-grained reactivity is for.
+
+> This is the same example from the previous section. The router is such an integrated system that it makes sense to provide a single example highlighting multiple features, even if we haven’t explain them all yet.
+
+[Click to open CodeSandbox.](https://codesandbox.io/p/sandbox/16-router-fy4tjv?file=%2Fsrc%2Fmain.rs&selection=%5B%7B%22endColumn%22%3A1%2C%22endLineNumber%22%3A3%2C%22startColumn%22%3A1%2C%22startLineNumber%22%3A3%7D%5D)
+
+<iframe src="https://codesandbox.io/p/sandbox/16-router-fy4tjv?file=%2Fsrc%2Fmain.rs&selection=%5B%7B%22endColumn%22%3A1%2C%22endLineNumber%22%3A3%2C%22startColumn%22%3A1%2C%22startLineNumber%22%3A3%7D%5D" width="100%" height="1000px" style="max-height: 100vh"></iframe>

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

@@ -1,2 +1,23 @@
-<meta http-equiv="refresh" content="0; URL=https://book.leptos.dev/router/19_a.html">
-<link rel="canonical" href="https://book.leptos.dev/router/19_a.html">
+# The `<A/>` Component
+
+Client-side navigation works perfectly fine with ordinary HTML `<a>` elements. The router adds a listener that handles every click on a `<a>` element and tries to handle it on the client side, i.e., without doing another round trip to the server to request HTML. This is what enables the snappy “single-page app” navigations you’re probably familiar with from most modern web apps.
+
+The router will bail out of handling an `<a>` click under a number of situations
+
+- the click event has had `prevent_default()` called on it
+- the <kbd>Meta</kbd>, <kbd>Alt</kbd>, <kbd>Ctrl</kbd>, or <kbd>Shift</kbd> keys were held during click
+- the `<a>` has a `target` or `download` attribute, or `rel="external"`
+- the link has a different origin from the current location
+
+In other words, the router will only try to do a client-side navigation when it’s pretty sure it can handle it, and it will upgrade every `<a>` element to get this special behavior.
+
+The router also provides an [`<A>`](https://docs.rs/leptos_router/latest/leptos_router/fn.A.html) component, which does two additional things:
+
+1. Correctly resolves relative nested routes. Relative routing with ordinary `<a>` tags can be tricky. For example, if you have a route like `/post/:id`, `<A href="1">` will generate the correct relative route, but `<a href="1">` likely will not (depending on where it appears in your view.) `<A/>` resolves routes relative to the path of the nested route within which it appears.
+2. Sets the `aria-current` attribute to `page` if this link is the active link (i.e., it’s a link to the page you’re on). This is helpful for accessibility and for styling. For example, if you want to set the link a different color if it’s a link to the page you’re currently on, you can match this attribute with a CSS selector.
+
+> Once again, this is the same example. Check out the relative `<A/>` components, and take a look at the CSS in `index.html` to see the ARIA-based styling.
+
+[Click to open CodeSandbox.](https://codesandbox.io/p/sandbox/16-router-fy4tjv?file=%2Fsrc%2Fmain.rs&selection=%5B%7B%22endColumn%22%3A1%2C%22endLineNumber%22%3A3%2C%22startColumn%22%3A1%2C%22startLineNumber%22%3A3%7D%5D)
+
+<iframe src="https://codesandbox.io/p/sandbox/16-router-fy4tjv?file=%2Fsrc%2Fmain.rs&selection=%5B%7B%22endColumn%22%3A1%2C%22endLineNumber%22%3A3%2C%22startColumn%22%3A1%2C%22startLineNumber%22%3A3%7D%5D" width="100%" height="1000px" style="max-height: 100vh"></iframe>