diff --git a/.cargo/config.toml b/.cargo/config.toml
deleted file mode 100644
index a2345e184..000000000
--- a/.cargo/config.toml
+++ /dev/null
@@ -1,10 +0,0 @@
-[alias]
-lint = "clippy --workspace --all-targets -- -Dclippy::todo"
-lint-all = "clippy --workspace --all-features --all-targets -- -Dclippy::todo"
-
-# lib checking
-ci-check-min = "hack --workspace check --no-default-features"
-ci-check-default = "hack --workspace check"
-ci-check-default-tests = "check --workspace --tests"
-ci-check-all-feature-powerset="hack --workspace --feature-powerset --depth=4 --skip=__compress,experimental-io-uring check"
-ci-check-all-feature-powerset-linux="hack --workspace --feature-powerset --depth=4 --skip=__compress check"
diff --git a/.clippy.toml b/.clippy.toml
new file mode 100644
index 000000000..ef8ae3555
--- /dev/null
+++ b/.clippy.toml
@@ -0,0 +1,8 @@
+disallowed-names = [
+  "..",
+  "e", # no single letter error bindings
+]
+disallowed-methods = [
+  { path = "std::cell::RefCell::default()", reason = "prefer explicit inner type default (remove allow-invalid when rust-lang/rust-clippy/#8581 is fixed)", allow-invalid = true },
+  { path = "std::rc::Rc::default()", reason = "prefer explicit inner type default (remove allow-invalid when rust-lang/rust-clippy/#8581 is fixed)", allow-invalid = true },
+]
diff --git a/.cspell.yml b/.cspell.yml
new file mode 100644
index 000000000..55a01c301
--- /dev/null
+++ b/.cspell.yml
@@ -0,0 +1,15 @@
+version: "0.2"
+words:
+  - actix
+  - addrs
+  - ALPN
+  - bytestring
+  - httparse
+  - MSRV
+  - realip
+  - rustls
+  - rustup
+  - serde
+  - uring
+  - webpki
+  - zstd
diff --git a/.github/FUNDING.yml b/.github/FUNDING.yml
index 6164c657c..1f3c63cbb 100644
--- a/.github/FUNDING.yml
+++ b/.github/FUNDING.yml
@@ -1,3 +1,3 @@
 # These are supported funding model platforms
 
-github: [robjtede]
+github: [robjtede, JohnTitor]
diff --git a/.github/dependabot.yml b/.github/dependabot.yml
index c7ecf5eaa..3aeae6b1b 100644
--- a/.github/dependabot.yml
+++ b/.github/dependabot.yml
@@ -1,10 +1,11 @@
 version: 2
 updates:
-  - package-ecosystem: cargo
-    directory: /
-    schedule:
-      interval: weekly
   - package-ecosystem: github-actions
     directory: /
     schedule:
       interval: weekly
+  - package-ecosystem: cargo
+    directory: /
+    schedule:
+      interval: weekly
+    versioning-strategy: lockfile-only
diff --git a/.github/workflows/bench.yml b/.github/workflows/bench.yml
index fd6bc6d73..8174e98fb 100644
--- a/.github/workflows/bench.yml
+++ b/.github/workflows/bench.yml
@@ -2,7 +2,7 @@ name: Benchmark
 
 on:
   push:
-    branches: [master]
+    branches: [main]
 
 permissions:
   contents: read
@@ -16,7 +16,7 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
 
       - name: Install Rust
         run: |
diff --git a/.github/workflows/ci-post-merge.yml b/.github/workflows/ci-post-merge.yml
index 1729d9a07..44bf05397 100644
--- a/.github/workflows/ci-post-merge.yml
+++ b/.github/workflows/ci-post-merge.yml
@@ -2,7 +2,7 @@ name: CI (post-merge)
 
 on:
   push:
-    branches: [master]
+    branches: [main]
 
 permissions:
   contents: read
@@ -28,11 +28,11 @@ jobs:
     runs-on: ${{ matrix.target.os }}
 
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
 
       - name: Install nasm
         if: matrix.target.os == 'windows-latest'
-        uses: ilammy/setup-nasm@v1.5.1
+        uses: ilammy/setup-nasm@72793074d3c8cdda771dba85f6deafe00623038b # v1.5.2
 
       - name: Install OpenSSL
         if: matrix.target.os == 'windows-latest'
@@ -44,20 +44,20 @@ jobs:
           echo "RUSTFLAGS=-C target-feature=+crt-static" >> $GITHUB_ENV
 
       - name: Install Rust (${{ matrix.version.name }})
-        uses: actions-rust-lang/setup-rust-toolchain@v1.9.0
+        uses: actions-rust-lang/setup-rust-toolchain@1780873c7b576612439a134613cc4cc74ce5538c # v1.15.2
         with:
           toolchain: ${{ matrix.version.version }}
 
       - name: Install just, cargo-hack, cargo-nextest, cargo-ci-cache-clean
-        uses: taiki-e/install-action@v2.38.0
+        uses: taiki-e/install-action@3575e532701a5fc614b0c842e4119af4cc5fd16d # v2.62.60
         with:
           tool: just,cargo-hack,cargo-nextest,cargo-ci-cache-clean
 
       - name: check minimal
-        run: cargo ci-check-min
+        run: just check-min
 
       - name: check default
-        run: cargo ci-check-default
+        run: just check-default
 
       - name: tests
         timeout-minutes: 60
@@ -71,21 +71,21 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
 
       - name: Free Disk Space
         run: ./scripts/free-disk-space.sh
 
+      - name: Setup mold linker
+        uses: rui314/setup-mold@725a8794d15fc7563f59595bd9556495c0564878 # v1
+
       - name: Install Rust
-        uses: actions-rust-lang/setup-rust-toolchain@v1.9.0
+        uses: actions-rust-lang/setup-rust-toolchain@1780873c7b576612439a134613cc4cc74ce5538c # v1.15.2
 
-      - name: Install cargo-hack
-        uses: taiki-e/install-action@v2.38.0
+      - name: Install just, cargo-hack
+        uses: taiki-e/install-action@3575e532701a5fc614b0c842e4119af4cc5fd16d # v2.62.60
         with:
-          tool: cargo-hack
+          tool: just,cargo-hack
 
-      - name: check feature combinations
-        run: cargo ci-check-all-feature-powerset
-
-      - name: check feature combinations
-        run: cargo ci-check-all-feature-powerset-linux
+      - name: Check feature combinations
+        run: just check-feature-combinations
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 1b6f7b460..c7b038fc8 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -6,7 +6,7 @@ on:
   merge_group:
     types: [checks_requested]
   push:
-    branches: [master]
+    branches: [main]
 
 permissions:
   contents: read
@@ -18,7 +18,7 @@ concurrency:
 jobs:
   read_msrv:
     name: Read MSRV
-    uses: actions-rust-lang/msrv/.github/workflows/msrv.yml@v0.1.0
+    uses: actions-rust-lang/msrv/.github/workflows/msrv.yml@8b553824444060021f2843d7b4d803f3624d15e5 # v0.1.0
 
   build_and_test:
     needs: read_msrv
@@ -39,11 +39,11 @@ jobs:
     runs-on: ${{ matrix.target.os }}
 
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
 
       - name: Install nasm
         if: matrix.target.os == 'windows-latest'
-        uses: ilammy/setup-nasm@v1.5.1
+        uses: ilammy/setup-nasm@72793074d3c8cdda771dba85f6deafe00623038b # v1.5.2
 
       - name: Install OpenSSL
         if: matrix.target.os == 'windows-latest'
@@ -56,15 +56,15 @@ jobs:
 
       - name: Setup mold linker
         if: matrix.target.os == 'ubuntu-latest'
-        uses: rui314/setup-mold@v1
+        uses: rui314/setup-mold@725a8794d15fc7563f59595bd9556495c0564878 # v1
 
       - name: Install Rust (${{ matrix.version.name }})
-        uses: actions-rust-lang/setup-rust-toolchain@v1.9.0
+        uses: actions-rust-lang/setup-rust-toolchain@1780873c7b576612439a134613cc4cc74ce5538c # v1.15.2
         with:
           toolchain: ${{ matrix.version.version }}
 
       - name: Install just, cargo-hack, cargo-nextest, cargo-ci-cache-clean
-        uses: taiki-e/install-action@v2.38.0
+        uses: taiki-e/install-action@3575e532701a5fc614b0c842e4119af4cc5fd16d # v2.62.60
         with:
           tool: just,cargo-hack,cargo-nextest,cargo-ci-cache-clean
 
@@ -73,10 +73,10 @@ jobs:
         run: just downgrade-for-msrv
 
       - name: check minimal
-        run: cargo ci-check-min
+        run: just check-min
 
       - name: check default
-        run: cargo ci-check-default
+        run: just check-default
 
       - name: tests
         timeout-minutes: 60
@@ -85,14 +85,18 @@ jobs:
       - name: CI cache clean
         run: cargo-ci-cache-clean
 
+      - name: deny check
+        if: matrix.version.name == 'stable' && matrix.target.os == 'ubuntu-latest'
+        uses: EmbarkStudios/cargo-deny-action@76cd80eb775d7bbbd2d80292136d74d39e1b4918 # v2.0.14
+
   io-uring:
     name: io-uring tests
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
 
       - name: Install Rust
-        uses: actions-rust-lang/setup-rust-toolchain@v1.9.0
+        uses: actions-rust-lang/setup-rust-toolchain@1780873c7b576612439a134613cc4cc74ce5538c # v1.15.2
         with:
           toolchain: nightly
 
@@ -105,15 +109,15 @@ jobs:
     name: doc tests
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
 
       - name: Install Rust (nightly)
-        uses: actions-rust-lang/setup-rust-toolchain@v1.9.0
+        uses: actions-rust-lang/setup-rust-toolchain@1780873c7b576612439a134613cc4cc74ce5538c # v1.15.2
         with:
           toolchain: nightly
 
       - name: Install just
-        uses: taiki-e/install-action@v2.38.0
+        uses: taiki-e/install-action@3575e532701a5fc614b0c842e4119af4cc5fd16d # v2.62.60
         with:
           tool: just
 
diff --git a/.github/workflows/coverage.yml b/.github/workflows/coverage.yml
index ca3115713..46c99353e 100644
--- a/.github/workflows/coverage.yml
+++ b/.github/workflows/coverage.yml
@@ -2,7 +2,7 @@ name: Coverage
 
 on:
   push:
-    branches: [master]
+    branches: [main]
 
 permissions:
   contents: read
@@ -15,16 +15,16 @@ jobs:
   coverage:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
 
       - name: Install Rust (nightly)
-        uses: actions-rust-lang/setup-rust-toolchain@v1.9.0
+        uses: actions-rust-lang/setup-rust-toolchain@1780873c7b576612439a134613cc4cc74ce5538c # v1.15.2
         with:
           toolchain: nightly
           components: llvm-tools
 
       - name: Install just, cargo-llvm-cov, cargo-nextest
-        uses: taiki-e/install-action@v2.38.0
+        uses: taiki-e/install-action@3575e532701a5fc614b0c842e4119af4cc5fd16d # v2.62.60
         with:
           tool: just,cargo-llvm-cov,cargo-nextest
 
@@ -32,7 +32,7 @@ jobs:
         run: just test-coverage-codecov
 
       - name: Upload coverage to Codecov
-        uses: codecov/codecov-action@v4.4.1
+        uses: codecov/codecov-action@5a1091511ad55cbe89839c7260b706298ca349f7 # v5.5.1
         with:
           files: codecov.json
           fail_ci_if_error: true
diff --git a/.github/workflows/lint.yml b/.github/workflows/lint.yml
index ca9d2bbeb..808741c81 100644
--- a/.github/workflows/lint.yml
+++ b/.github/workflows/lint.yml
@@ -15,10 +15,10 @@ jobs:
   fmt:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
 
       - name: Install Rust (nightly)
-        uses: actions-rust-lang/setup-rust-toolchain@v1.9.0
+        uses: actions-rust-lang/setup-rust-toolchain@1780873c7b576612439a134613cc4cc74ce5538c # v1.15.2
         with:
           toolchain: nightly
           components: rustfmt
@@ -33,15 +33,15 @@ jobs:
 
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
 
       - name: Install Rust
-        uses: actions-rust-lang/setup-rust-toolchain@v1.9.0
+        uses: actions-rust-lang/setup-rust-toolchain@1780873c7b576612439a134613cc4cc74ce5538c # v1.15.2
         with:
           components: clippy
 
       - name: Check with Clippy
-        uses: giraffate/clippy-action@v1.0.1
+        uses: giraffate/clippy-action@13b9d32482f25d29ead141b79e7e04e7900281e0 # v1.0.1
         with:
           reporter: github-pr-check
           github_token: ${{ secrets.GITHUB_TOKEN }}
@@ -52,10 +52,10 @@ jobs:
   lint-docs:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
 
       - name: Install Rust (nightly)
-        uses: actions-rust-lang/setup-rust-toolchain@v1.9.0
+        uses: actions-rust-lang/setup-rust-toolchain@1780873c7b576612439a134613cc4cc74ce5538c # v1.15.2
         with:
           toolchain: nightly
           components: rust-docs
@@ -66,51 +66,25 @@ jobs:
         run: cargo +nightly doc --no-deps --workspace --all-features
 
   check-external-types:
+    if: false # rustdoc mismatch currently
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@1af3b93b6815bc44a9784bd300feb67ff0d1eeb3 # v6.0.0
 
-      - name: Install Rust (nightly-2024-05-01)
-        uses: actions-rust-lang/setup-rust-toolchain@v1.9.0
+      - name: Install Rust (${{ vars.RUST_VERSION_EXTERNAL_TYPES }})
+        uses: actions-rust-lang/setup-rust-toolchain@1780873c7b576612439a134613cc4cc74ce5538c # v1.15.2
         with:
-          toolchain: nightly-2024-05-01
+          toolchain: ${{ vars.RUST_VERSION_EXTERNAL_TYPES }}
 
       - name: Install just
-        uses: taiki-e/install-action@v2.38.0
+        uses: taiki-e/install-action@3575e532701a5fc614b0c842e4119af4cc5fd16d # v2.62.60
         with:
           tool: just
 
       - name: Install cargo-check-external-types
-        uses: taiki-e/cache-cargo-install-action@v1.2.2
+        uses: taiki-e/cache-cargo-install-action@7447f04c51f2ba27ca35e7f1e28fab848c5b3ba7 # v2.3.1
         with:
           tool: cargo-check-external-types
 
       - name: check external types
-        run: just check-external-types-all +nightly-2024-05-01
-
-  public-api-diff:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout main branch
-        uses: actions/checkout@v4
-        with:
-          ref: ${{ github.base_ref }}
-
-      - name: Checkout PR branch
-        uses: actions/checkout@v4
-
-      - name: Install Rust (nightly-2024-06-07)
-        uses: actions-rust-lang/setup-rust-toolchain@v1.9.0
-        with:
-          toolchain: nightly-2024-06-07
-
-      - name: Install cargo-public-api
-        uses: taiki-e/install-action@v2.38.0
-        with:
-          tool: cargo-public-api
-
-      - name: Generate API diff
-        run: |
-          for f in $(find -mindepth 2 -maxdepth 2 -name Cargo.toml); do
-            cargo public-api --manifest-path "$f" --simplified diff ${{ github.event.pull_request.base.sha }}..${{ github.sha }}
-          done
+        run: just check-external-types-all +${{ vars.RUST_VERSION_EXTERNAL_TYPES }}
diff --git a/.gitignore b/.gitignore
index 48ccccb92..516ee9919 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,4 +1,3 @@
-Cargo.lock
 target/
 guide/build/
 /gh-pages
diff --git a/.taplo.toml b/.taplo.toml
new file mode 100644
index 000000000..c52daa476
--- /dev/null
+++ b/.taplo.toml
@@ -0,0 +1,38 @@
+exclude = ["target/*"]
+include = ["**/*.toml"]
+
+[formatting]
+column_width = 100
+align_comments = false
+
+[[rule]]
+include = ["**/Cargo.toml"]
+keys = ["features"]
+formatting.column_width = 105
+formatting.reorder_keys = false
+
+[[rule]]
+include = ["**/Cargo.toml"]
+keys = [
+  "dependencies",
+  "*-dependencies",
+  "workspace.dependencies",
+  "workspace.*-dependencies",
+  "target.*.dependencies",
+  "target.*.*-dependencies",
+]
+formatting.column_width = 120
+formatting.reorder_keys = true
+
+[[rule]]
+include = ["**/Cargo.toml"]
+keys = [
+  "dependencies.*",
+  "*-dependencies.*",
+  "workspace.dependencies.*",
+  "workspace.*-dependencies.*",
+  "target.*.dependencies",
+  "target.*.*-dependencies",
+]
+formatting.column_width = 120
+formatting.reorder_keys = false
diff --git a/Cargo.lock b/Cargo.lock
new file mode 100644
index 000000000..a180b4be1
--- /dev/null
+++ b/Cargo.lock
@@ -0,0 +1,3893 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "actix"
+version = "0.13.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "de7fa236829ba0841304542f7614c42b80fca007455315c45c785ccfa873a85b"
+dependencies = [
+ "actix-rt",
+ "bitflags 2.10.0",
+ "bytes",
+ "crossbeam-channel",
+ "futures-core",
+ "futures-sink",
+ "futures-task",
+ "futures-util",
+ "log",
+ "once_cell",
+ "parking_lot",
+ "pin-project-lite",
+ "smallvec",
+ "tokio",
+ "tokio-util",
+]
+
+[[package]]
+name = "actix-codec"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5f7b0a21988c1bf877cf4759ef5ddaac04c1c9fe808c9142ecb78ba97d97a28a"
+dependencies = [
+ "bitflags 2.10.0",
+ "bytes",
+ "futures-core",
+ "futures-sink",
+ "memchr",
+ "pin-project-lite",
+ "tokio",
+ "tokio-util",
+ "tracing",
+]
+
+[[package]]
+name = "actix-files"
+version = "0.6.9"
+dependencies = [
+ "actix-http",
+ "actix-rt",
+ "actix-server",
+ "actix-service",
+ "actix-test",
+ "actix-utils",
+ "actix-web",
+ "bitflags 2.10.0",
+ "bytes",
+ "derive_more",
+ "env_logger",
+ "futures-core",
+ "http-range",
+ "log",
+ "mime",
+ "mime_guess",
+ "percent-encoding",
+ "pin-project-lite",
+ "tempfile",
+ "tokio-uring",
+ "v_htmlescape",
+]
+
+[[package]]
+name = "actix-http"
+version = "3.11.2"
+dependencies = [
+ "actix-codec",
+ "actix-http-test",
+ "actix-rt",
+ "actix-server",
+ "actix-service",
+ "actix-tls",
+ "actix-utils",
+ "actix-web",
+ "async-stream",
+ "base64 0.22.1",
+ "bitflags 2.10.0",
+ "brotli",
+ "bytes",
+ "bytestring",
+ "criterion",
+ "derive_more",
+ "divan",
+ "encoding_rs",
+ "env_logger",
+ "flate2",
+ "foldhash",
+ "futures-core",
+ "futures-util",
+ "h2",
+ "http 0.2.12",
+ "httparse",
+ "httpdate",
+ "itoa",
+ "language-tags",
+ "local-channel",
+ "memchr",
+ "mime",
+ "once_cell",
+ "openssl",
+ "percent-encoding",
+ "pin-project-lite",
+ "rand 0.9.2",
+ "rcgen",
+ "regex",
+ "rustls 0.23.35",
+ "rustls-pemfile",
+ "rustversion",
+ "serde",
+ "serde_json",
+ "sha1",
+ "smallvec",
+ "static_assertions",
+ "tokio",
+ "tokio-util",
+ "tracing",
+ "zstd",
+]
+
+[[package]]
+name = "actix-http-test"
+version = "3.2.0"
+dependencies = [
+ "actix-codec",
+ "actix-http",
+ "actix-rt",
+ "actix-server",
+ "actix-service",
+ "actix-tls",
+ "actix-utils",
+ "awc",
+ "bytes",
+ "futures-core",
+ "http 0.2.12",
+ "log",
+ "openssl",
+ "serde",
+ "serde_json",
+ "serde_urlencoded",
+ "slab",
+ "socket2 0.6.1",
+ "tokio",
+]
+
+[[package]]
+name = "actix-macros"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e01ed3140b2f8d422c68afa1ed2e85d996ea619c988ac834d255db32138655cb"
+dependencies = [
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "actix-multipart"
+version = "0.7.2"
+dependencies = [
+ "actix-http",
+ "actix-multipart-derive",
+ "actix-multipart-rfc7578",
+ "actix-rt",
+ "actix-test",
+ "actix-utils",
+ "actix-web",
+ "assert_matches",
+ "awc",
+ "derive_more",
+ "env_logger",
+ "futures-core",
+ "futures-test",
+ "futures-util",
+ "httparse",
+ "local-waker",
+ "log",
+ "memchr",
+ "mime",
+ "multer",
+ "rand 0.9.2",
+ "serde",
+ "serde_json",
+ "serde_plain",
+ "tempfile",
+ "tokio",
+ "tokio-stream",
+]
+
+[[package]]
+name = "actix-multipart-derive"
+version = "0.7.0"
+dependencies = [
+ "actix-multipart",
+ "actix-web",
+ "bytesize",
+ "darling",
+ "proc-macro2",
+ "quote",
+ "rustversion-msrv",
+ "syn",
+ "trybuild",
+]
+
+[[package]]
+name = "actix-multipart-rfc7578"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "af5e8f1e4c6baf42b8b78f3b2a85df02b54f10f5fdf54bf1f9b40211c130e427"
+dependencies = [
+ "actix-http",
+ "bytes",
+ "common-multipart-rfc7578",
+ "futures-core",
+ "thiserror 1.0.69",
+]
+
+[[package]]
+name = "actix-router"
+version = "0.5.3"
+dependencies = [
+ "bytestring",
+ "cfg-if",
+ "criterion",
+ "http 0.2.12",
+ "percent-encoding",
+ "regex",
+ "regex-lite",
+ "serde",
+ "tracing",
+]
+
+[[package]]
+name = "actix-rt"
+version = "2.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "92589714878ca59a7626ea19734f0e07a6a875197eec751bb5d3f99e64998c63"
+dependencies = [
+ "actix-macros",
+ "futures-core",
+ "tokio",
+ "tokio-uring",
+]
+
+[[package]]
+name = "actix-server"
+version = "2.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a65064ea4a457eaf07f2fba30b4c695bf43b721790e9530d26cb6f9019ff7502"
+dependencies = [
+ "actix-rt",
+ "actix-service",
+ "actix-utils",
+ "futures-core",
+ "futures-util",
+ "mio",
+ "socket2 0.5.10",
+ "tokio",
+ "tokio-uring",
+ "tracing",
+]
+
+[[package]]
+name = "actix-service"
+version = "2.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9e46f36bf0e5af44bdc4bdb36fbbd421aa98c79a9bce724e1edeb3894e10dc7f"
+dependencies = [
+ "futures-core",
+ "pin-project-lite",
+]
+
+[[package]]
+name = "actix-test"
+version = "0.1.5"
+dependencies = [
+ "actix-codec",
+ "actix-http",
+ "actix-http-test",
+ "actix-rt",
+ "actix-service",
+ "actix-utils",
+ "actix-web",
+ "awc",
+ "futures-core",
+ "futures-util",
+ "log",
+ "openssl",
+ "rustls 0.20.9",
+ "rustls 0.21.12",
+ "rustls 0.22.4",
+ "rustls 0.23.35",
+ "serde",
+ "serde_json",
+ "serde_urlencoded",
+ "tokio",
+]
+
+[[package]]
+name = "actix-tls"
+version = "3.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6176099de3f58fbddac916a7f8c6db297e021d706e7a6b99947785fee14abe9f"
+dependencies = [
+ "actix-rt",
+ "actix-service",
+ "actix-utils",
+ "futures-core",
+ "http 0.2.12",
+ "http 1.4.0",
+ "impl-more",
+ "openssl",
+ "pin-project-lite",
+ "rustls-native-certs",
+ "rustls-pki-types",
+ "tokio",
+ "tokio-openssl",
+ "tokio-rustls 0.23.4",
+ "tokio-rustls 0.24.1",
+ "tokio-rustls 0.25.0",
+ "tokio-rustls 0.26.4",
+ "tokio-util",
+ "tracing",
+ "webpki-roots 0.22.6",
+ "webpki-roots 0.25.4",
+ "webpki-roots 0.26.11",
+]
+
+[[package]]
+name = "actix-utils"
+version = "3.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "88a1dcdff1466e3c2488e1cb5c36a71822750ad43839937f85d2f4d9f8b705d8"
+dependencies = [
+ "local-waker",
+ "pin-project-lite",
+]
+
+[[package]]
+name = "actix-web"
+version = "4.12.1"
+dependencies = [
+ "actix-codec",
+ "actix-files",
+ "actix-http",
+ "actix-macros",
+ "actix-router",
+ "actix-rt",
+ "actix-server",
+ "actix-service",
+ "actix-test",
+ "actix-tls",
+ "actix-utils",
+ "actix-web-codegen",
+ "awc",
+ "brotli",
+ "bytes",
+ "bytestring",
+ "cfg-if",
+ "const-str",
+ "cookie",
+ "core_affinity",
+ "criterion",
+ "derive_more",
+ "encoding_rs",
+ "env_logger",
+ "flate2",
+ "foldhash",
+ "futures-core",
+ "futures-util",
+ "impl-more",
+ "itoa",
+ "language-tags",
+ "log",
+ "mime",
+ "once_cell",
+ "openssl",
+ "pin-project-lite",
+ "rand 0.9.2",
+ "rcgen",
+ "regex",
+ "regex-lite",
+ "rustls 0.23.35",
+ "rustls-pemfile",
+ "serde",
+ "serde_json",
+ "serde_urlencoded",
+ "smallvec",
+ "socket2 0.6.1",
+ "static_assertions",
+ "time",
+ "tokio",
+ "tokio-util",
+ "tracing",
+ "url",
+ "zstd",
+]
+
+[[package]]
+name = "actix-web-actors"
+version = "4.3.1+deprecated"
+dependencies = [
+ "actix",
+ "actix-codec",
+ "actix-http",
+ "actix-rt",
+ "actix-test",
+ "actix-web",
+ "awc",
+ "bytes",
+ "bytestring",
+ "env_logger",
+ "futures-core",
+ "futures-util",
+ "mime",
+ "pin-project-lite",
+ "tokio",
+ "tokio-util",
+]
+
+[[package]]
+name = "actix-web-codegen"
+version = "4.3.0"
+dependencies = [
+ "actix-macros",
+ "actix-router",
+ "actix-rt",
+ "actix-test",
+ "actix-utils",
+ "actix-web",
+ "futures-core",
+ "proc-macro2",
+ "quote",
+ "rustversion-msrv",
+ "syn",
+ "trybuild",
+]
+
+[[package]]
+name = "adler2"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "320119579fcad9c21884f5c4861d16174d0e06250625266f50fe6898340abefa"
+
+[[package]]
+name = "aead"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d122413f284cf2d62fb1b7db97e02edb8cda96d769b16e443a4f6195e35662b0"
+dependencies = [
+ "crypto-common",
+ "generic-array",
+]
+
+[[package]]
+name = "aes"
+version = "0.8.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b169f7a6d4742236a0a00c541b845991d0ac43e546831af1249753ab4c3aa3a0"
+dependencies = [
+ "cfg-if",
+ "cipher",
+ "cpufeatures",
+]
+
+[[package]]
+name = "aes-gcm"
+version = "0.10.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "831010a0f742e1209b3bcea8fab6a8e149051ba6099432c8cb2cc117dec3ead1"
+dependencies = [
+ "aead",
+ "aes",
+ "cipher",
+ "ctr",
+ "ghash",
+ "subtle",
+]
+
+[[package]]
+name = "aho-corasick"
+version = "1.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ddd31a130427c27518df266943a5308ed92d4b226cc639f5a8f1002816174301"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "alloc-no-stdlib"
+version = "2.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cc7bb162ec39d46ab1ca8c77bf72e890535becd1751bb45f64c597edb4c8c6b3"
+
+[[package]]
+name = "alloc-stdlib"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "94fb8275041c72129eb51b7d0322c29b8387a0386127718b096429201a5d6ece"
+dependencies = [
+ "alloc-no-stdlib",
+]
+
+[[package]]
+name = "anes"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4b46cbb362ab8752921c97e041f5e366ee6297bd428a31275b9fcf1e380f7299"
+
+[[package]]
+name = "anstream"
+version = "0.6.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "43d5b281e737544384e969a5ccad3f1cdd24b48086a0fc1b2a5262a26b8f4f4a"
+dependencies = [
+ "anstyle",
+ "anstyle-parse",
+ "anstyle-query",
+ "anstyle-wincon",
+ "colorchoice",
+ "is_terminal_polyfill",
+ "utf8parse",
+]
+
+[[package]]
+name = "anstyle"
+version = "1.0.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5192cca8006f1fd4f7237516f40fa183bb07f8fbdfedaa0036de5ea9b0b45e78"
+
+[[package]]
+name = "anstyle-parse"
+version = "0.2.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4e7644824f0aa2c7b9384579234ef10eb7efb6a0deb83f9630a49594dd9c15c2"
+dependencies = [
+ "utf8parse",
+]
+
+[[package]]
+name = "anstyle-query"
+version = "1.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "40c48f72fd53cd289104fc64099abca73db4166ad86ea0b4341abe65af83dadc"
+dependencies = [
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "anstyle-wincon"
+version = "3.0.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "291e6a250ff86cd4a820112fb8898808a366d8f9f58ce16d1f538353ad55747d"
+dependencies = [
+ "anstyle",
+ "once_cell_polyfill",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "assert_matches"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b34d609dfbaf33d6889b2b7106d3ca345eacad44200913df5ba02bfd31d2ba9"
+
+[[package]]
+name = "async-stream"
+version = "0.3.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b5a71a6f37880a80d1d7f19efd781e4b5de42c88f0722cc13bcb6cc2cfe8476"
+dependencies = [
+ "async-stream-impl",
+ "futures-core",
+ "pin-project-lite",
+]
+
+[[package]]
+name = "async-stream-impl"
+version = "0.3.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c7c24de15d275a1ecfd47a380fb4d5ec9bfe0933f309ed5e705b775596a3574d"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "async-trait"
+version = "0.1.89"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9035ad2d096bed7955a320ee7e2230574d28fd3c3a0f186cbea1ff3c7eed5dbb"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "autocfg"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8"
+
+[[package]]
+name = "awc"
+version = "3.8.1"
+dependencies = [
+ "actix-codec",
+ "actix-http",
+ "actix-http-test",
+ "actix-rt",
+ "actix-server",
+ "actix-service",
+ "actix-test",
+ "actix-tls",
+ "actix-utils",
+ "actix-web",
+ "base64 0.22.1",
+ "brotli",
+ "bytes",
+ "cfg-if",
+ "const-str",
+ "cookie",
+ "derive_more",
+ "env_logger",
+ "flate2",
+ "futures-core",
+ "futures-util",
+ "h2",
+ "hickory-resolver",
+ "http 0.2.12",
+ "itoa",
+ "log",
+ "mime",
+ "openssl",
+ "percent-encoding",
+ "pin-project-lite",
+ "rand 0.9.2",
+ "rcgen",
+ "rustls 0.20.9",
+ "rustls 0.21.12",
+ "rustls 0.22.4",
+ "rustls 0.23.35",
+ "rustls-pemfile",
+ "serde",
+ "serde_json",
+ "serde_urlencoded",
+ "static_assertions",
+ "tokio",
+ "zstd",
+]
+
+[[package]]
+name = "aws-lc-rs"
+version = "1.15.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6b5ce75405893cd713f9ab8e297d8e438f624dde7d706108285f7e17a25a180f"
+dependencies = [
+ "aws-lc-sys",
+ "zeroize",
+]
+
+[[package]]
+name = "aws-lc-sys"
+version = "0.34.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "179c3777a8b5e70e90ea426114ffc565b2c1a9f82f6c4a0c5a34aa6ef5e781b6"
+dependencies = [
+ "cc",
+ "cmake",
+ "dunce",
+ "fs_extra",
+]
+
+[[package]]
+name = "base64"
+version = "0.20.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0ea22880d78093b0cbe17c89f64a7d457941e65759157ec6cb31a31d652b05e5"
+
+[[package]]
+name = "base64"
+version = "0.22.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"
+
+[[package]]
+name = "bitflags"
+version = "1.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
+
+[[package]]
+name = "bitflags"
+version = "2.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "812e12b5285cc515a9c72a5c1d3b6d46a19dac5acfef5265968c166106e31dd3"
+
+[[package]]
+name = "block-buffer"
+version = "0.10.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"
+dependencies = [
+ "generic-array",
+]
+
+[[package]]
+name = "brotli"
+version = "8.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4bd8b9603c7aa97359dbd97ecf258968c95f3adddd6db2f7e7a5bef101c84560"
+dependencies = [
+ "alloc-no-stdlib",
+ "alloc-stdlib",
+ "brotli-decompressor",
+]
+
+[[package]]
+name = "brotli-decompressor"
+version = "5.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "874bb8112abecc98cbd6d81ea4fa7e94fb9449648c93cc89aa40c81c24d7de03"
+dependencies = [
+ "alloc-no-stdlib",
+ "alloc-stdlib",
+]
+
+[[package]]
+name = "bumpalo"
+version = "3.19.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "46c5e41b57b8bba42a04676d81cb89e9ee8e859a1a66f80a5a72e1cb76b34d43"
+
+[[package]]
+name = "bytes"
+version = "1.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b35204fbdc0b3f4446b89fc1ac2cf84a8a68971995d0bf2e925ec7cd960f9cb3"
+
+[[package]]
+name = "bytesize"
+version = "2.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6bd91ee7b2422bcb158d90ef4d14f75ef67f340943fc4149891dcce8f8b972a3"
+
+[[package]]
+name = "bytestring"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "113b4343b5f6617e7ad401ced8de3cc8b012e73a594347c307b90db3e9271289"
+dependencies = [
+ "bytes",
+]
+
+[[package]]
+name = "cast"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5"
+
+[[package]]
+name = "cc"
+version = "1.2.47"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cd405d82c84ff7f35739f175f67d8b9fb7687a0e84ccdc78bd3568839827cf07"
+dependencies = [
+ "find-msvc-tools",
+ "jobserver",
+ "libc",
+ "shlex",
+]
+
+[[package]]
+name = "cfg-if"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
+
+[[package]]
+name = "ciborium"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42e69ffd6f0917f5c029256a24d0161db17cea3997d185db0d35926308770f0e"
+dependencies = [
+ "ciborium-io",
+ "ciborium-ll",
+ "serde",
+]
+
+[[package]]
+name = "ciborium-io"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "05afea1e0a06c9be33d539b876f1ce3692f4afea2cb41f740e7743225ed1c757"
+
+[[package]]
+name = "ciborium-ll"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "57663b653d948a338bfb3eeba9bb2fd5fcfaecb9e199e87e1eda4d9e8b240fd9"
+dependencies = [
+ "ciborium-io",
+ "half",
+]
+
+[[package]]
+name = "cipher"
+version = "0.4.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "773f3b9af64447d2ce9850330c473515014aa235e6a783b02db81ff39e4a3dad"
+dependencies = [
+ "crypto-common",
+ "inout",
+]
+
+[[package]]
+name = "clap"
+version = "4.5.53"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c9e340e012a1bf4935f5282ed1436d1489548e8f72308207ea5df0e23d2d03f8"
+dependencies = [
+ "clap_builder",
+]
+
+[[package]]
+name = "clap_builder"
+version = "4.5.53"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d76b5d13eaa18c901fd2f7fca939fefe3a0727a953561fefdf3b2922b8569d00"
+dependencies = [
+ "anstyle",
+ "clap_lex",
+ "terminal_size",
+]
+
+[[package]]
+name = "clap_lex"
+version = "0.7.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a1d728cc89cf3aee9ff92b05e62b19ee65a02b5702cff7d5a377e32c6ae29d8d"
+
+[[package]]
+name = "cmake"
+version = "0.1.54"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e7caa3f9de89ddbe2c607f4101924c5abec803763ae9534e4f4d7d8f84aa81f0"
+dependencies = [
+ "cc",
+]
+
+[[package]]
+name = "colorchoice"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b05b61dc5112cbb17e4b6cd61790d9845d13888356391624cbe7e41efeac1e75"
+
+[[package]]
+name = "common-multipart-rfc7578"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f08d53b5e0c302c5830cfa7511ba0edc3f241c691a95c0d184dfb761e11a6cc2"
+dependencies = [
+ "bytes",
+ "futures-core",
+ "futures-util",
+ "http 1.4.0",
+ "mime",
+ "mime_guess",
+ "rand 0.8.5",
+ "thiserror 1.0.69",
+]
+
+[[package]]
+name = "condtype"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf0a07a401f374238ab8e2f11a104d2851bf9ce711ec69804834de8af45c7af"
+
+[[package]]
+name = "const-str"
+version = "0.5.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3618cccc083bb987a415d85c02ca6c9994ea5b44731ec28b9ecf09658655fba9"
+
+[[package]]
+name = "cookie"
+version = "0.16.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e859cd57d0710d9e06c381b550c06e76992472a8c6d527aecd2fc673dcc231fb"
+dependencies = [
+ "aes-gcm",
+ "base64 0.20.0",
+ "hkdf",
+ "hmac",
+ "percent-encoding",
+ "rand 0.8.5",
+ "sha2",
+ "subtle",
+ "time",
+ "version_check",
+]
+
+[[package]]
+name = "core-foundation"
+version = "0.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b2a6cd9ae233e7f62ba4e9353e81a88df7fc8a5987b8d445b4d90c879bd156f6"
+dependencies = [
+ "core-foundation-sys",
+ "libc",
+]
+
+[[package]]
+name = "core-foundation-sys"
+version = "0.8.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b"
+
+[[package]]
+name = "core_affinity"
+version = "0.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a034b3a7b624016c6e13f5df875747cc25f884156aad2abd12b6c46797971342"
+dependencies = [
+ "libc",
+ "num_cpus",
+ "winapi",
+]
+
+[[package]]
+name = "cpufeatures"
+version = "0.2.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "59ed5838eebb26a2bb2e58f6d5b5316989ae9d08bab10e0e6d103e656d1b0280"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "crc32fast"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9481c1c90cbf2ac953f07c8d4a58aa3945c425b7185c9154d67a65e4230da511"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "criterion"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2b12d017a929603d80db1831cd3a24082f8137ce19c69e6447f54f5fc8d692f"
+dependencies = [
+ "anes",
+ "cast",
+ "ciborium",
+ "clap",
+ "criterion-plot",
+ "is-terminal",
+ "itertools",
+ "num-traits",
+ "once_cell",
+ "oorandom",
+ "plotters",
+ "rayon",
+ "regex",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "tinytemplate",
+ "walkdir",
+]
+
+[[package]]
+name = "criterion-plot"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6b50826342786a51a89e2da3a28f1c32b06e387201bc2d19791f622c673706b1"
+dependencies = [
+ "cast",
+ "itertools",
+]
+
+[[package]]
+name = "critical-section"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "790eea4361631c5e7d22598ecd5723ff611904e3344ce8720784c93e3d83d40b"
+
+[[package]]
+name = "crossbeam-channel"
+version = "0.5.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "82b8f8f868b36967f9606790d1903570de9ceaf870a7bf9fbbd3016d636a2cb2"
+dependencies = [
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-deque"
+version = "0.8.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9dd111b7b7f7d55b72c0a6ae361660ee5853c9af73f70c3c2ef6858b950e2e51"
+dependencies = [
+ "crossbeam-epoch",
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-epoch"
+version = "0.9.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5b82ac4a3c2ca9c3460964f020e1402edd5753411d7737aa39c3714ad1b5420e"
+dependencies = [
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-utils"
+version = "0.8.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"
+
+[[package]]
+name = "crunchy"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "460fbee9c2c2f33933d720630a6a0bac33ba7053db5344fac858d4b8952d77d5"
+
+[[package]]
+name = "crypto-common"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "78c8292055d1c1df0cce5d180393dc8cce0abec0a7102adb6c7b1eef6016d60a"
+dependencies = [
+ "generic-array",
+ "rand_core 0.6.4",
+ "typenum",
+]
+
+[[package]]
+name = "ctr"
+version = "0.9.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0369ee1ad671834580515889b80f2ea915f23b8be8d0daa4bbaf2ac5c7590835"
+dependencies = [
+ "cipher",
+]
+
+[[package]]
+name = "darling"
+version = "0.20.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fc7f46116c46ff9ab3eb1597a45688b6715c6e628b5c133e288e709a29bcb4ee"
+dependencies = [
+ "darling_core",
+ "darling_macro",
+]
+
+[[package]]
+name = "darling_core"
+version = "0.20.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0d00b9596d185e565c2207a0b01f8bd1a135483d02d9b7b0a54b11da8d53412e"
+dependencies = [
+ "fnv",
+ "ident_case",
+ "proc-macro2",
+ "quote",
+ "strsim",
+ "syn",
+]
+
+[[package]]
+name = "darling_macro"
+version = "0.20.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fc34b93ccb385b40dc71c6fceac4b2ad23662c7eeb248cf10d529b7e055b6ead"
+dependencies = [
+ "darling_core",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "data-encoding"
+version = "2.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2a2330da5de22e8a3cb63252ce2abb30116bf5265e89c0e01bc17015ce30a476"
+
+[[package]]
+name = "deranged"
+version = "0.5.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ececcb659e7ba858fb4f10388c250a7252eb0a27373f1a72b8748afdd248e587"
+dependencies = [
+ "powerfmt",
+]
+
+[[package]]
+name = "derive_more"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "093242cf7570c207c83073cf82f79706fe7b8317e98620a47d5be7c3d8497678"
+dependencies = [
+ "derive_more-impl",
+]
+
+[[package]]
+name = "derive_more-impl"
+version = "2.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bda628edc44c4bb645fbe0f758797143e4e07926f7ebf4e9bdfbd3d2ce621df3"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+ "unicode-xid",
+]
+
+[[package]]
+name = "digest"
+version = "0.10.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
+dependencies = [
+ "block-buffer",
+ "crypto-common",
+ "subtle",
+]
+
+[[package]]
+name = "displaydoc"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "97369cbbc041bc366949bc74d34658d6cda5621039731c6310521892a3a20ae0"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "divan"
+version = "0.1.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a405457ec78b8fe08b0e32b4a3570ab5dff6dd16eb9e76a5ee0a9d9cbd898933"
+dependencies = [
+ "cfg-if",
+ "clap",
+ "condtype",
+ "divan-macros",
+ "libc",
+ "regex-lite",
+]
+
+[[package]]
+name = "divan-macros"
+version = "0.1.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9556bc800956545d6420a640173e5ba7dfa82f38d3ea5a167eb555bc69ac3323"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "dunce"
+version = "1.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "92773504d58c093f6de2459af4af33faa518c13451eb8f2b5698ed3d36e7c813"
+
+[[package]]
+name = "either"
+version = "1.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "48c757948c5ede0e46177b7add2e67155f70e33c07fea8284df6576da70b3719"
+
+[[package]]
+name = "encoding_rs"
+version = "0.8.35"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "75030f3c4f45dafd7586dd6780965a8c7e8e285a5ecb86713e63a79c5b2766f3"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "enum-as-inner"
+version = "0.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a1e6a265c649f3f5979b601d26f1d05ada116434c87741c9493cb56218f76cbc"
+dependencies = [
+ "heck",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "env_filter"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1bf3c259d255ca70051b30e2e95b5446cdb8949ac4cd22c0d7fd634d89f568e2"
+dependencies = [
+ "log",
+ "regex",
+]
+
+[[package]]
+name = "env_logger"
+version = "0.11.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "13c863f0904021b108aa8b2f55046443e6b1ebde8fd4a15c399893aae4fa069f"
+dependencies = [
+ "anstream",
+ "anstyle",
+ "env_filter",
+ "jiff",
+ "log",
+]
+
+[[package]]
+name = "equivalent"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f"
+
+[[package]]
+name = "errno"
+version = "0.3.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"
+dependencies = [
+ "libc",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "fastrand"
+version = "2.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "37909eebbb50d72f9059c3b6d82c0463f2ff062c9e95845c43a6c9c0355411be"
+
+[[package]]
+name = "find-msvc-tools"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3a3076410a55c90011c298b04d0cfa770b00fa04e1e3c97d3f6c9de105a03844"
+
+[[package]]
+name = "flate2"
+version = "1.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bfe33edd8e85a12a67454e37f8c75e730830d83e313556ab9ebf9ee7fbeb3bfb"
+dependencies = [
+ "crc32fast",
+ "miniz_oxide",
+]
+
+[[package]]
+name = "fnv"
+version = "1.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
+
+[[package]]
+name = "foldhash"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d9c4f5dac5e15c24eb999c26181a6ca40b39fe946cbe4c263c7209467bc83af2"
+
+[[package]]
+name = "foreign-types"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f6f339eb8adc052cd2ca78910fda869aefa38d22d5cb648e6485e4d3fc06f3b1"
+dependencies = [
+ "foreign-types-shared",
+]
+
+[[package]]
+name = "foreign-types-shared"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "00b0228411908ca8685dba7fc2cdd70ec9990a6e753e89b6ac91a84c40fbaf4b"
+
+[[package]]
+name = "form_urlencoded"
+version = "1.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cb4cb245038516f5f85277875cdaa4f7d2c9a0fa0468de06ed190163b1581fcf"
+dependencies = [
+ "percent-encoding",
+]
+
+[[package]]
+name = "fs_extra"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42703706b716c37f96a77aea830392ad231f44c9e9a67872fa5548707e11b11c"
+
+[[package]]
+name = "futures-channel"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2dff15bf788c671c1934e366d07e30c1814a8ef514e1af724a602e8a2fbe1b10"
+dependencies = [
+ "futures-core",
+]
+
+[[package]]
+name = "futures-core"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "05f29059c0c2090612e8d742178b0580d2dc940c837851ad723096f87af6663e"
+
+[[package]]
+name = "futures-executor"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e28d1d997f585e54aebc3f97d39e72338912123a67330d723fdbb564d646c9f"
+dependencies = [
+ "futures-core",
+ "futures-task",
+ "futures-util",
+]
+
+[[package]]
+name = "futures-io"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9e5c1b78ca4aae1ac06c48a526a655760685149f0d465d21f37abfe57ce075c6"
+
+[[package]]
+name = "futures-macro"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "162ee34ebcb7c64a8abebc059ce0fee27c2262618d7b60ed8faf72fef13c3650"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "futures-sink"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e575fab7d1e0dcb8d0c7bcf9a63ee213816ab51902e6d244a95819acacf1d4f7"
+
+[[package]]
+name = "futures-task"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f90f7dce0722e95104fcb095585910c0977252f286e354b5e3bd38902cd99988"
+
+[[package]]
+name = "futures-test"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5961fb6311645f46e2cdc2964a8bfae6743fd72315eaec181a71ae3eb2467113"
+dependencies = [
+ "futures-core",
+ "futures-executor",
+ "futures-io",
+ "futures-macro",
+ "futures-sink",
+ "futures-task",
+ "futures-util",
+ "pin-project",
+]
+
+[[package]]
+name = "futures-util"
+version = "0.3.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9fa08315bb612088cc391249efdc3bc77536f16c91f6cf495e6fbe85b20a4a81"
+dependencies = [
+ "futures-core",
+ "futures-io",
+ "futures-sink",
+ "futures-task",
+ "memchr",
+ "pin-project-lite",
+ "pin-utils",
+ "slab",
+]
+
+[[package]]
+name = "generic-array"
+version = "0.14.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"
+dependencies = [
+ "typenum",
+ "version_check",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.2.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "335ff9f135e4384c8150d6f27c6daed433577f86b4750418338c01a1a2528592"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "wasi",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "899def5c37c4fd7b2664648c28120ecec138e4d395b459e5ca34f9cce2dd77fd"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "r-efi",
+ "wasip2",
+]
+
+[[package]]
+name = "ghash"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0d8a4362ccb29cb0b265253fb0a2728f592895ee6854fd9bc13f2ffda266ff1"
+dependencies = [
+ "opaque-debug",
+ "polyval",
+]
+
+[[package]]
+name = "glob"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0cc23270f6e1808e30a928bdc84dea0b9b4136a8bc82338574f23baf47bbd280"
+
+[[package]]
+name = "h2"
+version = "0.3.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0beca50380b1fc32983fc1cb4587bfa4bb9e78fc259aad4a0032d2080309222d"
+dependencies = [
+ "bytes",
+ "fnv",
+ "futures-core",
+ "futures-sink",
+ "futures-util",
+ "http 0.2.12",
+ "indexmap",
+ "slab",
+ "tokio",
+ "tokio-util",
+ "tracing",
+]
+
+[[package]]
+name = "half"
+version = "2.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6dd08c532ae367adf81c312a4580bc67f1d0fe8bc9c460520283f4c0ff277888"
+dependencies = [
+ "cfg-if",
+ "crunchy",
+]
+
+[[package]]
+name = "hashbrown"
+version = "0.16.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "841d1cc9bed7f9236f321df977030373f4a4163ae1a7dbfe1a51a2c1a51d9100"
+
+[[package]]
+name = "heck"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
+
+[[package]]
+name = "hermit-abi"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fc0fef456e4baa96da950455cd02c081ca953b141298e41db3fc7e36b1da849c"
+
+[[package]]
+name = "hickory-proto"
+version = "0.25.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8a6fe56c0038198998a6f217ca4e7ef3a5e51f46163bd6dd60b5c71ca6c6502"
+dependencies = [
+ "async-trait",
+ "cfg-if",
+ "data-encoding",
+ "enum-as-inner",
+ "futures-channel",
+ "futures-io",
+ "futures-util",
+ "idna",
+ "ipnet",
+ "once_cell",
+ "rand 0.9.2",
+ "ring 0.17.14",
+ "thiserror 2.0.17",
+ "tinyvec",
+ "tokio",
+ "tracing",
+ "url",
+]
+
+[[package]]
+name = "hickory-resolver"
+version = "0.25.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc62a9a99b0bfb44d2ab95a7208ac952d31060efc16241c87eaf36406fecf87a"
+dependencies = [
+ "cfg-if",
+ "futures-util",
+ "hickory-proto",
+ "ipconfig",
+ "moka",
+ "once_cell",
+ "parking_lot",
+ "rand 0.9.2",
+ "resolv-conf",
+ "smallvec",
+ "thiserror 2.0.17",
+ "tokio",
+ "tracing",
+]
+
+[[package]]
+name = "hkdf"
+version = "0.12.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7b5f8eb2ad728638ea2c7d47a21db23b7b58a72ed6a38256b8a1849f15fbbdf7"
+dependencies = [
+ "hmac",
+]
+
+[[package]]
+name = "hmac"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6c49c37c09c17a53d937dfbb742eb3a961d65a994e6bcdcf37e7399d0cc8ab5e"
+dependencies = [
+ "digest",
+]
+
+[[package]]
+name = "http"
+version = "0.2.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "601cbb57e577e2f5ef5be8e7b83f0f63994f25aa94d673e54a92d5c516d101f1"
+dependencies = [
+ "bytes",
+ "fnv",
+ "itoa",
+]
+
+[[package]]
+name = "http"
+version = "1.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e3ba2a386d7f85a81f119ad7498ebe444d2e22c2af0b86b069416ace48b3311a"
+dependencies = [
+ "bytes",
+ "itoa",
+]
+
+[[package]]
+name = "http-range"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "21dec9db110f5f872ed9699c3ecf50cf16f423502706ba5c72462e28d3157573"
+
+[[package]]
+name = "httparse"
+version = "1.10.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6dbf3de79e51f3d586ab4cb9d5c3e2c14aa28ed23d180cf89b4df0454a69cc87"
+
+[[package]]
+name = "httpdate"
+version = "1.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df3b46402a9d5adb4c86a0cf463f42e19994e3ee891101b1841f30a545cb49a9"
+
+[[package]]
+name = "icu_collections"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "db2fa452206ebee18c4b5c2274dbf1de17008e874b4dc4f0aea9d01ca79e4526"
+dependencies = [
+ "displaydoc",
+ "yoke",
+ "zerofrom",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_locid"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "13acbb8371917fc971be86fc8057c41a64b521c184808a698c02acc242dbf637"
+dependencies = [
+ "displaydoc",
+ "litemap",
+ "tinystr",
+ "writeable",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_locid_transform"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "01d11ac35de8e40fdeda00d9e1e9d92525f3f9d887cdd7aa81d727596788b54e"
+dependencies = [
+ "displaydoc",
+ "icu_locid",
+ "icu_locid_transform_data",
+ "icu_provider",
+ "tinystr",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_locid_transform_data"
+version = "1.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7515e6d781098bf9f7205ab3fc7e9709d34554ae0b21ddbcb5febfa4bc7df11d"
+
+[[package]]
+name = "icu_normalizer"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "19ce3e0da2ec68599d193c93d088142efd7f9c5d6fc9b803774855747dc6a84f"
+dependencies = [
+ "displaydoc",
+ "icu_collections",
+ "icu_normalizer_data",
+ "icu_properties",
+ "icu_provider",
+ "smallvec",
+ "utf16_iter",
+ "utf8_iter",
+ "write16",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_normalizer_data"
+version = "1.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c5e8338228bdc8ab83303f16b797e177953730f601a96c25d10cb3ab0daa0cb7"
+
+[[package]]
+name = "icu_properties"
+version = "1.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "93d6020766cfc6302c15dbbc9c8778c37e62c14427cb7f6e601d849e092aeef5"
+dependencies = [
+ "displaydoc",
+ "icu_collections",
+ "icu_locid_transform",
+ "icu_properties_data",
+ "icu_provider",
+ "tinystr",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_properties_data"
+version = "1.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85fb8799753b75aee8d2a21d7c14d9f38921b54b3dbda10f5a3c7a7b82dba5e2"
+
+[[package]]
+name = "icu_provider"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6ed421c8a8ef78d3e2dbc98a973be2f3770cb42b606e3ab18d6237c4dfde68d9"
+dependencies = [
+ "displaydoc",
+ "icu_locid",
+ "icu_provider_macros",
+ "stable_deref_trait",
+ "tinystr",
+ "writeable",
+ "yoke",
+ "zerofrom",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_provider_macros"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1ec89e9337638ecdc08744df490b221a7399bf8d164eb52a665454e60e075ad6"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "ident_case"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b9e0384b61958566e926dc50660321d12159025e767c18e043daf26b70104c39"
+
+[[package]]
+name = "idna"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3b0875f23caa03898994f6ddc501886a45c7d3d62d04d2d90788d47be1b1e4de"
+dependencies = [
+ "idna_adapter",
+ "smallvec",
+ "utf8_iter",
+]
+
+[[package]]
+name = "idna_adapter"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "daca1df1c957320b2cf139ac61e7bd64fed304c5040df000a745aa1de3b4ef71"
+dependencies = [
+ "icu_normalizer",
+ "icu_properties",
+]
+
+[[package]]
+name = "impl-more"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e8a5a9a0ff0086c7a148acb942baaabeadf9504d10400b5a05645853729b9cd2"
+
+[[package]]
+name = "indexmap"
+version = "2.11.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4b0f83760fb341a774ed326568e19f5a863af4a952def8c39f9ab92fd95b88e5"
+dependencies = [
+ "equivalent",
+ "hashbrown",
+]
+
+[[package]]
+name = "inout"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "879f10e63c20629ecabbb64a8010319738c66a5cd0c29b02d63d272b03751d01"
+dependencies = [
+ "generic-array",
+]
+
+[[package]]
+name = "io-uring"
+version = "0.6.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "595a0399f411a508feb2ec1e970a4a30c249351e30208960d58298de8660b0e5"
+dependencies = [
+ "bitflags 1.3.2",
+ "libc",
+]
+
+[[package]]
+name = "ipconfig"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b58db92f96b720de98181bbbe63c831e87005ab460c1bf306eb2622b4707997f"
+dependencies = [
+ "socket2 0.5.10",
+ "widestring",
+ "windows-sys 0.48.0",
+ "winreg",
+]
+
+[[package]]
+name = "ipnet"
+version = "2.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "469fb0b9cefa57e3ef31275ee7cacb78f2fdca44e4765491884a2b119d4eb130"
+
+[[package]]
+name = "is-terminal"
+version = "0.4.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3640c1c38b8e4e43584d8df18be5fc6b0aa314ce6ebf51b53313d4306cca8e46"
+dependencies = [
+ "hermit-abi",
+ "libc",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "is_terminal_polyfill"
+version = "1.70.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a6cb138bb79a146c1bd460005623e142ef0181e3d0219cb493e02f7d08a35695"
+
+[[package]]
+name = "itertools"
+version = "0.10.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b0fd2260e829bddf4cb6ea802289de2f86d6a7a690192fbe91b3f46e0f2c8473"
+dependencies = [
+ "either",
+]
+
+[[package]]
+name = "itoa"
+version = "1.0.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4a5f13b858c8d314ee3e8f639011f7ccefe71f97f96e50151fb991f267928e2c"
+
+[[package]]
+name = "jiff"
+version = "0.2.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "49cce2b81f2098e7e3efc35bc2e0a6b7abec9d34128283d7a26fa8f32a6dbb35"
+dependencies = [
+ "jiff-static",
+ "log",
+ "portable-atomic",
+ "portable-atomic-util",
+ "serde_core",
+]
+
+[[package]]
+name = "jiff-static"
+version = "0.2.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "980af8b43c3ad5d8d349ace167ec8170839f753a42d233ba19e08afe1850fa69"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "jobserver"
+version = "0.1.34"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9afb3de4395d6b3e67a780b6de64b51c978ecf11cb9a462c66be7d4ca9039d33"
+dependencies = [
+ "getrandom 0.3.4",
+ "libc",
+]
+
+[[package]]
+name = "js-sys"
+version = "0.3.82"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b011eec8cc36da2aab2d5cff675ec18454fad408585853910a202391cf9f8e65"
+dependencies = [
+ "once_cell",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "language-tags"
+version = "0.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d4345964bb142484797b161f473a503a434de77149dd8c7427788c6e13379388"
+
+[[package]]
+name = "libc"
+version = "0.2.177"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2874a2af47a2325c2001a6e6fad9b16a53b802102b528163885171cf92b15976"
+
+[[package]]
+name = "linux-raw-sys"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df1d3c3b53da64cf5760482273a98e575c651a67eec7f77df96b5b642de8f039"
+
+[[package]]
+name = "litemap"
+version = "0.7.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4ee93343901ab17bd981295f2cf0026d4ad018c7c31ba84549a4ddbb47a45104"
+
+[[package]]
+name = "local-channel"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6cbc85e69b8df4b8bb8b89ec634e7189099cea8927a276b7384ce5488e53ec8"
+dependencies = [
+ "futures-core",
+ "futures-sink",
+ "local-waker",
+]
+
+[[package]]
+name = "local-waker"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4d873d7c67ce09b42110d801813efbc9364414e356be9935700d368351657487"
+
+[[package]]
+name = "lock_api"
+version = "0.4.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "224399e74b87b5f3557511d98dff8b14089b3dadafcab6bb93eab67d3aace965"
+dependencies = [
+ "scopeguard",
+]
+
+[[package]]
+name = "log"
+version = "0.4.28"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "34080505efa8e45a4b816c349525ebe327ceaa8559756f0356cba97ef3bf7432"
+
+[[package]]
+name = "memchr"
+version = "2.7.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f52b00d39961fc5b2736ea853c9cc86238e165017a493d1d5c8eac6bdc4cc273"
+
+[[package]]
+name = "mime"
+version = "0.3.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6877bb514081ee2a7ff5ef9de3281f14a4dd4bceac4c09388074a6b5df8a139a"
+
+[[package]]
+name = "mime_guess"
+version = "2.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f7c44f8e672c00fe5308fa235f821cb4198414e1c77935c1ab6948d3fd78550e"
+dependencies = [
+ "mime",
+ "unicase",
+]
+
+[[package]]
+name = "miniz_oxide"
+version = "0.8.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1fa76a2c86f704bdb222d66965fb3d63269ce38518b83cb0575fca855ebb6316"
+dependencies = [
+ "adler2",
+ "simd-adler32",
+]
+
+[[package]]
+name = "mio"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "69d83b0086dc8ecf3ce9ae2874b2d1290252e2a30720bea58a5c6639b0092873"
+dependencies = [
+ "libc",
+ "log",
+ "wasi",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "moka"
+version = "0.12.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8261cd88c312e0004c1d51baad2980c66528dfdb2bee62003e643a4d8f86b077"
+dependencies = [
+ "crossbeam-channel",
+ "crossbeam-epoch",
+ "crossbeam-utils",
+ "equivalent",
+ "parking_lot",
+ "portable-atomic",
+ "rustc_version",
+ "smallvec",
+ "tagptr",
+ "uuid",
+]
+
+[[package]]
+name = "multer"
+version = "3.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "83e87776546dc87511aa5ee218730c92b666d7264ab6ed41f9d215af9cd5224b"
+dependencies = [
+ "bytes",
+ "encoding_rs",
+ "futures-util",
+ "http 1.4.0",
+ "httparse",
+ "memchr",
+ "mime",
+ "spin 0.9.8",
+ "version_check",
+]
+
+[[package]]
+name = "num-conv"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "51d515d32fb182ee37cda2ccdcb92950d6a3c2893aa280e540671c2cd0f3b1d9"
+
+[[package]]
+name = "num-traits"
+version = "0.2.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "num_cpus"
+version = "1.17.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "91df4bbde75afed763b708b7eee1e8e7651e02d97f6d5dd763e89367e957b23b"
+dependencies = [
+ "hermit-abi",
+ "libc",
+]
+
+[[package]]
+name = "once_cell"
+version = "1.21.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d"
+dependencies = [
+ "critical-section",
+ "portable-atomic",
+]
+
+[[package]]
+name = "once_cell_polyfill"
+version = "1.70.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "384b8ab6d37215f3c5301a95a4accb5d64aa607f1fcb26a11b5303878451b4fe"
+
+[[package]]
+name = "oorandom"
+version = "11.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d6790f58c7ff633d8771f42965289203411a5e5c68388703c06e14f24770b41e"
+
+[[package]]
+name = "opaque-debug"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c08d65885ee38876c4f86fa503fb49d7b507c2b62552df7c70b2fce627e06381"
+
+[[package]]
+name = "openssl"
+version = "0.10.75"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "08838db121398ad17ab8531ce9de97b244589089e290a384c900cb9ff7434328"
+dependencies = [
+ "bitflags 2.10.0",
+ "cfg-if",
+ "foreign-types",
+ "libc",
+ "once_cell",
+ "openssl-macros",
+ "openssl-sys",
+]
+
+[[package]]
+name = "openssl-macros"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a948666b637a0f465e8564c73e89d4dde00d72d4d473cc972f390fc3dcee7d9c"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "openssl-probe"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d05e27ee213611ffe7d6348b942e8f942b37114c00cc03cec254295a4a17852e"
+
+[[package]]
+name = "openssl-sys"
+version = "0.9.111"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "82cab2d520aa75e3c58898289429321eb788c3106963d0dc886ec7a5f4adc321"
+dependencies = [
+ "cc",
+ "libc",
+ "pkg-config",
+ "vcpkg",
+]
+
+[[package]]
+name = "parking_lot"
+version = "0.12.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "93857453250e3077bd71ff98b6a65ea6621a19bb0f559a85248955ac12c45a1a"
+dependencies = [
+ "lock_api",
+ "parking_lot_core",
+]
+
+[[package]]
+name = "parking_lot_core"
+version = "0.9.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2621685985a2ebf1c516881c026032ac7deafcda1a2c9b7850dc81e3dfcb64c1"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "redox_syscall",
+ "smallvec",
+ "windows-link",
+]
+
+[[package]]
+name = "pem"
+version = "3.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1d30c53c26bc5b31a98cd02d20f25a7c8567146caf63ed593a9d87b2775291be"
+dependencies = [
+ "base64 0.22.1",
+ "serde_core",
+]
+
+[[package]]
+name = "percent-encoding"
+version = "2.3.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b4f627cb1b25917193a259e49bdad08f671f8d9708acfd5fe0a8c1455d87220"
+
+[[package]]
+name = "pin-project"
+version = "1.1.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "677f1add503faace112b9f1373e43e9e054bfdd22ff1a63c1bc485eaec6a6a8a"
+dependencies = [
+ "pin-project-internal",
+]
+
+[[package]]
+name = "pin-project-internal"
+version = "1.1.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6e918e4ff8c4549eb882f14b3a4bc8c8bc93de829416eacf579f1207a8fbf861"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "pin-project-lite"
+version = "0.2.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3b3cff922bd51709b605d9ead9aa71031d81447142d828eb4a6eba76fe619f9b"
+
+[[package]]
+name = "pin-utils"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184"
+
+[[package]]
+name = "pkg-config"
+version = "0.3.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7edddbd0b52d732b21ad9a5fab5c704c14cd949e5e9a1ec5929a24fded1b904c"
+
+[[package]]
+name = "plotters"
+version = "0.3.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5aeb6f403d7a4911efb1e33402027fc44f29b5bf6def3effcc22d7bb75f2b747"
+dependencies = [
+ "num-traits",
+ "plotters-backend",
+ "plotters-svg",
+ "wasm-bindgen",
+ "web-sys",
+]
+
+[[package]]
+name = "plotters-backend"
+version = "0.3.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df42e13c12958a16b3f7f4386b9ab1f3e7933914ecea48da7139435263a4172a"
+
+[[package]]
+name = "plotters-svg"
+version = "0.3.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "51bae2ac328883f7acdfea3d66a7c35751187f870bc81f94563733a154d7a670"
+dependencies = [
+ "plotters-backend",
+]
+
+[[package]]
+name = "polyval"
+version = "0.6.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9d1fe60d06143b2430aa532c94cfe9e29783047f06c0d7fd359a9a51b729fa25"
+dependencies = [
+ "cfg-if",
+ "cpufeatures",
+ "opaque-debug",
+ "universal-hash",
+]
+
+[[package]]
+name = "portable-atomic"
+version = "1.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f84267b20a16ea918e43c6a88433c2d54fa145c92a811b5b047ccbe153674483"
+
+[[package]]
+name = "portable-atomic-util"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d8a2f0d8d040d7848a709caf78912debcc3f33ee4b3cac47d73d1e1069e83507"
+dependencies = [
+ "portable-atomic",
+]
+
+[[package]]
+name = "powerfmt"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "439ee305def115ba05938db6eb1644ff94165c5ab5e9420d1c1bcedbba909391"
+
+[[package]]
+name = "ppv-lite86"
+version = "0.2.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85eae3c4ed2f50dcfe72643da4befc30deadb458a9b590d720cde2f2b1e97da9"
+dependencies = [
+ "zerocopy",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.103"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5ee95bc4ef87b8d5ba32e8b7714ccc834865276eab0aed5c9958d00ec45f49e8"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.42"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a338cc41d27e6cc6dce6cefc13a0729dfbb81c262b1f519331575dd80ef3067f"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "r-efi"
+version = "5.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f"
+
+[[package]]
+name = "rand"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404"
+dependencies = [
+ "libc",
+ "rand_chacha 0.3.1",
+ "rand_core 0.6.4",
+]
+
+[[package]]
+name = "rand"
+version = "0.9.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6db2770f06117d490610c7488547d543617b21bfa07796d7a12f6f1bd53850d1"
+dependencies = [
+ "rand_chacha 0.9.0",
+ "rand_core 0.9.3",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88"
+dependencies = [
+ "ppv-lite86",
+ "rand_core 0.6.4",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb"
+dependencies = [
+ "ppv-lite86",
+ "rand_core 0.9.3",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.6.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c"
+dependencies = [
+ "getrandom 0.2.16",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.9.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "99d9a13982dcf210057a8a78572b2217b667c3beacbf3a0d8b454f6f82837d38"
+dependencies = [
+ "getrandom 0.3.4",
+]
+
+[[package]]
+name = "rayon"
+version = "1.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b418a60154510ca1a002a752ca9714984e21e4241e804d32555251faf8b78ffa"
+dependencies = [
+ "either",
+ "rayon-core",
+]
+
+[[package]]
+name = "rayon-core"
+version = "1.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1465873a3dfdaa8ae7cb14b4383657caab0b3e8a0aa9ae8e04b044854c8dfce2"
+dependencies = [
+ "crossbeam-deque",
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "rcgen"
+version = "0.13.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "75e669e5202259b5314d1ea5397316ad400819437857b90861765f24c4cf80a2"
+dependencies = [
+ "pem",
+ "ring 0.17.14",
+ "rustls-pki-types",
+ "time",
+ "yasna",
+]
+
+[[package]]
+name = "redox_syscall"
+version = "0.5.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed2bf2547551a7053d6fdfafda3f938979645c44812fbfcda098faae3f1a362d"
+dependencies = [
+ "bitflags 2.10.0",
+]
+
+[[package]]
+name = "regex"
+version = "1.12.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "843bc0191f75f3e22651ae5f1e72939ab2f72a4bc30fa80a066bd66edefc24d4"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-automata",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-automata"
+version = "0.4.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5276caf25ac86c8d810222b3dbb938e512c55c6831a10f3e6ed1c93b84041f1c"
+dependencies = [
+ "aho-corasick",
+ "memchr",
+ "regex-syntax",
+]
+
+[[package]]
+name = "regex-lite"
+version = "0.1.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8d942b98df5e658f56f20d592c7f868833fe38115e65c33003d8cd224b0155da"
+
+[[package]]
+name = "regex-syntax"
+version = "0.8.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7a2d987857b319362043e95f5353c0535c1f58eec5336fdfcf626430af7def58"
+
+[[package]]
+name = "resolv-conf"
+version = "0.7.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e061d1b48cb8d38042de4ae0a7a6401009d6143dc80d2e2d6f31f0bdd6470c7"
+
+[[package]]
+name = "ring"
+version = "0.16.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3053cf52e236a3ed746dfc745aa9cacf1b791d846bdaf412f60a8d7d6e17c8fc"
+dependencies = [
+ "cc",
+ "libc",
+ "once_cell",
+ "spin 0.5.2",
+ "untrusted 0.7.1",
+ "web-sys",
+ "winapi",
+]
+
+[[package]]
+name = "ring"
+version = "0.17.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a4689e6c2294d81e88dc6261c768b63bc4fcdb852be6d1352498b114f61383b7"
+dependencies = [
+ "cc",
+ "cfg-if",
+ "getrandom 0.2.16",
+ "libc",
+ "untrusted 0.9.0",
+ "windows-sys 0.52.0",
+]
+
+[[package]]
+name = "rustc_version"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cfcb3a22ef46e85b45de6ee7e79d063319ebb6594faafcf1c225ea92ab6e9b92"
+dependencies = [
+ "semver",
+]
+
+[[package]]
+name = "rustix"
+version = "1.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cd15f8a2c5551a84d56efdc1cd049089e409ac19a3072d5037a17fd70719ff3e"
+dependencies = [
+ "bitflags 2.10.0",
+ "errno",
+ "libc",
+ "linux-raw-sys",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "rustls"
+version = "0.20.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1b80e3dec595989ea8510028f30c408a4630db12c9cbb8de34203b89d6577e99"
+dependencies = [
+ "log",
+ "ring 0.16.20",
+ "sct",
+ "webpki",
+]
+
+[[package]]
+name = "rustls"
+version = "0.21.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f56a14d1f48b391359b22f731fd4bd7e43c97f3c50eee276f3aa09c94784d3e"
+dependencies = [
+ "log",
+ "ring 0.17.14",
+ "rustls-webpki 0.101.7",
+ "sct",
+]
+
+[[package]]
+name = "rustls"
+version = "0.22.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bf4ef73721ac7bcd79b2b315da7779d8fc09718c6b3d2d1b2d94850eb8c18432"
+dependencies = [
+ "log",
+ "ring 0.17.14",
+ "rustls-pki-types",
+ "rustls-webpki 0.102.8",
+ "subtle",
+ "zeroize",
+]
+
+[[package]]
+name = "rustls"
+version = "0.23.35"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "533f54bc6a7d4f647e46ad909549eda97bf5afc1585190ef692b4286b198bd8f"
+dependencies = [
+ "aws-lc-rs",
+ "log",
+ "once_cell",
+ "rustls-pki-types",
+ "rustls-webpki 0.103.8",
+ "subtle",
+ "zeroize",
+]
+
+[[package]]
+name = "rustls-native-certs"
+version = "0.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9980d917ebb0c0536119ba501e90834767bffc3d60641457fd84a1f3fd337923"
+dependencies = [
+ "openssl-probe",
+ "rustls-pki-types",
+ "schannel",
+ "security-framework",
+]
+
+[[package]]
+name = "rustls-pemfile"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dce314e5fee3f39953d46bb63bb8a46d40c2f8fb7cc5a3b6cab2bde9721d6e50"
+dependencies = [
+ "rustls-pki-types",
+]
+
+[[package]]
+name = "rustls-pki-types"
+version = "1.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "94182ad936a0c91c324cd46c6511b9510ed16af436d7b5bab34beab0afd55f7a"
+dependencies = [
+ "zeroize",
+]
+
+[[package]]
+name = "rustls-webpki"
+version = "0.101.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b6275d1ee7a1cd780b64aca7726599a1dbc893b1e64144529e55c3c2f745765"
+dependencies = [
+ "ring 0.17.14",
+ "untrusted 0.9.0",
+]
+
+[[package]]
+name = "rustls-webpki"
+version = "0.102.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "64ca1bc8749bd4cf37b5ce386cc146580777b4e8572c7b97baf22c83f444bee9"
+dependencies = [
+ "ring 0.17.14",
+ "rustls-pki-types",
+ "untrusted 0.9.0",
+]
+
+[[package]]
+name = "rustls-webpki"
+version = "0.103.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2ffdfa2f5286e2247234e03f680868ac2815974dc39e00ea15adc445d0aafe52"
+dependencies = [
+ "aws-lc-rs",
+ "ring 0.17.14",
+ "rustls-pki-types",
+ "untrusted 0.9.0",
+]
+
+[[package]]
+name = "rustversion"
+version = "1.0.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d"
+
+[[package]]
+name = "rustversion-msrv"
+version = "0.100.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6ceb60223ee771fb5dfe462e29e5ee92bca9a7b9c555584f4d361045dae0e12"
+
+[[package]]
+name = "ryu"
+version = "1.0.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "28d3b2b1366ec20994f1fd18c3c594f05c5dd4bc44d8bb0c1c632c8d6829481f"
+
+[[package]]
+name = "same-file"
+version = "1.0.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502"
+dependencies = [
+ "winapi-util",
+]
+
+[[package]]
+name = "schannel"
+version = "0.1.28"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "891d81b926048e76efe18581bf793546b4c0eaf8448d72be8de2bbee5fd166e1"
+dependencies = [
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "scopeguard"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"
+
+[[package]]
+name = "sct"
+version = "0.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "da046153aa2352493d6cb7da4b6e5c0c057d8a1d0a9aa8560baffdd945acd414"
+dependencies = [
+ "ring 0.17.14",
+ "untrusted 0.9.0",
+]
+
+[[package]]
+name = "security-framework"
+version = "3.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b3297343eaf830f66ede390ea39da1d462b6b0c1b000f420d0a83f898bbbe6ef"
+dependencies = [
+ "bitflags 2.10.0",
+ "core-foundation",
+ "core-foundation-sys",
+ "libc",
+ "security-framework-sys",
+]
+
+[[package]]
+name = "security-framework-sys"
+version = "2.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cc1f0cbffaac4852523ce30d8bd3c5cdc873501d96ff467ca09b6767bb8cd5c0"
+dependencies = [
+ "core-foundation-sys",
+ "libc",
+]
+
+[[package]]
+name = "semver"
+version = "1.0.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d767eb0aabc880b29956c35734170f26ed551a859dbd361d140cdbeca61ab1e2"
+
+[[package]]
+name = "serde"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a8e94ea7f378bd32cbbd37198a4a91436180c5bb472411e48b5ec2e2124ae9e"
+dependencies = [
+ "serde_core",
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_core"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "41d385c7d4ca58e59fc732af25c3983b67ac852c1a25000afe1175de458b67ad"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.228"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d540f220d3187173da220f885ab66608367b6574e925011a9353e4badda91d79"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "serde_json"
+version = "1.0.145"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "402a6f66d8c709116cf22f558eab210f5a50187f702eb4d7e5ef38d9a7f1c79c"
+dependencies = [
+ "itoa",
+ "memchr",
+ "ryu",
+ "serde",
+ "serde_core",
+]
+
+[[package]]
+name = "serde_plain"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9ce1fc6db65a611022b23a0dec6975d63fb80a302cb3388835ff02c097258d50"
+dependencies = [
+ "serde",
+]
+
+[[package]]
+name = "serde_spanned"
+version = "1.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e24345aa0fe688594e73770a5f6d1b216508b4f93484c0026d521acd30134392"
+dependencies = [
+ "serde_core",
+]
+
+[[package]]
+name = "serde_urlencoded"
+version = "0.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d3491c14715ca2294c4d6a88f15e84739788c1d030eed8c110436aafdaa2f3fd"
+dependencies = [
+ "form_urlencoded",
+ "itoa",
+ "ryu",
+ "serde",
+]
+
+[[package]]
+name = "sha1"
+version = "0.10.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e3bf829a2d51ab4a5ddf1352d8470c140cadc8301b2ae1789db023f01cedd6ba"
+dependencies = [
+ "cfg-if",
+ "cpufeatures",
+ "digest",
+]
+
+[[package]]
+name = "sha2"
+version = "0.10.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a7507d819769d01a365ab707794a4084392c824f54a7a6a7862f8c3d0892b283"
+dependencies = [
+ "cfg-if",
+ "cpufeatures",
+ "digest",
+]
+
+[[package]]
+name = "shlex"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
+
+[[package]]
+name = "signal-hook-registry"
+version = "1.4.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7664a098b8e616bdfcc2dc0e9ac44eb231eedf41db4e9fe95d8d32ec728dedad"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "simd-adler32"
+version = "0.3.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d66dc143e6b11c1eddc06d5c423cfc97062865baf299914ab64caa38182078fe"
+
+[[package]]
+name = "slab"
+version = "0.4.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7a2ae44ef20feb57a68b23d846850f861394c2e02dc425a50098ae8c90267589"
+
+[[package]]
+name = "smallvec"
+version = "1.15.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "67b1b7a3b5fe4f1376887184045fcf45c69e92af734b7aaddc05fb777b6fbd03"
+
+[[package]]
+name = "socket2"
+version = "0.4.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9f7916fc008ca5542385b89a3d3ce689953c143e9304a9bf8beec1de48994c0d"
+dependencies = [
+ "libc",
+ "winapi",
+]
+
+[[package]]
+name = "socket2"
+version = "0.5.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e22376abed350d73dd1cd119b57ffccad95b4e585a7cda43e286245ce23c0678"
+dependencies = [
+ "libc",
+ "windows-sys 0.52.0",
+]
+
+[[package]]
+name = "socket2"
+version = "0.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "17129e116933cf371d018bb80ae557e889637989d8638274fb25622827b03881"
+dependencies = [
+ "libc",
+ "windows-sys 0.60.2",
+]
+
+[[package]]
+name = "spin"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6e63cff320ae2c57904679ba7cb63280a3dc4613885beafb148ee7bf9aa9042d"
+
+[[package]]
+name = "spin"
+version = "0.9.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6980e8d7511241f8acf4aebddbb1ff938df5eebe98691418c4468d0b72a96a67"
+
+[[package]]
+name = "stable_deref_trait"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6ce2be8dc25455e1f91df71bfa12ad37d7af1092ae736f3a6cd0e37bc7810596"
+
+[[package]]
+name = "static_assertions"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
+
+[[package]]
+name = "strsim"
+version = "0.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f"
+
+[[package]]
+name = "subtle"
+version = "2.6.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "13c2bddecc57b384dee18652358fb23172facb8a2c51ccc10d74c157bdea3292"
+
+[[package]]
+name = "syn"
+version = "2.0.111"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "390cc9a294ab71bdb1aa2e99d13be9c753cd2d7bd6560c77118597410c4d2e87"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "synstructure"
+version = "0.13.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "728a70f3dbaf5bab7f0c4b1ac8d7ae5ea60a4b5549c8a5914361c99147a709d2"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "tagptr"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7b2093cf4c8eb1e67749a6762251bc9cd836b6fc171623bd0a9d324d37af2417"
+
+[[package]]
+name = "target-triple"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "591ef38edfb78ca4771ee32cf494cb8771944bee237a9b91fc9c1424ac4b777b"
+
+[[package]]
+name = "tempfile"
+version = "3.23.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2d31c77bdf42a745371d260a26ca7163f1e0924b64afa0b688e61b5a9fa02f16"
+dependencies = [
+ "fastrand",
+ "getrandom 0.3.4",
+ "once_cell",
+ "rustix",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "termcolor"
+version = "1.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "06794f8f6c5c898b3275aebefa6b8a1cb24cd2c6c79397ab15774837a0bc5755"
+dependencies = [
+ "winapi-util",
+]
+
+[[package]]
+name = "terminal_size"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "60b8cb979cb11c32ce1603f8137b22262a9d131aaa5c37b5678025f22b8becd0"
+dependencies = [
+ "rustix",
+ "windows-sys 0.60.2",
+]
+
+[[package]]
+name = "thiserror"
+version = "1.0.69"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52"
+dependencies = [
+ "thiserror-impl 1.0.69",
+]
+
+[[package]]
+name = "thiserror"
+version = "2.0.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f63587ca0f12b72a0600bcba1d40081f830876000bb46dd2337a3051618f4fc8"
+dependencies = [
+ "thiserror-impl 2.0.17",
+]
+
+[[package]]
+name = "thiserror-impl"
+version = "1.0.69"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "thiserror-impl"
+version = "2.0.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3ff15c8ecd7de3849db632e14d18d2571fa09dfc5ed93479bc4485c7a517c913"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "time"
+version = "0.3.44"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "91e7d9e3bb61134e77bde20dd4825b97c010155709965fedf0f49bb138e52a9d"
+dependencies = [
+ "deranged",
+ "itoa",
+ "num-conv",
+ "powerfmt",
+ "serde",
+ "time-core",
+ "time-macros",
+]
+
+[[package]]
+name = "time-core"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "40868e7c1d2f0b8d73e4a8c7f0ff63af4f6d19be117e90bd73eb1d62cf831c6b"
+
+[[package]]
+name = "time-macros"
+version = "0.2.24"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "30cfb0125f12d9c277f35663a0a33f8c30190f4e4574868a330595412d34ebf3"
+dependencies = [
+ "num-conv",
+ "time-core",
+]
+
+[[package]]
+name = "tinystr"
+version = "0.7.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9117f5d4db391c1cf6927e7bea3db74b9a1c1add8f7eda9ffd5364f40f57b82f"
+dependencies = [
+ "displaydoc",
+ "zerovec",
+]
+
+[[package]]
+name = "tinytemplate"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "be4d6b5f19ff7664e8c98d03e2139cb510db9b0a60b55f8e8709b689d939b6bc"
+dependencies = [
+ "serde",
+ "serde_json",
+]
+
+[[package]]
+name = "tinyvec"
+version = "1.10.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bfa5fdc3bce6191a1dbc8c02d5c8bffcf557bafa17c124c5264a458f1b0613fa"
+dependencies = [
+ "tinyvec_macros",
+]
+
+[[package]]
+name = "tinyvec_macros"
+version = "0.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20"
+
+[[package]]
+name = "tokio"
+version = "1.48.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ff360e02eab121e0bc37a2d3b4d4dc622e6eda3a8e5253d5435ecf5bd4c68408"
+dependencies = [
+ "bytes",
+ "libc",
+ "mio",
+ "parking_lot",
+ "pin-project-lite",
+ "signal-hook-registry",
+ "socket2 0.6.1",
+ "tokio-macros",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "tokio-macros"
+version = "2.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "af407857209536a95c8e56f8231ef2c2e2aff839b22e07a1ffcbc617e9db9fa5"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "tokio-openssl"
+version = "0.6.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "59df6849caa43bb7567f9a36f863c447d95a11d5903c9cc334ba32576a27eadd"
+dependencies = [
+ "openssl",
+ "openssl-sys",
+ "tokio",
+]
+
+[[package]]
+name = "tokio-rustls"
+version = "0.23.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c43ee83903113e03984cb9e5cebe6c04a5116269e900e3ddba8f068a62adda59"
+dependencies = [
+ "rustls 0.20.9",
+ "tokio",
+ "webpki",
+]
+
+[[package]]
+name = "tokio-rustls"
+version = "0.24.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c28327cf380ac148141087fbfb9de9d7bd4e84ab5d2c28fbc911d753de8a7081"
+dependencies = [
+ "rustls 0.21.12",
+ "tokio",
+]
+
+[[package]]
+name = "tokio-rustls"
+version = "0.25.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "775e0c0f0adb3a2f22a00c4745d728b479985fc15ee7ca6a2608388c5569860f"
+dependencies = [
+ "rustls 0.22.4",
+ "rustls-pki-types",
+ "tokio",
+]
+
+[[package]]
+name = "tokio-rustls"
+version = "0.26.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1729aa945f29d91ba541258c8df89027d5792d85a8841fb65e8bf0f4ede4ef61"
+dependencies = [
+ "rustls 0.23.35",
+ "tokio",
+]
+
+[[package]]
+name = "tokio-stream"
+version = "0.1.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "eca58d7bba4a75707817a2c44174253f9236b2d5fbd055602e9d5c07c139a047"
+dependencies = [
+ "futures-core",
+ "pin-project-lite",
+ "tokio",
+]
+
+[[package]]
+name = "tokio-uring"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "748482e3e13584a34664a710168ad5068e8cb1d968aa4ffa887e83ca6dd27967"
+dependencies = [
+ "bytes",
+ "futures-util",
+ "io-uring",
+ "libc",
+ "slab",
+ "socket2 0.4.10",
+ "tokio",
+]
+
+[[package]]
+name = "tokio-util"
+version = "0.7.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2efa149fe76073d6e8fd97ef4f4eca7b67f599660115591483572e406e165594"
+dependencies = [
+ "bytes",
+ "futures-core",
+ "futures-sink",
+ "pin-project-lite",
+ "tokio",
+]
+
+[[package]]
+name = "toml"
+version = "0.9.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0dc8b1fb61449e27716ec0e1bdf0f6b8f3e8f6b05391e8497b8b6d7804ea6d8"
+dependencies = [
+ "indexmap",
+ "serde_core",
+ "serde_spanned",
+ "toml_datetime",
+ "toml_parser",
+ "toml_writer",
+ "winnow",
+]
+
+[[package]]
+name = "toml_datetime"
+version = "0.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2cdb639ebbc97961c51720f858597f7f24c4fc295327923af55b74c3c724533"
+dependencies = [
+ "serde_core",
+]
+
+[[package]]
+name = "toml_parser"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c0cbe268d35bdb4bb5a56a2de88d0ad0eb70af5384a99d648cd4b3d04039800e"
+dependencies = [
+ "winnow",
+]
+
+[[package]]
+name = "toml_writer"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df8b2b54733674ad286d16267dcfc7a71ed5c776e4ac7aa3c3e2561f7c637bf2"
+
+[[package]]
+name = "tracing"
+version = "0.1.43"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2d15d90a0b5c19378952d479dc858407149d7bb45a14de0142f6c534b16fc647"
+dependencies = [
+ "log",
+ "pin-project-lite",
+ "tracing-attributes",
+ "tracing-core",
+]
+
+[[package]]
+name = "tracing-attributes"
+version = "0.1.31"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7490cfa5ec963746568740651ac6781f701c9c5ea257c58e057f3ba8cf69e8da"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "tracing-core"
+version = "0.1.35"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7a04e24fab5c89c6a36eb8558c9656f30d81de51dfa4d3b45f26b21d61fa0a6c"
+dependencies = [
+ "once_cell",
+]
+
+[[package]]
+name = "trybuild"
+version = "1.0.114"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3e17e807bff86d2a06b52bca4276746584a78375055b6e45843925ce2802b335"
+dependencies = [
+ "glob",
+ "serde",
+ "serde_derive",
+ "serde_json",
+ "target-triple",
+ "termcolor",
+ "toml",
+]
+
+[[package]]
+name = "typenum"
+version = "1.19.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "562d481066bde0658276a35467c4af00bdc6ee726305698a55b86e61d7ad82bb"
+
+[[package]]
+name = "unicase"
+version = "2.8.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "75b844d17643ee918803943289730bec8aac480150456169e647ed0b576ba539"
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9312f7c4f6ff9069b165498234ce8be658059c6728633667c526e27dc2cf1df5"
+
+[[package]]
+name = "unicode-xid"
+version = "0.2.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853"
+
+[[package]]
+name = "universal-hash"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fc1de2c688dc15305988b563c3854064043356019f97a4b46276fe734c4f07ea"
+dependencies = [
+ "crypto-common",
+ "subtle",
+]
+
+[[package]]
+name = "untrusted"
+version = "0.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a156c684c91ea7d62626509bce3cb4e1d9ed5c4d978f7b4352658f96a4c26b4a"
+
+[[package]]
+name = "untrusted"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1"
+
+[[package]]
+name = "url"
+version = "2.5.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "08bc136a29a3d1758e07a9cca267be308aeebf5cfd5a10f3f67ab2097683ef5b"
+dependencies = [
+ "form_urlencoded",
+ "idna",
+ "percent-encoding",
+ "serde",
+]
+
+[[package]]
+name = "utf16_iter"
+version = "1.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c8232dd3cdaed5356e0f716d285e4b40b932ac434100fe9b7e0e8e935b9e6246"
+
+[[package]]
+name = "utf8_iter"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be"
+
+[[package]]
+name = "utf8parse"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
+
+[[package]]
+name = "uuid"
+version = "1.18.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2f87b8aa10b915a06587d0dec516c282ff295b475d94abf425d62b57710070a2"
+dependencies = [
+ "getrandom 0.3.4",
+ "js-sys",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "v_htmlescape"
+version = "0.15.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4e8257fbc510f0a46eb602c10215901938b5c2a7d5e70fc11483b1d3c9b5b18c"
+
+[[package]]
+name = "vcpkg"
+version = "0.2.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426"
+
+[[package]]
+name = "version_check"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
+
+[[package]]
+name = "walkdir"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "29790946404f91d9c5d06f9874efddea1dc06c5efe94541a7d6863108e3a5e4b"
+dependencies = [
+ "same-file",
+ "winapi-util",
+]
+
+[[package]]
+name = "wasi"
+version = "0.11.1+wasi-snapshot-preview1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ccf3ec651a847eb01de73ccad15eb7d99f80485de043efb2f370cd654f4ea44b"
+
+[[package]]
+name = "wasip2"
+version = "1.0.1+wasi-0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0562428422c63773dad2c345a1882263bbf4d65cf3f42e90921f787ef5ad58e7"
+dependencies = [
+ "wit-bindgen",
+]
+
+[[package]]
+name = "wasm-bindgen"
+version = "0.2.105"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "da95793dfc411fbbd93f5be7715b0578ec61fe87cb1a42b12eb625caa5c5ea60"
+dependencies = [
+ "cfg-if",
+ "once_cell",
+ "rustversion",
+ "wasm-bindgen-macro",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-macro"
+version = "0.2.105"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "04264334509e04a7bf8690f2384ef5265f05143a4bff3889ab7a3269adab59c2"
+dependencies = [
+ "quote",
+ "wasm-bindgen-macro-support",
+]
+
+[[package]]
+name = "wasm-bindgen-macro-support"
+version = "0.2.105"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "420bc339d9f322e562942d52e115d57e950d12d88983a14c79b86859ee6c7ebc"
+dependencies = [
+ "bumpalo",
+ "proc-macro2",
+ "quote",
+ "syn",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-shared"
+version = "0.2.105"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "76f218a38c84bcb33c25ec7059b07847d465ce0e0a76b995e134a45adcb6af76"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "web-sys"
+version = "0.3.82"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3a1f95c0d03a47f4ae1f7a64643a6bb97465d9b740f0fa8f90ea33915c99a9a1"
+dependencies = [
+ "js-sys",
+ "wasm-bindgen",
+]
+
+[[package]]
+name = "webpki"
+version = "0.22.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed63aea5ce73d0ff405984102c42de94fc55a6b75765d621c65262469b3c9b53"
+dependencies = [
+ "ring 0.17.14",
+ "untrusted 0.9.0",
+]
+
+[[package]]
+name = "webpki-roots"
+version = "0.22.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6c71e40d7d2c34a5106301fb632274ca37242cd0c9d3e64dbece371a40a2d87"
+dependencies = [
+ "webpki",
+]
+
+[[package]]
+name = "webpki-roots"
+version = "0.25.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5f20c57d8d7db6d3b86154206ae5d8fba62dd39573114de97c2cb0578251f8e1"
+
+[[package]]
+name = "webpki-roots"
+version = "0.26.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "521bc38abb08001b01866da9f51eb7c5d647a19260e00054a8c7fd5f9e57f7a9"
+dependencies = [
+ "webpki-roots 1.0.4",
+]
+
+[[package]]
+name = "webpki-roots"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b2878ef029c47c6e8cf779119f20fcf52bde7ad42a731b2a304bc221df17571e"
+dependencies = [
+ "rustls-pki-types",
+]
+
+[[package]]
+name = "widestring"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72069c3113ab32ab29e5584db3c6ec55d416895e60715417b5b883a357c3e471"
+
+[[package]]
+name = "winapi"
+version = "0.3.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419"
+dependencies = [
+ "winapi-i686-pc-windows-gnu",
+ "winapi-x86_64-pc-windows-gnu",
+]
+
+[[package]]
+name = "winapi-i686-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
+
+[[package]]
+name = "winapi-util"
+version = "0.1.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22"
+dependencies = [
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "winapi-x86_64-pc-windows-gnu"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
+
+[[package]]
+name = "windows-link"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"
+
+[[package]]
+name = "windows-sys"
+version = "0.48.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "677d2418bec65e3338edb076e806bc1ec15693c5d0104683f2efe857f61056a9"
+dependencies = [
+ "windows-targets 0.48.5",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.52.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d"
+dependencies = [
+ "windows-targets 0.52.6",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.60.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f2f500e4d28234f72040990ec9d39e3a6b950f9f22d3dba18416c35882612bcb"
+dependencies = [
+ "windows-targets 0.53.5",
+]
+
+[[package]]
+name = "windows-sys"
+version = "0.61.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc"
+dependencies = [
+ "windows-link",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a2fa6e2155d7247be68c096456083145c183cbbbc2764150dda45a87197940c"
+dependencies = [
+ "windows_aarch64_gnullvm 0.48.5",
+ "windows_aarch64_msvc 0.48.5",
+ "windows_i686_gnu 0.48.5",
+ "windows_i686_msvc 0.48.5",
+ "windows_x86_64_gnu 0.48.5",
+ "windows_x86_64_gnullvm 0.48.5",
+ "windows_x86_64_msvc 0.48.5",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973"
+dependencies = [
+ "windows_aarch64_gnullvm 0.52.6",
+ "windows_aarch64_msvc 0.52.6",
+ "windows_i686_gnu 0.52.6",
+ "windows_i686_gnullvm 0.52.6",
+ "windows_i686_msvc 0.52.6",
+ "windows_x86_64_gnu 0.52.6",
+ "windows_x86_64_gnullvm 0.52.6",
+ "windows_x86_64_msvc 0.52.6",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.53.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4945f9f551b88e0d65f3db0bc25c33b8acea4d9e41163edf90dcd0b19f9069f3"
+dependencies = [
+ "windows-link",
+ "windows_aarch64_gnullvm 0.53.1",
+ "windows_aarch64_msvc 0.53.1",
+ "windows_i686_gnu 0.53.1",
+ "windows_i686_gnullvm 0.53.1",
+ "windows_i686_msvc 0.53.1",
+ "windows_x86_64_gnu 0.53.1",
+ "windows_x86_64_gnullvm 0.53.1",
+ "windows_x86_64_msvc 0.53.1",
+]
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2b38e32f0abccf9987a4e3079dfb67dcd799fb61361e53e2882c3cbaf0d905d8"
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a9d8416fa8b42f5c947f8482c43e7d89e73a173cead56d044f6a56104a6d1b53"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc35310971f3b2dbbf3f0690a219f40e2d9afcf64f9ab7cc1be722937c26b4bc"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b9d782e804c2f632e395708e99a94275910eb9100b2114651e04744e9b125006"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a75915e7def60c94dcef72200b9a8e58e5091744960da64ec734a6c6e9b3743e"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "960e6da069d81e09becb0ca57a65220ddff016ff2d6af6a223cf372a506593a3"
+
+[[package]]
+name = "windows_i686_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
+
+[[package]]
+name = "windows_i686_gnullvm"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fa7359d10048f68ab8b09fa71c3daccfb0e9b559aed648a8f95469c27057180c"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f55c233f70c4b27f66c523580f78f1004e8b5a8b659e05a4eb49d4166cca406"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e7ac75179f18232fe9c285163565a57ef8d3c89254a30685b57d83a38d326c2"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "53d40abd2583d23e4718fddf1ebec84dbff8381c07cae67ff7768bbf19c6718e"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9c3842cdd74a865a8066ab39c8a7a473c0778a3f29370b5fd6b4b9aa7df4a499"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b7b52767868a23d5bab768e390dc5f5c55825b6d30b86c844ff2dc7414044cc"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0ffa179e2d07eee8ad8f57493436566c7cc30ac536a3379fdf008f47f6bb7ae1"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed94fce61571a4006852b7389a063ab983c02eb1bb37b47f8272ce92d06d9538"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.53.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d6bbff5f0aada427a1e5a6da5f1f98158182f26556f345ac9e04d36d0ebed650"
+
+[[package]]
+name = "winnow"
+version = "0.7.13"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "21a0236b59786fed61e2a80582dd500fe61f18b5dca67a4a067d0bc9039339cf"
+
+[[package]]
+name = "winreg"
+version = "0.50.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "524e57b2c537c0f9b1e69f1965311ec12182b4122e45035b1508cd24d2adadb1"
+dependencies = [
+ "cfg-if",
+ "windows-sys 0.48.0",
+]
+
+[[package]]
+name = "wit-bindgen"
+version = "0.46.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f17a85883d4e6d00e8a97c586de764dabcc06133f7f1d55dce5cdc070ad7fe59"
+
+[[package]]
+name = "write16"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d1890f4022759daae28ed4fe62859b1236caebfc61ede2f63ed4e695f3f6d936"
+
+[[package]]
+name = "writeable"
+version = "0.5.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e9df38ee2d2c3c5948ea468a8406ff0db0b29ae1ffde1bcf20ef305bcc95c51"
+
+[[package]]
+name = "yasna"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e17bb3549cc1321ae1296b9cdc2698e2b6cb1992adfa19a8c72e5b7a738f44cd"
+dependencies = [
+ "time",
+]
+
+[[package]]
+name = "yoke"
+version = "0.7.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "120e6aef9aa629e3d4f52dc8cc43a015c7724194c97dfaf45180d2daf2b77f40"
+dependencies = [
+ "serde",
+ "stable_deref_trait",
+ "yoke-derive",
+ "zerofrom",
+]
+
+[[package]]
+name = "yoke-derive"
+version = "0.7.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2380878cad4ac9aac1e2435f3eb4020e8374b5f13c296cb75b4620ff8e229154"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+ "synstructure",
+]
+
+[[package]]
+name = "zerocopy"
+version = "0.8.30"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4ea879c944afe8a2b25fef16bb4ba234f47c694565e97383b36f3a878219065c"
+dependencies = [
+ "zerocopy-derive",
+]
+
+[[package]]
+name = "zerocopy-derive"
+version = "0.8.30"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf955aa904d6040f70dc8e9384444cb1030aed272ba3cb09bbc4ab9e7c1f34f5"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "zerofrom"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cff3ee08c995dee1859d998dea82f7374f2826091dd9cd47def953cae446cd2e"
+dependencies = [
+ "zerofrom-derive",
+]
+
+[[package]]
+name = "zerofrom-derive"
+version = "0.1.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d71e5d6e06ab090c67b5e44993ec16b72dcbaabc526db883a360057678b48502"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+ "synstructure",
+]
+
+[[package]]
+name = "zeroize"
+version = "1.8.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b97154e67e32c85465826e8bcc1c59429aaaf107c1e4a9e53c8d8ccd5eff88d0"
+
+[[package]]
+name = "zerovec"
+version = "0.10.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "aa2b893d79df23bfb12d5461018d408ea19dfafe76c2c7ef6d4eba614f8ff079"
+dependencies = [
+ "yoke",
+ "zerofrom",
+ "zerovec-derive",
+]
+
+[[package]]
+name = "zerovec-derive"
+version = "0.10.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6eafa6dfb17584ea3e2bd6e76e0cc15ad7af12b09abdd1ca55961bed9b1063c6"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "zstd"
+version = "0.13.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e91ee311a569c327171651566e07972200e76fcfe2242a4fa446149a3881c08a"
+dependencies = [
+ "zstd-safe",
+]
+
+[[package]]
+name = "zstd-safe"
+version = "7.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f49c4d5f0abb602a93fb8736af2a4f4dd9512e36f7f570d66e65ff867ed3b9d"
+dependencies = [
+ "zstd-sys",
+]
+
+[[package]]
+name = "zstd-sys"
+version = "2.0.16+zstd.1.5.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "91e19ebc2adc8f83e43039e79776e3fda8ca919132d68a1fed6a5faca2683748"
+dependencies = [
+ "cc",
+ "pkg-config",
+]
diff --git a/Cargo.toml b/Cargo.toml
index 19d5dd116..0e90abaef 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,17 +1,17 @@
 [workspace]
 resolver = "2"
 members = [
-    "actix-files",
-    "actix-http-test",
-    "actix-http",
-    "actix-multipart",
-    "actix-multipart-derive",
-    "actix-router",
-    "actix-test",
-    "actix-web-actors",
-    "actix-web-codegen",
-    "actix-web",
-    "awc",
+  "actix-files",
+  "actix-http-test",
+  "actix-http",
+  "actix-multipart",
+  "actix-multipart-derive",
+  "actix-router",
+  "actix-test",
+  "actix-web-actors",
+  "actix-web-codegen",
+  "actix-web",
+  "awc",
 ]
 
 [workspace.package]
@@ -19,7 +19,7 @@ homepage = "https://actix.rs"
 repository = "https://github.com/actix/actix-web"
 license = "MIT OR Apache-2.0"
 edition = "2021"
-rust-version = "1.72"
+rust-version = "1.82"
 
 [profile.dev]
 # Disabling debug info speeds up builds a bunch and we don't rely on it for debugging that much.
@@ -51,3 +51,11 @@ awc = { path = "awc" }
 # actix-utils = { path = "../actix-net/actix-utils" }
 # actix-tls = { path = "../actix-net/actix-tls" }
 # actix-server = { path = "../actix-net/actix-server" }
+
+[workspace.lints.rust]
+rust_2018_idioms = { level = "deny" }
+future_incompatible = { level = "deny" }
+nonstandard_style = { level = "deny" }
+
+[workspace.lints.clippy]
+# clone_on_ref_ptr = { level = "deny" }
diff --git a/actix-files/CHANGES.md b/actix-files/CHANGES.md
index e94f43907..f4e0385e0 100644
--- a/actix-files/CHANGES.md
+++ b/actix-files/CHANGES.md
@@ -2,6 +2,22 @@
 
 ## Unreleased
 
+- Minimum supported Rust version (MSRV) is now 1.82.
+
+## 0.6.9
+
+- Correct `derive_more` dependency feature requirements.
+
+## 0.6.8
+
+- Add `Files::with_permanent_redirect()` method.
+- Change default redirect status code to 307 Temporary Redirect.
+
+## 0.6.7
+
+- Add `{Files, NamedFile}::read_mode_threshold()` methods to allow faster synchronous reads of small files.
+- Minimum supported Rust version (MSRV) is now 1.75.
+
 ## 0.6.6
 
 - Update `tokio-uring` dependency to `0.4`.
diff --git a/actix-files/Cargo.toml b/actix-files/Cargo.toml
index 57cd4e913..148442d4f 100644
--- a/actix-files/Cargo.toml
+++ b/actix-files/Cargo.toml
@@ -1,10 +1,7 @@
 [package]
 name = "actix-files"
-version = "0.6.6"
-authors = [
-    "Nikolay Kim <fafhrd91@gmail.com>",
-    "Rob Ede <robjtede@icloud.com>",
-]
+version = "0.6.9"
+authors = ["Nikolay Kim <fafhrd91@gmail.com>", "Rob Ede <robjtede@icloud.com>"]
 description = "Static file serving for Actix Web"
 keywords = ["actix", "http", "async", "futures"]
 homepage = "https://actix.rs"
@@ -14,13 +11,7 @@ license = "MIT OR Apache-2.0"
 edition = "2021"
 
 [package.metadata.cargo_check_external_types]
-allowed_external_types = [
-    "actix_http::*",
-    "actix_service::*",
-    "actix_web::*",
-    "http::*",
-    "mime::*",
-]
+allowed_external_types = ["actix_http::*", "actix_service::*", "actix_web::*", "http::*", "mime::*"]
 
 [features]
 experimental-io-uring = ["actix-web/experimental-io-uring", "tokio-uring"]
@@ -33,7 +24,7 @@ actix-web = { version = "4", default-features = false }
 
 bitflags = "2"
 bytes = "1"
-derive_more = "0.99.5"
+derive_more = { version = "2", features = ["deref", "deref_mut", "display", "error", "from"] }
 futures-core = { version = "0.3.17", default-features = false, features = ["alloc"] }
 http-range = "0.1.4"
 log = "0.4"
@@ -54,3 +45,6 @@ actix-test = "0.1"
 actix-web = "4"
 env_logger = "0.11"
 tempfile = "3.2"
+
+[lints]
+workspace = true
diff --git a/actix-files/README.md b/actix-files/README.md
index f6d5143f5..6c3e20417 100644
--- a/actix-files/README.md
+++ b/actix-files/README.md
@@ -3,11 +3,11 @@
 <!-- prettier-ignore-start -->
 
 [![crates.io](https://img.shields.io/crates/v/actix-files?label=latest)](https://crates.io/crates/actix-files)
-[![Documentation](https://docs.rs/actix-files/badge.svg?version=0.6.6)](https://docs.rs/actix-files/0.6.6)
+[![Documentation](https://docs.rs/actix-files/badge.svg?version=0.6.9)](https://docs.rs/actix-files/0.6.9)
 ![Version](https://img.shields.io/badge/rustc-1.72+-ab6000.svg)
 ![License](https://img.shields.io/crates/l/actix-files.svg)
 <br />
-[![dependency status](https://deps.rs/crate/actix-files/0.6.6/status.svg)](https://deps.rs/crate/actix-files/0.6.6)
+[![dependency status](https://deps.rs/crate/actix-files/0.6.9/status.svg)](https://deps.rs/crate/actix-files/0.6.9)
 [![Download](https://img.shields.io/crates/d/actix-files.svg)](https://crates.io/crates/actix-files)
 [![Chat on Discord](https://img.shields.io/discord/771444961383153695?label=chat&logo=discord)](https://discord.gg/NWpN5mmg3x)
 
diff --git a/actix-files/src/chunked.rs b/actix-files/src/chunked.rs
index c6c019038..03452e9ae 100644
--- a/actix-files/src/chunked.rs
+++ b/actix-files/src/chunked.rs
@@ -14,6 +14,12 @@ use pin_project_lite::pin_project;
 
 use super::named::File;
 
+#[derive(Debug, Clone, Copy)]
+pub(crate) enum ReadMode {
+    Sync,
+    Async,
+}
+
 pin_project! {
     /// Adapter to read a `std::file::File` in chunks.
     #[doc(hidden)]
@@ -24,6 +30,7 @@ pin_project! {
         state: ChunkedReadFileState<Fut>,
         counter: u64,
         callback: F,
+        read_mode: ReadMode,
     }
 }
 
@@ -57,6 +64,7 @@ pub(crate) fn new_chunked_read(
     size: u64,
     offset: u64,
     file: File,
+    read_mode_threshold: u64,
 ) -> impl Stream<Item = Result<Bytes, Error>> {
     ChunkedReadFile {
         size,
@@ -69,31 +77,50 @@ pub(crate) fn new_chunked_read(
         },
         counter: 0,
         callback: chunked_read_file_callback,
+        read_mode: if size < read_mode_threshold {
+            ReadMode::Sync
+        } else {
+            ReadMode::Async
+        },
     }
 }
 
 #[cfg(not(feature = "experimental-io-uring"))]
-async fn chunked_read_file_callback(
+fn chunked_read_file_callback_sync(
     mut file: File,
     offset: u64,
     max_bytes: usize,
-) -> Result<(File, Bytes), Error> {
+) -> Result<(File, Bytes), io::Error> {
     use io::{Read as _, Seek as _};
 
-    let res = actix_web::web::block(move || {
-        let mut buf = Vec::with_capacity(max_bytes);
+    let mut buf = Vec::with_capacity(max_bytes);
 
-        file.seek(io::SeekFrom::Start(offset))?;
+    file.seek(io::SeekFrom::Start(offset))?;
 
-        let n_bytes = file.by_ref().take(max_bytes as u64).read_to_end(&mut buf)?;
+    let n_bytes = file.by_ref().take(max_bytes as u64).read_to_end(&mut buf)?;
 
-        if n_bytes == 0 {
-            Err(io::Error::from(io::ErrorKind::UnexpectedEof))
-        } else {
-            Ok((file, Bytes::from(buf)))
+    if n_bytes == 0 {
+        Err(io::Error::from(io::ErrorKind::UnexpectedEof))
+    } else {
+        Ok((file, Bytes::from(buf)))
+    }
+}
+
+#[cfg(not(feature = "experimental-io-uring"))]
+#[inline]
+async fn chunked_read_file_callback(
+    file: File,
+    offset: u64,
+    max_bytes: usize,
+    read_mode: ReadMode,
+) -> Result<(File, Bytes), Error> {
+    let res = match read_mode {
+        ReadMode::Sync => chunked_read_file_callback_sync(file, offset, max_bytes)?,
+        ReadMode::Async => {
+            actix_web::web::block(move || chunked_read_file_callback_sync(file, offset, max_bytes))
+                .await??
         }
-    })
-    .await??;
+    };
 
     Ok(res)
 }
@@ -171,7 +198,7 @@ where
 #[cfg(not(feature = "experimental-io-uring"))]
 impl<F, Fut> Stream for ChunkedReadFile<F, Fut>
 where
-    F: Fn(File, u64, usize) -> Fut,
+    F: Fn(File, u64, usize, ReadMode) -> Fut,
     Fut: Future<Output = Result<(File, Bytes), Error>>,
 {
     type Item = Result<Bytes, Error>;
@@ -193,7 +220,7 @@ where
                         .take()
                         .expect("ChunkedReadFile polled after completion");
 
-                    let fut = (this.callback)(file, offset, max_bytes);
+                    let fut = (this.callback)(file, offset, max_bytes, *this.read_mode);
 
                     this.state
                         .project_replace(ChunkedReadFileState::Future { fut });
diff --git a/actix-files/src/error.rs b/actix-files/src/error.rs
index d614651fc..e762116e6 100644
--- a/actix-files/src/error.rs
+++ b/actix-files/src/error.rs
@@ -6,11 +6,11 @@ use derive_more::Display;
 pub enum FilesError {
     /// Path is not a directory.
     #[allow(dead_code)]
-    #[display(fmt = "path is not a directory. Unable to serve static files")]
+    #[display("path is not a directory. Unable to serve static files")]
     IsNotDirectory,
 
     /// Cannot render directory.
-    #[display(fmt = "unable to render directory without index file")]
+    #[display("unable to render directory without index file")]
     IsDirectory,
 }
 
@@ -25,19 +25,19 @@ impl ResponseError for FilesError {
 #[non_exhaustive]
 pub enum UriSegmentError {
     /// Segment started with the wrapped invalid character.
-    #[display(fmt = "segment started with invalid character: ('{_0}')")]
+    #[display("segment started with invalid character: ('{_0}')")]
     BadStart(char),
 
     /// Segment contained the wrapped invalid character.
-    #[display(fmt = "segment contained invalid character ('{_0}')")]
+    #[display("segment contained invalid character ('{_0}')")]
     BadChar(char),
 
     /// Segment ended with the wrapped invalid character.
-    #[display(fmt = "segment ended with invalid character: ('{_0}')")]
+    #[display("segment ended with invalid character: ('{_0}')")]
     BadEnd(char),
 
     /// Path is not a valid UTF-8 string after percent-decoding.
-    #[display(fmt = "path is not a valid UTF-8 string after percent-decoding")]
+    #[display("path is not a valid UTF-8 string after percent-decoding")]
     NotValidUtf8,
 }
 
diff --git a/actix-files/src/files.rs b/actix-files/src/files.rs
index cfd3b9c22..3491f59e2 100644
--- a/actix-files/src/files.rs
+++ b/actix-files/src/files.rs
@@ -41,6 +41,7 @@ pub struct Files {
     index: Option<String>,
     show_index: bool,
     redirect_to_slash: bool,
+    with_permanent_redirect: bool,
     default: Rc<RefCell<Option<Rc<HttpNewService>>>>,
     renderer: Rc<DirectoryRenderer>,
     mime_override: Option<Rc<MimeOverride>>,
@@ -49,6 +50,7 @@ pub struct Files {
     use_guards: Option<Rc<dyn Guard>>,
     guards: Vec<Rc<dyn Guard>>,
     hidden_files: bool,
+    read_mode_threshold: u64,
 }
 
 impl fmt::Debug for Files {
@@ -64,6 +66,7 @@ impl Clone for Files {
             index: self.index.clone(),
             show_index: self.show_index,
             redirect_to_slash: self.redirect_to_slash,
+            with_permanent_redirect: self.with_permanent_redirect,
             default: self.default.clone(),
             renderer: self.renderer.clone(),
             file_flags: self.file_flags,
@@ -73,6 +76,7 @@ impl Clone for Files {
             use_guards: self.use_guards.clone(),
             guards: self.guards.clone(),
             hidden_files: self.hidden_files,
+            read_mode_threshold: self.read_mode_threshold,
         }
     }
 }
@@ -111,6 +115,7 @@ impl Files {
             index: None,
             show_index: false,
             redirect_to_slash: false,
+            with_permanent_redirect: false,
             default: Rc::new(RefCell::new(None)),
             renderer: Rc::new(directory_listing),
             mime_override: None,
@@ -119,6 +124,7 @@ impl Files {
             use_guards: None,
             guards: Vec::new(),
             hidden_files: false,
+            read_mode_threshold: 0,
         }
     }
 
@@ -141,6 +147,14 @@ impl Files {
         self
     }
 
+    /// Redirect with permanent redirect status code (308).
+    ///
+    /// By default redirect with temporary redirect status code (307).
+    pub fn with_permanent_redirect(mut self) -> Self {
+        self.with_permanent_redirect = true;
+        self
+    }
+
     /// Set custom directory renderer.
     pub fn files_listing_renderer<F>(mut self, f: F) -> Self
     where
@@ -204,6 +218,23 @@ impl Files {
         self
     }
 
+    /// Sets the size threshold that determines file read mode (sync/async).
+    ///
+    /// When a file is smaller than the threshold (bytes), the reader will switch from synchronous
+    /// (blocking) file-reads to async reads to avoid blocking the main-thread when processing large
+    /// files.
+    ///
+    /// Tweaking this value according to your expected usage may lead to signifiant performance
+    /// gains (or losses in other handlers, if `size` is too high).
+    ///
+    /// When the `experimental-io-uring` crate feature is enabled, file reads are always async.
+    ///
+    /// Default is 0, meaning all files are read asynchronously.
+    pub fn read_mode_threshold(mut self, size: u64) -> Self {
+        self.read_mode_threshold = size;
+        self
+    }
+
     /// Specifies whether to use ETag or not.
     ///
     /// Default is true.
@@ -367,6 +398,8 @@ impl ServiceFactory<ServiceRequest> for Files {
             file_flags: self.file_flags,
             guards: self.use_guards.clone(),
             hidden_files: self.hidden_files,
+            size_threshold: self.read_mode_threshold,
+            with_permanent_redirect: self.with_permanent_redirect,
         };
 
         if let Some(ref default) = *self.default.borrow() {
diff --git a/actix-files/src/lib.rs b/actix-files/src/lib.rs
index 167f996c0..9859db456 100644
--- a/actix-files/src/lib.rs
+++ b/actix-files/src/lib.rs
@@ -11,11 +11,10 @@
 //!     .service(Files::new("/static", ".").prefer_utf8(true));
 //! ```
 
-#![deny(rust_2018_idioms, nonstandard_style)]
-#![warn(future_incompatible, missing_docs, missing_debug_implementations)]
+#![warn(missing_docs, missing_debug_implementations)]
 #![doc(html_logo_url = "https://actix.rs/img/logo.png")]
 #![doc(html_favicon_url = "https://actix.rs/favicon.ico")]
-#![cfg_attr(docsrs, feature(doc_auto_cfg))]
+#![cfg_attr(docsrs, feature(doc_cfg))]
 
 use std::path::Path;
 
@@ -307,11 +306,11 @@ mod tests {
         let resp = file.respond_to(&req);
         assert_eq!(
             resp.headers().get(header::CONTENT_TYPE).unwrap(),
-            "application/javascript; charset=utf-8"
+            "text/javascript",
         );
         assert_eq!(
             resp.headers().get(header::CONTENT_DISPOSITION).unwrap(),
-            "inline; filename=\"test.js\""
+            "inline; filename=\"test.js\"",
         );
     }
 
@@ -737,7 +736,21 @@ mod tests {
         .await;
         let req = TestRequest::with_uri("/tests").to_request();
         let resp = test::call_service(&srv, req).await;
-        assert_eq!(resp.status(), StatusCode::FOUND);
+        assert_eq!(resp.status(), StatusCode::TEMPORARY_REDIRECT);
+
+        // should redirect if index present with permanent redirect
+        let srv = test::init_service(
+            App::new().service(
+                Files::new("/", ".")
+                    .index_file("test.png")
+                    .redirect_to_slash_directory()
+                    .with_permanent_redirect(),
+            ),
+        )
+        .await;
+        let req = TestRequest::with_uri("/tests").to_request();
+        let resp = test::call_service(&srv, req).await;
+        assert_eq!(resp.status(), StatusCode::PERMANENT_REDIRECT);
 
         // should redirect if files listing is enabled
         let srv = test::init_service(
@@ -750,7 +763,7 @@ mod tests {
         .await;
         let req = TestRequest::with_uri("/tests").to_request();
         let resp = test::call_service(&srv, req).await;
-        assert_eq!(resp.status(), StatusCode::FOUND);
+        assert_eq!(resp.status(), StatusCode::TEMPORARY_REDIRECT);
 
         // should not redirect if the path is wrong
         let req = TestRequest::with_uri("/not_existing").to_request();
diff --git a/actix-files/src/named.rs b/actix-files/src/named.rs
index 9e4a37737..23aa10d5c 100644
--- a/actix-files/src/named.rs
+++ b/actix-files/src/named.rs
@@ -80,6 +80,7 @@ pub struct NamedFile {
     pub(crate) content_type: Mime,
     pub(crate) content_disposition: ContentDisposition,
     pub(crate) encoding: Option<ContentEncoding>,
+    pub(crate) read_mode_threshold: u64,
 }
 
 #[cfg(not(feature = "experimental-io-uring"))]
@@ -200,6 +201,7 @@ impl NamedFile {
             encoding,
             status_code: StatusCode::OK,
             flags: Flags::default(),
+            read_mode_threshold: 0,
         })
     }
 
@@ -353,6 +355,23 @@ impl NamedFile {
         self
     }
 
+    /// Sets the size threshold that determines file read mode (sync/async).
+    ///
+    /// When a file is smaller than the threshold (bytes), the reader will switch from synchronous
+    /// (blocking) file-reads to async reads to avoid blocking the main-thread when processing large
+    /// files.
+    ///
+    /// Tweaking this value according to your expected usage may lead to signifiant performance
+    /// gains (or losses in other handlers, if `size` is too high).
+    ///
+    /// When the `experimental-io-uring` crate feature is enabled, file reads are always async.
+    ///
+    /// Default is 0, meaning all files are read asynchronously.
+    pub fn read_mode_threshold(mut self, size: u64) -> Self {
+        self.read_mode_threshold = size;
+        self
+    }
+
     /// Specifies whether to return `ETag` header in response.
     ///
     /// Default is true.
@@ -440,7 +459,8 @@ impl NamedFile {
                 res.insert_header((header::CONTENT_ENCODING, current_encoding.as_str()));
             }
 
-            let reader = chunked::new_chunked_read(self.md.len(), 0, self.file);
+            let reader =
+                chunked::new_chunked_read(self.md.len(), 0, self.file, self.read_mode_threshold);
 
             return res.streaming(reader);
         }
@@ -577,7 +597,7 @@ impl NamedFile {
                 .map_into_boxed_body();
         }
 
-        let reader = chunked::new_chunked_read(length, offset, self.file);
+        let reader = chunked::new_chunked_read(length, offset, self.file, self.read_mode_threshold);
 
         if offset != 0 || length != self.md.len() {
             res.status(StatusCode::PARTIAL_CONTENT);
diff --git a/actix-files/src/service.rs b/actix-files/src/service.rs
index 3d3b36c40..f63ba46c6 100644
--- a/actix-files/src/service.rs
+++ b/actix-files/src/service.rs
@@ -39,6 +39,8 @@ pub struct FilesServiceInner {
     pub(crate) file_flags: named::Flags,
     pub(crate) guards: Option<Rc<dyn Guard>>,
     pub(crate) hidden_files: bool,
+    pub(crate) size_threshold: u64,
+    pub(crate) with_permanent_redirect: bool,
 }
 
 impl fmt::Debug for FilesServiceInner {
@@ -70,7 +72,9 @@ impl FilesService {
         named_file.flags = self.file_flags;
 
         let (req, _) = req.into_parts();
-        let res = named_file.into_response(&req);
+        let res = named_file
+            .read_mode_threshold(self.size_threshold)
+            .into_response(&req);
         ServiceResponse::new(req, res)
     }
 
@@ -79,7 +83,7 @@ impl FilesService {
 
         let (req, _) = req.into_parts();
 
-        (self.renderer)(&dir, &req).unwrap_or_else(|e| ServiceResponse::from_err(e, req))
+        (self.renderer)(&dir, &req).unwrap_or_else(|err| ServiceResponse::from_err(err, req))
     }
 }
 
@@ -145,11 +149,15 @@ impl Service<ServiceRequest> for FilesService {
                 {
                     let redirect_to = format!("{}/", req.path());
 
-                    return Ok(req.into_response(
-                        HttpResponse::Found()
-                            .insert_header((header::LOCATION, redirect_to))
-                            .finish(),
-                    ));
+                    let response = if this.with_permanent_redirect {
+                        HttpResponse::PermanentRedirect()
+                    } else {
+                        HttpResponse::TemporaryRedirect()
+                    }
+                    .insert_header((header::LOCATION, redirect_to))
+                    .finish();
+
+                    return Ok(req.into_response(response));
                 }
 
                 match this.index {
@@ -169,17 +177,7 @@ impl Service<ServiceRequest> for FilesService {
                 }
             } else {
                 match NamedFile::open_async(&path).await {
-                    Ok(mut named_file) => {
-                        if let Some(ref mime_override) = this.mime_override {
-                            let new_disposition = mime_override(&named_file.content_type.type_());
-                            named_file.content_disposition.disposition = new_disposition;
-                        }
-                        named_file.flags = this.file_flags;
-
-                        let (req, _) = req.into_parts();
-                        let res = named_file.into_response(&req);
-                        Ok(ServiceResponse::new(req, res))
-                    }
+                    Ok(named_file) => Ok(this.serve_named_file(req, named_file)),
                     Err(err) => this.handle_err(err, req).await,
                 }
             }
diff --git a/actix-http-test/CHANGES.md b/actix-http-test/CHANGES.md
index 4d133e3ec..0e8a746f6 100644
--- a/actix-http-test/CHANGES.md
+++ b/actix-http-test/CHANGES.md
@@ -2,7 +2,7 @@
 
 ## Unreleased
 
-- Minimum supported Rust version (MSRV) is now 1.72.
+- Minimum supported Rust version (MSRV) is now 1.82.
 
 ## 3.2.0
 
diff --git a/actix-http-test/Cargo.toml b/actix-http-test/Cargo.toml
index 0947579a5..6ddee64cf 100644
--- a/actix-http-test/Cargo.toml
+++ b/actix-http-test/Cargo.toml
@@ -7,10 +7,10 @@ keywords = ["http", "web", "framework", "async", "futures"]
 homepage = "https://actix.rs"
 repository = "https://github.com/actix/actix-web"
 categories = [
-    "network-programming",
-    "asynchronous",
-    "web-programming::http-server",
-    "web-programming::websocket",
+  "network-programming",
+  "asynchronous",
+  "web-programming::http-server",
+  "web-programming::websocket",
 ]
 license = "MIT OR Apache-2.0"
 edition = "2021"
@@ -20,14 +20,14 @@ features = []
 
 [package.metadata.cargo_check_external_types]
 allowed_external_types = [
-    "actix_codec::*",
-    "actix_http::*",
-    "actix_server::*",
-    "awc::*",
-    "bytes::*",
-    "futures_core::*",
-    "http::*",
-    "tokio::*",
+  "actix_codec::*",
+  "actix_http::*",
+  "actix_server::*",
+  "awc::*",
+  "bytes::*",
+  "futures_core::*",
+  "http::*",
+  "tokio::*",
 ]
 
 [features]
@@ -37,25 +37,28 @@ default = []
 openssl = ["tls-openssl", "awc/openssl"]
 
 [dependencies]
-actix-service = "2"
 actix-codec = "0.5"
-actix-tls = "3"
-actix-utils = "3"
 actix-rt = "2.2"
 actix-server = "2"
+actix-service = "2"
+actix-tls = "3"
+actix-utils = "3"
 awc = { version = "3", default-features = false }
 
 bytes = "1"
 futures-core = { version = "0.3.17", default-features = false }
 http = "0.2.7"
 log = "0.4"
-socket2 = "0.5"
 serde = "1"
 serde_json = "1"
-slab = "0.4"
 serde_urlencoded = "0.7"
+slab = "0.4"
+socket2 = "0.6"
 tls-openssl = { version = "0.10.55", package = "openssl", optional = true }
-tokio = { version = "1.24.2", features = ["sync"] }
+tokio = { version = "1.38.2", features = ["sync"] }
 
 [dev-dependencies]
 actix-http = "3"
+
+[lints]
+workspace = true
diff --git a/actix-http-test/src/lib.rs b/actix-http-test/src/lib.rs
index 554af9102..e3ea69e5c 100644
--- a/actix-http-test/src/lib.rs
+++ b/actix-http-test/src/lib.rs
@@ -1,10 +1,8 @@
 //! Various helpers for Actix applications to use during testing.
 
-#![deny(rust_2018_idioms, nonstandard_style)]
-#![warn(future_incompatible)]
 #![doc(html_logo_url = "https://actix.rs/img/logo.png")]
 #![doc(html_favicon_url = "https://actix.rs/favicon.ico")]
-#![cfg_attr(docsrs, feature(doc_auto_cfg))]
+#![cfg_attr(docsrs, feature(doc_cfg))]
 
 #[cfg(feature = "openssl")]
 extern crate tls_openssl as openssl;
@@ -108,7 +106,7 @@ pub async fn test_server_with_addr<F: ServerServiceFactory<TcpStream>>(
             builder.set_verify(SslVerifyMode::NONE);
             let _ = builder
                 .set_alpn_protos(b"\x02h2\x08http/1.1")
-                .map_err(|e| log::error!("Can not set alpn protocol: {:?}", e));
+                .map_err(|err| log::error!("Can not set ALPN protocol: {err}"));
 
             Connector::new()
                 .conn_lifetime(Duration::from_secs(0))
diff --git a/actix-http/CHANGES.md b/actix-http/CHANGES.md
index 6c0a3867a..97301a460 100644
--- a/actix-http/CHANGES.md
+++ b/actix-http/CHANGES.md
@@ -2,6 +2,47 @@
 
 ## Unreleased
 
+- Minimum supported Rust version (MSRV) is now 1.82.
+
+## 3.11.2
+
+- Properly wake Payload receivers when feeding errors or EOF.
+- Add `ServiceConfigBuilder` type to facilitate future configuration extensions.
+- Add a configuration option to allow/disallow half closed connections in HTTP/1. This defaults to allow, reverting the change made in 3.11.1.
+- Shutdown connections when HTTP Responses are written without reading full Requests.
+
+## 3.11.1
+
+- Prevent more hangs after client disconnects.
+- More malformed WebSocket frames are now gracefully rejected.
+- Using `TestRequest::set_payload()` now sets a Content-Length header.
+
+## 3.11.0
+
+- Update `brotli` dependency to `8`.
+
+## 3.10.0
+
+### Added
+
+- Add `header::CLEAR_SITE_DATA` constant.
+- Add `Extensions::get_or_insert[_with]()` methods.
+- Implement `From<Bytes>` for `Payload`.
+- Implement `From<Vec<u8>>` for `Payload`.
+
+### Changed
+
+- Update `brotli` dependency to `7`.
+- Minimum supported Rust version (MSRV) is now 1.75.
+
+## 3.9.0
+
+### Added
+
+- Implement `FromIterator<(HeaderName, HeaderValue)>` for `HeaderMap`.
+
+## 3.8.0
+
 ### Added
 
 - Add `error::InvalidStatusCode` re-export.
diff --git a/actix-http/Cargo.toml b/actix-http/Cargo.toml
index 4dc0f0bd8..9f41e627f 100644
--- a/actix-http/Cargo.toml
+++ b/actix-http/Cargo.toml
@@ -1,113 +1,108 @@
 [package]
 name = "actix-http"
-version = "3.7.0"
-authors = [
-    "Nikolay Kim <fafhrd91@gmail.com>",
-    "Rob Ede <robjtede@icloud.com>",
-]
+version = "3.11.2"
+authors = ["Nikolay Kim <fafhrd91@gmail.com>", "Rob Ede <robjtede@icloud.com>"]
 description = "HTTP types and services for the Actix ecosystem"
 keywords = ["actix", "http", "framework", "async", "futures"]
 homepage = "https://actix.rs"
 repository = "https://github.com/actix/actix-web"
 categories = [
-    "network-programming",
-    "asynchronous",
-    "web-programming::http-server",
-    "web-programming::websocket",
+  "network-programming",
+  "asynchronous",
+  "web-programming::http-server",
+  "web-programming::websocket",
 ]
 license.workspace = true
 edition.workspace = true
 rust-version.workspace = true
 
 [package.metadata.docs.rs]
-rustdoc-args = ["--cfg", "docsrs"]
 features = [
-    "http2",
-    "ws",
-    "openssl",
-    "rustls-0_20",
-    "rustls-0_21",
-    "rustls-0_22",
-    "rustls-0_23",
-    "compress-brotli",
-    "compress-gzip",
-    "compress-zstd",
+  "http2",
+  "ws",
+  "openssl",
+  "rustls-0_20",
+  "rustls-0_21",
+  "rustls-0_22",
+  "rustls-0_23",
+  "compress-brotli",
+  "compress-gzip",
+  "compress-zstd",
 ]
 
 [package.metadata.cargo_check_external_types]
 allowed_external_types = [
-    "actix_codec::*",
-    "actix_service::*",
-    "actix_tls::*",
-    "actix_utils::*",
-    "bytes::*",
-    "bytestring::*",
-    "encoding_rs::*",
-    "futures_core::*",
-    "h2::*",
-    "http::*",
-    "httparse::*",
-    "language_tags::*",
-    "mime::*",
-    "openssl::*",
-    "rustls::*",
-    "tokio_util::*",
-    "tokio::*",
+  "actix_codec::*",
+  "actix_service::*",
+  "actix_tls::*",
+  "actix_utils::*",
+  "bytes::*",
+  "bytestring::*",
+  "encoding_rs::*",
+  "futures_core::*",
+  "h2::*",
+  "http::*",
+  "httparse::*",
+  "language_tags::*",
+  "mime::*",
+  "openssl::*",
+  "rustls::*",
+  "tokio_util::*",
+  "tokio::*",
 ]
 
 [features]
 default = []
 
 # HTTP/2 protocol support
-http2 = ["h2"]
+http2 = ["dep:h2"]
 
 # WebSocket protocol implementation
-ws = [
-    "local-channel",
-    "base64",
-    "rand",
-    "sha1",
-]
+ws = ["dep:local-channel", "dep:base64", "dep:rand", "dep:sha1"]
 
 # TLS via OpenSSL
-openssl = ["actix-tls/accept", "actix-tls/openssl"]
+openssl = ["__tls", "actix-tls/accept", "actix-tls/openssl"]
 
 # TLS via Rustls v0.20
-rustls = ["rustls-0_20"]
+rustls = ["__tls", "rustls-0_20"]
 
 # TLS via Rustls v0.20
-rustls-0_20 = ["actix-tls/accept", "actix-tls/rustls-0_20"]
+rustls-0_20 = ["__tls", "actix-tls/accept", "actix-tls/rustls-0_20"]
 
 # TLS via Rustls v0.21
-rustls-0_21 = ["actix-tls/accept", "actix-tls/rustls-0_21"]
+rustls-0_21 = ["__tls", "actix-tls/accept", "actix-tls/rustls-0_21"]
 
 # TLS via Rustls v0.22
-rustls-0_22 = ["actix-tls/accept", "actix-tls/rustls-0_22"]
+rustls-0_22 = ["__tls", "actix-tls/accept", "actix-tls/rustls-0_22"]
 
 # TLS via Rustls v0.23
-rustls-0_23 = ["actix-tls/accept", "actix-tls/rustls-0_23"]
+rustls-0_23 = ["__tls", "actix-tls/accept", "actix-tls/rustls-0_23"]
 
 # Compression codecs
-compress-brotli = ["__compress", "brotli"]
-compress-gzip   = ["__compress", "flate2"]
-compress-zstd   = ["__compress", "zstd"]
+compress-brotli = ["__compress", "dep:brotli"]
+compress-gzip = ["__compress", "dep:flate2"]
+compress-zstd = ["__compress", "dep:zstd"]
 
 # Internal (PRIVATE!) features used to aid testing and checking feature status.
 # Don't rely on these whatsoever. They are semver-exempt and may disappear at anytime.
 __compress = []
 
-[dependencies]
-actix-service = "2"
-actix-codec = "0.5"
-actix-utils = "3"
-actix-rt = { version = "2.2", default-features = false }
+# Internal (PRIVATE!) features used to aid checking feature status.
+# Don't rely on these whatsoever. They may disappear at anytime.
+__tls = []
+
+[dependencies]
+actix-codec = "0.5"
+actix-rt = { version = "2.2", default-features = false }
+actix-service = "2"
+actix-utils = "3"
 
-ahash = "0.8"
 bitflags = "2"
 bytes = "1"
 bytestring = "1"
-derive_more = "0.99.5"
+derive_more = { version = "2", features = ["as_ref", "deref", "deref_mut", "display", "error", "from"] }
 encoding_rs = "0.8"
+foldhash = "0.1"
 futures-core = { version = "0.3.17", default-features = false, features = ["alloc"] }
 http = "0.2.7"
 httparse = "1.5.1"
@@ -118,24 +113,24 @@ mime = "0.3.4"
 percent-encoding = "2.1"
 pin-project-lite = "0.2"
 smallvec = "1.6.1"
-tokio = { version = "1.24.2", features = [] }
+tokio = { version = "1.38.2", features = [] }
 tokio-util = { version = "0.7", features = ["io", "codec"] }
 tracing = { version = "0.1.30", default-features = false, features = ["log"] }
 
 # http2
-h2 = { version = "0.3.26", optional = true }
+h2 = { version = "0.3.27", optional = true }
 
 # websockets
-local-channel = { version = "0.1", optional = true }
 base64 = { version = "0.22", optional = true }
-rand = { version = "0.8", optional = true }
+local-channel = { version = "0.1", optional = true }
+rand = { version = "0.9", optional = true }
 sha1 = { version = "0.10", optional = true }
 
 # openssl/rustls
 actix-tls = { version = "3.4", default-features = false, optional = true }
 
 # compress-*
-brotli = { version = "6", optional = true }
+brotli = { version = "8", optional = true }
 flate2 = { version = "1.0.13", optional = true }
 zstd = { version = "0.13", optional = true }
 
@@ -151,17 +146,20 @@ divan = "0.1.8"
 env_logger = "0.11"
 futures-util = { version = "0.3.17", default-features = false, features = ["alloc"] }
 memchr = "2.4"
-once_cell = "1.9"
+once_cell = "1.21"
 rcgen = "0.13"
 regex = "1.3"
-rustversion = "1"
 rustls-pemfile = "2"
-serde = { version = "1.0", features = ["derive"] }
+rustversion = "1"
+serde = { version = "1", features = ["derive"] }
 serde_json = "1.0"
 static_assertions = "1"
 tls-openssl = { package = "openssl", version = "0.10.55" }
 tls-rustls_023 = { package = "rustls", version = "0.23" }
-tokio = { version = "1.24.2", features = ["net", "rt", "macros"] }
+tokio = { version = "1.38.2", features = ["net", "rt", "macros", "sync"] }
+
+[lints]
+workspace = true
 
 [[example]]
 name = "ws"
diff --git a/actix-http/README.md b/actix-http/README.md
index 0ba3fdcac..be44e8e68 100644
--- a/actix-http/README.md
+++ b/actix-http/README.md
@@ -5,11 +5,11 @@
 <!-- prettier-ignore-start -->
 
 [![crates.io](https://img.shields.io/crates/v/actix-http?label=latest)](https://crates.io/crates/actix-http)
-[![Documentation](https://docs.rs/actix-http/badge.svg?version=3.7.0)](https://docs.rs/actix-http/3.7.0)
+[![Documentation](https://docs.rs/actix-http/badge.svg?version=3.11.2)](https://docs.rs/actix-http/3.11.2)
 ![Version](https://img.shields.io/badge/rustc-1.72+-ab6000.svg)
 ![MIT or Apache 2.0 licensed](https://img.shields.io/crates/l/actix-http.svg)
 <br />
-[![dependency status](https://deps.rs/crate/actix-http/3.7.0/status.svg)](https://deps.rs/crate/actix-http/3.7.0)
+[![dependency status](https://deps.rs/crate/actix-http/3.11.2/status.svg)](https://deps.rs/crate/actix-http/3.11.2)
 [![Download](https://img.shields.io/crates/d/actix-http.svg)](https://crates.io/crates/actix-http)
 [![Chat on Discord](https://img.shields.io/discord/771444961383153695?label=chat&logo=discord)](https://discord.gg/NWpN5mmg3x)
 
diff --git a/actix-http/examples/actix-web.rs b/actix-http/examples/actix-web.rs
index 449e5899b..e07abfd97 100644
--- a/actix-http/examples/actix-web.rs
+++ b/actix-http/examples/actix-web.rs
@@ -1,10 +1,10 @@
 use actix_http::HttpService;
 use actix_server::Server;
 use actix_service::map_config;
-use actix_web::{dev::AppConfig, get, App};
+use actix_web::{dev::AppConfig, get, App, Responder};
 
 #[get("/")]
-async fn index() -> &'static str {
+async fn index() -> impl Responder {
     "Hello, world. From Actix Web!"
 }
 
diff --git a/actix-http/examples/echo.rs b/actix-http/examples/echo.rs
index ae6f00cce..11fd2750e 100644
--- a/actix-http/examples/echo.rs
+++ b/actix-http/examples/echo.rs
@@ -23,7 +23,7 @@ async fn main() -> io::Result<()> {
                         body.extend_from_slice(&item?);
                     }
 
-                    info!("request body: {:?}", body);
+                    info!("request body: {body:?}");
 
                     let res = Response::build(StatusCode::OK)
                         .insert_header(("x-head", HeaderValue::from_static("dummy value!")))
@@ -31,8 +31,7 @@ async fn main() -> io::Result<()> {
 
                     Ok::<_, Error>(res)
                 })
-                // No TLS
-                .tcp()
+                .tcp() // No TLS
         })?
         .run()
         .await
diff --git a/actix-http/examples/hello-world.rs b/actix-http/examples/hello-world.rs
index cf10beddf..afa3883a4 100644
--- a/actix-http/examples/hello-world.rs
+++ b/actix-http/examples/hello-world.rs
@@ -17,7 +17,7 @@ async fn main() -> io::Result<()> {
                     ext.insert(42u32);
                 })
                 .finish(|req: Request| async move {
-                    info!("{:?}", req);
+                    info!("{req:?}");
 
                     let mut res = Response::build(StatusCode::OK);
                     res.insert_header(("x-head", HeaderValue::from_static("dummy value!")));
diff --git a/actix-http/examples/streaming-error.rs b/actix-http/examples/streaming-error.rs
index 8c8a249cb..8d494b64e 100644
--- a/actix-http/examples/streaming-error.rs
+++ b/actix-http/examples/streaming-error.rs
@@ -22,16 +22,16 @@ async fn main() -> io::Result<()> {
         .bind("streaming-error", ("127.0.0.1", 8080), || {
             HttpService::build()
                 .finish(|req| async move {
-                    info!("{:?}", req);
+                    info!("{req:?}");
                     let res = Response::ok();
 
                     Ok::<_, Infallible>(res.set_body(BodyStream::new(stream! {
                         yield Ok(Bytes::from("123"));
                         yield Ok(Bytes::from("456"));
 
-                        actix_rt::time::sleep(Duration::from_millis(1000)).await;
+                        actix_rt::time::sleep(Duration::from_secs(1)).await;
 
-                        yield Err(io::Error::new(io::ErrorKind::Other, ""));
+                        yield Err(io::Error::other("abc"));
                     })))
                 })
                 .tcp()
diff --git a/actix-http/examples/ws.rs b/actix-http/examples/ws.rs
index fb86bc5ea..af83e4c3d 100644
--- a/actix-http/examples/ws.rs
+++ b/actix-http/examples/ws.rs
@@ -17,7 +17,6 @@ use bytes::{Bytes, BytesMut};
 use bytestring::ByteString;
 use futures_core::{ready, Stream};
 use tokio_util::codec::Encoder;
-use tracing::{info, trace};
 
 #[actix_rt::main]
 async fn main() -> io::Result<()> {
@@ -37,12 +36,12 @@ async fn main() -> io::Result<()> {
 }
 
 async fn handler(req: Request) -> Result<Response<BodyStream<Heartbeat>>, Error> {
-    info!("handshaking");
+    tracing::info!("handshaking");
     let mut res = ws::handshake(req.head())?;
 
     // handshake will always fail under HTTP/2
 
-    info!("responding");
+    tracing::info!("responding");
     res.message_body(BodyStream::new(Heartbeat::new(ws::Codec::new())))
 }
 
@@ -64,7 +63,7 @@ impl Stream for Heartbeat {
     type Item = Result<Bytes, Error>;
 
     fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
-        trace!("poll");
+        tracing::trace!("poll");
 
         ready!(self.as_mut().interval.poll_tick(cx));
 
diff --git a/actix-http/src/body/body_stream.rs b/actix-http/src/body/body_stream.rs
index 4574b2519..657ffe9c8 100644
--- a/actix-http/src/body/body_stream.rs
+++ b/actix-http/src/body/body_stream.rs
@@ -131,7 +131,7 @@ mod tests {
         assert_eq!(to_bytes(body).await.ok(), Some(Bytes::from("12")));
     }
     #[derive(Debug, Display, Error)]
-    #[display(fmt = "stream error")]
+    #[display("stream error")]
     struct StreamErr;
 
     #[actix_rt::test]
diff --git a/actix-http/src/body/utils.rs b/actix-http/src/body/utils.rs
index d1449179f..a234222aa 100644
--- a/actix-http/src/body/utils.rs
+++ b/actix-http/src/body/utils.rs
@@ -38,7 +38,7 @@ pub async fn to_bytes<B: MessageBody>(body: B) -> Result<Bytes, B::Error> {
 
 /// Error type returned from [`to_bytes_limited`] when body produced exceeds limit.
 #[derive(Debug, Display, Error)]
-#[display(fmt = "limit exceeded while collecting body bytes")]
+#[display("limit exceeded while collecting body bytes")]
 #[non_exhaustive]
 pub struct BodyLimitExceeded;
 
@@ -190,7 +190,7 @@ mod tests {
 
     #[actix_rt::test]
     async fn to_body_limit_error() {
-        let err_stream = stream::once(async { Err(io::Error::new(io::ErrorKind::Other, "")) });
+        let err_stream = stream::once(async { Err(io::Error::other("")) });
         let body = SizedStream::new(8, err_stream);
         // not too big, but propagates error from body stream
         assert!(to_bytes_limited(body, 10).await.unwrap().is_err());
diff --git a/actix-http/src/builder.rs b/actix-http/src/builder.rs
index 916083a98..09b379e87 100644
--- a/actix-http/src/builder.rs
+++ b/actix-http/src/builder.rs
@@ -7,7 +7,7 @@ use crate::{
     body::{BoxBody, MessageBody},
     h1::{self, ExpectHandler, H1Service, UpgradeHandler},
     service::HttpService,
-    ConnectCallback, Extensions, KeepAlive, Request, Response, ServiceConfig,
+    ConnectCallback, Extensions, KeepAlive, Request, Response, ServiceConfigBuilder,
 };
 
 /// An HTTP service builder.
@@ -19,6 +19,7 @@ pub struct HttpServiceBuilder<T, S, X = ExpectHandler, U = UpgradeHandler> {
     client_disconnect_timeout: Duration,
     secure: bool,
     local_addr: Option<net::SocketAddr>,
+    h1_allow_half_closed: bool,
     expect: X,
     upgrade: Option<U>,
     on_connect_ext: Option<Rc<ConnectCallback<T>>>,
@@ -40,6 +41,7 @@ where
             client_disconnect_timeout: Duration::ZERO,
             secure: false,
             local_addr: None,
+            h1_allow_half_closed: true,
 
             // dispatcher parts
             expect: ExpectHandler,
@@ -124,6 +126,18 @@ where
         self.client_disconnect_timeout(dur)
     }
 
+    /// Sets whether HTTP/1 connections should support half-closures.
+    ///
+    /// Clients can choose to shutdown their writer-side of the connection after completing their
+    /// request and while waiting for the server response. Setting this to `false` will cause the
+    /// server to abort the connection handling as soon as it detects an EOF from the client.
+    ///
+    /// The default behavior is to allow, i.e. `true`
+    pub fn h1_allow_half_closed(mut self, allow: bool) -> Self {
+        self.h1_allow_half_closed = allow;
+        self
+    }
+
     /// Provide service for `EXPECT: 100-Continue` support.
     ///
     /// Service get called with request that contains `EXPECT` header.
@@ -142,6 +156,7 @@ where
             client_disconnect_timeout: self.client_disconnect_timeout,
             secure: self.secure,
             local_addr: self.local_addr,
+            h1_allow_half_closed: self.h1_allow_half_closed,
             expect: expect.into_factory(),
             upgrade: self.upgrade,
             on_connect_ext: self.on_connect_ext,
@@ -166,6 +181,7 @@ where
             client_disconnect_timeout: self.client_disconnect_timeout,
             secure: self.secure,
             local_addr: self.local_addr,
+            h1_allow_half_closed: self.h1_allow_half_closed,
             expect: self.expect,
             upgrade: Some(upgrade.into_factory()),
             on_connect_ext: self.on_connect_ext,
@@ -195,13 +211,14 @@ where
         S::InitError: fmt::Debug,
         S::Response: Into<Response<B>>,
     {
-        let cfg = ServiceConfig::new(
-            self.keep_alive,
-            self.client_request_timeout,
-            self.client_disconnect_timeout,
-            self.secure,
-            self.local_addr,
-        );
+        let cfg = ServiceConfigBuilder::new()
+            .keep_alive(self.keep_alive)
+            .client_request_timeout(self.client_request_timeout)
+            .client_disconnect_timeout(self.client_disconnect_timeout)
+            .secure(self.secure)
+            .local_addr(self.local_addr)
+            .h1_allow_half_closed(self.h1_allow_half_closed)
+            .build();
 
         H1Service::with_config(cfg, service.into_factory())
             .expect(self.expect)
@@ -220,13 +237,14 @@ where
 
         B: MessageBody + 'static,
     {
-        let cfg = ServiceConfig::new(
-            self.keep_alive,
-            self.client_request_timeout,
-            self.client_disconnect_timeout,
-            self.secure,
-            self.local_addr,
-        );
+        let cfg = ServiceConfigBuilder::new()
+            .keep_alive(self.keep_alive)
+            .client_request_timeout(self.client_request_timeout)
+            .client_disconnect_timeout(self.client_disconnect_timeout)
+            .secure(self.secure)
+            .local_addr(self.local_addr)
+            .h1_allow_half_closed(self.h1_allow_half_closed)
+            .build();
 
         crate::h2::H2Service::with_config(cfg, service.into_factory())
             .on_connect_ext(self.on_connect_ext)
@@ -242,13 +260,14 @@ where
 
         B: MessageBody + 'static,
     {
-        let cfg = ServiceConfig::new(
-            self.keep_alive,
-            self.client_request_timeout,
-            self.client_disconnect_timeout,
-            self.secure,
-            self.local_addr,
-        );
+        let cfg = ServiceConfigBuilder::new()
+            .keep_alive(self.keep_alive)
+            .client_request_timeout(self.client_request_timeout)
+            .client_disconnect_timeout(self.client_disconnect_timeout)
+            .secure(self.secure)
+            .local_addr(self.local_addr)
+            .h1_allow_half_closed(self.h1_allow_half_closed)
+            .build();
 
         HttpService::with_config(cfg, service.into_factory())
             .expect(self.expect)
diff --git a/actix-http/src/config.rs b/actix-http/src/config.rs
index b3b215da4..96e2aef07 100644
--- a/actix-http/src/config.rs
+++ b/actix-http/src/config.rs
@@ -1,5 +1,5 @@
 use std::{
-    net,
+    net::SocketAddr,
     rc::Rc,
     time::{Duration, Instant},
 };
@@ -8,8 +8,76 @@ use bytes::BytesMut;
 
 use crate::{date::DateService, KeepAlive};
 
+/// A builder for creating a [`ServiceConfig`]
+#[derive(Default, Debug)]
+pub struct ServiceConfigBuilder {
+    inner: Inner,
+}
+
+impl ServiceConfigBuilder {
+    /// Creates a new, default, [`ServiceConfigBuilder`]
+    ///
+    /// It uses the following default values:
+    ///
+    /// - [`KeepAlive::default`] for the connection keep-alive setting
+    /// - 5 seconds for the client request timeout
+    /// - 0 seconds for the client shutdown timeout
+    /// - secure value of `false`
+    /// - [`None`] for the local address setting
+    /// - Allow for half closed HTTP/1 connections
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Sets the `secure` attribute for this configuration
+    pub fn secure(mut self, secure: bool) -> Self {
+        self.inner.secure = secure;
+        self
+    }
+
+    /// Sets the local address for this configuration
+    pub fn local_addr(mut self, local_addr: Option<SocketAddr>) -> Self {
+        self.inner.local_addr = local_addr;
+        self
+    }
+
+    /// Sets connection keep-alive setting
+    pub fn keep_alive(mut self, keep_alive: KeepAlive) -> Self {
+        self.inner.keep_alive = keep_alive;
+        self
+    }
+
+    /// Sets the timeout for the client to finish sending the head of its first request
+    pub fn client_request_timeout(mut self, timeout: Duration) -> Self {
+        self.inner.client_request_timeout = timeout;
+        self
+    }
+
+    /// Sets the timeout for cleanly disconnecting from the client after connection shutdown has
+    /// started
+    pub fn client_disconnect_timeout(mut self, timeout: Duration) -> Self {
+        self.inner.client_disconnect_timeout = timeout;
+        self
+    }
+
+    /// Sets whether HTTP/1 connections should support half-closures.
+    ///
+    /// Clients can choose to shutdown their writer-side of the connection after completing their
+    /// request and while waiting for the server response. Setting this to `false` will cause the
+    /// server to abort the connection handling as soon as it detects an EOF from the client
+    pub fn h1_allow_half_closed(mut self, allow: bool) -> Self {
+        self.inner.h1_allow_half_closed = allow;
+        self
+    }
+
+    /// Builds a [`ServiceConfig`] from this [`ServiceConfigBuilder`] instance
+    pub fn build(self) -> ServiceConfig {
+        ServiceConfig(Rc::new(self.inner))
+    }
+}
+
 /// HTTP service configuration.
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Default)]
 pub struct ServiceConfig(Rc<Inner>);
 
 #[derive(Debug)]
@@ -18,19 +86,22 @@ struct Inner {
     client_request_timeout: Duration,
     client_disconnect_timeout: Duration,
     secure: bool,
-    local_addr: Option<std::net::SocketAddr>,
+    local_addr: Option<SocketAddr>,
     date_service: DateService,
+    h1_allow_half_closed: bool,
 }
 
-impl Default for ServiceConfig {
+impl Default for Inner {
     fn default() -> Self {
-        Self::new(
-            KeepAlive::default(),
-            Duration::from_secs(5),
-            Duration::ZERO,
-            false,
-            None,
-        )
+        Self {
+            keep_alive: KeepAlive::default(),
+            client_request_timeout: Duration::from_secs(5),
+            client_disconnect_timeout: Duration::ZERO,
+            secure: false,
+            local_addr: None,
+            date_service: DateService::new(),
+            h1_allow_half_closed: true,
+        }
     }
 }
 
@@ -41,7 +112,7 @@ impl ServiceConfig {
         client_request_timeout: Duration,
         client_disconnect_timeout: Duration,
         secure: bool,
-        local_addr: Option<net::SocketAddr>,
+        local_addr: Option<SocketAddr>,
     ) -> ServiceConfig {
         ServiceConfig(Rc::new(Inner {
             keep_alive: keep_alive.normalize(),
@@ -50,6 +121,7 @@ impl ServiceConfig {
             secure,
             local_addr,
             date_service: DateService::new(),
+            h1_allow_half_closed: true,
         }))
     }
 
@@ -63,7 +135,7 @@ impl ServiceConfig {
     ///
     /// Returns `None` for connections via UDS (Unix Domain Socket).
     #[inline]
-    pub fn local_addr(&self) -> Option<net::SocketAddr> {
+    pub fn local_addr(&self) -> Option<SocketAddr> {
         self.0.local_addr
     }
 
@@ -100,6 +172,15 @@ impl ServiceConfig {
         (timeout != Duration::ZERO).then(|| self.now() + timeout)
     }
 
+    /// Whether HTTP/1 connections should support half-closures.
+    ///
+    /// Clients can choose to shutdown their writer-side of the connection after completing their
+    /// request and while waiting for the server response. If this configuration is `false`, the
+    /// server will abort the connection handling as soon as it detects an EOF from the client
+    pub fn h1_allow_half_closed(&self) -> bool {
+        self.0.h1_allow_half_closed
+    }
+
     pub(crate) fn now(&self) -> Instant {
         self.0.date_service.now()
     }
diff --git a/actix-http/src/encoding/decoder.rs b/actix-http/src/encoding/decoder.rs
index cda534d60..1247c0a55 100644
--- a/actix-http/src/encoding/decoder.rs
+++ b/actix-http/src/encoding/decoder.rs
@@ -100,10 +100,7 @@ where
         loop {
             if let Some(ref mut fut) = this.fut {
                 let (chunk, decoder) = ready!(Pin::new(fut).poll(cx)).map_err(|_| {
-                    PayloadError::Io(io::Error::new(
-                        io::ErrorKind::Other,
-                        "Blocking task was cancelled unexpectedly",
-                    ))
+                    PayloadError::Io(io::Error::other("Blocking task was cancelled unexpectedly"))
                 })??;
 
                 *this.decoder = Some(decoder);
diff --git a/actix-http/src/encoding/encoder.rs b/actix-http/src/encoding/encoder.rs
index 180927ac6..0da95c462 100644
--- a/actix-http/src/encoding/encoder.rs
+++ b/actix-http/src/encoding/encoder.rs
@@ -183,8 +183,7 @@ where
             if let Some(ref mut fut) = this.fut {
                 let mut encoder = ready!(Pin::new(fut).poll(cx))
                     .map_err(|_| {
-                        EncoderError::Io(io::Error::new(
-                            io::ErrorKind::Other,
+                        EncoderError::Io(io::Error::other(
                             "Blocking task was cancelled unexpectedly",
                         ))
                     })?
@@ -415,11 +414,11 @@ fn new_brotli_compressor() -> Box<brotli::CompressorWriter<Writer>> {
 #[non_exhaustive]
 pub enum EncoderError {
     /// Wrapped body stream error.
-    #[display(fmt = "body")]
+    #[display("body")]
     Body(Box<dyn StdError>),
 
     /// Generic I/O error.
-    #[display(fmt = "io")]
+    #[display("io")]
     Io(io::Error),
 }
 
diff --git a/actix-http/src/error.rs b/actix-http/src/error.rs
index 6f332118e..e4d640518 100644
--- a/actix-http/src/error.rs
+++ b/actix-http/src/error.rs
@@ -80,28 +80,28 @@ impl From<Error> for Response<BoxBody> {
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Display)]
 pub(crate) enum Kind {
-    #[display(fmt = "error processing HTTP")]
+    #[display("error processing HTTP")]
     Http,
 
-    #[display(fmt = "error parsing HTTP message")]
+    #[display("error parsing HTTP message")]
     Parse,
 
-    #[display(fmt = "request payload read error")]
+    #[display("request payload read error")]
     Payload,
 
-    #[display(fmt = "response body write error")]
+    #[display("response body write error")]
     Body,
 
-    #[display(fmt = "send response error")]
+    #[display("send response error")]
     SendResponse,
 
-    #[display(fmt = "error in WebSocket process")]
+    #[display("error in WebSocket process")]
     Ws,
 
-    #[display(fmt = "connection error")]
+    #[display("connection error")]
     Io,
 
-    #[display(fmt = "encoder error")]
+    #[display("encoder error")]
     Encoder,
 }
 
@@ -160,44 +160,44 @@ impl From<crate::ws::ProtocolError> for Error {
 #[non_exhaustive]
 pub enum ParseError {
     /// An invalid `Method`, such as `GE.T`.
-    #[display(fmt = "invalid method specified")]
+    #[display("invalid method specified")]
     Method,
 
     /// An invalid `Uri`, such as `exam ple.domain`.
-    #[display(fmt = "URI error: {}", _0)]
+    #[display("URI error: {}", _0)]
     Uri(InvalidUri),
 
     /// An invalid `HttpVersion`, such as `HTP/1.1`
-    #[display(fmt = "invalid HTTP version specified")]
+    #[display("invalid HTTP version specified")]
     Version,
 
     /// An invalid `Header`.
-    #[display(fmt = "invalid Header provided")]
+    #[display("invalid Header provided")]
     Header,
 
     /// A message head is too large to be reasonable.
-    #[display(fmt = "message head is too large")]
+    #[display("message head is too large")]
     TooLarge,
 
     /// A message reached EOF, but is not complete.
-    #[display(fmt = "message is incomplete")]
+    #[display("message is incomplete")]
     Incomplete,
 
     /// An invalid `Status`, such as `1337 ELITE`.
-    #[display(fmt = "invalid status provided")]
+    #[display("invalid status provided")]
     Status,
 
     /// A timeout occurred waiting for an IO event.
     #[allow(dead_code)]
-    #[display(fmt = "timeout")]
+    #[display("timeout")]
     Timeout,
 
     /// An I/O error that occurred while trying to read or write to a network stream.
-    #[display(fmt = "I/O error: {}", _0)]
+    #[display("I/O error: {}", _0)]
     Io(io::Error),
 
     /// Parsing a field as string failed.
-    #[display(fmt = "UTF-8 error: {}", _0)]
+    #[display("UTF-8 error: {}", _0)]
     Utf8(Utf8Error),
 }
 
@@ -256,28 +256,28 @@ impl From<ParseError> for Response<BoxBody> {
 #[non_exhaustive]
 pub enum PayloadError {
     /// A payload reached EOF, but is not complete.
-    #[display(fmt = "payload reached EOF before completing: {:?}", _0)]
+    #[display("payload reached EOF before completing: {:?}", _0)]
     Incomplete(Option<io::Error>),
 
     /// Content encoding stream corruption.
-    #[display(fmt = "can not decode content-encoding")]
+    #[display("can not decode content-encoding")]
     EncodingCorrupted,
 
     /// Payload reached size limit.
-    #[display(fmt = "payload reached size limit")]
+    #[display("payload reached size limit")]
     Overflow,
 
     /// Payload length is unknown.
-    #[display(fmt = "payload length is unknown")]
+    #[display("payload length is unknown")]
     UnknownLength,
 
     /// HTTP/2 payload error.
     #[cfg(feature = "http2")]
-    #[display(fmt = "{}", _0)]
+    #[display("{}", _0)]
     Http2Payload(::h2::Error),
 
     /// Generic I/O error.
-    #[display(fmt = "{}", _0)]
+    #[display("{}", _0)]
     Io(io::Error),
 }
 
@@ -326,44 +326,44 @@ impl From<PayloadError> for Error {
 #[non_exhaustive]
 pub enum DispatchError {
     /// Service error.
-    #[display(fmt = "service error")]
+    #[display("service error")]
     Service(Response<BoxBody>),
 
     /// Body streaming error.
-    #[display(fmt = "body error: {}", _0)]
+    #[display("body error: {}", _0)]
     Body(Box<dyn StdError>),
 
     /// Upgrade service error.
-    #[display(fmt = "upgrade error")]
+    #[display("upgrade error")]
     Upgrade,
 
     /// An `io::Error` that occurred while trying to read or write to a network stream.
-    #[display(fmt = "I/O error: {}", _0)]
+    #[display("I/O error: {}", _0)]
     Io(io::Error),
 
     /// Request parse error.
-    #[display(fmt = "request parse error: {}", _0)]
+    #[display("request parse error: {}", _0)]
     Parse(ParseError),
 
     /// HTTP/2 error.
-    #[display(fmt = "{}", _0)]
+    #[display("{}", _0)]
     #[cfg(feature = "http2")]
     H2(h2::Error),
 
     /// The first request did not complete within the specified timeout.
-    #[display(fmt = "request did not complete within the specified timeout")]
+    #[display("request did not complete within the specified timeout")]
     SlowRequestTimeout,
 
     /// Disconnect timeout. Makes sense for TLS streams.
-    #[display(fmt = "connection shutdown timeout")]
+    #[display("connection shutdown timeout")]
     DisconnectTimeout,
 
     /// Handler dropped payload before reading EOF.
-    #[display(fmt = "handler dropped payload before reading EOF")]
+    #[display("handler dropped payload before reading EOF")]
     HandlerDroppedPayload,
 
     /// Internal error.
-    #[display(fmt = "internal error")]
+    #[display("internal error")]
     InternalError,
 }
 
@@ -389,11 +389,11 @@ impl StdError for DispatchError {
 #[non_exhaustive]
 pub enum ContentTypeError {
     /// Can not parse content type.
-    #[display(fmt = "could not parse content type")]
+    #[display("could not parse content type")]
     ParseError,
 
     /// Unknown content encoding.
-    #[display(fmt = "unknown content encoding")]
+    #[display("unknown content encoding")]
     UnknownEncoding,
 }
 
@@ -415,7 +415,7 @@ mod tests {
 
     #[test]
     fn test_as_response() {
-        let orig = io::Error::new(io::ErrorKind::Other, "other");
+        let orig = io::Error::other("other");
         let err: Error = ParseError::Io(orig).into();
         assert_eq!(
             format!("{}", err),
@@ -425,14 +425,14 @@ mod tests {
 
     #[test]
     fn test_error_display() {
-        let orig = io::Error::new(io::ErrorKind::Other, "other");
+        let orig = io::Error::other("other");
         let err = Error::new_io().with_cause(orig);
         assert_eq!("connection error: other", err.to_string());
     }
 
     #[test]
     fn test_error_http_response() {
-        let orig = io::Error::new(io::ErrorKind::Other, "other");
+        let orig = io::Error::other("other");
         let err = Error::new_io().with_cause(orig);
         let resp: Response<BoxBody> = err.into();
         assert_eq!(resp.status(), StatusCode::INTERNAL_SERVER_ERROR);
@@ -440,7 +440,7 @@ mod tests {
 
     #[test]
     fn test_payload_error() {
-        let err: PayloadError = io::Error::new(io::ErrorKind::Other, "ParseError").into();
+        let err: PayloadError = io::Error::other("ParseError").into();
         assert!(err.to_string().contains("ParseError"));
 
         let err = PayloadError::Incomplete(None);
@@ -475,7 +475,7 @@ mod tests {
 
     #[test]
     fn test_from() {
-        from_and_cause!(io::Error::new(io::ErrorKind::Other, "other") => ParseError::Io(..));
+        from_and_cause!(io::Error::other("other") => ParseError::Io(..));
         from!(httparse::Error::HeaderName => ParseError::Header);
         from!(httparse::Error::HeaderName => ParseError::Header);
         from!(httparse::Error::HeaderValue => ParseError::Header);
diff --git a/actix-http/src/extensions.rs b/actix-http/src/extensions.rs
index f2047a9ce..9c85caf37 100644
--- a/actix-http/src/extensions.rs
+++ b/actix-http/src/extensions.rs
@@ -31,7 +31,7 @@ impl Hasher for NoOpHasher {
 /// All entries into this map must be owned types (or static references).
 #[derive(Default)]
 pub struct Extensions {
-    /// Use AHasher with a std HashMap with for faster lookups on the small `TypeId` keys.
+    // use no-op hasher with a std HashMap with for faster lookups on the small `TypeId` keys
     map: HashMap<TypeId, Box<dyn Any>, BuildHasherDefault<NoOpHasher>>,
 }
 
@@ -104,6 +104,46 @@ impl Extensions {
             .and_then(|boxed| boxed.downcast_mut())
     }
 
+    /// Inserts the given `value` into the extensions if it is not present, then returns a reference
+    /// to the value in the extensions.
+    ///
+    /// ```
+    /// # use actix_http::Extensions;
+    /// let mut map = Extensions::new();
+    /// assert_eq!(map.get::<Vec<u32>>(), None);
+    ///
+    /// map.get_or_insert(Vec::<u32>::new()).push(1);
+    /// assert_eq!(map.get::<Vec<u32>>(), Some(&vec![1]));
+    ///
+    /// map.get_or_insert(Vec::<u32>::new()).push(2);
+    /// assert_eq!(map.get::<Vec<u32>>(), Some(&vec![1,2]));
+    /// ```
+    pub fn get_or_insert<T: 'static>(&mut self, value: T) -> &mut T {
+        self.get_or_insert_with(|| value)
+    }
+
+    /// Inserts a value computed from `f` into the extensions if the given `value` is not present,
+    /// then returns a reference to the value in the extensions.
+    ///
+    /// ```
+    /// # use actix_http::Extensions;
+    /// let mut map = Extensions::new();
+    /// assert_eq!(map.get::<Vec<u32>>(), None);
+    ///
+    /// map.get_or_insert_with(Vec::<u32>::new).push(1);
+    /// assert_eq!(map.get::<Vec<u32>>(), Some(&vec![1]));
+    ///
+    /// map.get_or_insert_with(Vec::<u32>::new).push(2);
+    /// assert_eq!(map.get::<Vec<u32>>(), Some(&vec![1,2]));
+    /// ```
+    pub fn get_or_insert_with<T: 'static, F: FnOnce() -> T>(&mut self, default: F) -> &mut T {
+        self.map
+            .entry(TypeId::of::<T>())
+            .or_insert_with(|| Box::new(default()))
+            .downcast_mut()
+            .expect("extensions map should now contain a T value")
+    }
+
     /// Remove an item from the map of a given type.
     ///
     /// If an item of this type was already stored, it will be returned.
diff --git a/actix-http/src/h1/dispatcher.rs b/actix-http/src/h1/dispatcher.rs
index 00b51360e..03851d0fb 100644
--- a/actix-http/src/h1/dispatcher.rs
+++ b/actix-http/src/h1/dispatcher.rs
@@ -386,7 +386,14 @@ where
         let mut this = self.project();
         this.state.set(match size {
             BodySize::None | BodySize::Sized(0) => {
-                this.flags.insert(Flags::FINISHED);
+                let payload_unfinished = this.payload.is_some();
+
+                if payload_unfinished {
+                    this.flags.insert(Flags::SHUTDOWN | Flags::FINISHED);
+                } else {
+                    this.flags.insert(Flags::FINISHED);
+                }
+
                 State::None
             }
             _ => State::SendPayload { body },
@@ -404,7 +411,14 @@ where
         let mut this = self.project();
         this.state.set(match size {
             BodySize::None | BodySize::Sized(0) => {
-                this.flags.insert(Flags::FINISHED);
+                let payload_unfinished = this.payload.is_some();
+
+                if payload_unfinished {
+                    this.flags.insert(Flags::SHUTDOWN | Flags::FINISHED);
+                } else {
+                    this.flags.insert(Flags::FINISHED);
+                }
+
                 State::None
             }
             _ => State::SendErrorPayload { body },
@@ -503,10 +517,22 @@ where
                             Poll::Ready(None) => {
                                 this.codec.encode(Message::Chunk(None), this.write_buf)?;
 
+                                // if we have not yet pipelined to the next request, then
+                                // this.payload was the payload for the request we just finished
+                                // responding to. We can check to see if we finished reading it
+                                // yet, and if not, shutdown the connection.
+                                let payload_unfinished = this.payload.is_some();
+                                let not_pipelined = this.messages.is_empty();
+
                                 // payload stream finished.
                                 // set state to None and handle next message
                                 this.state.set(State::None);
-                                this.flags.insert(Flags::FINISHED);
+
+                                if not_pipelined && payload_unfinished {
+                                    this.flags.insert(Flags::SHUTDOWN | Flags::FINISHED);
+                                } else {
+                                    this.flags.insert(Flags::FINISHED);
+                                }
 
                                 continue 'res;
                             }
@@ -542,10 +568,22 @@ where
                             Poll::Ready(None) => {
                                 this.codec.encode(Message::Chunk(None), this.write_buf)?;
 
-                                // payload stream finished
+                                // if we have not yet pipelined to the next request, then
+                                // this.payload was the payload for the request we just finished
+                                // responding to. We can check to see if we finished reading it
+                                // yet, and if not, shutdown the connection.
+                                let payload_unfinished = this.payload.is_some();
+                                let not_pipelined = this.messages.is_empty();
+
+                                // payload stream finished.
                                 // set state to None and handle next message
                                 this.state.set(State::None);
-                                this.flags.insert(Flags::FINISHED);
+
+                                if not_pipelined && payload_unfinished {
+                                    this.flags.insert(Flags::SHUTDOWN | Flags::FINISHED);
+                                } else {
+                                    this.flags.insert(Flags::FINISHED);
+                                }
 
                                 continue 'res;
                             }
@@ -1181,8 +1219,16 @@ where
                     let inner_p = inner.as_mut().project();
                     let state_is_none = inner_p.state.is_none();
 
-                    // read half is closed; we do not process any responses
-                    if inner_p.flags.contains(Flags::READ_DISCONNECT) && state_is_none {
+                    // If the read-half is closed, we start the shutdown procedure if either is
+                    // true:
+                    //
+                    // - state is [`State::None`], which means that we're done with request
+                    //   processing, so if the client closed its writer-side it means that it won't
+                    //   send more requests.
+                    // - The user requested to not allow half-closures
+                    if inner_p.flags.contains(Flags::READ_DISCONNECT)
+                        && (!inner_p.config.h1_allow_half_closed() || state_is_none)
+                    {
                         trace!("read half closed; start shutdown");
                         inner_p.flags.insert(Flags::SHUTDOWN);
                     }
@@ -1216,6 +1262,9 @@ where
                         inner_p.shutdown_timer,
                     );
 
+                    if inner_p.flags.contains(Flags::SHUTDOWN) {
+                        cx.waker().wake_by_ref();
+                    }
                     Poll::Pending
                 };
 
diff --git a/actix-http/src/h1/dispatcher_tests.rs b/actix-http/src/h1/dispatcher_tests.rs
index 50259e6ce..49582ad8a 100644
--- a/actix-http/src/h1/dispatcher_tests.rs
+++ b/actix-http/src/h1/dispatcher_tests.rs
@@ -1,4 +1,10 @@
-use std::{future::Future, str, task::Poll, time::Duration};
+use std::{
+    future::Future,
+    pin::Pin,
+    str,
+    task::{Context, Poll},
+    time::Duration,
+};
 
 use actix_codec::Framed;
 use actix_rt::{pin, time::sleep};
@@ -9,7 +15,7 @@ use futures_util::future::lazy;
 
 use super::dispatcher::{Dispatcher, DispatcherState, DispatcherStateProj, Flags};
 use crate::{
-    body::MessageBody,
+    body::{BoxBody, MessageBody},
     config::ServiceConfig,
     h1::{Codec, ExpectHandler, UpgradeHandler},
     service::HttpFlow,
@@ -17,6 +23,26 @@ use crate::{
     Error, HttpMessage, KeepAlive, Method, OnConnectData, Request, Response, StatusCode,
 };
 
+struct YieldService;
+
+impl Service<Request> for YieldService {
+    type Response = Response<BoxBody>;
+    type Error = Response<BoxBody>;
+    type Future = Pin<Box<dyn Future<Output = Result<Self::Response, Self::Error>>>>;
+
+    actix_service::always_ready!();
+
+    fn call(&self, _: Request) -> Self::Future {
+        Box::pin(async {
+            // Yield twice because the dispatcher can poll the service twice per dispatcher's poll:
+            // once in `handle_request` and another in `poll_response`
+            actix_rt::task::yield_now().await;
+            actix_rt::task::yield_now().await;
+            Ok(Response::ok())
+        })
+    }
+}
+
 fn find_slice(haystack: &[u8], needle: &[u8], from: usize) -> Option<usize> {
     memchr::memmem::find(&haystack[from..], needle)
 }
@@ -509,6 +535,73 @@ async fn pipelining_ok_then_ok() {
     .await;
 }
 
+#[actix_rt::test]
+async fn early_response_with_payload_closes_connection() {
+    lazy(|cx| {
+        let buf = TestBuffer::new(
+            "\
+                GET /unfinished HTTP/1.1\r\n\
+                Content-Length: 2\r\n\
+                \r\n\
+                ",
+        );
+
+        let cfg = ServiceConfig::new(
+            KeepAlive::Os,
+            Duration::from_millis(1),
+            Duration::from_millis(1),
+            false,
+            None,
+        );
+
+        let services = HttpFlow::new(echo_path_service(), ExpectHandler, None);
+
+        let h1 = Dispatcher::<_, _, _, _, UpgradeHandler>::new(
+            buf.clone(),
+            services,
+            cfg,
+            None,
+            OnConnectData::default(),
+        );
+
+        pin!(h1);
+
+        assert!(matches!(&h1.inner, DispatcherState::Normal { .. }));
+
+        match h1.as_mut().poll(cx) {
+            Poll::Pending => panic!("Should have shut down"),
+            Poll::Ready(res) => assert!(res.is_ok()),
+        }
+
+        // polls: initial => shutdown
+        assert_eq!(h1.poll_count, 2);
+
+        {
+            let mut res = buf.write_buf_slice_mut();
+            stabilize_date_header(&mut res);
+            let res = &res[..];
+
+            let exp = b"\
+                HTTP/1.1 200 OK\r\n\
+                content-length: 11\r\n\
+                date: Thu, 01 Jan 1970 12:34:56 UTC\r\n\r\n\
+                /unfinished\
+                ";
+
+            assert_eq!(
+                res,
+                exp,
+                "\nexpected response not in write buffer:\n\
+               response: {:?}\n\
+               expected: {:?}",
+                String::from_utf8_lossy(res),
+                String::from_utf8_lossy(exp)
+            );
+        }
+    })
+    .await;
+}
+
 #[actix_rt::test]
 async fn pipelining_ok_then_bad() {
     lazy(|cx| {
@@ -924,6 +1017,91 @@ async fn handler_drop_payload() {
     .await;
 }
 
+#[actix_rt::test]
+async fn allow_half_closed() {
+    let buf = TestSeqBuffer::new(http_msg("GET / HTTP/1.1"));
+    buf.close_read();
+    let services = HttpFlow::new(YieldService, ExpectHandler, None::<UpgradeHandler>);
+
+    let mut cx = Context::from_waker(futures_util::task::noop_waker_ref());
+    let disptacher = Dispatcher::new(
+        buf.clone(),
+        services,
+        ServiceConfig::default(),
+        None,
+        OnConnectData::default(),
+    );
+    pin!(disptacher);
+
+    assert!(disptacher.as_mut().poll(&mut cx).is_pending());
+    assert_eq!(disptacher.poll_count, 1);
+
+    assert!(disptacher.as_mut().poll(&mut cx).is_ready());
+    assert_eq!(disptacher.poll_count, 3);
+
+    let mut res = BytesMut::from(buf.take_write_buf().as_ref());
+    stabilize_date_header(&mut res);
+    let exp = http_msg(
+        r"
+        HTTP/1.1 200 OK
+        content-length: 0
+        date: Thu, 01 Jan 1970 12:34:56 UTC
+        ",
+    );
+    assert_eq!(
+        res,
+        exp,
+        "\nexpected response not in write buffer:\n\
+               response: {:?}\n\
+               expected: {:?}",
+        String::from_utf8_lossy(&res),
+        String::from_utf8_lossy(&exp)
+    );
+
+    let DispatcherStateProj::Normal { inner } = disptacher.as_mut().project().inner.project()
+    else {
+        panic!("End dispatcher state should be Normal");
+    };
+    assert!(inner.state.is_none());
+}
+
+#[actix_rt::test]
+async fn disallow_half_closed() {
+    use crate::{config::ServiceConfigBuilder, h1::dispatcher::State};
+
+    let buf = TestSeqBuffer::new(http_msg("GET / HTTP/1.1"));
+    buf.close_read();
+    let services = HttpFlow::new(YieldService, ExpectHandler, None::<UpgradeHandler>);
+    let config = ServiceConfigBuilder::new()
+        .h1_allow_half_closed(false)
+        .build();
+
+    let mut cx = Context::from_waker(futures_util::task::noop_waker_ref());
+    let disptacher = Dispatcher::new(
+        buf.clone(),
+        services,
+        config,
+        None,
+        OnConnectData::default(),
+    );
+    pin!(disptacher);
+
+    assert!(disptacher.as_mut().poll(&mut cx).is_pending());
+    assert_eq!(disptacher.poll_count, 1);
+
+    assert!(disptacher.as_mut().poll(&mut cx).is_ready());
+    assert_eq!(disptacher.poll_count, 2);
+
+    let res = BytesMut::from(buf.take_write_buf().as_ref());
+    assert!(res.is_empty());
+
+    let DispatcherStateProj::Normal { inner } = disptacher.as_mut().project().inner.project()
+    else {
+        panic!("End dispatcher state should be Normal");
+    };
+    assert!(matches!(inner.state, State::ServiceCall { .. }))
+}
+
 fn http_msg(msg: impl AsRef<str>) -> BytesMut {
     let mut msg = msg
         .as_ref()
diff --git a/actix-http/src/h1/encoder.rs b/actix-http/src/h1/encoder.rs
index abe396ce2..81af7868b 100644
--- a/actix-http/src/h1/encoder.rs
+++ b/actix-http/src/h1/encoder.rs
@@ -310,10 +310,10 @@ impl MessageType for RequestHeadType {
                 Version::HTTP_11 => "HTTP/1.1",
                 Version::HTTP_2 => "HTTP/2.0",
                 Version::HTTP_3 => "HTTP/3.0",
-                _ => return Err(io::Error::new(io::ErrorKind::Other, "unsupported version")),
+                _ => return Err(io::Error::other("Unsupported version")),
             }
         )
-        .map_err(|e| io::Error::new(io::ErrorKind::Other, e))
+        .map_err(io::Error::other)
     }
 }
 
@@ -433,7 +433,7 @@ impl TransferEncoding {
                     buf.extend_from_slice(b"0\r\n\r\n");
                 } else {
                     writeln!(helpers::MutWriter(buf), "{:X}\r", msg.len())
-                        .map_err(|e| io::Error::new(io::ErrorKind::Other, e))?;
+                        .map_err(io::Error::other)?;
 
                     buf.reserve(msg.len() + 2);
                     buf.extend_from_slice(msg);
diff --git a/actix-http/src/h1/payload.rs b/actix-http/src/h1/payload.rs
index 2ad3a14a3..d478c677a 100644
--- a/actix-http/src/h1/payload.rs
+++ b/actix-http/src/h1/payload.rs
@@ -200,11 +200,13 @@ impl Inner {
     #[inline]
     fn set_error(&mut self, err: PayloadError) {
         self.err = Some(err);
+        self.wake();
     }
 
     #[inline]
     fn feed_eof(&mut self) {
         self.eof = true;
+        self.wake();
     }
 
     #[inline]
@@ -253,8 +255,13 @@ impl Inner {
 
 #[cfg(test)]
 mod tests {
+    use std::{task::Poll, time::Duration};
+
+    use actix_rt::time::timeout;
     use actix_utils::future::poll_fn;
+    use futures_util::{FutureExt, StreamExt};
     use static_assertions::{assert_impl_all, assert_not_impl_any};
+    use tokio::sync::oneshot;
 
     use super::*;
 
@@ -263,6 +270,67 @@ mod tests {
 
     assert_impl_all!(Inner: Unpin, Send, Sync);
 
+    const WAKE_TIMEOUT: Duration = Duration::from_secs(2);
+
+    fn prepare_waking_test(
+        mut payload: Payload,
+        expected: Option<Result<(), ()>>,
+    ) -> (oneshot::Receiver<()>, actix_rt::task::JoinHandle<()>) {
+        let (tx, rx) = oneshot::channel();
+
+        let handle = actix_rt::spawn(async move {
+            // Make sure to poll once to set the waker
+            poll_fn(|cx| {
+                assert!(payload.poll_next_unpin(cx).is_pending());
+                Poll::Ready(())
+            })
+            .await;
+            tx.send(()).unwrap();
+
+            // actix-rt is single-threaded, so this won't race with `rx.await`
+            let mut pend_once = false;
+            poll_fn(|_| {
+                if pend_once {
+                    Poll::Ready(())
+                } else {
+                    // Return pending without storing wakers, we already did on the previous
+                    // `poll_fn`, now this task will only continue if the `sender` wakes us
+                    pend_once = true;
+                    Poll::Pending
+                }
+            })
+            .await;
+
+            let got = payload.next().now_or_never().unwrap();
+            match expected {
+                Some(Ok(_)) => assert!(got.unwrap().is_ok()),
+                Some(Err(_)) => assert!(got.unwrap().is_err()),
+                None => assert!(got.is_none()),
+            }
+        });
+        (rx, handle)
+    }
+
+    #[actix_rt::test]
+    async fn wake_on_error() {
+        let (mut sender, payload) = Payload::create(false);
+        let (rx, handle) = prepare_waking_test(payload, Some(Err(())));
+
+        rx.await.unwrap();
+        sender.set_error(PayloadError::Incomplete(None));
+        timeout(WAKE_TIMEOUT, handle).await.unwrap().unwrap();
+    }
+
+    #[actix_rt::test]
+    async fn wake_on_eof() {
+        let (mut sender, payload) = Payload::create(false);
+        let (rx, handle) = prepare_waking_test(payload, None);
+
+        rx.await.unwrap();
+        sender.feed_eof();
+        timeout(WAKE_TIMEOUT, handle).await.unwrap().unwrap();
+    }
+
     #[actix_rt::test]
     async fn test_unread_data() {
         let (_, mut payload) = Payload::create(false);
diff --git a/actix-http/src/h1/service.rs b/actix-http/src/h1/service.rs
index f2f8a0e48..2cf76edb2 100644
--- a/actix-http/src/h1/service.rs
+++ b/actix-http/src/h1/service.rs
@@ -480,15 +480,15 @@ where
         let cfg = self.cfg.clone();
 
         Box::pin(async move {
-            let expect = expect
-                .await
-                .map_err(|e| error!("Init http expect service error: {:?}", e))?;
+            let expect = expect.await.map_err(|err| {
+                tracing::error!("Initialization of HTTP expect service error: {err:?}");
+            })?;
 
             let upgrade = match upgrade {
                 Some(upgrade) => {
-                    let upgrade = upgrade
-                        .await
-                        .map_err(|e| error!("Init http upgrade service error: {:?}", e))?;
+                    let upgrade = upgrade.await.map_err(|err| {
+                        tracing::error!("Initialization of HTTP upgrade service error: {err:?}");
+                    })?;
                     Some(upgrade)
                 }
                 None => None,
@@ -496,7 +496,7 @@ where
 
             let service = service
                 .await
-                .map_err(|e| error!("Init http service error: {:?}", e))?;
+                .map_err(|err| error!("Initialization of HTTP service error: {err:?}"))?;
 
             Ok(H1ServiceHandler::new(
                 cfg,
@@ -541,6 +541,6 @@ where
 
     fn call(&self, (io, addr): (T, Option<net::SocketAddr>)) -> Self::Future {
         let conn_data = OnConnectData::from_io(&io, self.on_connect_ext.as_deref());
-        Dispatcher::new(io, self.flow.clone(), self.cfg.clone(), addr, conn_data)
+        Dispatcher::new(io, Rc::clone(&self.flow), self.cfg.clone(), addr, conn_data)
     }
 }
diff --git a/actix-http/src/h2/service.rs b/actix-http/src/h2/service.rs
index 636ac3161..debc73e59 100644
--- a/actix-http/src/h2/service.rs
+++ b/actix-http/src/h2/service.rs
@@ -434,7 +434,7 @@ where
 
         H2ServiceHandlerResponse {
             state: State::Handshake(
-                Some(self.flow.clone()),
+                Some(Rc::clone(&self.flow)),
                 Some(self.cfg.clone()),
                 addr,
                 on_connect_data,
diff --git a/actix-http/src/header/common.rs b/actix-http/src/header/common.rs
index 6942dc26a..ebdd6708f 100644
--- a/actix-http/src/header/common.rs
+++ b/actix-http/src/header/common.rs
@@ -18,6 +18,14 @@ pub const CACHE_STATUS: HeaderName = HeaderName::from_static("cache-status");
 // TODO(breaking): replace with http's version
 pub const CDN_CACHE_CONTROL: HeaderName = HeaderName::from_static("cdn-cache-control");
 
+/// Response header field that sends a signal to the user agent that it ought to remove all data of
+/// a certain set of types.
+///
+/// See the [W3C Clear-Site-Data spec] for full semantics.
+///
+/// [W3C Clear-Site-Data spec]: https://www.w3.org/TR/clear-site-data/#header
+pub const CLEAR_SITE_DATA: HeaderName = HeaderName::from_static("clear-site-data");
+
 /// Response header that prevents a document from loading any cross-origin resources that don't
 /// explicitly grant the document permission (using [CORP] or [CORS]).
 ///
diff --git a/actix-http/src/header/map.rs b/actix-http/src/header/map.rs
index b86798a4c..a9a201e1a 100644
--- a/actix-http/src/header/map.rs
+++ b/actix-http/src/header/map.rs
@@ -2,7 +2,7 @@
 
 use std::{borrow::Cow, collections::hash_map, iter, ops};
 
-use ahash::AHashMap;
+use foldhash::{HashMap as FoldHashMap, HashMapExt as _};
 use http::header::{HeaderName, HeaderValue};
 use smallvec::{smallvec, SmallVec};
 
@@ -13,8 +13,9 @@ use super::AsHeaderName;
 /// `HeaderMap` is a "multi-map" of [`HeaderName`] to one or more [`HeaderValue`]s.
 ///
 /// # Examples
+///
 /// ```
-/// use actix_http::header::{self, HeaderMap, HeaderValue};
+/// # use actix_http::header::{self, HeaderMap, HeaderValue};
 ///
 /// let mut map = HeaderMap::new();
 ///
@@ -29,9 +30,24 @@ use super::AsHeaderName;
 ///
 /// assert!(!map.contains_key(header::ORIGIN));
 /// ```
+///
+/// Construct a header map using the [`FromIterator`] implementation. Note that it uses the append
+/// strategy, so duplicate header names are preserved.
+///
+/// ```
+/// use actix_http::header::{self, HeaderMap, HeaderValue};
+///
+/// let headers = HeaderMap::from_iter([
+///     (header::CONTENT_TYPE, HeaderValue::from_static("text/plain")),
+///     (header::COOKIE, HeaderValue::from_static("foo=1")),
+///     (header::COOKIE, HeaderValue::from_static("bar=1")),
+/// ]);
+///
+/// assert_eq!(headers.len(), 3);
+/// ```
 #[derive(Debug, Clone, Default)]
 pub struct HeaderMap {
-    pub(crate) inner: AHashMap<HeaderName, Value>,
+    pub(crate) inner: FoldHashMap<HeaderName, Value>,
 }
 
 /// A bespoke non-empty list for HeaderMap values.
@@ -100,7 +116,7 @@ impl HeaderMap {
     /// ```
     pub fn with_capacity(capacity: usize) -> Self {
         HeaderMap {
-            inner: AHashMap::with_capacity(capacity),
+            inner: FoldHashMap::with_capacity(capacity),
         }
     }
 
@@ -368,8 +384,8 @@ impl HeaderMap {
     /// let removed = map.insert(header::ACCEPT, HeaderValue::from_static("text/html"));
     /// assert!(!removed.is_empty());
     /// ```
-    pub fn insert(&mut self, key: HeaderName, val: HeaderValue) -> Removed {
-        let value = self.inner.insert(key, Value::one(val));
+    pub fn insert(&mut self, name: HeaderName, val: HeaderValue) -> Removed {
+        let value = self.inner.insert(name, Value::one(val));
         Removed::new(value)
     }
 
@@ -636,6 +652,16 @@ impl<'a> IntoIterator for &'a HeaderMap {
     }
 }
 
+impl FromIterator<(HeaderName, HeaderValue)> for HeaderMap {
+    fn from_iter<T: IntoIterator<Item = (HeaderName, HeaderValue)>>(iter: T) -> Self {
+        iter.into_iter()
+            .fold(Self::new(), |mut map, (name, value)| {
+                map.append(name, value);
+                map
+            })
+    }
+}
+
 /// Convert a `http::HeaderMap` to our `HeaderMap`.
 impl From<http::HeaderMap> for HeaderMap {
     fn from(mut map: http::HeaderMap) -> Self {
@@ -804,7 +830,7 @@ impl<'a> Drain<'a> {
     }
 }
 
-impl<'a> Iterator for Drain<'a> {
+impl Iterator for Drain<'_> {
     type Item = (Option<HeaderName>, HeaderValue);
 
     fn next(&mut self) -> Option<Self::Item> {
diff --git a/actix-http/src/header/mod.rs b/actix-http/src/header/mod.rs
index 79f91afef..b22c43f76 100644
--- a/actix-http/src/header/mod.rs
+++ b/actix-http/src/header/mod.rs
@@ -42,9 +42,9 @@ pub use self::{
     as_name::AsHeaderName,
     // re-export list is explicit so that any updates to `http` do not conflict with this set
     common::{
-        CACHE_STATUS, CDN_CACHE_CONTROL, CROSS_ORIGIN_EMBEDDER_POLICY, CROSS_ORIGIN_OPENER_POLICY,
-        CROSS_ORIGIN_RESOURCE_POLICY, PERMISSIONS_POLICY, X_FORWARDED_FOR, X_FORWARDED_HOST,
-        X_FORWARDED_PROTO,
+        CACHE_STATUS, CDN_CACHE_CONTROL, CLEAR_SITE_DATA, CROSS_ORIGIN_EMBEDDER_POLICY,
+        CROSS_ORIGIN_OPENER_POLICY, CROSS_ORIGIN_RESOURCE_POLICY, PERMISSIONS_POLICY,
+        X_FORWARDED_FOR, X_FORWARDED_HOST, X_FORWARDED_PROTO,
     },
     into_pair::TryIntoHeaderPair,
     into_value::TryIntoHeaderValue,
diff --git a/actix-http/src/header/shared/content_encoding.rs b/actix-http/src/header/shared/content_encoding.rs
index c3b4bc4c2..6c4cc9229 100644
--- a/actix-http/src/header/shared/content_encoding.rs
+++ b/actix-http/src/header/shared/content_encoding.rs
@@ -11,7 +11,7 @@ use crate::{
 
 /// Error returned when a content encoding is unknown.
 #[derive(Debug, Display, Error)]
-#[display(fmt = "unsupported content encoding")]
+#[display("unsupported content encoding")]
 pub struct ContentEncodingParseError;
 
 /// Represents a supported content encoding.
diff --git a/actix-http/src/header/shared/quality.rs b/actix-http/src/header/shared/quality.rs
index c2276cf1b..c9b6c2ae6 100644
--- a/actix-http/src/header/shared/quality.rs
+++ b/actix-http/src/header/shared/quality.rs
@@ -125,7 +125,7 @@ pub fn itoa_fmt<W: fmt::Write, V: itoa::Integer>(mut wr: W, value: V) -> fmt::Re
 }
 
 #[derive(Debug, Clone, Display, Error)]
-#[display(fmt = "quality out of bounds")]
+#[display("quality out of bounds")]
 #[non_exhaustive]
 pub struct QualityOutOfBounds;
 
diff --git a/actix-http/src/helpers.rs b/actix-http/src/helpers.rs
index 7f28018e7..61175bdc9 100644
--- a/actix-http/src/helpers.rs
+++ b/actix-http/src/helpers.rs
@@ -61,7 +61,7 @@ pub fn write_content_length<B: BufMut>(n: u64, buf: &mut B, camel_case: bool) {
 /// perform a remaining length check before writing.
 pub(crate) struct MutWriter<'a, B>(pub(crate) &'a mut B);
 
-impl<'a, B> io::Write for MutWriter<'a, B>
+impl<B> io::Write for MutWriter<'_, B>
 where
     B: BufMut,
 {
diff --git a/actix-http/src/http_message.rs b/actix-http/src/http_message.rs
index 3ba9ef752..2800f40ba 100644
--- a/actix-http/src/http_message.rs
+++ b/actix-http/src/http_message.rs
@@ -103,7 +103,7 @@ pub trait HttpMessage: Sized {
     }
 }
 
-impl<'a, T> HttpMessage for &'a mut T
+impl<T> HttpMessage for &mut T
 where
     T: HttpMessage,
 {
diff --git a/actix-http/src/lib.rs b/actix-http/src/lib.rs
index f9697c4d5..ae3713f20 100644
--- a/actix-http/src/lib.rs
+++ b/actix-http/src/lib.rs
@@ -6,10 +6,10 @@
 //! | ------------------- | ------------------------------------------- |
 //! | `http2`             | HTTP/2 support via [h2].                    |
 //! | `openssl`           | TLS support via [OpenSSL].                  |
-//! | `rustls`            | TLS support via [rustls]  0.20.             |
-//! | `rustls-0_21`       | TLS support via [rustls]  0.21.             |
-//! | `rustls-0_22`       | TLS support via [rustls]  0.22.             |
-//! | `rustls-0_23`       | TLS support via [rustls]  0.23.             |
+//! | `rustls-0_20`       | TLS support via rustls 0.20.                |
+//! | `rustls-0_21`       | TLS support via rustls 0.21.                |
+//! | `rustls-0_22`       | TLS support via rustls 0.22.                |
+//! | `rustls-0_23`       | TLS support via [rustls] 0.23.              |
 //! | `compress-brotli`   | Payload compression support: Brotli.        |
 //! | `compress-gzip`     | Payload compression support: Deflate, Gzip. |
 //! | `compress-zstd`     | Payload compression support: Zstd.          |
@@ -20,8 +20,6 @@
 //! [rustls]: https://crates.io/crates/rustls
 //! [trust-dns]: https://crates.io/crates/trust-dns
 
-#![deny(rust_2018_idioms, nonstandard_style)]
-#![warn(future_incompatible)]
 #![allow(
     clippy::type_complexity,
     clippy::too_many_arguments,
@@ -29,7 +27,7 @@
 )]
 #![doc(html_logo_url = "https://actix.rs/img/logo.png")]
 #![doc(html_favicon_url = "https://actix.rs/favicon.ico")]
-#![cfg_attr(docsrs, feature(doc_auto_cfg))]
+#![cfg_attr(docsrs, feature(doc_cfg))]
 
 pub use http::{uri, uri::Uri, Method, StatusCode, Version};
 
@@ -61,17 +59,11 @@ pub mod ws;
 
 #[allow(deprecated)]
 pub use self::payload::PayloadStream;
-#[cfg(any(
-    feature = "openssl",
-    feature = "rustls-0_20",
-    feature = "rustls-0_21",
-    feature = "rustls-0_22",
-    feature = "rustls-0_23",
-))]
+#[cfg(feature = "__tls")]
 pub use self::service::TlsAcceptorConfig;
 pub use self::{
     builder::HttpServiceBuilder,
-    config::ServiceConfig,
+    config::{ServiceConfig, ServiceConfigBuilder},
     error::Error,
     extensions::Extensions,
     header::ContentEncoding,
diff --git a/actix-http/src/message.rs b/actix-http/src/message.rs
index 47b128fd0..d2241b229 100644
--- a/actix-http/src/message.rs
+++ b/actix-http/src/message.rs
@@ -66,7 +66,7 @@ impl<T: Head> ops::DerefMut for Message<T> {
 
 impl<T: Head> Drop for Message<T> {
     fn drop(&mut self) {
-        T::with_pool(|p| p.release(self.head.clone()))
+        T::with_pool(|p| p.release(Rc::clone(&self.head)))
     }
 }
 
diff --git a/actix-http/src/payload.rs b/actix-http/src/payload.rs
index 7d476c55f..d7a52417e 100644
--- a/actix-http/src/payload.rs
+++ b/actix-http/src/payload.rs
@@ -41,13 +41,31 @@ pin_project! {
 }
 
 impl<S> From<crate::h1::Payload> for Payload<S> {
+    #[inline]
     fn from(payload: crate::h1::Payload) -> Self {
         Payload::H1 { payload }
     }
 }
 
+impl<S> From<Bytes> for Payload<S> {
+    #[inline]
+    fn from(bytes: Bytes) -> Self {
+        let (_, mut pl) = crate::h1::Payload::create(true);
+        pl.unread_data(bytes);
+        self::Payload::from(pl)
+    }
+}
+
+impl<S> From<Vec<u8>> for Payload<S> {
+    #[inline]
+    fn from(vec: Vec<u8>) -> Self {
+        Payload::from(Bytes::from(vec))
+    }
+}
+
 #[cfg(feature = "http2")]
 impl<S> From<crate::h2::Payload> for Payload<S> {
+    #[inline]
     fn from(payload: crate::h2::Payload) -> Self {
         Payload::H2 { payload }
     }
@@ -55,6 +73,7 @@ impl<S> From<crate::h2::Payload> for Payload<S> {
 
 #[cfg(feature = "http2")]
 impl<S> From<::h2::RecvStream> for Payload<S> {
+    #[inline]
     fn from(stream: ::h2::RecvStream) -> Self {
         Payload::H2 {
             payload: crate::h2::Payload::new(stream),
@@ -63,13 +82,15 @@ impl<S> From<::h2::RecvStream> for Payload<S> {
 }
 
 impl From<BoxedPayloadStream> for Payload {
+    #[inline]
     fn from(payload: BoxedPayloadStream) -> Self {
         Payload::Stream { payload }
     }
 }
 
 impl<S> Payload<S> {
-    /// Takes current payload and replaces it with `None` value
+    /// Takes current payload and replaces it with `None` value.
+    #[must_use]
     pub fn take(&mut self) -> Payload<S> {
         mem::replace(self, Payload::None)
     }
diff --git a/actix-http/src/responses/builder.rs b/actix-http/src/responses/builder.rs
index 91c69ba54..bb7d0f712 100644
--- a/actix-http/src/responses/builder.rs
+++ b/actix-http/src/responses/builder.rs
@@ -351,12 +351,9 @@ mod tests {
         assert_eq!(resp.headers().get(CONTENT_TYPE).unwrap(), "text/plain");
 
         let resp = Response::build(StatusCode::OK)
-            .content_type(mime::APPLICATION_JAVASCRIPT_UTF_8)
+            .content_type(mime::TEXT_JAVASCRIPT)
             .body(Bytes::new());
-        assert_eq!(
-            resp.headers().get(CONTENT_TYPE).unwrap(),
-            "application/javascript; charset=utf-8"
-        );
+        assert_eq!(resp.headers().get(CONTENT_TYPE).unwrap(), "text/javascript");
     }
 
     #[test]
diff --git a/actix-http/src/service.rs b/actix-http/src/service.rs
index a58be93c7..3be099d9f 100644
--- a/actix-http/src/service.rs
+++ b/actix-http/src/service.rs
@@ -241,25 +241,13 @@ where
 }
 
 /// Configuration options used when accepting TLS connection.
-#[cfg(any(
-    feature = "openssl",
-    feature = "rustls-0_20",
-    feature = "rustls-0_21",
-    feature = "rustls-0_22",
-    feature = "rustls-0_23",
-))]
+#[cfg(feature = "__tls")]
 #[derive(Debug, Default)]
 pub struct TlsAcceptorConfig {
     pub(crate) handshake_timeout: Option<std::time::Duration>,
 }
 
-#[cfg(any(
-    feature = "openssl",
-    feature = "rustls-0_20",
-    feature = "rustls-0_21",
-    feature = "rustls-0_22",
-    feature = "rustls-0_23",
-))]
+#[cfg(feature = "__tls")]
 impl TlsAcceptorConfig {
     /// Set TLS handshake timeout duration.
     pub fn handshake_timeout(self, dur: std::time::Duration) -> Self {
@@ -787,23 +775,23 @@ where
         let cfg = self.cfg.clone();
 
         Box::pin(async move {
-            let expect = expect
-                .await
-                .map_err(|e| error!("Init http expect service error: {:?}", e))?;
+            let expect = expect.await.map_err(|err| {
+                tracing::error!("Initialization of HTTP expect service error: {err:?}");
+            })?;
 
             let upgrade = match upgrade {
                 Some(upgrade) => {
-                    let upgrade = upgrade
-                        .await
-                        .map_err(|e| error!("Init http upgrade service error: {:?}", e))?;
+                    let upgrade = upgrade.await.map_err(|err| {
+                        tracing::error!("Initialization of HTTP upgrade service error: {err:?}");
+                    })?;
                     Some(upgrade)
                 }
                 None => None,
             };
 
-            let service = service
-                .await
-                .map_err(|e| error!("Init http service error: {:?}", e))?;
+            let service = service.await.map_err(|err| {
+                tracing::error!("Initialization of HTTP service error: {err:?}");
+            })?;
 
             Ok(HttpServiceHandler::new(
                 cfg,
@@ -922,7 +910,7 @@ where
                     handshake: Some((
                         crate::h2::handshake_with_timeout(io, &self.cfg),
                         self.cfg.clone(),
-                        self.flow.clone(),
+                        Rc::clone(&self.flow),
                         conn_data,
                         peer_addr,
                     )),
@@ -938,7 +926,7 @@ where
                 state: State::H1 {
                     dispatcher: h1::Dispatcher::new(
                         io,
-                        self.flow.clone(),
+                        Rc::clone(&self.flow),
                         self.cfg.clone(),
                         peer_addr,
                         conn_data,
diff --git a/actix-http/src/test.rs b/actix-http/src/test.rs
index 3815e64c6..926efe2f5 100644
--- a/actix-http/src/test.rs
+++ b/actix-http/src/test.rs
@@ -11,7 +11,7 @@ use std::{
 
 use actix_codec::{AsyncRead, AsyncWrite, ReadBuf};
 use bytes::{Bytes, BytesMut};
-use http::{Method, Uri, Version};
+use http::{header, Method, Uri, Version};
 
 use crate::{
     header::{HeaderMap, TryIntoHeaderPair},
@@ -98,9 +98,13 @@ impl TestRequest {
     }
 
     /// Set request payload.
+    ///
+    /// This sets the `Content-Length` header with the size of `data`.
     pub fn set_payload(&mut self, data: impl Into<Bytes>) -> &mut Self {
         let mut payload = crate::h1::Payload::empty();
-        payload.unread_data(data.into());
+        let bytes = data.into();
+        self.insert_header((header::CONTENT_LENGTH, bytes.len()));
+        payload.unread_data(bytes);
         parts(&mut self.0).payload = Some(payload.into());
         self
     }
@@ -159,8 +163,8 @@ impl TestBuffer {
     #[allow(dead_code)]
     pub(crate) fn clone(&self) -> Self {
         Self {
-            read_buf: self.read_buf.clone(),
-            write_buf: self.write_buf.clone(),
+            read_buf: Rc::clone(&self.read_buf),
+            write_buf: Rc::clone(&self.write_buf),
             err: self.err.clone(),
         }
     }
@@ -271,6 +275,7 @@ impl TestSeqBuffer {
     {
         Self(Rc::new(RefCell::new(TestSeqInner {
             read_buf: data.into(),
+            read_closed: false,
             write_buf: BytesMut::new(),
             err: None,
         })))
@@ -289,36 +294,59 @@ impl TestSeqBuffer {
         Ref::map(self.0.borrow(), |inner| &inner.write_buf)
     }
 
+    pub fn take_write_buf(&self) -> Bytes {
+        self.0.borrow_mut().write_buf.split().freeze()
+    }
+
     pub fn err(&self) -> Ref<'_, Option<io::Error>> {
         Ref::map(self.0.borrow(), |inner| &inner.err)
     }
 
     /// Add data to read buffer.
+    ///
+    /// # Panics
+    ///
+    /// Panics if called after [`TestSeqBuffer::close_read`] has been called
     pub fn extend_read_buf<T: AsRef<[u8]>>(&mut self, data: T) {
-        self.0
-            .borrow_mut()
-            .read_buf
-            .extend_from_slice(data.as_ref())
+        let mut inner = self.0.borrow_mut();
+        if inner.read_closed {
+            panic!("Tried to extend the read buffer after calling close_read");
+        }
+
+        inner.read_buf.extend_from_slice(data.as_ref())
+    }
+
+    /// Closes the [`AsyncRead`]/[`Read`] part of this test buffer.
+    ///
+    /// The current data in the buffer will still be returned by a call to read/poll_read, however,
+    /// after the buffer is empty, it will return `Ok(0)` to signify the EOF condition
+    pub fn close_read(&self) {
+        self.0.borrow_mut().read_closed = true;
     }
 }
 
 pub struct TestSeqInner {
     read_buf: BytesMut,
+    read_closed: bool,
     write_buf: BytesMut,
     err: Option<io::Error>,
 }
 
 impl io::Read for TestSeqBuffer {
     fn read(&mut self, dst: &mut [u8]) -> Result<usize, io::Error> {
-        if self.0.borrow().read_buf.is_empty() {
-            if self.0.borrow().err.is_some() {
-                Err(self.0.borrow_mut().err.take().unwrap())
+        let mut inner = self.0.borrow_mut();
+
+        if inner.read_buf.is_empty() {
+            if let Some(err) = inner.err.take() {
+                Err(err)
+            } else if inner.read_closed {
+                Ok(0)
             } else {
                 Err(io::Error::new(io::ErrorKind::WouldBlock, ""))
             }
         } else {
-            let size = std::cmp::min(self.0.borrow().read_buf.len(), dst.len());
-            let b = self.0.borrow_mut().read_buf.split_to(size);
+            let size = std::cmp::min(inner.read_buf.len(), dst.len());
+            let b = inner.read_buf.split_to(size);
             dst[..size].copy_from_slice(&b);
             Ok(size)
         }
diff --git a/actix-http/src/ws/dispatcher.rs b/actix-http/src/ws/dispatcher.rs
index 1354d5ae1..7d0a300b7 100644
--- a/actix-http/src/ws/dispatcher.rs
+++ b/actix-http/src/ws/dispatcher.rs
@@ -114,14 +114,14 @@ mod inner {
     {
         fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
             match *self {
-                DispatcherError::Service(ref e) => {
-                    write!(fmt, "DispatcherError::Service({:?})", e)
+                DispatcherError::Service(ref err) => {
+                    write!(fmt, "DispatcherError::Service({err:?})")
                 }
-                DispatcherError::Encoder(ref e) => {
-                    write!(fmt, "DispatcherError::Encoder({:?})", e)
+                DispatcherError::Encoder(ref err) => {
+                    write!(fmt, "DispatcherError::Encoder({err:?})")
                 }
-                DispatcherError::Decoder(ref e) => {
-                    write!(fmt, "DispatcherError::Decoder({:?})", e)
+                DispatcherError::Decoder(ref err) => {
+                    write!(fmt, "DispatcherError::Decoder({err:?})")
                 }
             }
         }
@@ -136,9 +136,9 @@ mod inner {
     {
         fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
             match *self {
-                DispatcherError::Service(ref e) => write!(fmt, "{}", e),
-                DispatcherError::Encoder(ref e) => write!(fmt, "{:?}", e),
-                DispatcherError::Decoder(ref e) => write!(fmt, "{:?}", e),
+                DispatcherError::Service(ref err) => write!(fmt, "{err}"),
+                DispatcherError::Encoder(ref err) => write!(fmt, "{err:?}"),
+                DispatcherError::Decoder(ref err) => write!(fmt, "{err:?}"),
             }
         }
     }
diff --git a/actix-http/src/ws/frame.rs b/actix-http/src/ws/frame.rs
index 35b3f8e66..7147cc92a 100644
--- a/actix-http/src/ws/frame.rs
+++ b/actix-http/src/ws/frame.rs
@@ -94,11 +94,21 @@ impl Parser {
             Some(res) => res,
         };
 
+        let frame_len = match idx.checked_add(length) {
+            Some(len) => len,
+            None => return Err(ProtocolError::Overflow),
+        };
+
         // not enough data
-        if src.len() < idx + length {
+        if src.len() < frame_len {
             let min_length = min(length, max_size);
-            if src.capacity() < idx + min_length {
-                src.reserve(idx + min_length - src.capacity());
+            let required_cap = match idx.checked_add(min_length) {
+                Some(cap) => cap,
+                None => return Err(ProtocolError::Overflow),
+            };
+
+            if src.capacity() < required_cap {
+                src.reserve(required_cap - src.capacity());
             }
             return Ok(None);
         }
@@ -402,4 +412,14 @@ mod tests {
         Parser::write_close(&mut buf, None, false);
         assert_eq!(&buf[..], &vec![0x88, 0x00][..]);
     }
+
+    #[test]
+    fn test_parse_length_overflow() {
+        let buf: [u8; 14] = [
+            0x0a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xeb, 0x0e, 0x8f,
+        ];
+        let mut buf = BytesMut::from(&buf[..]);
+        let result = Parser::parse(&mut buf, true, 65536);
+        assert!(matches!(result, Err(ProtocolError::Overflow)));
+    }
 }
diff --git a/actix-http/src/ws/mod.rs b/actix-http/src/ws/mod.rs
index 3ed53b70a..c2ae010c2 100644
--- a/actix-http/src/ws/mod.rs
+++ b/actix-http/src/ws/mod.rs
@@ -27,43 +27,43 @@ pub use self::{
 #[derive(Debug, Display, Error, From)]
 pub enum ProtocolError {
     /// Received an unmasked frame from client.
-    #[display(fmt = "received an unmasked frame from client")]
+    #[display("received an unmasked frame from client")]
     UnmaskedFrame,
 
     /// Received a masked frame from server.
-    #[display(fmt = "received a masked frame from server")]
+    #[display("received a masked frame from server")]
     MaskedFrame,
 
     /// Encountered invalid opcode.
-    #[display(fmt = "invalid opcode ({})", _0)]
+    #[display("invalid opcode ({})", _0)]
     InvalidOpcode(#[error(not(source))] u8),
 
     /// Invalid control frame length
-    #[display(fmt = "invalid control frame length ({})", _0)]
+    #[display("invalid control frame length ({})", _0)]
     InvalidLength(#[error(not(source))] usize),
 
     /// Bad opcode.
-    #[display(fmt = "bad opcode")]
+    #[display("bad opcode")]
     BadOpCode,
 
     /// A payload reached size limit.
-    #[display(fmt = "payload reached size limit")]
+    #[display("payload reached size limit")]
     Overflow,
 
     /// Continuation has not started.
-    #[display(fmt = "continuation has not started")]
+    #[display("continuation has not started")]
     ContinuationNotStarted,
 
     /// Received new continuation but it is already started.
-    #[display(fmt = "received new continuation but it has already started")]
+    #[display("received new continuation but it has already started")]
     ContinuationStarted,
 
     /// Unknown continuation fragment.
-    #[display(fmt = "unknown continuation fragment: {}", _0)]
+    #[display("unknown continuation fragment: {}", _0)]
     ContinuationFragment(#[error(not(source))] OpCode),
 
     /// I/O error.
-    #[display(fmt = "I/O error: {}", _0)]
+    #[display("I/O error: {}", _0)]
     Io(io::Error),
 }
 
@@ -71,27 +71,27 @@ pub enum ProtocolError {
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Display, Error)]
 pub enum HandshakeError {
     /// Only get method is allowed.
-    #[display(fmt = "method not allowed")]
+    #[display("method not allowed")]
     GetMethodRequired,
 
     /// Upgrade header if not set to WebSocket.
-    #[display(fmt = "WebSocket upgrade is expected")]
+    #[display("WebSocket upgrade is expected")]
     NoWebsocketUpgrade,
 
     /// Connection header is not set to upgrade.
-    #[display(fmt = "connection upgrade is expected")]
+    #[display("connection upgrade is expected")]
     NoConnectionUpgrade,
 
     /// WebSocket version header is not set.
-    #[display(fmt = "WebSocket version header is required")]
+    #[display("WebSocket version header is required")]
     NoVersionHeader,
 
     /// Unsupported WebSocket version.
-    #[display(fmt = "unsupported WebSocket version")]
+    #[display("unsupported WebSocket version")]
     UnsupportedVersion,
 
     /// WebSocket key is not set or wrong.
-    #[display(fmt = "unknown WebSocket key")]
+    #[display("unknown WebSocket key")]
     BadWebsocketKey,
 }
 
diff --git a/actix-http/tests/test_client.rs b/actix-http/tests/test_client.rs
index 5888527f1..2d940984d 100644
--- a/actix-http/tests/test_client.rs
+++ b/actix-http/tests/test_client.rs
@@ -94,7 +94,7 @@ async fn with_query_parameter() {
 }
 
 #[derive(Debug, Display, Error)]
-#[display(fmt = "expect failed")]
+#[display("expect failed")]
 struct ExpectFailed;
 
 impl From<ExpectFailed> for Response<BoxBody> {
diff --git a/actix-http/tests/test_openssl.rs b/actix-http/tests/test_openssl.rs
index 4dd22b585..83456b0cb 100644
--- a/actix-http/tests/test_openssl.rs
+++ b/actix-http/tests/test_openssl.rs
@@ -398,7 +398,7 @@ async fn h2_response_http_error_handling() {
 }
 
 #[derive(Debug, Display, Error)]
-#[display(fmt = "error")]
+#[display("error")]
 struct BadRequest;
 
 impl From<BadRequest> for Response<BoxBody> {
diff --git a/actix-http/tests/test_rustls.rs b/actix-http/tests/test_rustls.rs
index 3ca0d94c2..43e47c0a4 100644
--- a/actix-http/tests/test_rustls.rs
+++ b/actix-http/tests/test_rustls.rs
@@ -480,7 +480,7 @@ async fn h2_response_http_error_handling() {
 }
 
 #[derive(Debug, Display, Error)]
-#[display(fmt = "error")]
+#[display("error")]
 struct BadRequest;
 
 impl From<BadRequest> for Response<BoxBody> {
diff --git a/actix-http/tests/test_server.rs b/actix-http/tests/test_server.rs
index 4ba64a53c..aafcde19a 100644
--- a/actix-http/tests/test_server.rs
+++ b/actix-http/tests/test_server.rs
@@ -16,6 +16,7 @@ use actix_utils::future::{err, ok, ready};
 use bytes::Bytes;
 use derive_more::{Display, Error};
 use futures_util::{stream::once, FutureExt as _, StreamExt as _};
+use rand::Rng as _;
 use regex::Regex;
 
 #[actix_rt::test]
@@ -62,7 +63,7 @@ async fn h1_2() {
 }
 
 #[derive(Debug, Display, Error)]
-#[display(fmt = "expect failed")]
+#[display("expect failed")]
 struct ExpectFailed;
 
 impl From<ExpectFailed> for Response<BoxBody> {
@@ -164,7 +165,10 @@ async fn chunked_payload() {
 
         for chunk_size in chunk_sizes.iter() {
             let mut bytes = Vec::new();
-            let random_bytes: Vec<u8> = (0..*chunk_size).map(|_| rand::random::<u8>()).collect();
+            let random_bytes = rand::rng()
+                .sample_iter(rand::distr::StandardUniform)
+                .take(*chunk_size)
+                .collect::<Vec<_>>();
 
             bytes.extend(format!("{:X}\r\n", chunk_size).as_bytes());
             bytes.extend(&random_bytes[..]);
@@ -723,7 +727,7 @@ async fn h1_response_http_error_handling() {
 }
 
 #[derive(Debug, Display, Error)]
-#[display(fmt = "error")]
+#[display("error")]
 struct BadRequest;
 
 impl From<BadRequest> for Response<BoxBody> {
diff --git a/actix-http/tests/test_ws.rs b/actix-http/tests/test_ws.rs
index 9a78074c4..da16ab5f5 100644
--- a/actix-http/tests/test_ws.rs
+++ b/actix-http/tests/test_ws.rs
@@ -37,16 +37,16 @@ impl WsService {
 
 #[derive(Debug, Display, Error, From)]
 enum WsServiceError {
-    #[display(fmt = "HTTP error")]
+    #[display("HTTP error")]
     Http(actix_http::Error),
 
-    #[display(fmt = "WS handshake error")]
+    #[display("WS handshake error")]
     Ws(actix_http::ws::HandshakeError),
 
-    #[display(fmt = "I/O error")]
+    #[display("I/O error")]
     Io(std::io::Error),
 
-    #[display(fmt = "dispatcher error")]
+    #[display("dispatcher error")]
     Dispatcher,
 }
 
diff --git a/actix-multipart-derive/CHANGES.md b/actix-multipart-derive/CHANGES.md
index 1b44ba4b7..4b1ca7b34 100644
--- a/actix-multipart-derive/CHANGES.md
+++ b/actix-multipart-derive/CHANGES.md
@@ -2,6 +2,10 @@
 
 ## Unreleased
 
+- Minimum supported Rust version (MSRV) is now 1.82.
+
+## 0.7.0
+
 - Minimum supported Rust version (MSRV) is now 1.72.
 
 ## 0.6.1
diff --git a/actix-multipart-derive/Cargo.toml b/actix-multipart-derive/Cargo.toml
index e978864a3..9859f6c8b 100644
--- a/actix-multipart-derive/Cargo.toml
+++ b/actix-multipart-derive/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "actix-multipart-derive"
-version = "0.6.1"
+version = "0.7.0"
 authors = ["Jacob Halsey <jacob@jhalsey.com>"]
 description = "Multipart form derive macro for Actix Web"
 keywords = ["http", "web", "framework", "async", "futures"]
@@ -11,21 +11,23 @@ edition.workspace = true
 rust-version.workspace = true
 
 [package.metadata.docs.rs]
-rustdoc-args = ["--cfg", "docsrs"]
 all-features = true
 
 [lib]
 proc-macro = true
 
 [dependencies]
+bytesize = "2"
 darling = "0.20"
-parse-size = "1"
 proc-macro2 = "1"
 quote = "1"
 syn = "2"
 
 [dev-dependencies]
-actix-multipart = "0.6"
+actix-multipart = "0.7"
 actix-web = "4"
-rustversion = "1"
+rustversion-msrv = "0.100"
 trybuild = "1"
+
+[lints]
+workspace = true
diff --git a/actix-multipart-derive/README.md b/actix-multipart-derive/README.md
index ec0afffdd..bf75613ed 100644
--- a/actix-multipart-derive/README.md
+++ b/actix-multipart-derive/README.md
@@ -5,11 +5,11 @@
 <!-- prettier-ignore-start -->
 
 [![crates.io](https://img.shields.io/crates/v/actix-multipart-derive?label=latest)](https://crates.io/crates/actix-multipart-derive)
-[![Documentation](https://docs.rs/actix-multipart-derive/badge.svg?version=0.6.1)](https://docs.rs/actix-multipart-derive/0.6.1)
+[![Documentation](https://docs.rs/actix-multipart-derive/badge.svg?version=0.7.0)](https://docs.rs/actix-multipart-derive/0.7.0)
 ![Version](https://img.shields.io/badge/rustc-1.72+-ab6000.svg)
 ![MIT or Apache 2.0 licensed](https://img.shields.io/crates/l/actix-multipart-derive.svg)
 <br />
-[![dependency status](https://deps.rs/crate/actix-multipart-derive/0.6.1/status.svg)](https://deps.rs/crate/actix-multipart-derive/0.6.1)
+[![dependency status](https://deps.rs/crate/actix-multipart-derive/0.7.0/status.svg)](https://deps.rs/crate/actix-multipart-derive/0.7.0)
 [![Download](https://img.shields.io/crates/d/actix-multipart-derive.svg)](https://crates.io/crates/actix-multipart-derive)
 [![Chat on Discord](https://img.shields.io/discord/771444961383153695?label=chat&logo=discord)](https://discord.gg/NWpN5mmg3x)
 
diff --git a/actix-multipart-derive/src/lib.rs b/actix-multipart-derive/src/lib.rs
index 9552ad2d9..7aed4c5e6 100644
--- a/actix-multipart-derive/src/lib.rs
+++ b/actix-multipart-derive/src/lib.rs
@@ -2,16 +2,15 @@
 //!
 //! See [`macro@MultipartForm`] for usage examples.
 
-#![deny(rust_2018_idioms, nonstandard_style)]
-#![warn(future_incompatible)]
 #![doc(html_logo_url = "https://actix.rs/img/logo.png")]
 #![doc(html_favicon_url = "https://actix.rs/favicon.ico")]
-#![cfg_attr(docsrs, feature(doc_auto_cfg))]
+#![cfg_attr(docsrs, feature(doc_cfg))]
+#![allow(clippy::disallowed_names)] // false positives in some macro expansions
 
 use std::collections::HashSet;
 
+use bytesize::ByteSize;
 use darling::{FromDeriveInput, FromField, FromMeta};
-use parse_size::parse_size;
 use proc_macro::TokenStream;
 use proc_macro2::Ident;
 use quote::quote;
@@ -37,6 +36,7 @@ struct MultipartFormAttrs {
     duplicate_field: DuplicateField,
 }
 
+#[allow(clippy::disallowed_names)] // false positive in macro expansion
 #[derive(FromField, Default)]
 #[darling(attributes(multipart), default)]
 struct FieldAttrs {
@@ -103,7 +103,7 @@ struct ParsedField<'t> {
 /// # Field Limits
 ///
 /// You can use the `#[multipart(limit = "<size>")]` attribute to set field level limits. The limit
-/// string is parsed using [parse_size].
+/// string is parsed using [`bytesize`].
 ///
 /// Note: the form is also subject to the global limits configured using `MultipartFormConfig`.
 ///
@@ -138,7 +138,7 @@ struct ParsedField<'t> {
 /// `#[multipart(duplicate_field = "<behavior>")]` attribute:
 ///
 /// - "ignore": (default) Extra fields are ignored. I.e., the first one is persisted.
-/// - "deny": A `MultipartError::UnsupportedField` error response is returned.
+/// - "deny": A `MultipartError::UnknownField` error response is returned.
 /// - "replace": Each field is processed, but only the last one is persisted.
 ///
 /// Note that `Vec` fields will ignore this option.
@@ -150,7 +150,7 @@ struct ParsedField<'t> {
 /// struct Form { }
 /// ```
 ///
-/// [parse_size]: https://docs.rs/parse-size/1/parse_size
+/// [`bytesize`]: https://docs.rs/bytesize/2
 #[proc_macro_derive(MultipartForm, attributes(multipart))]
 pub fn impl_multipart_form(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
     let input: syn::DeriveInput = parse_macro_input!(input);
@@ -191,8 +191,8 @@ pub fn impl_multipart_form(input: proc_macro::TokenStream) -> proc_macro::TokenS
             let attrs = FieldAttrs::from_field(field).map_err(|err| err.write_errors())?;
             let serialization_name = attrs.rename.unwrap_or_else(|| rust_name.to_string());
 
-            let limit = match attrs.limit.map(|limit| match parse_size(&limit) {
-                Ok(size) => Ok(usize::try_from(size).unwrap()),
+            let limit = match attrs.limit.map(|limit| match limit.parse::<ByteSize>() {
+                Ok(ByteSize(size)) => Ok(usize::try_from(size).unwrap()),
                 Err(err) => Err(syn::Error::new(
                     field.ident.as_ref().unwrap().span(),
                     format!("Could not parse size limit `{}`: {}", limit, err),
@@ -229,7 +229,7 @@ pub fn impl_multipart_form(input: proc_macro::TokenStream) -> proc_macro::TokenS
     // Return value when a field name is not supported by the form
     let unknown_field_result = if attrs.deny_unknown_fields {
         quote!(::std::result::Result::Err(
-            ::actix_multipart::MultipartError::UnsupportedField(field.name().to_string())
+            ::actix_multipart::MultipartError::UnknownField(field.name().unwrap().to_string())
         ))
     } else {
         quote!(::std::result::Result::Ok(()))
@@ -292,7 +292,7 @@ pub fn impl_multipart_form(input: proc_macro::TokenStream) -> proc_macro::TokenS
                 limits: &'t mut ::actix_multipart::form::Limits,
                 state: &'t mut ::actix_multipart::form::State,
             ) -> ::std::pin::Pin<::std::boxed::Box<dyn ::std::future::Future<Output = ::std::result::Result<(), ::actix_multipart::MultipartError>> + 't>> {
-                match field.name() {
+                match field.name().unwrap() {
                     #handle_field_impl
                     _ => return ::std::boxed::Box::pin(::std::future::ready(#unknown_field_result)),
                 }
diff --git a/actix-multipart-derive/tests/trybuild.rs b/actix-multipart-derive/tests/trybuild.rs
index 6b25d78df..7bd140324 100644
--- a/actix-multipart-derive/tests/trybuild.rs
+++ b/actix-multipart-derive/tests/trybuild.rs
@@ -1,4 +1,4 @@
-#[rustversion::stable(1.72)] // MSRV
+#[rustversion_msrv::msrv]
 #[test]
 fn compile_macros() {
     let t = trybuild::TestCases::new();
diff --git a/actix-multipart-derive/tests/trybuild/size-limit-parse-fail.stderr b/actix-multipart-derive/tests/trybuild/size-limit-parse-fail.stderr
index fc02a78c4..089569c09 100644
--- a/actix-multipart-derive/tests/trybuild/size-limit-parse-fail.stderr
+++ b/actix-multipart-derive/tests/trybuild/size-limit-parse-fail.stderr
@@ -1,16 +1,16 @@
-error: Could not parse size limit `2 bytes`: invalid digit found in string
+error: Could not parse size limit `2 bytes`: couldn't parse "bytes" into a known SI unit, Failed to parse unit "byt..."
  --> tests/trybuild/size-limit-parse-fail.rs:6:5
   |
 6 |     description: Text<String>,
   |     ^^^^^^^^^^^
 
-error: Could not parse size limit `2 megabytes`: invalid digit found in string
+error: Could not parse size limit `2 megabytes`: couldn't parse "megabytes" into a known SI unit, Failed to parse unit "meg..."
   --> tests/trybuild/size-limit-parse-fail.rs:12:5
    |
 12 |     description: Text<String>,
    |     ^^^^^^^^^^^
 
-error: Could not parse size limit `four meters`: invalid digit found in string
+error: Could not parse size limit `four meters`: couldn't parse "four meters" into a ByteSize, cannot parse float from empty string
   --> tests/trybuild/size-limit-parse-fail.rs:18:5
    |
 18 |     description: Text<String>,
diff --git a/actix-multipart/CHANGES.md b/actix-multipart/CHANGES.md
index a91edf9c8..fe5d24a2a 100644
--- a/actix-multipart/CHANGES.md
+++ b/actix-multipart/CHANGES.md
@@ -2,6 +2,28 @@
 
 ## Unreleased
 
+- Minimum supported Rust version (MSRV) is now 1.82.
+
+## 0.7.2
+
+- Fix re-exported version of `actix-multipart-derive`.
+
+## 0.7.1
+
+- Expose `LimitExceeded` error type.
+
+## 0.7.0
+
+- Add `MultipartError::ContentTypeIncompatible` variant.
+- Add `MultipartError::ContentDispositionNameMissing` variant.
+- Add `Field::bytes()` method.
+- Rename `MultipartError::{NoContentDisposition => ContentDispositionMissing}` variant.
+- Rename `MultipartError::{NoContentType => ContentTypeMissing}` variant.
+- Rename `MultipartError::{ParseContentType => ContentTypeParse}` variant.
+- Rename `MultipartError::{Boundary => BoundaryMissing}` variant.
+- Rename `MultipartError::{UnsupportedField => UnknownField}` variant.
+- Remove top-level re-exports of `test` utilities.
+
 ## 0.6.2
 
 - Add testing utilities under new module `test`.
diff --git a/actix-multipart/Cargo.toml b/actix-multipart/Cargo.toml
index 5e9b78d84..384430f06 100644
--- a/actix-multipart/Cargo.toml
+++ b/actix-multipart/Cargo.toml
@@ -1,34 +1,34 @@
 [package]
 name = "actix-multipart"
-version = "0.6.2"
+version = "0.7.2"
 authors = [
-    "Nikolay Kim <fafhrd91@gmail.com>",
-    "Jacob Halsey <jacob@jhalsey.com>",
+  "Nikolay Kim <fafhrd91@gmail.com>",
+  "Jacob Halsey <jacob@jhalsey.com>",
+  "Rob Ede <robjtede@icloud.com>",
 ]
-description = "Multipart form support for Actix Web"
-keywords = ["http", "web", "framework", "async", "futures"]
-homepage = "https://actix.rs"
-repository = "https://github.com/actix/actix-web"
-license = "MIT OR Apache-2.0"
-edition = "2021"
+description = "Multipart request & form support for Actix Web"
+keywords = ["http", "actix", "web", "multipart", "form"]
+homepage.workspace = true
+repository.workspace = true
+license.workspace = true
+edition.workspace = true
 
 [package.metadata.docs.rs]
-rustdoc-args = ["--cfg", "docsrs"]
 all-features = true
 
 [package.metadata.cargo_check_external_types]
 allowed_external_types = [
-    "actix_http::*",
-    "actix_multipart_derive::*",
-    "actix_utils::*",
-    "actix_web::*",
-    "bytes::*",
-    "futures_core::*",
-    "mime::*",
-    "serde_json::*",
-    "serde_plain::*",
-    "serde::*",
-    "tempfile::*",
+  "actix_http::*",
+  "actix_multipart_derive::*",
+  "actix_utils::*",
+  "actix_web::*",
+  "bytes::*",
+  "futures_core::*",
+  "mime::*",
+  "serde_json::*",
+  "serde_plain::*",
+  "serde::*",
+  "tempfile::*",
 ]
 
 [features]
@@ -37,12 +37,11 @@ derive = ["actix-multipart-derive"]
 tempfile = ["dep:tempfile", "tokio/fs"]
 
 [dependencies]
-actix-multipart-derive = { version = "=0.6.1", optional = true }
+actix-multipart-derive = { version = "=0.7.0", optional = true }
 actix-utils = "3"
 actix-web = { version = "4", default-features = false }
 
-bytes = "1"
-derive_more = "0.99.5"
+derive_more = { version = "2", features = ["display", "error", "from"] }
 futures-core = { version = "0.3.17", default-features = false, features = ["alloc"] }
 futures-util = { version = "0.3.17", default-features = false, features = ["alloc"] }
 httparse = "1.3"
@@ -50,21 +49,27 @@ local-waker = "0.1"
 log = "0.4"
 memchr = "2.5"
 mime = "0.3"
-rand = "0.8"
+rand = "0.9"
 serde = "1"
 serde_json = "1"
 serde_plain = "1"
 tempfile = { version = "3.4", optional = true }
-tokio = { version = "1.24.2", features = ["sync", "io-util"] }
+tokio = { version = "1.38.2", features = ["sync", "io-util"] }
 
 [dev-dependencies]
 actix-http = "3"
-actix-multipart-rfc7578 = "0.10"
+actix-multipart-rfc7578 = "0.11"
 actix-rt = "2.2"
 actix-test = "0.1"
 actix-web = "4"
+assert_matches = "1"
 awc = "3"
+env_logger = "0.11"
+futures-test = "0.3"
 futures-util = { version = "0.3.17", default-features = false, features = ["alloc"] }
 multer = "3"
-tokio = { version = "1.24.2", features = ["sync"] }
+tokio = { version = "1.38.2", features = ["sync"] }
 tokio-stream = "0.1"
+
+[lints]
+workspace = true
diff --git a/actix-multipart/README.md b/actix-multipart/README.md
index d61347f32..3f1055e9e 100644
--- a/actix-multipart/README.md
+++ b/actix-multipart/README.md
@@ -3,11 +3,11 @@
 <!-- prettier-ignore-start -->
 
 [![crates.io](https://img.shields.io/crates/v/actix-multipart?label=latest)](https://crates.io/crates/actix-multipart)
-[![Documentation](https://docs.rs/actix-multipart/badge.svg?version=0.6.2)](https://docs.rs/actix-multipart/0.6.2)
+[![Documentation](https://docs.rs/actix-multipart/badge.svg?version=0.7.2)](https://docs.rs/actix-multipart/0.7.2)
 ![Version](https://img.shields.io/badge/rustc-1.72+-ab6000.svg)
 ![MIT or Apache 2.0 licensed](https://img.shields.io/crates/l/actix-multipart.svg)
 <br />
-[![dependency status](https://deps.rs/crate/actix-multipart/0.6.2/status.svg)](https://deps.rs/crate/actix-multipart/0.6.2)
+[![dependency status](https://deps.rs/crate/actix-multipart/0.7.2/status.svg)](https://deps.rs/crate/actix-multipart/0.7.2)
 [![Download](https://img.shields.io/crates/d/actix-multipart.svg)](https://crates.io/crates/actix-multipart)
 [![Chat on Discord](https://img.shields.io/discord/771444961383153695?label=chat&logo=discord)](https://discord.gg/NWpN5mmg3x)
 
@@ -15,14 +15,19 @@
 
 <!-- cargo-rdme start -->
 
-Multipart form support for Actix Web.
+Multipart request & form support for Actix Web.
+
+The [`Multipart`] extractor aims to support all kinds of `multipart/*` requests, including `multipart/form-data`, `multipart/related` and `multipart/mixed`. This is a lower-level extractor which supports reading [multipart fields](Field), in the order they are sent by the client.
+
+Due to additional requirements for `multipart/form-data` requests, the higher level [`MultipartForm`] extractor and derive macro only supports this media type.
 
 ## Examples
 
 ```rust
-use actix_web::{post, App, HttpServer, Responder};
-
-use actix_multipart::form::{json::Json as MPJson, tempfile::TempFile, MultipartForm};
+use actix_multipart::form::{
+    json::Json as MpJson, tempfile::TempFile, MultipartForm, MultipartFormConfig,
+};
+use actix_web::{middleware::Logger, post, App, HttpServer, Responder};
 use serde::Deserialize;
 
 #[derive(Debug, Deserialize)]
@@ -32,37 +37,51 @@ struct Metadata {
 
 #[derive(Debug, MultipartForm)]
 struct UploadForm {
+    // Note: the form is also subject to the global limits configured using `MultipartFormConfig`.
     #[multipart(limit = "100MB")]
     file: TempFile,
-    json: MPJson<Metadata>,
+    json: MpJson<Metadata>,
 }
 
 #[post("/videos")]
-pub async fn post_video(MultipartForm(form): MultipartForm<UploadForm>) -> impl Responder {
+async fn post_video(MultipartForm(form): MultipartForm<UploadForm>) -> impl Responder {
     format!(
-        "Uploaded file {}, with size: {}",
-        form.json.name, form.file.size
+        "Uploaded file {}, with size: {}\ntemporary file ({}) was deleted\n",
+        form.json.name,
+        form.file.size,
+        form.file.file.path().display(),
     )
 }
 
 #[actix_web::main]
 async fn main() -> std::io::Result<()> {
-    HttpServer::new(move || App::new().service(post_video))
-        .bind(("127.0.0.1", 8080))?
-        .run()
-        .await
+    env_logger::init_from_env(env_logger::Env::new().default_filter_or("info"));
+
+    HttpServer::new(move || {
+        App::new()
+            .service(post_video)
+            .wrap(Logger::default())
+            // Also increase the global total limit to 100MiB.
+            .app_data(MultipartFormConfig::default().total_limit(100 * 1024 * 1024))
+    })
+    .workers(2)
+    .bind(("127.0.0.1", 8080))?
+    .run()
+    .await
 }
 ```
 
-<!-- cargo-rdme end -->
+cURL request:
 
-[More available in the examples repo &rarr;](https://github.com/actix/examples/tree/master/forms/multipart)
-
-Curl request :
-
-```bash
+```sh
 curl -v --request POST \
   --url http://localhost:8080/videos \
   -F 'json={"name": "Cargo.lock"};type=application/json' \
   -F file=@./Cargo.lock
 ```
+
+[`MultipartForm`]: struct@form::MultipartForm
+
+<!-- cargo-rdme end -->
+
+[More available in the examples repo &rarr;](https://github.com/actix/examples/tree/main/forms/multipart)
diff --git a/actix-multipart/examples/form.rs b/actix-multipart/examples/form.rs
new file mode 100644
index 000000000..e3fda9a23
--- /dev/null
+++ b/actix-multipart/examples/form.rs
@@ -0,0 +1,45 @@
+use actix_multipart::form::{
+    json::Json as MpJson, tempfile::TempFile, MultipartForm, MultipartFormConfig,
+};
+use actix_web::{middleware::Logger, post, App, HttpServer, Responder};
+use serde::Deserialize;
+
+#[derive(Debug, Deserialize)]
+struct Metadata {
+    name: String,
+}
+
+#[derive(Debug, MultipartForm)]
+struct UploadForm {
+    // Note: the form is also subject to the global limits configured using `MultipartFormConfig`.
+    #[multipart(limit = "100MB")]
+    file: TempFile,
+    json: MpJson<Metadata>,
+}
+
+#[post("/videos")]
+async fn post_video(MultipartForm(form): MultipartForm<UploadForm>) -> impl Responder {
+    format!(
+        "Uploaded file {}, with size: {}\ntemporary file ({}) was deleted\n",
+        form.json.name,
+        form.file.size,
+        form.file.file.path().display(),
+    )
+}
+
+#[actix_web::main]
+async fn main() -> std::io::Result<()> {
+    env_logger::init_from_env(env_logger::Env::new().default_filter_or("info"));
+
+    HttpServer::new(move || {
+        App::new()
+            .service(post_video)
+            .wrap(Logger::default())
+            // Also increase the global total limit to 100MiB.
+            .app_data(MultipartFormConfig::default().total_limit(100 * 1024 * 1024))
+    })
+    .workers(2)
+    .bind(("127.0.0.1", 8080))?
+    .run()
+    .await
+}
diff --git a/actix-multipart/src/error.rs b/actix-multipart/src/error.rs
index 77b5a559f..cb4f06d39 100644
--- a/actix-multipart/src/error.rs
+++ b/actix-multipart/src/error.rs
@@ -10,78 +10,96 @@ use derive_more::{Display, Error, From};
 /// A set of errors that can occur during parsing multipart streams.
 #[derive(Debug, Display, From, Error)]
 #[non_exhaustive]
-pub enum MultipartError {
-    /// Content-Disposition header is not found or is not equal to "form-data".
+pub enum Error {
+    /// Could not find Content-Type header.
+    #[display("Could not find Content-Type header")]
+    ContentTypeMissing,
+
+    /// Could not parse Content-Type header.
+    #[display("Could not parse Content-Type header")]
+    ContentTypeParse,
+
+    /// Parsed Content-Type did not have "multipart" top-level media type.
     ///
-    /// According to [RFC 7578 §4.2](https://datatracker.ietf.org/doc/html/rfc7578#section-4.2) a
-    /// Content-Disposition header must always be present and equal to "form-data".
-    #[display(fmt = "No Content-Disposition `form-data` header")]
-    NoContentDisposition,
+    /// Also raised when extracting a [`MultipartForm`] from a request that does not have the
+    /// "multipart/form-data" media type.
+    ///
+    /// [`MultipartForm`]: struct@crate::form::MultipartForm
+    #[display("Parsed Content-Type did not have 'multipart' top-level media type")]
+    ContentTypeIncompatible,
 
-    /// Content-Type header is not found
-    #[display(fmt = "No Content-Type header found")]
-    NoContentType,
+    /// Multipart boundary is not found.
+    #[display("Multipart boundary is not found")]
+    BoundaryMissing,
 
-    /// Can not parse Content-Type header
-    #[display(fmt = "Can not parse Content-Type header")]
-    ParseContentType,
+    /// Content-Disposition header was not found or not of disposition type "form-data" when parsing
+    /// a "form-data" field.
+    ///
+    /// As per [RFC 7578 §4.2], a "multipart/form-data" field's Content-Disposition header must
+    /// always be present and have a disposition type of "form-data".
+    ///
+    /// [RFC 7578 §4.2]: https://datatracker.ietf.org/doc/html/rfc7578#section-4.2
+    #[display("Content-Disposition header was not found when parsing a \"form-data\" field")]
+    ContentDispositionMissing,
 
-    /// Multipart boundary is not found
-    #[display(fmt = "Multipart boundary is not found")]
-    Boundary,
+    /// Content-Disposition name parameter was not found when parsing a "form-data" field.
+    ///
+    /// As per [RFC 7578 §4.2], a "multipart/form-data" field's Content-Disposition header must
+    /// always include a "name" parameter.
+    ///
+    /// [RFC 7578 §4.2]: https://datatracker.ietf.org/doc/html/rfc7578#section-4.2
+    #[display("Content-Disposition header was not found when parsing a \"form-data\" field")]
+    ContentDispositionNameMissing,
 
-    /// Nested multipart is not supported
-    #[display(fmt = "Nested multipart is not supported")]
+    /// Nested multipart is not supported.
+    #[display("Nested multipart is not supported")]
     Nested,
 
-    /// Multipart stream is incomplete
-    #[display(fmt = "Multipart stream is incomplete")]
+    /// Multipart stream is incomplete.
+    #[display("Multipart stream is incomplete")]
     Incomplete,
 
-    /// Error during field parsing
-    #[display(fmt = "{}", _0)]
+    /// Field parsing failed.
+    #[display("Error during field parsing")]
     Parse(ParseError),
 
-    /// Payload error
-    #[display(fmt = "{}", _0)]
+    /// HTTP payload error.
+    #[display("Payload error")]
     Payload(PayloadError),
 
-    /// Not consumed
-    #[display(fmt = "Multipart stream is not consumed")]
+    /// Stream is not consumed.
+    #[display("Stream is not consumed")]
     NotConsumed,
 
-    /// An error from a field handler in a form
-    #[display(
-        fmt = "An error occurred processing field `{}`: {}",
-        field_name,
-        source
-    )]
+    /// Form field handler raised error.
+    #[display("An error occurred processing field: {name}")]
     Field {
-        field_name: String,
+        name: String,
         source: actix_web::Error,
     },
 
-    /// Duplicate field
-    #[display(fmt = "Duplicate field found for: `{}`", _0)]
+    /// Duplicate field found (for structure that opted-in to denying duplicate fields).
+    #[display("Duplicate field found: {_0}")]
     #[from(ignore)]
     DuplicateField(#[error(not(source))] String),
 
-    /// Missing field
-    #[display(fmt = "Field with name `{}` is required", _0)]
+    /// Required field is missing.
+    #[display("Required field is missing: {_0}")]
     #[from(ignore)]
     MissingField(#[error(not(source))] String),
 
-    /// Unknown field
-    #[display(fmt = "Unsupported field `{}`", _0)]
+    /// Unknown field (for structure that opted-in to denying unknown fields).
+    #[display("Unknown field: {_0}")]
     #[from(ignore)]
-    UnsupportedField(#[error(not(source))] String),
+    UnknownField(#[error(not(source))] String),
 }
 
-/// Return `BadRequest` for `MultipartError`
-impl ResponseError for MultipartError {
+/// Return `BadRequest` for `MultipartError`.
+impl ResponseError for Error {
     fn status_code(&self) -> StatusCode {
         match &self {
-            MultipartError::Field { source, .. } => source.as_response_error().status_code(),
+            Error::Field { source, .. } => source.as_response_error().status_code(),
+            Error::ContentTypeIncompatible => StatusCode::UNSUPPORTED_MEDIA_TYPE,
             _ => StatusCode::BAD_REQUEST,
         }
     }
@@ -93,7 +111,7 @@ mod tests {
 
     #[test]
     fn test_multipart_error() {
-        let resp = MultipartError::Boundary.error_response();
+        let resp = Error::BoundaryMissing.error_response();
         assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
     }
 }
diff --git a/actix-multipart/src/extractor.rs b/actix-multipart/src/extractor.rs
index 56ed69ae4..31999228e 100644
--- a/actix-multipart/src/extractor.rs
+++ b/actix-multipart/src/extractor.rs
@@ -1,21 +1,20 @@
-//! Multipart payload support
-
 use actix_utils::future::{ready, Ready};
 use actix_web::{dev::Payload, Error, FromRequest, HttpRequest};
 
-use crate::server::Multipart;
+use crate::multipart::Multipart;
 
-/// Get request's payload as multipart stream.
+/// Extract request's payload as multipart stream.
 ///
-/// Content-type: multipart/form-data;
+/// Content-type: multipart/*;
 ///
 /// # Examples
+///
 /// ```
-/// use actix_web::{web, HttpResponse, Error};
+/// use actix_web::{web, HttpResponse};
 /// use actix_multipart::Multipart;
 /// use futures_util::StreamExt as _;
 ///
-/// async fn index(mut payload: Multipart) -> Result<HttpResponse, Error> {
+/// async fn index(mut payload: Multipart) -> actix_web::Result<HttpResponse> {
 ///     // iterate over multipart stream
 ///     while let Some(item) = payload.next().await {
 ///            let mut field = item?;
@@ -26,7 +25,7 @@ use crate::server::Multipart;
 ///            }
 ///     }
 ///
-///     Ok(HttpResponse::Ok().into())
+///     Ok(HttpResponse::Ok().finish())
 /// }
 /// ```
 impl FromRequest for Multipart {
@@ -35,9 +34,6 @@ impl FromRequest for Multipart {
 
     #[inline]
     fn from_request(req: &HttpRequest, payload: &mut Payload) -> Self::Future {
-        ready(Ok(match Multipart::boundary(req.headers()) {
-            Ok(boundary) => Multipart::from_boundary(boundary, payload.take()),
-            Err(err) => Multipart::from_error(err),
-        }))
+        ready(Ok(Multipart::from_req(req, payload)))
     }
 }
diff --git a/actix-multipart/src/field.rs b/actix-multipart/src/field.rs
new file mode 100644
index 000000000..0bbb8a657
--- /dev/null
+++ b/actix-multipart/src/field.rs
@@ -0,0 +1,501 @@
+use std::{
+    cell::RefCell,
+    cmp, fmt,
+    future::poll_fn,
+    mem,
+    pin::Pin,
+    rc::Rc,
+    task::{ready, Context, Poll},
+};
+
+use actix_web::{
+    error::PayloadError,
+    http::header::{self, ContentDisposition, HeaderMap},
+    web::{Bytes, BytesMut},
+};
+use derive_more::{Display, Error};
+use futures_core::Stream;
+use mime::Mime;
+
+use crate::{
+    error::Error,
+    payload::{PayloadBuffer, PayloadRef},
+    safety::Safety,
+};
+
+/// Error type returned from [`Field::bytes()`] when field data is larger than limit.
+#[derive(Debug, Display, Error)]
+#[display("size limit exceeded while collecting field data")]
+#[non_exhaustive]
+pub struct LimitExceeded;
+
+/// A single field in a multipart stream.
+pub struct Field {
+    /// Field's Content-Type.
+    content_type: Option<Mime>,
+
+    /// Field's Content-Disposition.
+    content_disposition: Option<ContentDisposition>,
+
+    /// Form field name.
+    ///
+    /// A non-optional storage for form field names to avoid unwraps in `form` module. Will be an
+    /// empty string in non-form contexts.
+    ///
+    // INVARIANT: always non-empty when request content-type is multipart/form-data.
+    pub(crate) form_field_name: String,
+
+    /// Field's header map.
+    headers: HeaderMap,
+
+    safety: Safety,
+    inner: Rc<RefCell<InnerField>>,
+}
+
+impl Field {
+    pub(crate) fn new(
+        content_type: Option<Mime>,
+        content_disposition: Option<ContentDisposition>,
+        form_field_name: Option<String>,
+        headers: HeaderMap,
+        safety: Safety,
+        inner: Rc<RefCell<InnerField>>,
+    ) -> Self {
+        Field {
+            content_type,
+            content_disposition,
+            form_field_name: form_field_name.unwrap_or_default(),
+            headers,
+            inner,
+            safety,
+        }
+    }
+
+    /// Returns a reference to the field's header map.
+    pub fn headers(&self) -> &HeaderMap {
+        &self.headers
+    }
+
+    /// Returns a reference to the field's content (mime) type, if it is supplied by the client.
+    ///
+    /// According to [RFC 7578](https://www.rfc-editor.org/rfc/rfc7578#section-4.4), if it is not
+    /// present, it should default to "text/plain". Note it is the responsibility of the client to
+    /// provide the appropriate content type, there is no attempt to validate this by the server.
+    pub fn content_type(&self) -> Option<&Mime> {
+        self.content_type.as_ref()
+    }
+
+    /// Returns this field's parsed Content-Disposition header, if set.
+    ///
+    /// # Validation
+    ///
+    /// Per [RFC 7578 §4.2], the parts of a multipart/form-data payload MUST contain a
+    /// Content-Disposition header field where the disposition type is `form-data` and MUST also
+    /// contain an additional parameter of `name` with its value being the original field name from
+    /// the form. This requirement is enforced during extraction for multipart/form-data requests,
+    /// but not other kinds of multipart requests (such as multipart/related).
+    ///
+    /// As such, it is safe to `.unwrap()` calls `.content_disposition()` if you've verified.
+    ///
+    /// The [`name()`](Self::name) method is also provided as a convenience for obtaining the
+    /// aforementioned name parameter.
+    ///
+    /// [RFC 7578 §4.2]: https://datatracker.ietf.org/doc/html/rfc7578#section-4.2
+    pub fn content_disposition(&self) -> Option<&ContentDisposition> {
+        self.content_disposition.as_ref()
+    }
+
+    /// Returns the field's name, if set.
+    ///
+    /// See [`content_disposition()`](Self::content_disposition) regarding guarantees on presence of
+    /// the "name" field.
+    pub fn name(&self) -> Option<&str> {
+        self.content_disposition()?.get_name()
+    }
+
+    /// Collects the raw field data, up to `limit` bytes.
+    ///
+    /// # Errors
+    ///
+    /// Any errors produced by the data stream are returned as `Ok(Err(Error))` immediately.
+    ///
+    /// If the buffered data size would exceed `limit`, an `Err(LimitExceeded)` is returned. Note
+    /// that, in this case, the full data stream is exhausted before returning the error so that
+    /// subsequent fields can still be read. To better defend against malicious/infinite requests,
+    /// it is advisable to also put a timeout on this call.
+    pub async fn bytes(&mut self, limit: usize) -> Result<Result<Bytes, Error>, LimitExceeded> {
+        /// Sensible default (2kB) for initial, bounded allocation when collecting body bytes.
+        const INITIAL_ALLOC_BYTES: usize = 2 * 1024;
+
+        let mut exceeded_limit = false;
+        let mut buf = BytesMut::with_capacity(INITIAL_ALLOC_BYTES);
+
+        let mut field = Pin::new(self);
+
+        match poll_fn(|cx| loop {
+            match ready!(field.as_mut().poll_next(cx)) {
+                // if already over limit, discard chunk to advance multipart request
+                Some(Ok(_chunk)) if exceeded_limit => {}
+
+                // if limit is exceeded set flag to true and continue
+                Some(Ok(chunk)) if buf.len() + chunk.len() > limit => {
+                    exceeded_limit = true;
+                    // eagerly de-allocate field data buffer
+                    let _ = mem::take(&mut buf);
+                }
+
+                Some(Ok(chunk)) => buf.extend_from_slice(&chunk),
+
+                None => return Poll::Ready(Ok(())),
+                Some(Err(err)) => return Poll::Ready(Err(err)),
+            }
+        })
+        .await
+        {
+            // propagate error returned from body poll
+            Err(err) => Ok(Err(err)),
+
+            // limit was exceeded while reading body
+            Ok(()) if exceeded_limit => Err(LimitExceeded),
+
+            // otherwise return body buffer
+            Ok(()) => Ok(Ok(buf.freeze())),
+        }
+    }
+}
+
+impl Stream for Field {
+    type Item = Result<Bytes, Error>;
+
+    fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
+        let this = self.get_mut();
+        let mut inner = this.inner.borrow_mut();
+
+        if let Some(mut buffer) = inner
+            .payload
+            .as_ref()
+            .expect("Field should not be polled after completion")
+            .get_mut(&this.safety)
+        {
+            // check safety and poll read payload to buffer.
+            buffer.poll_stream(cx)?;
+        } else if !this.safety.is_clean() {
+            // safety violation
+            return Poll::Ready(Some(Err(Error::NotConsumed)));
+        } else {
+            return Poll::Pending;
+        }
+
+        inner.poll(&this.safety)
+    }
+}
+
+impl fmt::Debug for Field {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        if let Some(ct) = &self.content_type {
+            writeln!(f, "\nField: {}", ct)?;
+        } else {
+            writeln!(f, "\nField:")?;
+        }
+        writeln!(f, "  boundary: {}", self.inner.borrow().boundary)?;
+        writeln!(f, "  headers:")?;
+        for (key, val) in self.headers.iter() {
+            writeln!(f, "    {:?}: {:?}", key, val)?;
+        }
+        Ok(())
+    }
+}
+
+pub(crate) struct InnerField {
+    /// Payload is initialized as Some and is `take`n when the field stream finishes.
+    payload: Option<PayloadRef>,
+
+    /// Field boundary (without "--" prefix).
+    boundary: String,
+
+    /// True if request payload has been exhausted.
+    eof: bool,
+
+    /// Field data's stated size according to it's Content-Length header.
+    length: Option<u64>,
+}
+
+impl InnerField {
+    pub(crate) fn new_in_rc(
+        payload: PayloadRef,
+        boundary: String,
+        headers: &HeaderMap,
+    ) -> Result<Rc<RefCell<InnerField>>, PayloadError> {
+        Self::new(payload, boundary, headers).map(|this| Rc::new(RefCell::new(this)))
+    }
+
+    pub(crate) fn new(
+        payload: PayloadRef,
+        boundary: String,
+        headers: &HeaderMap,
+    ) -> Result<InnerField, PayloadError> {
+        let len = if let Some(len) = headers.get(&header::CONTENT_LENGTH) {
+            match len.to_str().ok().and_then(|len| len.parse::<u64>().ok()) {
+                Some(len) => Some(len),
+                None => return Err(PayloadError::Incomplete(None)),
+            }
+        } else {
+            None
+        };
+
+        Ok(InnerField {
+            boundary,
+            payload: Some(payload),
+            eof: false,
+            length: len,
+        })
+    }
+
+    /// Reads body part content chunk of the specified size.
+    ///
+    /// The body part must has `Content-Length` header with proper value.
+    pub(crate) fn read_len(
+        payload: &mut PayloadBuffer,
+        size: &mut u64,
+    ) -> Poll<Option<Result<Bytes, Error>>> {
+        if *size == 0 {
+            Poll::Ready(None)
+        } else {
+            match payload.read_max(*size)? {
+                Some(mut chunk) => {
+                    let len = cmp::min(chunk.len() as u64, *size);
+                    *size -= len;
+                    let ch = chunk.split_to(len as usize);
+                    if !chunk.is_empty() {
+                        payload.unprocessed(chunk);
+                    }
+                    Poll::Ready(Some(Ok(ch)))
+                }
+                None => {
+                    if payload.eof && (*size != 0) {
+                        Poll::Ready(Some(Err(Error::Incomplete)))
+                    } else {
+                        Poll::Pending
+                    }
+                }
+            }
+        }
+    }
+
+    /// Reads content chunk of body part with unknown length.
+    ///
+    /// The `Content-Length` header for body part is not necessary.
+    pub(crate) fn read_stream(
+        payload: &mut PayloadBuffer,
+        boundary: &str,
+    ) -> Poll<Option<Result<Bytes, Error>>> {
+        let mut pos = 0;
+
+        let len = payload.buf.len();
+
+        if len == 0 {
+            return if payload.eof {
+                Poll::Ready(Some(Err(Error::Incomplete)))
+            } else {
+                Poll::Pending
+            };
+        }
+
+        // check boundary
+        if len > 4 && payload.buf[0] == b'\r' {
+            let b_len = if payload.buf.starts_with(b"\r\n") && &payload.buf[2..4] == b"--" {
+                Some(4)
+            } else if &payload.buf[1..3] == b"--" {
+                Some(3)
+            } else {
+                None
+            };
+
+            if let Some(b_len) = b_len {
+                let b_size = boundary.len() + b_len;
+                if len < b_size {
+                    return Poll::Pending;
+                } else if &payload.buf[b_len..b_size] == boundary.as_bytes() {
+                    // found boundary
+                    return Poll::Ready(None);
+                }
+            }
+        }
+
+        loop {
+            return if let Some(idx) = memchr::memmem::find(&payload.buf[pos..], b"\r") {
+                let cur = pos + idx;
+
+                // check if we have enough data for boundary detection
+                if cur + 4 > len {
+                    if cur > 0 {
+                        Poll::Ready(Some(Ok(payload.buf.split_to(cur).freeze())))
+                    } else {
+                        Poll::Pending
+                    }
+                } else {
+                    // check boundary
+                    if (&payload.buf[cur..cur + 2] == b"\r\n"
+                        && &payload.buf[cur + 2..cur + 4] == b"--")
+                        || (&payload.buf[cur..=cur] == b"\r"
+                            && &payload.buf[cur + 1..cur + 3] == b"--")
+                    {
+                        if cur != 0 {
+                            // return buffer
+                            Poll::Ready(Some(Ok(payload.buf.split_to(cur).freeze())))
+                        } else {
+                            pos = cur + 1;
+                            continue;
+                        }
+                    } else {
+                        // not boundary
+                        pos = cur + 1;
+                        continue;
+                    }
+                }
+            } else {
+                Poll::Ready(Some(Ok(payload.buf.split().freeze())))
+            };
+        }
+    }
+
+    pub(crate) fn poll(&mut self, safety: &Safety) -> Poll<Option<Result<Bytes, Error>>> {
+        if self.payload.is_none() {
+            return Poll::Ready(None);
+        }
+
+        let Some(mut payload) = self
+            .payload
+            .as_ref()
+            .expect("Field should not be polled after completion")
+            .get_mut(safety)
+        else {
+            return Poll::Pending;
+        };
+
+        if !self.eof {
+            let res = if let Some(ref mut len) = self.length {
+                Self::read_len(&mut payload, len)
+            } else {
+                Self::read_stream(&mut payload, &self.boundary)
+            };
+
+            match ready!(res) {
+                Some(Ok(bytes)) => return Poll::Ready(Some(Ok(bytes))),
+                Some(Err(err)) => return Poll::Ready(Some(Err(err))),
+                None => self.eof = true,
+            }
+        }
+
+        let result = match payload.readline() {
+            Ok(None) => Poll::Pending,
+            Ok(Some(line)) => {
+                if line.as_ref() != b"\r\n" {
+                    log::warn!("multipart field did not read all the data or it is malformed");
+                }
+                Poll::Ready(None)
+            }
+            Err(err) => Poll::Ready(Some(Err(err))),
+        };
+
+        drop(payload);
+
+        if let Poll::Ready(None) = result {
+            // drop payload buffer and make future un-poll-able
+            let _ = self.payload.take();
+        }
+
+        result
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use futures_util::{stream, StreamExt as _};
+
+    use super::*;
+    use crate::Multipart;
+
+    // TODO: use test utility when multi-file support is introduced
+    fn create_double_request_with_header() -> (Bytes, HeaderMap) {
+        let bytes = Bytes::from(
+            "testasdadsad\r\n\
+             --abbc761f78ff4d7cb7573b5a23f96ef0\r\n\
+             Content-Disposition: form-data; name=\"file\"; filename=\"fn.txt\"\r\n\
+             Content-Type: text/plain; charset=utf-8\r\n\
+             \r\n\
+             one+one+one\r\n\
+             --abbc761f78ff4d7cb7573b5a23f96ef0\r\n\
+             Content-Disposition: form-data; name=\"file\"; filename=\"fn.txt\"\r\n\
+             Content-Type: text/plain; charset=utf-8\r\n\
+             \r\n\
+             two+two+two\r\n\
+             --abbc761f78ff4d7cb7573b5a23f96ef0--\r\n",
+        );
+        let mut headers = HeaderMap::new();
+        headers.insert(
+            header::CONTENT_TYPE,
+            header::HeaderValue::from_static(
+                "multipart/mixed; boundary=\"abbc761f78ff4d7cb7573b5a23f96ef0\"",
+            ),
+        );
+        (bytes, headers)
+    }
+
+    #[actix_rt::test]
+    async fn bytes_unlimited() {
+        let (body, headers) = create_double_request_with_header();
+
+        let mut multipart = Multipart::new(&headers, stream::iter([Ok(body)]));
+
+        let field = multipart
+            .next()
+            .await
+            .expect("multipart should have two fields")
+            .expect("multipart body should be well formatted")
+            .bytes(usize::MAX)
+            .await
+            .expect("field data should not be size limited")
+            .expect("reading field data should not error");
+        assert_eq!(field, "one+one+one");
+
+        let field = multipart
+            .next()
+            .await
+            .expect("multipart should have two fields")
+            .expect("multipart body should be well formatted")
+            .bytes(usize::MAX)
+            .await
+            .expect("field data should not be size limited")
+            .expect("reading field data should not error");
+        assert_eq!(field, "two+two+two");
+    }
+
+    #[actix_rt::test]
+    async fn bytes_limited() {
+        let (body, headers) = create_double_request_with_header();
+
+        let mut multipart = Multipart::new(&headers, stream::iter([Ok(body)]));
+
+        multipart
+            .next()
+            .await
+            .expect("multipart should have two fields")
+            .expect("multipart body should be well formatted")
+            .bytes(8) // smaller than data size
+            .await
+            .expect_err("field data should be size limited");
+
+        // next field still readable
+        let field = multipart
+            .next()
+            .await
+            .expect("multipart should have two fields")
+            .expect("multipart body should be well formatted")
+            .bytes(usize::MAX)
+            .await
+            .expect("field data should not be size limited")
+            .expect("reading field data should not error");
+        assert_eq!(field, "two+two+two");
+    }
+}
diff --git a/actix-multipart/src/form/bytes.rs b/actix-multipart/src/form/bytes.rs
index 3c5e2eb10..51b0cf7d9 100644
--- a/actix-multipart/src/form/bytes.rs
+++ b/actix-multipart/src/form/bytes.rs
@@ -1,7 +1,6 @@
 //! Reads a field into memory.
 
-use actix_web::HttpRequest;
-use bytes::BytesMut;
+use actix_web::{web::BytesMut, HttpRequest};
 use futures_core::future::LocalBoxFuture;
 use futures_util::TryStreamExt as _;
 use mime::Mime;
@@ -15,7 +14,7 @@ use crate::{
 #[derive(Debug)]
 pub struct Bytes {
     /// The data.
-    pub data: bytes::Bytes,
+    pub data: actix_web::web::Bytes,
 
     /// The value of the `Content-Type` header.
     pub content_type: Option<Mime>,
@@ -41,8 +40,9 @@ impl<'t> FieldReader<'t> for Bytes {
                 content_type: field.content_type().map(ToOwned::to_owned),
                 file_name: field
                     .content_disposition()
+                    .expect("multipart form fields should have a content-disposition header")
                     .get_filename()
-                    .map(str::to_owned),
+                    .map(ToOwned::to_owned),
             })
         })
     }
diff --git a/actix-multipart/src/form/json.rs b/actix-multipart/src/form/json.rs
index bb4e03bf6..70874e5de 100644
--- a/actix-multipart/src/form/json.rs
+++ b/actix-multipart/src/form/json.rs
@@ -32,7 +32,6 @@ where
     fn read_field(req: &'t HttpRequest, field: Field, limits: &'t mut Limits) -> Self::Future {
         Box::pin(async move {
             let config = JsonConfig::from_req(req);
-            let field_name = field.name().to_owned();
 
             if config.validate_content_type {
                 let valid = if let Some(mime) = field.content_type() {
@@ -43,17 +42,19 @@ where
 
                 if !valid {
                     return Err(MultipartError::Field {
-                        field_name,
+                        name: field.form_field_name,
                         source: config.map_error(req, JsonFieldError::ContentType),
                     });
                 }
             }
 
+            let form_field_name = field.form_field_name.clone();
+
             let bytes = Bytes::read_field(req, field, limits).await?;
 
             Ok(Json(serde_json::from_slice(bytes.data.as_ref()).map_err(
                 |err| MultipartError::Field {
-                    field_name,
+                    name: form_field_name,
                     source: config.map_error(req, JsonFieldError::Deserialize(err)),
                 },
             )?))
@@ -65,11 +66,11 @@ where
 #[non_exhaustive]
 pub enum JsonFieldError {
     /// Deserialize error.
-    #[display(fmt = "Json deserialize error: {}", _0)]
+    #[display("Json deserialize error: {}", _0)]
     Deserialize(serde_json::Error),
 
     /// Content type error.
-    #[display(fmt = "Content type error")]
+    #[display("Content type error")]
     ContentType,
 }
 
@@ -133,8 +134,7 @@ impl Default for JsonConfig {
 mod tests {
     use std::collections::HashMap;
 
-    use actix_web::{http::StatusCode, web, App, HttpResponse, Responder};
-    use bytes::Bytes;
+    use actix_web::{http::StatusCode, web, web::Bytes, App, HttpResponse, Responder};
 
     use crate::form::{
         json::{Json, JsonConfig},
diff --git a/actix-multipart/src/form/mod.rs b/actix-multipart/src/form/mod.rs
index 68cdefec5..693a45e8e 100644
--- a/actix-multipart/src/form/mod.rs
+++ b/actix-multipart/src/form/mod.rs
@@ -1,4 +1,4 @@
-//! Process and extract typed data from a multipart stream.
+//! Extract and process typed data from fields of a `multipart/form-data` request.
 
 use std::{
     any::Any,
@@ -80,13 +80,13 @@ where
         state: &'t mut State,
         duplicate_field: DuplicateField,
     ) -> Self::Future {
-        if state.contains_key(field.name()) {
+        if state.contains_key(&field.form_field_name) {
             match duplicate_field {
                 DuplicateField::Ignore => return Box::pin(ready(Ok(()))),
 
                 DuplicateField::Deny => {
                     return Box::pin(ready(Err(MultipartError::DuplicateField(
-                        field.name().to_owned(),
+                        field.form_field_name,
                     ))))
                 }
 
@@ -95,7 +95,7 @@ where
         }
 
         Box::pin(async move {
-            let field_name = field.name().to_owned();
+            let field_name = field.form_field_name.clone();
             let t = T::read_field(req, field, limits).await?;
             state.insert(field_name, Box::new(t));
             Ok(())
@@ -123,10 +123,8 @@ where
         Box::pin(async move {
             // Note: Vec GroupReader always allows duplicates
 
-            let field_name = field.name().to_owned();
-
             let vec = state
-                .entry(field_name)
+                .entry(field.form_field_name.clone())
                 .or_insert_with(|| Box::<Vec<T>>::default())
                 .downcast_mut::<Vec<T>>()
                 .unwrap();
@@ -159,13 +157,13 @@ where
         state: &'t mut State,
         duplicate_field: DuplicateField,
     ) -> Self::Future {
-        if state.contains_key(field.name()) {
+        if state.contains_key(&field.form_field_name) {
             match duplicate_field {
                 DuplicateField::Ignore => return Box::pin(ready(Ok(()))),
 
                 DuplicateField::Deny => {
                     return Box::pin(ready(Err(MultipartError::DuplicateField(
-                        field.name().to_owned(),
+                        field.form_field_name,
                     ))))
                 }
 
@@ -174,7 +172,7 @@ where
         }
 
         Box::pin(async move {
-            let field_name = field.name().to_owned();
+            let field_name = field.form_field_name.clone();
             let t = T::read_field(req, field, limits).await?;
             state.insert(field_name, Box::new(t));
             Ok(())
@@ -281,6 +279,9 @@ impl Limits {
 /// [`MultipartCollect`] trait. You should use the [`macro@MultipartForm`] macro to derive this
 /// for your struct.
 ///
+/// Note that this extractor rejects requests with any other Content-Type such as `multipart/mixed`,
+/// `multipart/related`, or non-multipart media types.
+///
 /// Add a [`MultipartFormConfig`] to your app data to configure extraction.
 #[derive(Deref, DerefMut)]
 pub struct MultipartForm<T: MultipartCollect>(pub T);
@@ -294,14 +295,24 @@ impl<T: MultipartCollect> MultipartForm<T> {
 
 impl<T> FromRequest for MultipartForm<T>
 where
-    T: MultipartCollect,
+    T: MultipartCollect + 'static,
 {
     type Error = Error;
     type Future = LocalBoxFuture<'static, Result<Self, Self::Error>>;
 
     #[inline]
     fn from_request(req: &HttpRequest, payload: &mut dev::Payload) -> Self::Future {
-        let mut payload = Multipart::new(req.headers(), payload.take());
+        let mut multipart = Multipart::from_req(req, payload);
+
+        let content_type = match multipart.content_type_or_bail() {
+            Ok(content_type) => content_type,
+            Err(err) => return Box::pin(ready(Err(err.into()))),
+        };
+
+        if content_type.subtype() != mime::FORM_DATA {
+            // this extractor only supports multipart/form-data
+            return Box::pin(ready(Err(MultipartError::ContentTypeIncompatible.into())));
+        };
 
         let config = MultipartFormConfig::from_req(req);
         let mut limits = Limits::new(config.total_limit, config.memory_limit);
@@ -313,14 +324,20 @@ where
         Box::pin(
             async move {
                 let mut state = State::default();
-                // We need to ensure field limits are shared for all instances of this field name
+
+                // ensure limits are shared for all fields with this name
                 let mut field_limits = HashMap::<String, Option<usize>>::new();
 
-                while let Some(field) = payload.try_next().await? {
+                while let Some(field) = multipart.try_next().await? {
+                    debug_assert!(
+                        !field.form_field_name.is_empty(),
+                        "multipart form fields should have names",
+                    );
+
                     // Retrieve the limit for this field
                     let entry = field_limits
-                        .entry(field.name().to_owned())
-                        .or_insert_with(|| T::limit(field.name()));
+                        .entry(field.form_field_name.clone())
+                        .or_insert_with(|| T::limit(&field.form_field_name));
 
                     limits.field_limit_remaining.clone_from(entry);
 
@@ -329,6 +346,7 @@ where
                     // Update the stored limit
                     *entry = limits.field_limit_remaining;
                 }
+
                 let inner = T::from_state(state)?;
                 Ok(MultipartForm(inner))
             }
@@ -752,6 +770,41 @@ mod tests {
         assert_eq!(response.status(), StatusCode::BAD_REQUEST);
     }
 
+    #[actix_rt::test]
+    async fn non_multipart_form_data() {
+        #[derive(MultipartForm)]
+        struct TestNonMultipartFormData {
+            #[allow(unused)]
+            #[multipart(limit = "30B")]
+            foo: Text<String>,
+        }
+
+        async fn non_multipart_form_data_route(
+            _form: MultipartForm<TestNonMultipartFormData>,
+        ) -> String {
+            unreachable!("request is sent with multipart/mixed");
+        }
+
+        let srv = actix_test::start(|| {
+            App::new().route("/", web::post().to(non_multipart_form_data_route))
+        });
+
+        let mut form = multipart::Form::default();
+        form.add_text("foo", "foo");
+
+        // mangle content-type, keeping the boundary
+        let ct = form.content_type().replacen("/form-data", "/mixed", 1);
+
+        let res = Client::default()
+            .post(srv.url("/"))
+            .content_type(ct)
+            .send_body(multipart::Body::from(form))
+            .await
+            .unwrap();
+
+        assert_eq!(res.status(), StatusCode::UNSUPPORTED_MEDIA_TYPE);
+    }
+
     #[should_panic(expected = "called `Result::unwrap()` on an `Err` value: Connect(Disconnected)")]
     #[actix_web::test]
     async fn field_try_next_panic() {
diff --git a/actix-multipart/src/form/tempfile.rs b/actix-multipart/src/form/tempfile.rs
index 9371a026b..218b91bff 100644
--- a/actix-multipart/src/form/tempfile.rs
+++ b/actix-multipart/src/form/tempfile.rs
@@ -42,38 +42,36 @@ impl<'t> FieldReader<'t> for TempFile {
     fn read_field(req: &'t HttpRequest, mut field: Field, limits: &'t mut Limits) -> Self::Future {
         Box::pin(async move {
             let config = TempFileConfig::from_req(req);
-            let field_name = field.name().to_owned();
             let mut size = 0;
 
-            let file = config
-                .create_tempfile()
-                .map_err(|err| config.map_error(req, &field_name, TempFileError::FileIo(err)))?;
+            let file = config.create_tempfile().map_err(|err| {
+                config.map_error(req, &field.form_field_name, TempFileError::FileIo(err))
+            })?;
 
-            let mut file_async =
-                tokio::fs::File::from_std(file.reopen().map_err(|err| {
-                    config.map_error(req, &field_name, TempFileError::FileIo(err))
-                })?);
+            let mut file_async = tokio::fs::File::from_std(file.reopen().map_err(|err| {
+                config.map_error(req, &field.form_field_name, TempFileError::FileIo(err))
+            })?);
 
             while let Some(chunk) = field.try_next().await? {
                 limits.try_consume_limits(chunk.len(), false)?;
                 size += chunk.len();
                 file_async.write_all(chunk.as_ref()).await.map_err(|err| {
-                    config.map_error(req, &field_name, TempFileError::FileIo(err))
+                    config.map_error(req, &field.form_field_name, TempFileError::FileIo(err))
                 })?;
             }
 
-            file_async
-                .flush()
-                .await
-                .map_err(|err| config.map_error(req, &field_name, TempFileError::FileIo(err)))?;
+            file_async.flush().await.map_err(|err| {
+                config.map_error(req, &field.form_field_name, TempFileError::FileIo(err))
+            })?;
 
             Ok(TempFile {
                 file,
                 content_type: field.content_type().map(ToOwned::to_owned),
                 file_name: field
                     .content_disposition()
+                    .expect("multipart form fields should have a content-disposition header")
                     .get_filename()
-                    .map(str::to_owned),
+                    .map(ToOwned::to_owned),
                 size,
             })
         })
@@ -84,7 +82,7 @@ impl<'t> FieldReader<'t> for TempFile {
 #[non_exhaustive]
 pub enum TempFileError {
     /// File I/O Error
-    #[display(fmt = "File I/O error: {}", _0)]
+    #[display("File I/O error: {}", _0)]
     FileIo(std::io::Error),
 }
 
@@ -137,7 +135,7 @@ impl TempFileConfig {
         };
 
         MultipartError::Field {
-            field_name: field_name.to_owned(),
+            name: field_name.to_owned(),
             source,
         }
     }
diff --git a/actix-multipart/src/form/text.rs b/actix-multipart/src/form/text.rs
index 83e211524..b56a20353 100644
--- a/actix-multipart/src/form/text.rs
+++ b/actix-multipart/src/form/text.rs
@@ -36,7 +36,6 @@ where
     fn read_field(req: &'t HttpRequest, field: Field, limits: &'t mut Limits) -> Self::Future {
         Box::pin(async move {
             let config = TextConfig::from_req(req);
-            let field_name = field.name().to_owned();
 
             if config.validate_content_type {
                 let valid = if let Some(mime) = field.content_type() {
@@ -49,22 +48,24 @@ where
 
                 if !valid {
                     return Err(MultipartError::Field {
-                        field_name,
+                        name: field.form_field_name,
                         source: config.map_error(req, TextError::ContentType),
                     });
                 }
             }
 
+            let form_field_name = field.form_field_name.clone();
+
             let bytes = Bytes::read_field(req, field, limits).await?;
 
             let text = str::from_utf8(&bytes.data).map_err(|err| MultipartError::Field {
-                field_name: field_name.clone(),
+                name: form_field_name.clone(),
                 source: config.map_error(req, TextError::Utf8Error(err)),
             })?;
 
             Ok(Text(serde_plain::from_str(text).map_err(|err| {
                 MultipartError::Field {
-                    field_name,
+                    name: form_field_name,
                     source: config.map_error(req, TextError::Deserialize(err)),
                 }
             })?))
@@ -76,15 +77,15 @@ where
 #[non_exhaustive]
 pub enum TextError {
     /// UTF-8 decoding error.
-    #[display(fmt = "UTF-8 decoding error: {}", _0)]
+    #[display("UTF-8 decoding error: {}", _0)]
     Utf8Error(str::Utf8Error),
 
     /// Deserialize error.
-    #[display(fmt = "Plain text deserialize error: {}", _0)]
+    #[display("Plain text deserialize error: {}", _0)]
     Deserialize(serde_plain::Error),
 
     /// Content type error.
-    #[display(fmt = "Content type error")]
+    #[display("Content type error")]
     ContentType,
 }
 
diff --git a/actix-multipart/src/lib.rs b/actix-multipart/src/lib.rs
index 51b06db38..ca5166d33 100644
--- a/actix-multipart/src/lib.rs
+++ b/actix-multipart/src/lib.rs
@@ -1,11 +1,19 @@
-//! Multipart form support for Actix Web.
+//! Multipart request & form support for Actix Web.
+//!
+//! The [`Multipart`] extractor aims to support all kinds of `multipart/*` requests, including
+//! `multipart/form-data`, `multipart/related` and `multipart/mixed`. This is a lower-level
+//! extractor which supports reading [multipart fields](Field), in the order they are sent by the
+//! client.
+//!
+//! Due to additional requirements for `multipart/form-data` requests, the higher level
+//! [`MultipartForm`] extractor and derive macro only supports this media type.
 //!
 //! # Examples
 //!
 //! ```no_run
 //! use actix_web::{post, App, HttpServer, Responder};
 //!
-//! use actix_multipart::form::{json::Json as MPJson, tempfile::TempFile, MultipartForm};
+//! use actix_multipart::form::{json::Json as MpJson, tempfile::TempFile, MultipartForm, MultipartFormConfig};
 //! use serde::Deserialize;
 //!
 //! #[derive(Debug, Deserialize)]
@@ -15,9 +23,10 @@
 //!
 //! #[derive(Debug, MultipartForm)]
 //! struct UploadForm {
+//!     // Note: the form is also subject to the global limits configured using `MultipartFormConfig`.
 //!     #[multipart(limit = "100MB")]
 //!     file: TempFile,
-//!     json: MPJson<Metadata>,
+//!     json: MpJson<Metadata>,
 //! }
 //!
 //! #[post("/videos")]
@@ -30,19 +39,32 @@
 //!
 //! #[actix_web::main]
 //! async fn main() -> std::io::Result<()> {
-//!     HttpServer::new(move || App::new().service(post_video))
-//!         .bind(("127.0.0.1", 8080))?
-//!         .run()
-//!         .await
+//!     HttpServer::new(move || {
+//!         App::new()
+//!             .service(post_video)
+//!             // Also increase the global total limit to 100MiB.
+//!             .app_data(MultipartFormConfig::default().total_limit(100 * 1024 * 1024))
+//!     })
+//!     .bind(("127.0.0.1", 8080))?
+//!     .run()
+//!     .await
 //! }
 //! ```
+//!
+//! cURL request:
+//!
+//! ```sh
+//! curl -v --request POST \
+//!   --url http://localhost:8080/videos \
+//!   -F 'json={"name": "Cargo.lock"};type=application/json' \
+//!   -F file=@./Cargo.lock
+//! ```
+//!
+//! [`MultipartForm`]: struct@form::MultipartForm
 
-#![deny(rust_2018_idioms, nonstandard_style)]
-#![warn(future_incompatible)]
-#![allow(clippy::borrow_interior_mutable_const)]
 #![doc(html_logo_url = "https://actix.rs/img/logo.png")]
 #![doc(html_favicon_url = "https://actix.rs/favicon.ico")]
-#![cfg_attr(docsrs, feature(doc_auto_cfg))]
+#![cfg_attr(docsrs, feature(doc_cfg))]
 
 // This allows us to use the actix_multipart_derive within this crate's tests
 #[cfg(test)]
@@ -50,14 +72,15 @@ extern crate self as actix_multipart;
 
 mod error;
 mod extractor;
+pub(crate) mod field;
 pub mod form;
-mod server;
+mod multipart;
+pub(crate) mod payload;
+pub(crate) mod safety;
 pub mod test;
 
 pub use self::{
-    error::MultipartError,
-    server::{Field, Multipart},
-    test::{
-        create_form_data_payload_and_headers, create_form_data_payload_and_headers_with_boundary,
-    },
+    error::Error as MultipartError,
+    field::{Field, LimitExceeded},
+    multipart::Multipart,
 };
diff --git a/actix-multipart/src/multipart.rs b/actix-multipart/src/multipart.rs
new file mode 100644
index 000000000..e38fbde9e
--- /dev/null
+++ b/actix-multipart/src/multipart.rs
@@ -0,0 +1,883 @@
+//! Multipart response payload support.
+
+use std::{
+    cell::RefCell,
+    pin::Pin,
+    rc::Rc,
+    task::{Context, Poll},
+};
+
+use actix_web::{
+    dev,
+    error::{ParseError, PayloadError},
+    http::header::{self, ContentDisposition, HeaderMap, HeaderName, HeaderValue},
+    web::Bytes,
+    HttpRequest,
+};
+use futures_core::stream::Stream;
+use mime::Mime;
+
+use crate::{
+    error::Error,
+    field::InnerField,
+    payload::{PayloadBuffer, PayloadRef},
+    safety::Safety,
+    Field,
+};
+
+const MAX_HEADERS: usize = 32;
+
+/// The server-side implementation of `multipart/form-data` requests.
+///
+/// This will parse the incoming stream into `MultipartItem` instances via its `Stream`
+/// implementation. `MultipartItem::Field` contains multipart field. `MultipartItem::Multipart` is
+/// used for nested multipart streams.
+pub struct Multipart {
+    flow: Flow,
+    safety: Safety,
+}
+
+enum Flow {
+    InFlight(Inner),
+
+    /// Error container is Some until an error is returned out of the flow.
+    Error(Option<Error>),
+}
+
+impl Multipart {
+    /// Creates multipart instance from parts.
+    pub fn new<S>(headers: &HeaderMap, stream: S) -> Self
+    where
+        S: Stream<Item = Result<Bytes, PayloadError>> + 'static,
+    {
+        match Self::find_ct_and_boundary(headers) {
+            Ok((ct, boundary)) => Self::from_ct_and_boundary(ct, boundary, stream),
+            Err(err) => Self::from_error(err),
+        }
+    }
+
+    /// Creates multipart instance from parts.
+    pub(crate) fn from_req(req: &HttpRequest, payload: &mut dev::Payload) -> Self {
+        match Self::find_ct_and_boundary(req.headers()) {
+            Ok((ct, boundary)) => Self::from_ct_and_boundary(ct, boundary, payload.take()),
+            Err(err) => Self::from_error(err),
+        }
+    }
+
+    /// Extract Content-Type and boundary info from headers.
+    pub(crate) fn find_ct_and_boundary(headers: &HeaderMap) -> Result<(Mime, String), Error> {
+        let content_type = headers
+            .get(&header::CONTENT_TYPE)
+            .ok_or(Error::ContentTypeMissing)?
+            .to_str()
+            .ok()
+            .and_then(|content_type| content_type.parse::<Mime>().ok())
+            .ok_or(Error::ContentTypeParse)?;
+
+        if content_type.type_() != mime::MULTIPART {
+            return Err(Error::ContentTypeIncompatible);
+        }
+
+        let boundary = content_type
+            .get_param(mime::BOUNDARY)
+            .ok_or(Error::BoundaryMissing)?
+            .as_str()
+            .to_owned();
+
+        Ok((content_type, boundary))
+    }
+
+    /// Constructs a new multipart reader from given Content-Type, boundary, and stream.
+    pub(crate) fn from_ct_and_boundary<S>(ct: Mime, boundary: String, stream: S) -> Multipart
+    where
+        S: Stream<Item = Result<Bytes, PayloadError>> + 'static,
+    {
+        Multipart {
+            safety: Safety::new(),
+            flow: Flow::InFlight(Inner {
+                payload: PayloadRef::new(PayloadBuffer::new(stream)),
+                content_type: ct,
+                boundary,
+                state: State::FirstBoundary,
+                item: Item::None,
+            }),
+        }
+    }
+
+    /// Constructs a new multipart reader from given `MultipartError`.
+    pub(crate) fn from_error(err: Error) -> Multipart {
+        Multipart {
+            flow: Flow::Error(Some(err)),
+            safety: Safety::new(),
+        }
+    }
+
+    /// Return requests parsed Content-Type or raise the stored error.
+    pub(crate) fn content_type_or_bail(&mut self) -> Result<mime::Mime, Error> {
+        match self.flow {
+            Flow::InFlight(ref inner) => Ok(inner.content_type.clone()),
+            Flow::Error(ref mut err) => Err(err
+                .take()
+                .expect("error should not be taken after it was returned")),
+        }
+    }
+}
+
+impl Stream for Multipart {
+    type Item = Result<Field, Error>;
+
+    fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
+        let this = self.get_mut();
+
+        match this.flow {
+            Flow::InFlight(ref mut inner) => {
+                if let Some(mut buffer) = inner.payload.get_mut(&this.safety) {
+                    // check safety and poll read payload to buffer.
+                    buffer.poll_stream(cx)?;
+                } else if !this.safety.is_clean() {
+                    // safety violation
+                    return Poll::Ready(Some(Err(Error::NotConsumed)));
+                } else {
+                    return Poll::Pending;
+                }
+
+                inner.poll(&this.safety, cx)
+            }
+
+            Flow::Error(ref mut err) => Poll::Ready(Some(Err(err
+                .take()
+                .expect("Multipart polled after finish")))),
+        }
+    }
+}
+
+#[derive(PartialEq, Debug)]
+enum State {
+    /// Skip data until first boundary.
+    FirstBoundary,
+
+    /// Reading boundary.
+    Boundary,
+
+    /// Reading Headers.
+    Headers,
+
+    /// Stream EOF.
+    Eof,
+}
+
+enum Item {
+    None,
+    Field(Rc<RefCell<InnerField>>),
+}
+
+struct Inner {
+    /// Request's payload stream & buffer.
+    payload: PayloadRef,
+
+    /// Request's Content-Type.
+    ///
+    /// Guaranteed to have "multipart" top-level media type, i.e., `multipart/*`.
+    content_type: Mime,
+
+    /// Field boundary.
+    boundary: String,
+
+    state: State,
+    item: Item,
+}
+
+impl Inner {
+    fn read_field_headers(payload: &mut PayloadBuffer) -> Result<Option<HeaderMap>, Error> {
+        match payload.read_until(b"\r\n\r\n")? {
+            None => {
+                if payload.eof {
+                    Err(Error::Incomplete)
+                } else {
+                    Ok(None)
+                }
+            }
+
+            Some(bytes) => {
+                let mut hdrs = [httparse::EMPTY_HEADER; MAX_HEADERS];
+
+                match httparse::parse_headers(&bytes, &mut hdrs).map_err(ParseError::from)? {
+                    httparse::Status::Complete((_, hdrs)) => {
+                        // convert headers
+                        let mut headers = HeaderMap::with_capacity(hdrs.len());
+
+                        for h in hdrs {
+                            let name =
+                                HeaderName::try_from(h.name).map_err(|_| ParseError::Header)?;
+                            let value =
+                                HeaderValue::try_from(h.value).map_err(|_| ParseError::Header)?;
+                            headers.append(name, value);
+                        }
+
+                        Ok(Some(headers))
+                    }
+
+                    httparse::Status::Partial => Err(ParseError::Header.into()),
+                }
+            }
+        }
+    }
+
+    /// Reads a field boundary from the payload buffer (and discards it).
+    ///
+    /// Reads "in-between" and "final" boundaries. E.g. for boundary = "foo":
+    ///
+    /// ```plain
+    /// --foo    <-- in-between fields
+    /// --foo--  <-- end of request body, should be followed by EOF
+    /// ```
+    ///
+    /// Returns:
+    ///
+    /// - `Ok(Some(true))` - final field boundary read (EOF)
+    /// - `Ok(Some(false))` - field boundary read
+    /// - `Ok(None)` - boundary not found, more data needs reading
+    /// - `Err(BoundaryMissing)` - multipart boundary is missing
+    fn read_boundary(payload: &mut PayloadBuffer, boundary: &str) -> Result<Option<bool>, Error> {
+        // TODO: need to read epilogue
+        let chunk = match payload.readline_or_eof()? {
+            // TODO: this might be okay as a let Some() else return Ok(None)
+            None => return Ok(payload.eof.then_some(true)),
+            Some(chunk) => chunk,
+        };
+
+        const BOUNDARY_MARKER: &[u8] = b"--";
+        const LINE_BREAK: &[u8] = b"\r\n";
+
+        let boundary_len = boundary.len();
+
+        if chunk.len() < boundary_len + 2 + 2
+            || !chunk.starts_with(BOUNDARY_MARKER)
+            || &chunk[2..boundary_len + 2] != boundary.as_bytes()
+        {
+            return Err(Error::BoundaryMissing);
+        }
+
+        // chunk facts:
+        // - long enough to contain boundary + 2 markers or 1 marker and line-break
+        // - starts with boundary marker
+        // - chunk contains correct boundary
+
+        if &chunk[boundary_len + 2..] == LINE_BREAK {
+            // boundary is followed by line-break, indicating more fields to come
+            return Ok(Some(false));
+        }
+
+        // boundary is followed by marker
+        if &chunk[boundary_len + 2..boundary_len + 4] == BOUNDARY_MARKER
+            && (
+                // chunk is exactly boundary len + 2 markers
+                chunk.len() == boundary_len + 2 + 2
+                // final boundary is allowed to end with a line-break
+                || &chunk[boundary_len + 4..] == LINE_BREAK
+            )
+        {
+            return Ok(Some(true));
+        }
+
+        Err(Error::BoundaryMissing)
+    }
+
+    fn skip_until_boundary(
+        payload: &mut PayloadBuffer,
+        boundary: &str,
+    ) -> Result<Option<bool>, Error> {
+        let mut eof = false;
+
+        loop {
+            match payload.readline()? {
+                Some(chunk) => {
+                    if chunk.is_empty() {
+                        return Err(Error::BoundaryMissing);
+                    }
+                    if chunk.len() < boundary.len() {
+                        continue;
+                    }
+                    if &chunk[..2] == b"--" && &chunk[2..chunk.len() - 2] == boundary.as_bytes() {
+                        break;
+                    } else {
+                        if chunk.len() < boundary.len() + 2 {
+                            continue;
+                        }
+                        let b: &[u8] = boundary.as_ref();
+                        if &chunk[..boundary.len()] == b
+                            && &chunk[boundary.len()..boundary.len() + 2] == b"--"
+                        {
+                            eof = true;
+                            break;
+                        }
+                    }
+                }
+                None => {
+                    return if payload.eof {
+                        Err(Error::Incomplete)
+                    } else {
+                        Ok(None)
+                    };
+                }
+            }
+        }
+        Ok(Some(eof))
+    }
+
+    fn poll(&mut self, safety: &Safety, cx: &Context<'_>) -> Poll<Option<Result<Field, Error>>> {
+        if self.state == State::Eof {
+            Poll::Ready(None)
+        } else {
+            // release field
+            loop {
+                // Nested multipart streams of fields has to be consumed
+                // before switching to next
+                if safety.current() {
+                    let stop = match self.item {
+                        Item::Field(ref mut field) => match field.borrow_mut().poll(safety) {
+                            Poll::Pending => return Poll::Pending,
+                            Poll::Ready(Some(Ok(_))) => continue,
+                            Poll::Ready(Some(Err(err))) => return Poll::Ready(Some(Err(err))),
+                            Poll::Ready(None) => true,
+                        },
+                        Item::None => false,
+                    };
+                    if stop {
+                        self.item = Item::None;
+                    }
+                    if let Item::None = self.item {
+                        break;
+                    }
+                }
+            }
+
+            let field_headers = if let Some(mut payload) = self.payload.get_mut(safety) {
+                match self.state {
+                    // read until first boundary
+                    State::FirstBoundary => {
+                        match Inner::skip_until_boundary(&mut payload, &self.boundary)? {
+                            None => return Poll::Pending,
+                            Some(eof) => {
+                                if eof {
+                                    self.state = State::Eof;
+                                    return Poll::Ready(None);
+                                } else {
+                                    self.state = State::Headers;
+                                }
+                            }
+                        }
+                    }
+
+                    // read boundary
+                    State::Boundary => match Inner::read_boundary(&mut payload, &self.boundary)? {
+                        None => return Poll::Pending,
+                        Some(eof) => {
+                            if eof {
+                                self.state = State::Eof;
+                                return Poll::Ready(None);
+                            } else {
+                                self.state = State::Headers;
+                            }
+                        }
+                    },
+
+                    _ => {}
+                }
+
+                // read field headers for next field
+                if self.state == State::Headers {
+                    if let Some(headers) = Inner::read_field_headers(&mut payload)? {
+                        self.state = State::Boundary;
+                        headers
+                    } else {
+                        return Poll::Pending;
+                    }
+                } else {
+                    unreachable!()
+                }
+            } else {
+                log::debug!("NotReady: field is in flight");
+                return Poll::Pending;
+            };
+
+            let field_content_disposition = field_headers
+                .get(&header::CONTENT_DISPOSITION)
+                .and_then(|cd| ContentDisposition::from_raw(cd).ok())
+                .filter(|content_disposition| {
+                    matches!(
+                        content_disposition.disposition,
+                        header::DispositionType::FormData,
+                    )
+                });
+
+            let form_field_name = if self.content_type.subtype() == mime::FORM_DATA {
+                // According to RFC 7578 §4.2, which relates to "multipart/form-data" requests
+                // specifically, fields must have a Content-Disposition header, its disposition
+                // type must be set as "form-data", and it must have a name parameter.
+
+                let Some(cd) = &field_content_disposition else {
+                    return Poll::Ready(Some(Err(Error::ContentDispositionMissing)));
+                };
+
+                let Some(field_name) = cd.get_name() else {
+                    return Poll::Ready(Some(Err(Error::ContentDispositionNameMissing)));
+                };
+
+                Some(field_name.to_owned())
+            } else {
+                None
+            };
+
+            // TODO: check out other multipart/* RFCs for specific requirements
+
+            let field_content_type: Option<Mime> = field_headers
+                .get(&header::CONTENT_TYPE)
+                .and_then(|ct| ct.to_str().ok())
+                .and_then(|ct| ct.parse().ok());
+
+            self.state = State::Boundary;
+
+            // nested multipart stream is not supported
+            if let Some(mime) = &field_content_type {
+                if mime.type_() == mime::MULTIPART {
+                    return Poll::Ready(Some(Err(Error::Nested)));
+                }
+            }
+
+            let field_inner =
+                InnerField::new_in_rc(self.payload.clone(), self.boundary.clone(), &field_headers)?;
+
+            self.item = Item::Field(Rc::clone(&field_inner));
+
+            Poll::Ready(Some(Ok(Field::new(
+                field_content_type,
+                field_content_disposition,
+                form_field_name,
+                field_headers,
+                safety.clone(cx),
+                field_inner,
+            ))))
+        }
+    }
+}
+
+impl Drop for Inner {
+    fn drop(&mut self) {
+        // InnerMultipartItem::Field has to be dropped first because of Safety.
+        self.item = Item::None;
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::time::Duration;
+
+    use actix_http::h1;
+    use actix_web::{
+        http::header::{DispositionParam, DispositionType},
+        rt,
+        test::TestRequest,
+        web::{BufMut as _, BytesMut},
+        FromRequest,
+    };
+    use assert_matches::assert_matches;
+    use futures_test::stream::StreamTestExt as _;
+    use futures_util::{stream, StreamExt as _};
+    use tokio::sync::mpsc;
+    use tokio_stream::wrappers::UnboundedReceiverStream;
+
+    use super::*;
+
+    const BOUNDARY: &str = "abbc761f78ff4d7cb7573b5a23f96ef0";
+
+    #[actix_rt::test]
+    async fn test_boundary() {
+        let headers = HeaderMap::new();
+        match Multipart::find_ct_and_boundary(&headers) {
+            Err(Error::ContentTypeMissing) => {}
+            _ => unreachable!("should not happen"),
+        }
+
+        let mut headers = HeaderMap::new();
+        headers.insert(
+            header::CONTENT_TYPE,
+            header::HeaderValue::from_static("test"),
+        );
+
+        match Multipart::find_ct_and_boundary(&headers) {
+            Err(Error::ContentTypeParse) => {}
+            _ => unreachable!("should not happen"),
+        }
+
+        let mut headers = HeaderMap::new();
+        headers.insert(
+            header::CONTENT_TYPE,
+            header::HeaderValue::from_static("multipart/mixed"),
+        );
+        match Multipart::find_ct_and_boundary(&headers) {
+            Err(Error::BoundaryMissing) => {}
+            _ => unreachable!("should not happen"),
+        }
+
+        let mut headers = HeaderMap::new();
+        headers.insert(
+            header::CONTENT_TYPE,
+            header::HeaderValue::from_static(
+                "multipart/mixed; boundary=\"5c02368e880e436dab70ed54e1c58209\"",
+            ),
+        );
+
+        assert_eq!(
+            Multipart::find_ct_and_boundary(&headers).unwrap().1,
+            "5c02368e880e436dab70ed54e1c58209",
+        );
+    }
+
+    fn create_stream() -> (
+        mpsc::UnboundedSender<Result<Bytes, PayloadError>>,
+        impl Stream<Item = Result<Bytes, PayloadError>>,
+    ) {
+        let (tx, rx) = mpsc::unbounded_channel();
+
+        (
+            tx,
+            UnboundedReceiverStream::new(rx).map(|res| res.map_err(|_| panic!())),
+        )
+    }
+
+    fn create_simple_request_with_header() -> (Bytes, HeaderMap) {
+        let (body, headers) = crate::test::create_form_data_payload_and_headers_with_boundary(
+            BOUNDARY,
+            "file",
+            Some("fn.txt".to_owned()),
+            Some(mime::TEXT_PLAIN_UTF_8),
+            Bytes::from_static(b"data"),
+        );
+
+        let mut buf = BytesMut::with_capacity(body.len() + 14);
+
+        // add junk before form to test pre-boundary data rejection
+        buf.put("testasdadsad\r\n".as_bytes());
+
+        buf.put(body);
+
+        (buf.freeze(), headers)
+    }
+
+    // TODO: use test utility when multi-file support is introduced
+    fn create_double_request_with_header() -> (Bytes, HeaderMap) {
+        let bytes = Bytes::from(
+            "testasdadsad\r\n\
+             --abbc761f78ff4d7cb7573b5a23f96ef0\r\n\
+             Content-Disposition: form-data; name=\"file\"; filename=\"fn.txt\"\r\n\
+             Content-Type: text/plain; charset=utf-8\r\nContent-Length: 4\r\n\r\n\
+             test\r\n\
+             --abbc761f78ff4d7cb7573b5a23f96ef0\r\n\
+             Content-Disposition: form-data; name=\"file\"; filename=\"fn.txt\"\r\n\
+             Content-Type: text/plain; charset=utf-8\r\nContent-Length: 4\r\n\r\n\
+             data\r\n\
+             --abbc761f78ff4d7cb7573b5a23f96ef0--\r\n",
+        );
+        let mut headers = HeaderMap::new();
+        headers.insert(
+            header::CONTENT_TYPE,
+            header::HeaderValue::from_static(
+                "multipart/mixed; boundary=\"abbc761f78ff4d7cb7573b5a23f96ef0\"",
+            ),
+        );
+        (bytes, headers)
+    }
+
+    #[actix_rt::test]
+    async fn test_multipart_no_end_crlf() {
+        let (sender, payload) = create_stream();
+        let (mut bytes, headers) = create_double_request_with_header();
+        let bytes_stripped = bytes.split_to(bytes.len()); // strip crlf
+
+        sender.send(Ok(bytes_stripped)).unwrap();
+        drop(sender); // eof
+
+        let mut multipart = Multipart::new(&headers, payload);
+
+        match multipart.next().await.unwrap() {
+            Ok(_) => {}
+            _ => unreachable!(),
+        }
+
+        match multipart.next().await.unwrap() {
+            Ok(_) => {}
+            _ => unreachable!(),
+        }
+
+        match multipart.next().await {
+            None => {}
+            _ => unreachable!(),
+        }
+    }
+
+    #[actix_rt::test]
+    async fn test_multipart() {
+        let (sender, payload) = create_stream();
+        let (bytes, headers) = create_double_request_with_header();
+
+        sender.send(Ok(bytes)).unwrap();
+
+        let mut multipart = Multipart::new(&headers, payload);
+        match multipart.next().await {
+            Some(Ok(mut field)) => {
+                let cd = field.content_disposition().unwrap();
+                assert_eq!(cd.disposition, DispositionType::FormData);
+                assert_eq!(cd.parameters[0], DispositionParam::Name("file".into()));
+
+                assert_eq!(field.content_type().unwrap().type_(), mime::TEXT);
+                assert_eq!(field.content_type().unwrap().subtype(), mime::PLAIN);
+
+                match field.next().await.unwrap() {
+                    Ok(chunk) => assert_eq!(chunk, "test"),
+                    _ => unreachable!(),
+                }
+                match field.next().await {
+                    None => {}
+                    _ => unreachable!(),
+                }
+            }
+            _ => unreachable!(),
+        }
+
+        match multipart.next().await.unwrap() {
+            Ok(mut field) => {
+                assert_eq!(field.content_type().unwrap().type_(), mime::TEXT);
+                assert_eq!(field.content_type().unwrap().subtype(), mime::PLAIN);
+
+                match field.next().await {
+                    Some(Ok(chunk)) => assert_eq!(chunk, "data"),
+                    _ => unreachable!(),
+                }
+                match field.next().await {
+                    None => {}
+                    _ => unreachable!(),
+                }
+            }
+            _ => unreachable!(),
+        }
+
+        match multipart.next().await {
+            None => {}
+            _ => unreachable!(),
+        }
+    }
+
+    // Loops, collecting all bytes until end-of-field
+    async fn get_whole_field(field: &mut Field) -> BytesMut {
+        let mut b = BytesMut::new();
+        loop {
+            match field.next().await {
+                Some(Ok(chunk)) => b.extend_from_slice(&chunk),
+                None => return b,
+                _ => unreachable!(),
+            }
+        }
+    }
+
+    #[actix_rt::test]
+    async fn test_stream() {
+        let (bytes, headers) = create_double_request_with_header();
+        let payload = stream::iter(bytes)
+            .map(|byte| Ok(Bytes::copy_from_slice(&[byte])))
+            .interleave_pending();
+
+        let mut multipart = Multipart::new(&headers, payload);
+        match multipart.next().await.unwrap() {
+            Ok(mut field) => {
+                let cd = field.content_disposition().unwrap();
+                assert_eq!(cd.disposition, DispositionType::FormData);
+                assert_eq!(cd.parameters[0], DispositionParam::Name("file".into()));
+
+                assert_eq!(field.content_type().unwrap().type_(), mime::TEXT);
+                assert_eq!(field.content_type().unwrap().subtype(), mime::PLAIN);
+
+                assert_eq!(get_whole_field(&mut field).await, "test");
+            }
+            _ => unreachable!(),
+        }
+
+        match multipart.next().await {
+            Some(Ok(mut field)) => {
+                assert_eq!(field.content_type().unwrap().type_(), mime::TEXT);
+                assert_eq!(field.content_type().unwrap().subtype(), mime::PLAIN);
+
+                assert_eq!(get_whole_field(&mut field).await, "data");
+            }
+            _ => unreachable!(),
+        }
+
+        match multipart.next().await {
+            None => {}
+            _ => unreachable!(),
+        }
+    }
+
+    #[actix_rt::test]
+    async fn test_multipart_from_error() {
+        let err = Error::ContentTypeMissing;
+        let mut multipart = Multipart::from_error(err);
+        assert!(multipart.next().await.unwrap().is_err())
+    }
+
+    #[actix_rt::test]
+    async fn test_multipart_from_boundary() {
+        let (_, payload) = create_stream();
+        let (_, headers) = create_simple_request_with_header();
+        let (ct, boundary) = Multipart::find_ct_and_boundary(&headers).unwrap();
+        let _ = Multipart::from_ct_and_boundary(ct, boundary, payload);
+    }
+
+    #[actix_rt::test]
+    async fn test_multipart_payload_consumption() {
+        // with sample payload and HttpRequest with no headers
+        let (_, inner_payload) = h1::Payload::create(false);
+        let mut payload = actix_web::dev::Payload::from(inner_payload);
+        let req = TestRequest::default().to_http_request();
+
+        // multipart should generate an error
+        let mut mp = Multipart::from_request(&req, &mut payload).await.unwrap();
+        assert!(mp.next().await.unwrap().is_err());
+
+        // and should not consume the payload
+        match payload {
+            actix_web::dev::Payload::H1 { .. } => {} //expected
+            _ => unreachable!(),
+        }
+    }
+
+    #[actix_rt::test]
+    async fn no_content_disposition_form_data() {
+        let bytes = Bytes::from(
+            "testasdadsad\r\n\
+             --abbc761f78ff4d7cb7573b5a23f96ef0\r\n\
+             Content-Type: text/plain; charset=utf-8\r\n\
+             Content-Length: 4\r\n\
+             \r\n\
+             test\r\n\
+             --abbc761f78ff4d7cb7573b5a23f96ef0\r\n",
+        );
+        let mut headers = HeaderMap::new();
+        headers.insert(
+            header::CONTENT_TYPE,
+            header::HeaderValue::from_static(
+                "multipart/form-data; boundary=\"abbc761f78ff4d7cb7573b5a23f96ef0\"",
+            ),
+        );
+        let payload = stream::iter(bytes)
+            .map(|byte| Ok(Bytes::copy_from_slice(&[byte])))
+            .interleave_pending();
+
+        let mut multipart = Multipart::new(&headers, payload);
+        let res = multipart.next().await.unwrap();
+        assert_matches!(
+            res.expect_err(
+                "according to RFC 7578, form-data fields require a content-disposition header"
+            ),
+            Error::ContentDispositionMissing
+        );
+    }
+
+    #[actix_rt::test]
+    async fn no_content_disposition_non_form_data() {
+        let bytes = Bytes::from(
+            "testasdadsad\r\n\
+             --abbc761f78ff4d7cb7573b5a23f96ef0\r\n\
+             Content-Type: text/plain; charset=utf-8\r\n\
+             Content-Length: 4\r\n\
+             \r\n\
+             test\r\n\
+             --abbc761f78ff4d7cb7573b5a23f96ef0\r\n",
+        );
+        let mut headers = HeaderMap::new();
+        headers.insert(
+            header::CONTENT_TYPE,
+            header::HeaderValue::from_static(
+                "multipart/mixed; boundary=\"abbc761f78ff4d7cb7573b5a23f96ef0\"",
+            ),
+        );
+        let payload = stream::iter(bytes)
+            .map(|byte| Ok(Bytes::copy_from_slice(&[byte])))
+            .interleave_pending();
+
+        let mut multipart = Multipart::new(&headers, payload);
+        let res = multipart.next().await.unwrap();
+        res.unwrap();
+    }
+
+    #[actix_rt::test]
+    async fn no_name_in_form_data_content_disposition() {
+        let bytes = Bytes::from(
+            "testasdadsad\r\n\
+             --abbc761f78ff4d7cb7573b5a23f96ef0\r\n\
+             Content-Disposition: form-data; filename=\"fn.txt\"\r\n\
+             Content-Type: text/plain; charset=utf-8\r\n\
+             Content-Length: 4\r\n\
+             \r\n\
+             test\r\n\
+             --abbc761f78ff4d7cb7573b5a23f96ef0\r\n",
+        );
+        let mut headers = HeaderMap::new();
+        headers.insert(
+            header::CONTENT_TYPE,
+            header::HeaderValue::from_static(
+                "multipart/form-data; boundary=\"abbc761f78ff4d7cb7573b5a23f96ef0\"",
+            ),
+        );
+        let payload = stream::iter(bytes)
+            .map(|byte| Ok(Bytes::copy_from_slice(&[byte])))
+            .interleave_pending();
+
+        let mut multipart = Multipart::new(&headers, payload);
+        let res = multipart.next().await.unwrap();
+        assert_matches!(
+            res.expect_err("according to RFC 7578, form-data fields require a name attribute"),
+            Error::ContentDispositionNameMissing
+        );
+    }
+
+    #[actix_rt::test]
+    async fn test_drop_multipart_dont_hang() {
+        let (sender, payload) = create_stream();
+        let (bytes, headers) = create_simple_request_with_header();
+        sender.send(Ok(bytes)).unwrap();
+        drop(sender); // eof
+
+        let mut multipart = Multipart::new(&headers, payload);
+        let mut field = multipart.next().await.unwrap().unwrap();
+
+        drop(multipart);
+
+        // should fail immediately
+        match field.next().await {
+            Some(Err(Error::NotConsumed)) => {}
+            _ => panic!(),
+        };
+    }
+
+    #[actix_rt::test]
+    async fn test_drop_field_awaken_multipart() {
+        let (sender, payload) = create_stream();
+        let (bytes, headers) = create_double_request_with_header();
+        sender.send(Ok(bytes)).unwrap();
+        drop(sender); // eof
+
+        let mut multipart = Multipart::new(&headers, payload);
+        let mut field = multipart.next().await.unwrap().unwrap();
+
+        let task = rt::spawn(async move {
+            rt::time::sleep(Duration::from_millis(500)).await;
+            assert_eq!(field.next().await.unwrap().unwrap(), "test");
+            drop(field);
+        });
+
+        // dropping field should awaken current task
+        let _ = multipart.next().await.unwrap().unwrap();
+        task.await.unwrap();
+    }
+}
diff --git a/actix-multipart/src/payload.rs b/actix-multipart/src/payload.rs
new file mode 100644
index 000000000..858634bc0
--- /dev/null
+++ b/actix-multipart/src/payload.rs
@@ -0,0 +1,255 @@
+use std::{
+    cell::{RefCell, RefMut},
+    cmp, mem,
+    pin::Pin,
+    rc::Rc,
+    task::{Context, Poll},
+};
+
+use actix_web::{
+    error::PayloadError,
+    web::{Bytes, BytesMut},
+};
+use futures_core::stream::{LocalBoxStream, Stream};
+
+use crate::{error::Error, safety::Safety};
+
+pub(crate) struct PayloadRef {
+    payload: Rc<RefCell<PayloadBuffer>>,
+}
+
+impl PayloadRef {
+    pub(crate) fn new(payload: PayloadBuffer) -> PayloadRef {
+        PayloadRef {
+            payload: Rc::new(RefCell::new(payload)),
+        }
+    }
+
+    pub(crate) fn get_mut(&self, safety: &Safety) -> Option<RefMut<'_, PayloadBuffer>> {
+        if safety.current() {
+            Some(self.payload.borrow_mut())
+        } else {
+            None
+        }
+    }
+}
+
+impl Clone for PayloadRef {
+    fn clone(&self) -> PayloadRef {
+        PayloadRef {
+            payload: Rc::clone(&self.payload),
+        }
+    }
+}
+
+/// Payload buffer.
+pub(crate) struct PayloadBuffer {
+    pub(crate) stream: LocalBoxStream<'static, Result<Bytes, PayloadError>>,
+    pub(crate) buf: BytesMut,
+    /// EOF flag. If true, no more payload reads will be attempted.
+    pub(crate) eof: bool,
+}
+
+impl PayloadBuffer {
+    /// Constructs new payload buffer.
+    pub(crate) fn new<S>(stream: S) -> Self
+    where
+        S: Stream<Item = Result<Bytes, PayloadError>> + 'static,
+    {
+        PayloadBuffer {
+            stream: Box::pin(stream),
+            buf: BytesMut::with_capacity(1_024), // pre-allocate 1KiB
+            eof: false,
+        }
+    }
+
+    pub(crate) fn poll_stream(&mut self, cx: &mut Context<'_>) -> Result<(), PayloadError> {
+        loop {
+            match Pin::new(&mut self.stream).poll_next(cx) {
+                Poll::Ready(Some(Ok(data))) => {
+                    self.buf.extend_from_slice(&data);
+                    // try to read more data
+                    continue;
+                }
+                Poll::Ready(Some(Err(err))) => return Err(err),
+                Poll::Ready(None) => {
+                    self.eof = true;
+                    return Ok(());
+                }
+                Poll::Pending => return Ok(()),
+            }
+        }
+    }
+
+    /// Reads exact number of bytes.
+    #[cfg(test)]
+    pub(crate) fn read_exact(&mut self, size: usize) -> Option<Bytes> {
+        if size <= self.buf.len() {
+            Some(self.buf.split_to(size).freeze())
+        } else {
+            None
+        }
+    }
+
+    pub(crate) fn read_max(&mut self, size: u64) -> Result<Option<Bytes>, Error> {
+        if !self.buf.is_empty() {
+            let size = cmp::min(self.buf.len() as u64, size) as usize;
+            Ok(Some(self.buf.split_to(size).freeze()))
+        } else if self.eof {
+            Err(Error::Incomplete)
+        } else {
+            Ok(None)
+        }
+    }
+
+    /// Reads until specified ending.
+    ///
+    /// Returns:
+    ///
+    /// - `Ok(Some(chunk))` - `needle` is found, with chunk ending after needle
+    /// - `Err(Incomplete)` - `needle` is not found and we're at EOF
+    /// - `Ok(None)` - `needle` is not found otherwise
+    pub(crate) fn read_until(&mut self, needle: &[u8]) -> Result<Option<Bytes>, Error> {
+        match memchr::memmem::find(&self.buf, needle) {
+            // buffer exhausted and EOF without finding needle
+            None if self.eof => Err(Error::Incomplete),
+
+            // needle not yet found
+            None => Ok(None),
+
+            // needle found, split chunk out of buf
+            Some(idx) => Ok(Some(self.buf.split_to(idx + needle.len()).freeze())),
+        }
+    }
+
+    /// Reads bytes until new line delimiter (`\n`, `0x0A`).
+    ///
+    /// Returns:
+    ///
+    /// - `Ok(Some(chunk))` - `needle` is found, with chunk ending after needle
+    /// - `Err(Incomplete)` - `needle` is not found and we're at EOF
+    /// - `Ok(None)` - `needle` is not found otherwise
+    #[inline]
+    pub(crate) fn readline(&mut self) -> Result<Option<Bytes>, Error> {
+        self.read_until(b"\n")
+    }
+
+    /// Reads bytes until new line delimiter or until EOF.
+    #[inline]
+    pub(crate) fn readline_or_eof(&mut self) -> Result<Option<Bytes>, Error> {
+        match self.readline() {
+            Err(Error::Incomplete) if self.eof => Ok(Some(self.buf.split().freeze())),
+            line => line,
+        }
+    }
+
+    /// Puts unprocessed data back to the buffer.
+    pub(crate) fn unprocessed(&mut self, data: Bytes) {
+        // TODO: use BytesMut::from when it's released, see https://github.com/tokio-rs/bytes/pull/710
+        let buf = BytesMut::from(&data[..]);
+        let buf = mem::replace(&mut self.buf, buf);
+        self.buf.extend_from_slice(&buf);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use actix_http::h1;
+    use futures_util::future::lazy;
+
+    use super::*;
+
+    #[actix_rt::test]
+    async fn basic() {
+        let (_, payload) = h1::Payload::create(false);
+        let mut payload = PayloadBuffer::new(payload);
+
+        assert_eq!(payload.buf.len(), 0);
+        lazy(|cx| payload.poll_stream(cx)).await.unwrap();
+        assert_eq!(None, payload.read_max(1).unwrap());
+    }
+
+    #[actix_rt::test]
+    async fn eof() {
+        let (mut sender, payload) = h1::Payload::create(false);
+        let mut payload = PayloadBuffer::new(payload);
+
+        assert_eq!(None, payload.read_max(4).unwrap());
+        sender.feed_data(Bytes::from("data"));
+        sender.feed_eof();
+        lazy(|cx| payload.poll_stream(cx)).await.unwrap();
+
+        assert_eq!(Some(Bytes::from("data")), payload.read_max(4).unwrap());
+        assert_eq!(payload.buf.len(), 0);
+        assert!(payload.read_max(1).is_err());
+        assert!(payload.eof);
+    }
+
+    #[actix_rt::test]
+    async fn err() {
+        let (mut sender, payload) = h1::Payload::create(false);
+        let mut payload = PayloadBuffer::new(payload);
+        assert_eq!(None, payload.read_max(1).unwrap());
+        sender.set_error(PayloadError::Incomplete(None));
+        lazy(|cx| payload.poll_stream(cx)).await.err().unwrap();
+    }
+
+    #[actix_rt::test]
+    async fn read_max() {
+        let (mut sender, payload) = h1::Payload::create(false);
+        let mut payload = PayloadBuffer::new(payload);
+
+        sender.feed_data(Bytes::from("line1"));
+        sender.feed_data(Bytes::from("line2"));
+        lazy(|cx| payload.poll_stream(cx)).await.unwrap();
+        assert_eq!(payload.buf.len(), 10);
+
+        assert_eq!(Some(Bytes::from("line1")), payload.read_max(5).unwrap());
+        assert_eq!(payload.buf.len(), 5);
+
+        assert_eq!(Some(Bytes::from("line2")), payload.read_max(5).unwrap());
+        assert_eq!(payload.buf.len(), 0);
+    }
+
+    #[actix_rt::test]
+    async fn read_exactly() {
+        let (mut sender, payload) = h1::Payload::create(false);
+        let mut payload = PayloadBuffer::new(payload);
+
+        assert_eq!(None, payload.read_exact(2));
+
+        sender.feed_data(Bytes::from("line1"));
+        sender.feed_data(Bytes::from("line2"));
+        lazy(|cx| payload.poll_stream(cx)).await.unwrap();
+
+        assert_eq!(Some(Bytes::from_static(b"li")), payload.read_exact(2));
+        assert_eq!(payload.buf.len(), 8);
+
+        assert_eq!(Some(Bytes::from_static(b"ne1l")), payload.read_exact(4));
+        assert_eq!(payload.buf.len(), 4);
+    }
+
+    #[actix_rt::test]
+    async fn read_until() {
+        let (mut sender, payload) = h1::Payload::create(false);
+        let mut payload = PayloadBuffer::new(payload);
+
+        assert_eq!(None, payload.read_until(b"ne").unwrap());
+
+        sender.feed_data(Bytes::from("line1"));
+        sender.feed_data(Bytes::from("line2"));
+        lazy(|cx| payload.poll_stream(cx)).await.unwrap();
+
+        assert_eq!(
+            Some(Bytes::from("line")),
+            payload.read_until(b"ne").unwrap()
+        );
+        assert_eq!(payload.buf.len(), 6);
+
+        assert_eq!(
+            Some(Bytes::from("1line2")),
+            payload.read_until(b"2").unwrap()
+        );
+        assert_eq!(payload.buf.len(), 0);
+    }
+}
diff --git a/actix-multipart/src/safety.rs b/actix-multipart/src/safety.rs
new file mode 100644
index 000000000..db6b3b18b
--- /dev/null
+++ b/actix-multipart/src/safety.rs
@@ -0,0 +1,60 @@
+use std::{cell::Cell, marker::PhantomData, rc::Rc, task};
+
+use local_waker::LocalWaker;
+
+/// Counter. It tracks of number of clones of payloads and give access to payload only to top most.
+///
+/// - When dropped, parent task is awakened. This is to support the case where `Field` is dropped in
+///   a separate task than `Multipart`.
+/// - Assumes that parent owners don't move to different tasks; only the top-most is allowed to.
+/// - If dropped and is not top most owner, is_clean flag is set to false.
+#[derive(Debug)]
+pub(crate) struct Safety {
+    task: LocalWaker,
+    level: usize,
+    payload: Rc<PhantomData<bool>>,
+    clean: Rc<Cell<bool>>,
+}
+
+impl Safety {
+    pub(crate) fn new() -> Safety {
+        let payload = Rc::new(PhantomData);
+        Safety {
+            task: LocalWaker::new(),
+            level: Rc::strong_count(&payload),
+            clean: Rc::new(Cell::new(true)),
+            payload,
+        }
+    }
+
+    pub(crate) fn current(&self) -> bool {
+        Rc::strong_count(&self.payload) == self.level && self.clean.get()
+    }
+
+    pub(crate) fn is_clean(&self) -> bool {
+        self.clean.get()
+    }
+
+    pub(crate) fn clone(&self, cx: &task::Context<'_>) -> Safety {
+        let payload = Rc::clone(&self.payload);
+        let s = Safety {
+            task: LocalWaker::new(),
+            level: Rc::strong_count(&payload),
+            clean: self.clean.clone(),
+            payload,
+        };
+        s.task.register(cx.waker());
+        s
+    }
+}
+
+impl Drop for Safety {
+    fn drop(&mut self) {
+        if Rc::strong_count(&self.payload) != self.level {
+            // Multipart dropped leaving a Field
+            self.clean.set(false);
+        }
+
+        self.task.wake();
+    }
+}
diff --git a/actix-multipart/src/server.rs b/actix-multipart/src/server.rs
deleted file mode 100644
index 0256aa7bf..000000000
--- a/actix-multipart/src/server.rs
+++ /dev/null
@@ -1,1374 +0,0 @@
-//! Multipart response payload support.
-
-use std::{
-    cell::{Cell, RefCell, RefMut},
-    cmp, fmt,
-    marker::PhantomData,
-    pin::Pin,
-    rc::Rc,
-    task::{Context, Poll},
-};
-
-use actix_web::{
-    error::{ParseError, PayloadError},
-    http::header::{self, ContentDisposition, HeaderMap, HeaderName, HeaderValue},
-};
-use bytes::{Bytes, BytesMut};
-use futures_core::stream::{LocalBoxStream, Stream};
-use local_waker::LocalWaker;
-
-use crate::error::MultipartError;
-
-const MAX_HEADERS: usize = 32;
-
-/// The server-side implementation of `multipart/form-data` requests.
-///
-/// This will parse the incoming stream into `MultipartItem` instances via its
-/// Stream implementation.
-/// `MultipartItem::Field` contains multipart field. `MultipartItem::Multipart`
-/// is used for nested multipart streams.
-pub struct Multipart {
-    safety: Safety,
-    error: Option<MultipartError>,
-    inner: Option<InnerMultipart>,
-}
-
-enum InnerMultipartItem {
-    None,
-    Field(Rc<RefCell<InnerField>>),
-}
-
-#[derive(PartialEq, Debug)]
-enum InnerState {
-    /// Stream eof
-    Eof,
-
-    /// Skip data until first boundary
-    FirstBoundary,
-
-    /// Reading boundary
-    Boundary,
-
-    /// Reading Headers,
-    Headers,
-}
-
-struct InnerMultipart {
-    payload: PayloadRef,
-    boundary: String,
-    state: InnerState,
-    item: InnerMultipartItem,
-}
-
-impl Multipart {
-    /// Create multipart instance for boundary.
-    pub fn new<S>(headers: &HeaderMap, stream: S) -> Multipart
-    where
-        S: Stream<Item = Result<Bytes, PayloadError>> + 'static,
-    {
-        match Self::boundary(headers) {
-            Ok(boundary) => Multipart::from_boundary(boundary, stream),
-            Err(err) => Multipart::from_error(err),
-        }
-    }
-
-    /// Extract boundary info from headers.
-    pub(crate) fn boundary(headers: &HeaderMap) -> Result<String, MultipartError> {
-        headers
-            .get(&header::CONTENT_TYPE)
-            .ok_or(MultipartError::NoContentType)?
-            .to_str()
-            .ok()
-            .and_then(|content_type| content_type.parse::<mime::Mime>().ok())
-            .ok_or(MultipartError::ParseContentType)?
-            .get_param(mime::BOUNDARY)
-            .map(|boundary| boundary.as_str().to_owned())
-            .ok_or(MultipartError::Boundary)
-    }
-
-    /// Create multipart instance for given boundary and stream
-    pub(crate) fn from_boundary<S>(boundary: String, stream: S) -> Multipart
-    where
-        S: Stream<Item = Result<Bytes, PayloadError>> + 'static,
-    {
-        Multipart {
-            error: None,
-            safety: Safety::new(),
-            inner: Some(InnerMultipart {
-                boundary,
-                payload: PayloadRef::new(PayloadBuffer::new(stream)),
-                state: InnerState::FirstBoundary,
-                item: InnerMultipartItem::None,
-            }),
-        }
-    }
-
-    /// Create Multipart instance from MultipartError
-    pub(crate) fn from_error(err: MultipartError) -> Multipart {
-        Multipart {
-            error: Some(err),
-            safety: Safety::new(),
-            inner: None,
-        }
-    }
-}
-
-impl Stream for Multipart {
-    type Item = Result<Field, MultipartError>;
-
-    fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
-        let this = self.get_mut();
-
-        match this.inner.as_mut() {
-            Some(inner) => {
-                if let Some(mut buffer) = inner.payload.get_mut(&this.safety) {
-                    // check safety and poll read payload to buffer.
-                    buffer.poll_stream(cx)?;
-                } else if !this.safety.is_clean() {
-                    // safety violation
-                    return Poll::Ready(Some(Err(MultipartError::NotConsumed)));
-                } else {
-                    return Poll::Pending;
-                }
-
-                inner.poll(&this.safety, cx)
-            }
-            None => Poll::Ready(Some(Err(this
-                .error
-                .take()
-                .expect("Multipart polled after finish")))),
-        }
-    }
-}
-
-impl InnerMultipart {
-    fn read_headers(payload: &mut PayloadBuffer) -> Result<Option<HeaderMap>, MultipartError> {
-        match payload.read_until(b"\r\n\r\n")? {
-            None => {
-                if payload.eof {
-                    Err(MultipartError::Incomplete)
-                } else {
-                    Ok(None)
-                }
-            }
-            Some(bytes) => {
-                let mut hdrs = [httparse::EMPTY_HEADER; MAX_HEADERS];
-                match httparse::parse_headers(&bytes, &mut hdrs) {
-                    Ok(httparse::Status::Complete((_, hdrs))) => {
-                        // convert headers
-                        let mut headers = HeaderMap::with_capacity(hdrs.len());
-
-                        for h in hdrs {
-                            let name =
-                                HeaderName::try_from(h.name).map_err(|_| ParseError::Header)?;
-                            let value =
-                                HeaderValue::try_from(h.value).map_err(|_| ParseError::Header)?;
-                            headers.append(name, value);
-                        }
-
-                        Ok(Some(headers))
-                    }
-                    Ok(httparse::Status::Partial) => Err(ParseError::Header.into()),
-                    Err(err) => Err(ParseError::from(err).into()),
-                }
-            }
-        }
-    }
-
-    fn read_boundary(
-        payload: &mut PayloadBuffer,
-        boundary: &str,
-    ) -> Result<Option<bool>, MultipartError> {
-        // TODO: need to read epilogue
-        match payload.readline_or_eof()? {
-            None => {
-                if payload.eof {
-                    Ok(Some(true))
-                } else {
-                    Ok(None)
-                }
-            }
-            Some(chunk) => {
-                if chunk.len() < boundary.len() + 4
-                    || &chunk[..2] != b"--"
-                    || &chunk[2..boundary.len() + 2] != boundary.as_bytes()
-                {
-                    Err(MultipartError::Boundary)
-                } else if &chunk[boundary.len() + 2..] == b"\r\n" {
-                    Ok(Some(false))
-                } else if &chunk[boundary.len() + 2..boundary.len() + 4] == b"--"
-                    && (chunk.len() == boundary.len() + 4
-                        || &chunk[boundary.len() + 4..] == b"\r\n")
-                {
-                    Ok(Some(true))
-                } else {
-                    Err(MultipartError::Boundary)
-                }
-            }
-        }
-    }
-
-    fn skip_until_boundary(
-        payload: &mut PayloadBuffer,
-        boundary: &str,
-    ) -> Result<Option<bool>, MultipartError> {
-        let mut eof = false;
-        loop {
-            match payload.readline()? {
-                Some(chunk) => {
-                    if chunk.is_empty() {
-                        return Err(MultipartError::Boundary);
-                    }
-                    if chunk.len() < boundary.len() {
-                        continue;
-                    }
-                    if &chunk[..2] == b"--" && &chunk[2..chunk.len() - 2] == boundary.as_bytes() {
-                        break;
-                    } else {
-                        if chunk.len() < boundary.len() + 2 {
-                            continue;
-                        }
-                        let b: &[u8] = boundary.as_ref();
-                        if &chunk[..boundary.len()] == b
-                            && &chunk[boundary.len()..boundary.len() + 2] == b"--"
-                        {
-                            eof = true;
-                            break;
-                        }
-                    }
-                }
-                None => {
-                    return if payload.eof {
-                        Err(MultipartError::Incomplete)
-                    } else {
-                        Ok(None)
-                    };
-                }
-            }
-        }
-        Ok(Some(eof))
-    }
-
-    fn poll(
-        &mut self,
-        safety: &Safety,
-        cx: &Context<'_>,
-    ) -> Poll<Option<Result<Field, MultipartError>>> {
-        if self.state == InnerState::Eof {
-            Poll::Ready(None)
-        } else {
-            // release field
-            loop {
-                // Nested multipart streams of fields has to be consumed
-                // before switching to next
-                if safety.current() {
-                    let stop = match self.item {
-                        InnerMultipartItem::Field(ref mut field) => {
-                            match field.borrow_mut().poll(safety) {
-                                Poll::Pending => return Poll::Pending,
-                                Poll::Ready(Some(Ok(_))) => continue,
-                                Poll::Ready(Some(Err(err))) => return Poll::Ready(Some(Err(err))),
-                                Poll::Ready(None) => true,
-                            }
-                        }
-                        InnerMultipartItem::None => false,
-                    };
-                    if stop {
-                        self.item = InnerMultipartItem::None;
-                    }
-                    if let InnerMultipartItem::None = self.item {
-                        break;
-                    }
-                }
-            }
-
-            let headers = if let Some(mut payload) = self.payload.get_mut(safety) {
-                match self.state {
-                    // read until first boundary
-                    InnerState::FirstBoundary => {
-                        match InnerMultipart::skip_until_boundary(&mut payload, &self.boundary)? {
-                            Some(eof) => {
-                                if eof {
-                                    self.state = InnerState::Eof;
-                                    return Poll::Ready(None);
-                                } else {
-                                    self.state = InnerState::Headers;
-                                }
-                            }
-                            None => return Poll::Pending,
-                        }
-                    }
-                    // read boundary
-                    InnerState::Boundary => {
-                        match InnerMultipart::read_boundary(&mut payload, &self.boundary)? {
-                            None => return Poll::Pending,
-                            Some(eof) => {
-                                if eof {
-                                    self.state = InnerState::Eof;
-                                    return Poll::Ready(None);
-                                } else {
-                                    self.state = InnerState::Headers;
-                                }
-                            }
-                        }
-                    }
-                    _ => {}
-                }
-
-                // read field headers for next field
-                if self.state == InnerState::Headers {
-                    if let Some(headers) = InnerMultipart::read_headers(&mut payload)? {
-                        self.state = InnerState::Boundary;
-                        headers
-                    } else {
-                        return Poll::Pending;
-                    }
-                } else {
-                    unreachable!()
-                }
-            } else {
-                log::debug!("NotReady: field is in flight");
-                return Poll::Pending;
-            };
-
-            // According to RFC 7578 §4.2, a Content-Disposition header must always be present and
-            // set to "form-data".
-
-            let content_disposition = headers
-                .get(&header::CONTENT_DISPOSITION)
-                .and_then(|cd| ContentDisposition::from_raw(cd).ok())
-                .filter(|content_disposition| {
-                    let is_form_data =
-                        content_disposition.disposition == header::DispositionType::FormData;
-
-                    let has_field_name = content_disposition
-                        .parameters
-                        .iter()
-                        .any(|param| matches!(param, header::DispositionParam::Name(_)));
-
-                    is_form_data && has_field_name
-                });
-
-            let cd = if let Some(content_disposition) = content_disposition {
-                content_disposition
-            } else {
-                return Poll::Ready(Some(Err(MultipartError::NoContentDisposition)));
-            };
-
-            let ct: Option<mime::Mime> = headers
-                .get(&header::CONTENT_TYPE)
-                .and_then(|ct| ct.to_str().ok())
-                .and_then(|ct| ct.parse().ok());
-
-            self.state = InnerState::Boundary;
-
-            // nested multipart stream is not supported
-            if let Some(mime) = &ct {
-                if mime.type_() == mime::MULTIPART {
-                    return Poll::Ready(Some(Err(MultipartError::Nested)));
-                }
-            }
-
-            let field =
-                InnerField::new_in_rc(self.payload.clone(), self.boundary.clone(), &headers)?;
-
-            self.item = InnerMultipartItem::Field(Rc::clone(&field));
-
-            Poll::Ready(Some(Ok(Field::new(
-                safety.clone(cx),
-                headers,
-                ct,
-                cd,
-                field,
-            ))))
-        }
-    }
-}
-
-impl Drop for InnerMultipart {
-    fn drop(&mut self) {
-        // InnerMultipartItem::Field has to be dropped first because of Safety.
-        self.item = InnerMultipartItem::None;
-    }
-}
-
-/// A single field in a multipart stream
-pub struct Field {
-    ct: Option<mime::Mime>,
-    cd: ContentDisposition,
-    headers: HeaderMap,
-    inner: Rc<RefCell<InnerField>>,
-    safety: Safety,
-}
-
-impl Field {
-    fn new(
-        safety: Safety,
-        headers: HeaderMap,
-        ct: Option<mime::Mime>,
-        cd: ContentDisposition,
-        inner: Rc<RefCell<InnerField>>,
-    ) -> Self {
-        Field {
-            ct,
-            cd,
-            headers,
-            inner,
-            safety,
-        }
-    }
-
-    /// Returns a reference to the field's header map.
-    pub fn headers(&self) -> &HeaderMap {
-        &self.headers
-    }
-
-    /// Returns a reference to the field's content (mime) type, if it is supplied by the client.
-    ///
-    /// According to [RFC 7578](https://www.rfc-editor.org/rfc/rfc7578#section-4.4), if it is not
-    /// present, it should default to "text/plain". Note it is the responsibility of the client to
-    /// provide the appropriate content type, there is no attempt to validate this by the server.
-    pub fn content_type(&self) -> Option<&mime::Mime> {
-        self.ct.as_ref()
-    }
-
-    /// Returns the field's Content-Disposition.
-    ///
-    /// Per [RFC 7578 §4.2]: "Each part MUST contain a Content-Disposition header field where the
-    /// disposition type is `form-data`. The Content-Disposition header field MUST also contain an
-    /// additional parameter of `name`; the value of the `name` parameter is the original field name
-    /// from the form."
-    ///
-    /// This crate validates that it exists before returning a `Field`. As such, it is safe to
-    /// unwrap `.content_disposition().get_name()`. The [name](Self::name) method is provided as
-    /// a convenience.
-    ///
-    /// [RFC 7578 §4.2]: https://datatracker.ietf.org/doc/html/rfc7578#section-4.2
-    pub fn content_disposition(&self) -> &ContentDisposition {
-        &self.cd
-    }
-
-    /// Returns the field's name.
-    ///
-    /// See [content_disposition](Self::content_disposition) regarding guarantees about existence of
-    /// the name field.
-    pub fn name(&self) -> &str {
-        self.content_disposition()
-            .get_name()
-            .expect("field name should be guaranteed to exist in multipart form-data")
-    }
-}
-
-impl Stream for Field {
-    type Item = Result<Bytes, MultipartError>;
-
-    fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
-        let this = self.get_mut();
-        let mut inner = this.inner.borrow_mut();
-        if let Some(mut buffer) = inner
-            .payload
-            .as_ref()
-            .expect("Field should not be polled after completion")
-            .get_mut(&this.safety)
-        {
-            // check safety and poll read payload to buffer.
-            buffer.poll_stream(cx)?;
-        } else if !this.safety.is_clean() {
-            // safety violation
-            return Poll::Ready(Some(Err(MultipartError::NotConsumed)));
-        } else {
-            return Poll::Pending;
-        }
-
-        inner.poll(&this.safety)
-    }
-}
-
-impl fmt::Debug for Field {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        if let Some(ct) = &self.ct {
-            writeln!(f, "\nField: {}", ct)?;
-        } else {
-            writeln!(f, "\nField:")?;
-        }
-        writeln!(f, "  boundary: {}", self.inner.borrow().boundary)?;
-        writeln!(f, "  headers:")?;
-        for (key, val) in self.headers.iter() {
-            writeln!(f, "    {:?}: {:?}", key, val)?;
-        }
-        Ok(())
-    }
-}
-
-struct InnerField {
-    /// Payload is initialized as Some and is `take`n when the field stream finishes.
-    payload: Option<PayloadRef>,
-    boundary: String,
-    eof: bool,
-    length: Option<u64>,
-}
-
-impl InnerField {
-    fn new_in_rc(
-        payload: PayloadRef,
-        boundary: String,
-        headers: &HeaderMap,
-    ) -> Result<Rc<RefCell<InnerField>>, PayloadError> {
-        Self::new(payload, boundary, headers).map(|this| Rc::new(RefCell::new(this)))
-    }
-
-    fn new(
-        payload: PayloadRef,
-        boundary: String,
-        headers: &HeaderMap,
-    ) -> Result<InnerField, PayloadError> {
-        let len = if let Some(len) = headers.get(&header::CONTENT_LENGTH) {
-            match len.to_str().ok().and_then(|len| len.parse::<u64>().ok()) {
-                Some(len) => Some(len),
-                None => return Err(PayloadError::Incomplete(None)),
-            }
-        } else {
-            None
-        };
-
-        Ok(InnerField {
-            boundary,
-            payload: Some(payload),
-            eof: false,
-            length: len,
-        })
-    }
-
-    /// Reads body part content chunk of the specified size.
-    /// The body part must has `Content-Length` header with proper value.
-    fn read_len(
-        payload: &mut PayloadBuffer,
-        size: &mut u64,
-    ) -> Poll<Option<Result<Bytes, MultipartError>>> {
-        if *size == 0 {
-            Poll::Ready(None)
-        } else {
-            match payload.read_max(*size)? {
-                Some(mut chunk) => {
-                    let len = cmp::min(chunk.len() as u64, *size);
-                    *size -= len;
-                    let ch = chunk.split_to(len as usize);
-                    if !chunk.is_empty() {
-                        payload.unprocessed(chunk);
-                    }
-                    Poll::Ready(Some(Ok(ch)))
-                }
-                None => {
-                    if payload.eof && (*size != 0) {
-                        Poll::Ready(Some(Err(MultipartError::Incomplete)))
-                    } else {
-                        Poll::Pending
-                    }
-                }
-            }
-        }
-    }
-
-    /// Reads content chunk of body part with unknown length.
-    /// The `Content-Length` header for body part is not necessary.
-    fn read_stream(
-        payload: &mut PayloadBuffer,
-        boundary: &str,
-    ) -> Poll<Option<Result<Bytes, MultipartError>>> {
-        let mut pos = 0;
-
-        let len = payload.buf.len();
-        if len == 0 {
-            return if payload.eof {
-                Poll::Ready(Some(Err(MultipartError::Incomplete)))
-            } else {
-                Poll::Pending
-            };
-        }
-
-        // check boundary
-        if len > 4 && payload.buf[0] == b'\r' {
-            let b_len = if &payload.buf[..2] == b"\r\n" && &payload.buf[2..4] == b"--" {
-                Some(4)
-            } else if &payload.buf[1..3] == b"--" {
-                Some(3)
-            } else {
-                None
-            };
-
-            if let Some(b_len) = b_len {
-                let b_size = boundary.len() + b_len;
-                if len < b_size {
-                    return Poll::Pending;
-                } else if &payload.buf[b_len..b_size] == boundary.as_bytes() {
-                    // found boundary
-                    return Poll::Ready(None);
-                }
-            }
-        }
-
-        loop {
-            return if let Some(idx) = memchr::memmem::find(&payload.buf[pos..], b"\r") {
-                let cur = pos + idx;
-
-                // check if we have enough data for boundary detection
-                if cur + 4 > len {
-                    if cur > 0 {
-                        Poll::Ready(Some(Ok(payload.buf.split_to(cur).freeze())))
-                    } else {
-                        Poll::Pending
-                    }
-                } else {
-                    // check boundary
-                    if (&payload.buf[cur..cur + 2] == b"\r\n"
-                        && &payload.buf[cur + 2..cur + 4] == b"--")
-                        || (&payload.buf[cur..=cur] == b"\r"
-                            && &payload.buf[cur + 1..cur + 3] == b"--")
-                    {
-                        if cur != 0 {
-                            // return buffer
-                            Poll::Ready(Some(Ok(payload.buf.split_to(cur).freeze())))
-                        } else {
-                            pos = cur + 1;
-                            continue;
-                        }
-                    } else {
-                        // not boundary
-                        pos = cur + 1;
-                        continue;
-                    }
-                }
-            } else {
-                Poll::Ready(Some(Ok(payload.buf.split().freeze())))
-            };
-        }
-    }
-
-    fn poll(&mut self, s: &Safety) -> Poll<Option<Result<Bytes, MultipartError>>> {
-        if self.payload.is_none() {
-            return Poll::Ready(None);
-        }
-
-        let result = if let Some(mut payload) = self
-            .payload
-            .as_ref()
-            .expect("Field should not be polled after completion")
-            .get_mut(s)
-        {
-            if !self.eof {
-                let res = if let Some(ref mut len) = self.length {
-                    InnerField::read_len(&mut payload, len)
-                } else {
-                    InnerField::read_stream(&mut payload, &self.boundary)
-                };
-
-                match res {
-                    Poll::Pending => return Poll::Pending,
-                    Poll::Ready(Some(Ok(bytes))) => return Poll::Ready(Some(Ok(bytes))),
-                    Poll::Ready(Some(Err(err))) => return Poll::Ready(Some(Err(err))),
-                    Poll::Ready(None) => self.eof = true,
-                }
-            }
-
-            match payload.readline() {
-                Ok(None) => Poll::Pending,
-                Ok(Some(line)) => {
-                    if line.as_ref() != b"\r\n" {
-                        log::warn!("multipart field did not read all the data or it is malformed");
-                    }
-                    Poll::Ready(None)
-                }
-                Err(err) => Poll::Ready(Some(Err(err))),
-            }
-        } else {
-            Poll::Pending
-        };
-
-        if let Poll::Ready(None) = result {
-            // drop payload buffer and make future un-poll-able
-            let _ = self.payload.take();
-        }
-
-        result
-    }
-}
-
-struct PayloadRef {
-    payload: Rc<RefCell<PayloadBuffer>>,
-}
-
-impl PayloadRef {
-    fn new(payload: PayloadBuffer) -> PayloadRef {
-        PayloadRef {
-            payload: Rc::new(payload.into()),
-        }
-    }
-
-    fn get_mut(&self, s: &Safety) -> Option<RefMut<'_, PayloadBuffer>> {
-        if s.current() {
-            Some(self.payload.borrow_mut())
-        } else {
-            None
-        }
-    }
-}
-
-impl Clone for PayloadRef {
-    fn clone(&self) -> PayloadRef {
-        PayloadRef {
-            payload: Rc::clone(&self.payload),
-        }
-    }
-}
-
-/// Counter. It tracks of number of clones of payloads and give access to payload only to top most.
-/// * When dropped, parent task is awakened. This is to support the case where Field is
-/// dropped in a separate task than Multipart.
-/// * Assumes that parent owners don't move to different tasks; only the top-most is allowed to.
-/// * If dropped and is not top most owner, is_clean flag is set to false.
-#[derive(Debug)]
-struct Safety {
-    task: LocalWaker,
-    level: usize,
-    payload: Rc<PhantomData<bool>>,
-    clean: Rc<Cell<bool>>,
-}
-
-impl Safety {
-    fn new() -> Safety {
-        let payload = Rc::new(PhantomData);
-        Safety {
-            task: LocalWaker::new(),
-            level: Rc::strong_count(&payload),
-            clean: Rc::new(Cell::new(true)),
-            payload,
-        }
-    }
-
-    fn current(&self) -> bool {
-        Rc::strong_count(&self.payload) == self.level && self.clean.get()
-    }
-
-    fn is_clean(&self) -> bool {
-        self.clean.get()
-    }
-
-    fn clone(&self, cx: &Context<'_>) -> Safety {
-        let payload = Rc::clone(&self.payload);
-        let s = Safety {
-            task: LocalWaker::new(),
-            level: Rc::strong_count(&payload),
-            clean: self.clean.clone(),
-            payload,
-        };
-        s.task.register(cx.waker());
-        s
-    }
-}
-
-impl Drop for Safety {
-    fn drop(&mut self) {
-        if Rc::strong_count(&self.payload) != self.level {
-            // Multipart dropped leaving a Field
-            self.clean.set(false);
-        }
-
-        self.task.wake();
-    }
-}
-
-/// Payload buffer.
-struct PayloadBuffer {
-    eof: bool,
-    buf: BytesMut,
-    stream: LocalBoxStream<'static, Result<Bytes, PayloadError>>,
-}
-
-impl PayloadBuffer {
-    /// Constructs new `PayloadBuffer` instance.
-    fn new<S>(stream: S) -> Self
-    where
-        S: Stream<Item = Result<Bytes, PayloadError>> + 'static,
-    {
-        PayloadBuffer {
-            eof: false,
-            buf: BytesMut::new(),
-            stream: Box::pin(stream),
-        }
-    }
-
-    fn poll_stream(&mut self, cx: &mut Context<'_>) -> Result<(), PayloadError> {
-        loop {
-            match Pin::new(&mut self.stream).poll_next(cx) {
-                Poll::Ready(Some(Ok(data))) => self.buf.extend_from_slice(&data),
-                Poll::Ready(Some(Err(err))) => return Err(err),
-                Poll::Ready(None) => {
-                    self.eof = true;
-                    return Ok(());
-                }
-                Poll::Pending => return Ok(()),
-            }
-        }
-    }
-
-    /// Read exact number of bytes
-    #[cfg(test)]
-    fn read_exact(&mut self, size: usize) -> Option<Bytes> {
-        if size <= self.buf.len() {
-            Some(self.buf.split_to(size).freeze())
-        } else {
-            None
-        }
-    }
-
-    fn read_max(&mut self, size: u64) -> Result<Option<Bytes>, MultipartError> {
-        if !self.buf.is_empty() {
-            let size = std::cmp::min(self.buf.len() as u64, size) as usize;
-            Ok(Some(self.buf.split_to(size).freeze()))
-        } else if self.eof {
-            Err(MultipartError::Incomplete)
-        } else {
-            Ok(None)
-        }
-    }
-
-    /// Read until specified ending
-    fn read_until(&mut self, line: &[u8]) -> Result<Option<Bytes>, MultipartError> {
-        let res = memchr::memmem::find(&self.buf, line)
-            .map(|idx| self.buf.split_to(idx + line.len()).freeze());
-
-        if res.is_none() && self.eof {
-            Err(MultipartError::Incomplete)
-        } else {
-            Ok(res)
-        }
-    }
-
-    /// Read bytes until new line delimiter
-    fn readline(&mut self) -> Result<Option<Bytes>, MultipartError> {
-        self.read_until(b"\n")
-    }
-
-    /// Read bytes until new line delimiter or eof
-    fn readline_or_eof(&mut self) -> Result<Option<Bytes>, MultipartError> {
-        match self.readline() {
-            Err(MultipartError::Incomplete) if self.eof => Ok(Some(self.buf.split().freeze())),
-            line => line,
-        }
-    }
-
-    /// Put unprocessed data back to the buffer
-    fn unprocessed(&mut self, data: Bytes) {
-        let buf = BytesMut::from(data.as_ref());
-        let buf = std::mem::replace(&mut self.buf, buf);
-        self.buf.extend_from_slice(&buf);
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use std::time::Duration;
-
-    use actix_http::h1;
-    use actix_web::{
-        http::header::{DispositionParam, DispositionType},
-        rt,
-        test::TestRequest,
-        FromRequest,
-    };
-    use bytes::BufMut as _;
-    use futures_util::{future::lazy, StreamExt as _};
-    use tokio::sync::mpsc;
-    use tokio_stream::wrappers::UnboundedReceiverStream;
-
-    use super::*;
-
-    const BOUNDARY: &str = "abbc761f78ff4d7cb7573b5a23f96ef0";
-
-    #[actix_rt::test]
-    async fn test_boundary() {
-        let headers = HeaderMap::new();
-        match Multipart::boundary(&headers) {
-            Err(MultipartError::NoContentType) => {}
-            _ => unreachable!("should not happen"),
-        }
-
-        let mut headers = HeaderMap::new();
-        headers.insert(
-            header::CONTENT_TYPE,
-            header::HeaderValue::from_static("test"),
-        );
-
-        match Multipart::boundary(&headers) {
-            Err(MultipartError::ParseContentType) => {}
-            _ => unreachable!("should not happen"),
-        }
-
-        let mut headers = HeaderMap::new();
-        headers.insert(
-            header::CONTENT_TYPE,
-            header::HeaderValue::from_static("multipart/mixed"),
-        );
-        match Multipart::boundary(&headers) {
-            Err(MultipartError::Boundary) => {}
-            _ => unreachable!("should not happen"),
-        }
-
-        let mut headers = HeaderMap::new();
-        headers.insert(
-            header::CONTENT_TYPE,
-            header::HeaderValue::from_static(
-                "multipart/mixed; boundary=\"5c02368e880e436dab70ed54e1c58209\"",
-            ),
-        );
-
-        assert_eq!(
-            Multipart::boundary(&headers).unwrap(),
-            "5c02368e880e436dab70ed54e1c58209"
-        );
-    }
-
-    fn create_stream() -> (
-        mpsc::UnboundedSender<Result<Bytes, PayloadError>>,
-        impl Stream<Item = Result<Bytes, PayloadError>>,
-    ) {
-        let (tx, rx) = mpsc::unbounded_channel();
-
-        (
-            tx,
-            UnboundedReceiverStream::new(rx).map(|res| res.map_err(|_| panic!())),
-        )
-    }
-
-    // Stream that returns from a Bytes, one char at a time and Pending every other poll()
-    struct SlowStream {
-        bytes: Bytes,
-        pos: usize,
-        ready: bool,
-    }
-
-    impl SlowStream {
-        fn new(bytes: Bytes) -> SlowStream {
-            SlowStream {
-                bytes,
-                pos: 0,
-                ready: false,
-            }
-        }
-    }
-
-    impl Stream for SlowStream {
-        type Item = Result<Bytes, PayloadError>;
-
-        fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
-            let this = self.get_mut();
-            if !this.ready {
-                this.ready = true;
-                cx.waker().wake_by_ref();
-                return Poll::Pending;
-            }
-
-            if this.pos == this.bytes.len() {
-                return Poll::Ready(None);
-            }
-
-            let res = Poll::Ready(Some(Ok(this.bytes.slice(this.pos..(this.pos + 1)))));
-            this.pos += 1;
-            this.ready = false;
-            res
-        }
-    }
-
-    fn create_simple_request_with_header() -> (Bytes, HeaderMap) {
-        let (body, headers) = crate::test::create_form_data_payload_and_headers_with_boundary(
-            BOUNDARY,
-            "file",
-            Some("fn.txt".to_owned()),
-            Some(mime::TEXT_PLAIN_UTF_8),
-            Bytes::from_static(b"data"),
-        );
-
-        let mut buf = BytesMut::with_capacity(body.len() + 14);
-
-        // add junk before form to test pre-boundary data rejection
-        buf.put("testasdadsad\r\n".as_bytes());
-
-        buf.put(body);
-
-        (buf.freeze(), headers)
-    }
-
-    // TODO: use test utility when multi-file support is introduced
-    fn create_double_request_with_header() -> (Bytes, HeaderMap) {
-        let bytes = Bytes::from(
-            "testasdadsad\r\n\
-             --abbc761f78ff4d7cb7573b5a23f96ef0\r\n\
-             Content-Disposition: form-data; name=\"file\"; filename=\"fn.txt\"\r\n\
-             Content-Type: text/plain; charset=utf-8\r\nContent-Length: 4\r\n\r\n\
-             test\r\n\
-             --abbc761f78ff4d7cb7573b5a23f96ef0\r\n\
-             Content-Disposition: form-data; name=\"file\"; filename=\"fn.txt\"\r\n\
-             Content-Type: text/plain; charset=utf-8\r\nContent-Length: 4\r\n\r\n\
-             data\r\n\
-             --abbc761f78ff4d7cb7573b5a23f96ef0--\r\n",
-        );
-        let mut headers = HeaderMap::new();
-        headers.insert(
-            header::CONTENT_TYPE,
-            header::HeaderValue::from_static(
-                "multipart/mixed; boundary=\"abbc761f78ff4d7cb7573b5a23f96ef0\"",
-            ),
-        );
-        (bytes, headers)
-    }
-
-    #[actix_rt::test]
-    async fn test_multipart_no_end_crlf() {
-        let (sender, payload) = create_stream();
-        let (mut bytes, headers) = create_double_request_with_header();
-        let bytes_stripped = bytes.split_to(bytes.len()); // strip crlf
-
-        sender.send(Ok(bytes_stripped)).unwrap();
-        drop(sender); // eof
-
-        let mut multipart = Multipart::new(&headers, payload);
-
-        match multipart.next().await.unwrap() {
-            Ok(_) => {}
-            _ => unreachable!(),
-        }
-
-        match multipart.next().await.unwrap() {
-            Ok(_) => {}
-            _ => unreachable!(),
-        }
-
-        match multipart.next().await {
-            None => {}
-            _ => unreachable!(),
-        }
-    }
-
-    #[actix_rt::test]
-    async fn test_multipart() {
-        let (sender, payload) = create_stream();
-        let (bytes, headers) = create_double_request_with_header();
-
-        sender.send(Ok(bytes)).unwrap();
-
-        let mut multipart = Multipart::new(&headers, payload);
-        match multipart.next().await {
-            Some(Ok(mut field)) => {
-                let cd = field.content_disposition();
-                assert_eq!(cd.disposition, DispositionType::FormData);
-                assert_eq!(cd.parameters[0], DispositionParam::Name("file".into()));
-
-                assert_eq!(field.content_type().unwrap().type_(), mime::TEXT);
-                assert_eq!(field.content_type().unwrap().subtype(), mime::PLAIN);
-
-                match field.next().await.unwrap() {
-                    Ok(chunk) => assert_eq!(chunk, "test"),
-                    _ => unreachable!(),
-                }
-                match field.next().await {
-                    None => {}
-                    _ => unreachable!(),
-                }
-            }
-            _ => unreachable!(),
-        }
-
-        match multipart.next().await.unwrap() {
-            Ok(mut field) => {
-                assert_eq!(field.content_type().unwrap().type_(), mime::TEXT);
-                assert_eq!(field.content_type().unwrap().subtype(), mime::PLAIN);
-
-                match field.next().await {
-                    Some(Ok(chunk)) => assert_eq!(chunk, "data"),
-                    _ => unreachable!(),
-                }
-                match field.next().await {
-                    None => {}
-                    _ => unreachable!(),
-                }
-            }
-            _ => unreachable!(),
-        }
-
-        match multipart.next().await {
-            None => {}
-            _ => unreachable!(),
-        }
-    }
-
-    // Loops, collecting all bytes until end-of-field
-    async fn get_whole_field(field: &mut Field) -> BytesMut {
-        let mut b = BytesMut::new();
-        loop {
-            match field.next().await {
-                Some(Ok(chunk)) => b.extend_from_slice(&chunk),
-                None => return b,
-                _ => unreachable!(),
-            }
-        }
-    }
-
-    #[actix_rt::test]
-    async fn test_stream() {
-        let (bytes, headers) = create_double_request_with_header();
-        let payload = SlowStream::new(bytes);
-
-        let mut multipart = Multipart::new(&headers, payload);
-        match multipart.next().await.unwrap() {
-            Ok(mut field) => {
-                let cd = field.content_disposition();
-                assert_eq!(cd.disposition, DispositionType::FormData);
-                assert_eq!(cd.parameters[0], DispositionParam::Name("file".into()));
-
-                assert_eq!(field.content_type().unwrap().type_(), mime::TEXT);
-                assert_eq!(field.content_type().unwrap().subtype(), mime::PLAIN);
-
-                assert_eq!(get_whole_field(&mut field).await, "test");
-            }
-            _ => unreachable!(),
-        }
-
-        match multipart.next().await {
-            Some(Ok(mut field)) => {
-                assert_eq!(field.content_type().unwrap().type_(), mime::TEXT);
-                assert_eq!(field.content_type().unwrap().subtype(), mime::PLAIN);
-
-                assert_eq!(get_whole_field(&mut field).await, "data");
-            }
-            _ => unreachable!(),
-        }
-
-        match multipart.next().await {
-            None => {}
-            _ => unreachable!(),
-        }
-    }
-
-    #[actix_rt::test]
-    async fn test_basic() {
-        let (_, payload) = h1::Payload::create(false);
-        let mut payload = PayloadBuffer::new(payload);
-
-        assert_eq!(payload.buf.len(), 0);
-        lazy(|cx| payload.poll_stream(cx)).await.unwrap();
-        assert_eq!(None, payload.read_max(1).unwrap());
-    }
-
-    #[actix_rt::test]
-    async fn test_eof() {
-        let (mut sender, payload) = h1::Payload::create(false);
-        let mut payload = PayloadBuffer::new(payload);
-
-        assert_eq!(None, payload.read_max(4).unwrap());
-        sender.feed_data(Bytes::from("data"));
-        sender.feed_eof();
-        lazy(|cx| payload.poll_stream(cx)).await.unwrap();
-
-        assert_eq!(Some(Bytes::from("data")), payload.read_max(4).unwrap());
-        assert_eq!(payload.buf.len(), 0);
-        assert!(payload.read_max(1).is_err());
-        assert!(payload.eof);
-    }
-
-    #[actix_rt::test]
-    async fn test_err() {
-        let (mut sender, payload) = h1::Payload::create(false);
-        let mut payload = PayloadBuffer::new(payload);
-        assert_eq!(None, payload.read_max(1).unwrap());
-        sender.set_error(PayloadError::Incomplete(None));
-        lazy(|cx| payload.poll_stream(cx)).await.err().unwrap();
-    }
-
-    #[actix_rt::test]
-    async fn test_readmax() {
-        let (mut sender, payload) = h1::Payload::create(false);
-        let mut payload = PayloadBuffer::new(payload);
-
-        sender.feed_data(Bytes::from("line1"));
-        sender.feed_data(Bytes::from("line2"));
-        lazy(|cx| payload.poll_stream(cx)).await.unwrap();
-        assert_eq!(payload.buf.len(), 10);
-
-        assert_eq!(Some(Bytes::from("line1")), payload.read_max(5).unwrap());
-        assert_eq!(payload.buf.len(), 5);
-
-        assert_eq!(Some(Bytes::from("line2")), payload.read_max(5).unwrap());
-        assert_eq!(payload.buf.len(), 0);
-    }
-
-    #[actix_rt::test]
-    async fn test_readexactly() {
-        let (mut sender, payload) = h1::Payload::create(false);
-        let mut payload = PayloadBuffer::new(payload);
-
-        assert_eq!(None, payload.read_exact(2));
-
-        sender.feed_data(Bytes::from("line1"));
-        sender.feed_data(Bytes::from("line2"));
-        lazy(|cx| payload.poll_stream(cx)).await.unwrap();
-
-        assert_eq!(Some(Bytes::from_static(b"li")), payload.read_exact(2));
-        assert_eq!(payload.buf.len(), 8);
-
-        assert_eq!(Some(Bytes::from_static(b"ne1l")), payload.read_exact(4));
-        assert_eq!(payload.buf.len(), 4);
-    }
-
-    #[actix_rt::test]
-    async fn test_readuntil() {
-        let (mut sender, payload) = h1::Payload::create(false);
-        let mut payload = PayloadBuffer::new(payload);
-
-        assert_eq!(None, payload.read_until(b"ne").unwrap());
-
-        sender.feed_data(Bytes::from("line1"));
-        sender.feed_data(Bytes::from("line2"));
-        lazy(|cx| payload.poll_stream(cx)).await.unwrap();
-
-        assert_eq!(
-            Some(Bytes::from("line")),
-            payload.read_until(b"ne").unwrap()
-        );
-        assert_eq!(payload.buf.len(), 6);
-
-        assert_eq!(
-            Some(Bytes::from("1line2")),
-            payload.read_until(b"2").unwrap()
-        );
-        assert_eq!(payload.buf.len(), 0);
-    }
-
-    #[actix_rt::test]
-    async fn test_multipart_from_error() {
-        let err = MultipartError::NoContentType;
-        let mut multipart = Multipart::from_error(err);
-        assert!(multipart.next().await.unwrap().is_err())
-    }
-
-    #[actix_rt::test]
-    async fn test_multipart_from_boundary() {
-        let (_, payload) = create_stream();
-        let (_, headers) = create_simple_request_with_header();
-        let boundary = Multipart::boundary(&headers);
-        assert!(boundary.is_ok());
-        let _ = Multipart::from_boundary(boundary.unwrap(), payload);
-    }
-
-    #[actix_rt::test]
-    async fn test_multipart_payload_consumption() {
-        // with sample payload and HttpRequest with no headers
-        let (_, inner_payload) = h1::Payload::create(false);
-        let mut payload = actix_web::dev::Payload::from(inner_payload);
-        let req = TestRequest::default().to_http_request();
-
-        // multipart should generate an error
-        let mut mp = Multipart::from_request(&req, &mut payload).await.unwrap();
-        assert!(mp.next().await.unwrap().is_err());
-
-        // and should not consume the payload
-        match payload {
-            actix_web::dev::Payload::H1 { .. } => {} //expected
-            _ => unreachable!(),
-        }
-    }
-
-    #[actix_rt::test]
-    async fn no_content_disposition() {
-        let bytes = Bytes::from(
-            "testasdadsad\r\n\
-             --abbc761f78ff4d7cb7573b5a23f96ef0\r\n\
-             Content-Type: text/plain; charset=utf-8\r\nContent-Length: 4\r\n\r\n\
-             test\r\n\
-             --abbc761f78ff4d7cb7573b5a23f96ef0\r\n",
-        );
-        let mut headers = HeaderMap::new();
-        headers.insert(
-            header::CONTENT_TYPE,
-            header::HeaderValue::from_static(
-                "multipart/mixed; boundary=\"abbc761f78ff4d7cb7573b5a23f96ef0\"",
-            ),
-        );
-        let payload = SlowStream::new(bytes);
-
-        let mut multipart = Multipart::new(&headers, payload);
-        let res = multipart.next().await.unwrap();
-        assert!(res.is_err());
-        assert!(matches!(
-            res.unwrap_err(),
-            MultipartError::NoContentDisposition,
-        ));
-    }
-
-    #[actix_rt::test]
-    async fn no_name_in_content_disposition() {
-        let bytes = Bytes::from(
-            "testasdadsad\r\n\
-             --abbc761f78ff4d7cb7573b5a23f96ef0\r\n\
-             Content-Disposition: form-data; filename=\"fn.txt\"\r\n\
-             Content-Type: text/plain; charset=utf-8\r\nContent-Length: 4\r\n\r\n\
-             test\r\n\
-             --abbc761f78ff4d7cb7573b5a23f96ef0\r\n",
-        );
-        let mut headers = HeaderMap::new();
-        headers.insert(
-            header::CONTENT_TYPE,
-            header::HeaderValue::from_static(
-                "multipart/mixed; boundary=\"abbc761f78ff4d7cb7573b5a23f96ef0\"",
-            ),
-        );
-        let payload = SlowStream::new(bytes);
-
-        let mut multipart = Multipart::new(&headers, payload);
-        let res = multipart.next().await.unwrap();
-        assert!(res.is_err());
-        assert!(matches!(
-            res.unwrap_err(),
-            MultipartError::NoContentDisposition,
-        ));
-    }
-
-    #[actix_rt::test]
-    async fn test_drop_multipart_dont_hang() {
-        let (sender, payload) = create_stream();
-        let (bytes, headers) = create_simple_request_with_header();
-        sender.send(Ok(bytes)).unwrap();
-        drop(sender); // eof
-
-        let mut multipart = Multipart::new(&headers, payload);
-        let mut field = multipart.next().await.unwrap().unwrap();
-
-        drop(multipart);
-
-        // should fail immediately
-        match field.next().await {
-            Some(Err(MultipartError::NotConsumed)) => {}
-            _ => panic!(),
-        };
-    }
-
-    #[actix_rt::test]
-    async fn test_drop_field_awaken_multipart() {
-        let (sender, payload) = create_stream();
-        let (bytes, headers) = create_double_request_with_header();
-        sender.send(Ok(bytes)).unwrap();
-        drop(sender); // eof
-
-        let mut multipart = Multipart::new(&headers, payload);
-        let mut field = multipart.next().await.unwrap().unwrap();
-
-        let task = rt::spawn(async move {
-            rt::time::sleep(Duration::from_secs(1)).await;
-            assert_eq!(field.next().await.unwrap().unwrap(), "test");
-            drop(field);
-        });
-
-        // dropping field should awaken current task
-        let _ = multipart.next().await.unwrap().unwrap();
-        task.await.unwrap();
-    }
-}
diff --git a/actix-multipart/src/test.rs b/actix-multipart/src/test.rs
index 77d918283..b0e907266 100644
--- a/actix-multipart/src/test.rs
+++ b/actix-multipart/src/test.rs
@@ -1,10 +1,11 @@
-use actix_web::http::header::{self, HeaderMap};
-use bytes::{BufMut as _, Bytes, BytesMut};
-use mime::Mime;
-use rand::{
-    distributions::{Alphanumeric, DistString as _},
-    thread_rng,
+//! Multipart testing utilities.
+
+use actix_web::{
+    http::header::{self, HeaderMap},
+    web::{BufMut as _, Bytes, BytesMut},
 };
+use mime::Mime;
+use rand::distr::{Alphanumeric, SampleString as _};
 
 const CRLF: &[u8] = b"\r\n";
 const CRLF_CRLF: &[u8] = b"\r\n\r\n";
@@ -21,8 +22,7 @@ const BOUNDARY_PREFIX: &str = "------------------------";
 ///
 /// ```
 /// use actix_multipart::test::create_form_data_payload_and_headers;
-/// use actix_web::test::TestRequest;
-/// use bytes::Bytes;
+/// use actix_web::{test::TestRequest, web::Bytes};
 /// use memchr::memmem::find;
 ///
 /// let (body, headers) = create_form_data_payload_and_headers(
@@ -61,7 +61,7 @@ pub fn create_form_data_payload_and_headers(
     content_type: Option<Mime>,
     file: Bytes,
 ) -> (Bytes, HeaderMap) {
-    let boundary = Alphanumeric.sample_string(&mut thread_rng(), 32);
+    let boundary = Alphanumeric.sample_string(&mut rand::rng(), 32);
 
     create_form_data_payload_and_headers_with_boundary(
         &boundary,
diff --git a/actix-router/CHANGES.md b/actix-router/CHANGES.md
index 6305b45c3..79488f01e 100644
--- a/actix-router/CHANGES.md
+++ b/actix-router/CHANGES.md
@@ -2,6 +2,8 @@
 
 ## Unreleased
 
+- Minimum supported Rust version (MSRV) is now 1.82.
+
 ## 0.5.3
 
 - Add `unicode` crate feature (on-by-default) to switch between `regex` and `regex-lite` as a trade-off between full unicode support and binary size.
diff --git a/actix-router/Cargo.toml b/actix-router/Cargo.toml
index 7e7e3beb8..ba801188a 100644
--- a/actix-router/Cargo.toml
+++ b/actix-router/Cargo.toml
@@ -2,9 +2,9 @@
 name = "actix-router"
 version = "0.5.3"
 authors = [
-    "Nikolay Kim <fafhrd91@gmail.com>",
-    "Ali MJ Al-Nasrawy <alimjalnasrawy@gmail.com>",
-    "Rob Ede <robjtede@icloud.com>",
+  "Nikolay Kim <fafhrd91@gmail.com>",
+  "Ali MJ Al-Nasrawy <alimjalnasrawy@gmail.com>",
+  "Rob Ede <robjtede@icloud.com>",
 ]
 description = "Resource path matching and router"
 keywords = ["actix", "router", "routing"]
@@ -13,10 +13,7 @@ license = "MIT OR Apache-2.0"
 edition = "2021"
 
 [package.metadata.cargo_check_external_types]
-allowed_external_types = [
-    "http::*",
-    "serde::*",
-]
+allowed_external_types = ["http::*", "serde::*"]
 
 [features]
 default = ["http", "unicode"]
@@ -35,8 +32,11 @@ tracing = { version = "0.1.30", default-features = false, features = ["log"] }
 [dev-dependencies]
 criterion = { version = "0.5", features = ["html_reports"] }
 http = "0.2.7"
-serde = { version = "1", features = ["derive"] }
 percent-encoding = "2.1"
+serde = { version = "1", features = ["derive"] }
+
+[lints]
+workspace = true
 
 [[bench]]
 name = "router"
diff --git a/actix-router/benches/router.rs b/actix-router/benches/router.rs
index 6f6b67b48..2c21fef6c 100644
--- a/actix-router/benches/router.rs
+++ b/actix-router/benches/router.rs
@@ -13,6 +13,7 @@ macro_rules! register {
         register!(finish => "(.*)", "(.*)", "(.*)", "(.*)")
     }};
     (finish => $p1:literal, $p2:literal, $p3:literal, $p4:literal) => {{
+        #[expect(clippy::useless_concat)]
         let arr = [
             concat!("/authorizations"),
             concat!("/authorizations/", $p1),
diff --git a/actix-router/src/de.rs b/actix-router/src/de.rs
index ce2dcf8f3..2f50619f8 100644
--- a/actix-router/src/de.rs
+++ b/actix-router/src/de.rs
@@ -511,11 +511,6 @@ mod tests {
         value: String,
     }
 
-    #[derive(Deserialize)]
-    struct Id {
-        _id: String,
-    }
-
     #[derive(Debug, Deserialize)]
     struct Test1(String, u32);
 
diff --git a/actix-router/src/lib.rs b/actix-router/src/lib.rs
index c4d0d2c87..cc59a9f58 100644
--- a/actix-router/src/lib.rs
+++ b/actix-router/src/lib.rs
@@ -1,10 +1,8 @@
 //! Resource path matching and router.
 
-#![deny(rust_2018_idioms, nonstandard_style)]
-#![warn(future_incompatible)]
 #![doc(html_logo_url = "https://actix.rs/img/logo.png")]
 #![doc(html_favicon_url = "https://actix.rs/favicon.ico")]
-#![cfg_attr(docsrs, feature(doc_auto_cfg))]
+#![cfg_attr(docsrs, feature(doc_cfg))]
 
 mod de;
 mod path;
diff --git a/actix-router/src/path.rs b/actix-router/src/path.rs
index 9031ab763..ab4a943fe 100644
--- a/actix-router/src/path.rs
+++ b/actix-router/src/path.rs
@@ -143,9 +143,9 @@ impl<T: ResourcePath> Path<T> {
         for (seg_name, val) in self.segments.iter() {
             if name == seg_name {
                 return match val {
-                    PathItem::Static(ref s) => Some(s),
-                    PathItem::Segment(s, e) => {
-                        Some(&self.path.path()[(*s as usize)..(*e as usize)])
+                    PathItem::Static(ref seg) => Some(seg),
+                    PathItem::Segment(start, end) => {
+                        Some(&self.path.path()[(*start as usize)..(*end as usize)])
                     }
                 };
             }
@@ -193,8 +193,10 @@ impl<'a, T: ResourcePath> Iterator for PathIter<'a, T> {
         if self.idx < self.params.segment_count() {
             let idx = self.idx;
             let res = match self.params.segments[idx].1 {
-                PathItem::Static(ref s) => s,
-                PathItem::Segment(s, e) => &self.params.path.path()[(s as usize)..(e as usize)],
+                PathItem::Static(ref seg) => seg,
+                PathItem::Segment(start, end) => {
+                    &self.params.path.path()[(start as usize)..(end as usize)]
+                }
             };
             self.idx += 1;
             return Some((&self.params.segments[idx].0, res));
@@ -217,8 +219,8 @@ impl<T: ResourcePath> Index<usize> for Path<T> {
 
     fn index(&self, idx: usize) -> &str {
         match self.segments[idx].1 {
-            PathItem::Static(ref s) => s,
-            PathItem::Segment(s, e) => &self.path.path()[(s as usize)..(e as usize)],
+            PathItem::Static(ref seg) => seg,
+            PathItem::Segment(start, end) => &self.path.path()[(start as usize)..(end as usize)],
         }
     }
 }
diff --git a/actix-router/src/quoter.rs b/actix-router/src/quoter.rs
index 6c929d3ac..78694ed72 100644
--- a/actix-router/src/quoter.rs
+++ b/actix-router/src/quoter.rs
@@ -105,7 +105,7 @@ fn hex_pair_to_char(d1: u8, d2: u8) -> Option<u8> {
     let d_low = char::from(d2).to_digit(16)?;
 
     // left shift high nibble by 4 bits
-    Some((d_high as u8) << 4 | (d_low as u8))
+    Some(((d_high as u8) << 4) | (d_low as u8))
 }
 
 #[derive(Debug, Default, Clone)]
diff --git a/actix-router/src/resource.rs b/actix-router/src/resource.rs
index 3a102945b..b5ee01958 100644
--- a/actix-router/src/resource.rs
+++ b/actix-router/src/resource.rs
@@ -1021,6 +1021,7 @@ impl ResourceDef {
             panic!("prefix resource definitions should not have tail segments");
         }
 
+        #[allow(clippy::literal_string_with_formatting_args)]
         if unprocessed.ends_with('*') {
             // unnamed tail segment
 
@@ -1369,6 +1370,7 @@ mod tests {
         assert_eq!(path.unprocessed(), "");
     }
 
+    #[allow(clippy::literal_string_with_formatting_args)]
     #[test]
     fn newline_patterns_and_paths() {
         let re = ResourceDef::new("/user/a\nb");
diff --git a/actix-router/src/resource_path.rs b/actix-router/src/resource_path.rs
index 45948aa2a..610dc344d 100644
--- a/actix-router/src/resource_path.rs
+++ b/actix-router/src/resource_path.rs
@@ -19,7 +19,7 @@ impl ResourcePath for String {
     }
 }
 
-impl<'a> ResourcePath for &'a str {
+impl ResourcePath for &str {
     fn path(&self) -> &str {
         self
     }
diff --git a/actix-router/src/router.rs b/actix-router/src/router.rs
index 1dd4449da..b20cb7ee3 100644
--- a/actix-router/src/router.rs
+++ b/actix-router/src/router.rs
@@ -145,6 +145,7 @@ mod tests {
     };
 
     #[allow(clippy::cognitive_complexity)]
+    #[allow(clippy::literal_string_with_formatting_args)]
     #[test]
     fn test_recognizer_1() {
         let mut router = Router::<usize>::build();
diff --git a/actix-test/CHANGES.md b/actix-test/CHANGES.md
index ec2dd6776..d567f060f 100644
--- a/actix-test/CHANGES.md
+++ b/actix-test/CHANGES.md
@@ -2,6 +2,8 @@
 
 ## Unreleased
 
+- Minimum supported Rust version (MSRV) is now 1.82.
+
 ## 0.1.5
 
 - Add `TestServerConfig::listen_address()` method.
diff --git a/actix-test/Cargo.toml b/actix-test/Cargo.toml
index e810ae80b..eb11e8469 100644
--- a/actix-test/Cargo.toml
+++ b/actix-test/Cargo.toml
@@ -1,37 +1,34 @@
 [package]
 name = "actix-test"
 version = "0.1.5"
-authors = [
-    "Nikolay Kim <fafhrd91@gmail.com>",
-    "Rob Ede <robjtede@icloud.com>",
-]
+authors = ["Nikolay Kim <fafhrd91@gmail.com>", "Rob Ede <robjtede@icloud.com>"]
 description = "Integration testing tools for Actix Web applications"
 keywords = ["http", "web", "framework", "async", "futures"]
 homepage = "https://actix.rs"
 repository = "https://github.com/actix/actix-web"
 categories = [
-    "network-programming",
-    "asynchronous",
-    "web-programming::http-server",
-    "web-programming::websocket",
+  "network-programming",
+  "asynchronous",
+  "web-programming::http-server",
+  "web-programming::websocket",
 ]
 license = "MIT OR Apache-2.0"
 edition = "2021"
 
 [package.metadata.cargo_check_external_types]
 allowed_external_types = [
-    "actix_codec::*",
-    "actix_http_test::*",
-    "actix_http::*",
-    "actix_service::*",
-    "actix_web::*",
-    "awc::*",
-    "bytes::*",
-    "futures_core::*",
-    "http::*",
-    "openssl::*",
-    "rustls::*",
-    "tokio::*",
+  "actix_codec::*",
+  "actix_http_test::*",
+  "actix_http::*",
+  "actix_service::*",
+  "actix_web::*",
+  "awc::*",
+  "bytes::*",
+  "futures_core::*",
+  "http::*",
+  "openssl::*",
+  "rustls::*",
+  "tokio::*",
 ]
 
 [features]
@@ -72,4 +69,7 @@ tls-rustls-0_20 = { package = "rustls", version = "0.20", optional = true }
 tls-rustls-0_21 = { package = "rustls", version = "0.21", optional = true }
 tls-rustls-0_22 = { package = "rustls", version = "0.22", optional = true }
 tls-rustls-0_23 = { package = "rustls", version = "0.23", default-features = false, optional = true }
-tokio = { version = "1.24.2", features = ["sync"] }
+tokio = { version = "1.38.2", features = ["sync"] }
+
+[lints]
+workspace = true
diff --git a/actix-test/src/lib.rs b/actix-test/src/lib.rs
index 9be99978d..84adacbce 100644
--- a/actix-test/src/lib.rs
+++ b/actix-test/src/lib.rs
@@ -27,11 +27,9 @@
 //! }
 //! ```
 
-#![deny(rust_2018_idioms, nonstandard_style)]
-#![warn(future_incompatible)]
 #![doc(html_logo_url = "https://actix.rs/img/logo.png")]
 #![doc(html_favicon_url = "https://actix.rs/favicon.ico")]
-#![cfg_attr(docsrs, feature(doc_auto_cfg))]
+#![cfg_attr(docsrs, feature(doc_cfg))]
 
 #[cfg(feature = "openssl")]
 extern crate tls_openssl as openssl;
diff --git a/actix-web-actors/CHANGES.md b/actix-web-actors/CHANGES.md
index 3e854c0b8..fc4279ea7 100644
--- a/actix-web-actors/CHANGES.md
+++ b/actix-web-actors/CHANGES.md
@@ -2,7 +2,12 @@
 
 ## Unreleased
 
-- Take the encoded buffer when yielding bytes in the response stream rather than splitting the buffer, reducing memory use
+- Minimum supported Rust version (MSRV) is now 1.82.
+
+## 4.3.1 <!-- v4.3.1+deprecated -->
+
+- Reduce memory usage by `take`-ing (rather than `split`-ing) the encoded buffer when yielding bytes in the response stream.
+- Mark crate as deprecated.
 - Minimum supported Rust version (MSRV) is now 1.72.
 
 ## 4.3.0
diff --git a/actix-web-actors/Cargo.toml b/actix-web-actors/Cargo.toml
index 3c74a4f47..c8ff628de 100644
--- a/actix-web-actors/Cargo.toml
+++ b/actix-web-actors/Cargo.toml
@@ -1,43 +1,47 @@
 [package]
 name = "actix-web-actors"
-version = "4.3.0"
+version = "4.3.1+deprecated"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Actix actors support for Actix Web"
 keywords = ["actix", "http", "web", "framework", "async"]
-homepage = "https://actix.rs"
-repository = "https://github.com/actix/actix-web"
-license = "MIT OR Apache-2.0"
-edition = "2021"
+homepage.workspace = true
+repository.workspace = true
+license.workspace = true
+edition.workspace = true
+rust-version.workspace = true
 
 [package.metadata.cargo_check_external_types]
 allowed_external_types = [
-    "actix::*",
-    "actix_http::*",
-    "actix_web::*",
-    "bytes::*",
-    "bytestring::*",
-    "futures_core::*",
+  "actix::*",
+  "actix_http::*",
+  "actix_web::*",
+  "bytes::*",
+  "bytestring::*",
+  "futures_core::*",
 ]
 
 [dependencies]
 actix = { version = ">=0.12, <0.14", default-features = false }
 actix-codec = "0.5"
 actix-http = "3"
-actix-web = { version = "4", default-features = false }
+actix-web = { version = "4", default-features = false, features = ["ws"] }
 
 bytes = "1"
 bytestring = "1"
 futures-core = { version = "0.3.17", default-features = false }
 pin-project-lite = "0.2"
-tokio = { version = "1.24.2", features = ["sync"] }
+tokio = { version = "1.38.2", features = ["sync"] }
 tokio-util = { version = "0.7", features = ["codec"] }
 
 [dev-dependencies]
 actix-rt = "2.2"
 actix-test = "0.1"
-awc = { version = "3", default-features = false }
 actix-web = { version = "4", features = ["macros"] }
+awc = { version = "3", default-features = false }
 
 env_logger = "0.11"
 futures-util = { version = "0.3.17", default-features = false, features = ["std"] }
 mime = "0.3"
+
+[lints]
+workspace = true
diff --git a/actix-web-actors/README.md b/actix-web-actors/README.md
index feb3d1b33..0ec91a224 100644
--- a/actix-web-actors/README.md
+++ b/actix-web-actors/README.md
@@ -1,15 +1,17 @@
 # `actix-web-actors`
 
 > Actix actors support for Actix Web.
+>
+> This crate is deprecated. Migrate to [`actix-ws`](https://crates.io/crates/actix-ws).
 
 <!-- prettier-ignore-start -->
 
 [![crates.io](https://img.shields.io/crates/v/actix-web-actors?label=latest)](https://crates.io/crates/actix-web-actors)
-[![Documentation](https://docs.rs/actix-web-actors/badge.svg?version=4.3.0)](https://docs.rs/actix-web-actors/4.3.0)
+[![Documentation](https://docs.rs/actix-web-actors/badge.svg?version=4.3.1)](https://docs.rs/actix-web-actors/4.3.1)
 ![Version](https://img.shields.io/badge/rustc-1.72+-ab6000.svg)
 ![License](https://img.shields.io/crates/l/actix-web-actors.svg)
 <br />
-[![dependency status](https://deps.rs/crate/actix-web-actors/4.3.0/status.svg)](https://deps.rs/crate/actix-web-actors/4.3.0)
+![maintenance-status](https://img.shields.io/badge/maintenance-deprecated-red.svg)
 [![Download](https://img.shields.io/crates/d/actix-web-actors.svg)](https://crates.io/crates/actix-web-actors)
 [![Chat on Discord](https://img.shields.io/discord/771444961383153695?label=chat&logo=discord)](https://discord.gg/NWpN5mmg3x)
 
diff --git a/actix-web-actors/src/lib.rs b/actix-web-actors/src/lib.rs
index d89b0ee35..619a2204f 100644
--- a/actix-web-actors/src/lib.rs
+++ b/actix-web-actors/src/lib.rs
@@ -1,5 +1,7 @@
 //! Actix actors support for Actix Web.
 //!
+//! This crate is deprecated. Migrate to [`actix-ws`](https://crates.io/crates/actix-ws).
+//!
 //! # Examples
 //!
 //! ```no_run
@@ -55,11 +57,9 @@
 //! * [`HttpContext`]: This struct provides actor support for streaming HTTP responses.
 //!
 
-#![deny(rust_2018_idioms, nonstandard_style)]
-#![warn(future_incompatible)]
 #![doc(html_logo_url = "https://actix.rs/img/logo.png")]
 #![doc(html_favicon_url = "https://actix.rs/favicon.ico")]
-#![cfg_attr(docsrs, feature(doc_auto_cfg))]
+#![cfg_attr(docsrs, feature(doc_cfg))]
 
 mod context;
 pub mod ws;
diff --git a/actix-web-actors/src/ws.rs b/actix-web-actors/src/ws.rs
index 7f7607fa9..22618c9b3 100644
--- a/actix-web-actors/src/ws.rs
+++ b/actix-web-actors/src/ws.rs
@@ -776,10 +776,7 @@ where
                     }
                     Poll::Pending => break,
                     Poll::Ready(Some(Err(err))) => {
-                        return Poll::Ready(Some(Err(ProtocolError::Io(io::Error::new(
-                            io::ErrorKind::Other,
-                            format!("{err}"),
-                        )))));
+                        return Poll::Ready(Some(Err(ProtocolError::Io(io::Error::other(err)))));
                     }
                 }
             }
@@ -795,14 +792,10 @@ where
             }
             Some(frm) => {
                 let msg = match frm {
-                    Frame::Text(data) => {
-                        Message::Text(ByteString::try_from(data).map_err(|e| {
-                            ProtocolError::Io(io::Error::new(
-                                io::ErrorKind::Other,
-                                format!("{}", e),
-                            ))
-                        })?)
-                    }
+                    Frame::Text(data) => Message::Text(
+                        ByteString::try_from(data)
+                            .map_err(|err| ProtocolError::Io(io::Error::other(err)))?,
+                    ),
                     Frame::Binary(data) => Message::Binary(data),
                     Frame::Ping(s) => Message::Ping(s),
                     Frame::Pong(s) => Message::Pong(s),
diff --git a/actix-web-codegen/CHANGES.md b/actix-web-codegen/CHANGES.md
index d143723f4..93f2ca8c3 100644
--- a/actix-web-codegen/CHANGES.md
+++ b/actix-web-codegen/CHANGES.md
@@ -2,6 +2,8 @@
 
 ## Unreleased
 
+- Minimum supported Rust version (MSRV) is now 1.82.
+
 ## 4.3.0
 
 - Add `#[scope]` macro.
diff --git a/actix-web-codegen/Cargo.toml b/actix-web-codegen/Cargo.toml
index 7500807d2..c2bd75c69 100644
--- a/actix-web-codegen/Cargo.toml
+++ b/actix-web-codegen/Cargo.toml
@@ -2,10 +2,7 @@
 name = "actix-web-codegen"
 version = "4.3.0"
 description = "Routing and runtime macros for Actix Web"
-authors = [
-    "Nikolay Kim <fafhrd91@gmail.com>",
-    "Rob Ede <robjtede@icloud.com>",
-]
+authors = ["Nikolay Kim <fafhrd91@gmail.com>", "Rob Ede <robjtede@icloud.com>"]
 homepage.workspace = true
 repository.workspace = true
 license.workspace = true
@@ -33,5 +30,8 @@ actix-utils = "3"
 actix-web = "4"
 
 futures-core = { version = "0.3.17", default-features = false, features = ["alloc"] }
+rustversion-msrv = "0.100"
 trybuild = "1"
-rustversion = "1"
+
+[lints]
+workspace = true
diff --git a/actix-web-codegen/src/lib.rs b/actix-web-codegen/src/lib.rs
index c518007a0..f6ca56aa0 100644
--- a/actix-web-codegen/src/lib.rs
+++ b/actix-web-codegen/src/lib.rs
@@ -73,11 +73,9 @@
 //! [DELETE]: macro@delete
 
 #![recursion_limit = "512"]
-#![deny(rust_2018_idioms, nonstandard_style)]
-#![warn(future_incompatible)]
 #![doc(html_logo_url = "https://actix.rs/img/logo.png")]
 #![doc(html_favicon_url = "https://actix.rs/favicon.ico")]
-#![cfg_attr(docsrs, feature(doc_auto_cfg))]
+#![cfg_attr(docsrs, feature(doc_cfg))]
 
 use proc_macro::TokenStream;
 use quote::quote;
diff --git a/actix-web-codegen/src/route.rs b/actix-web-codegen/src/route.rs
index e24903e3a..cd1ad4c66 100644
--- a/actix-web-codegen/src/route.rs
+++ b/actix-web-codegen/src/route.rs
@@ -59,6 +59,7 @@ macro_rules! standard_method_type {
     (
         $($variant:ident, $upper:ident, $lower:ident,)+
     ) => {
+        #[doc(hidden)]
         #[derive(Debug, Clone, PartialEq, Eq, Hash)]
         pub enum MethodType {
             $(
@@ -466,7 +467,7 @@ impl ToTokens for Route {
 
         let stream = quote! {
             #(#doc_attributes)*
-            #[allow(non_camel_case_types, missing_docs)]
+            #[allow(non_camel_case_types)]
             #vis struct #name;
 
             impl ::actix_web::dev::HttpServiceFactory for #name {
diff --git a/actix-web-codegen/tests/routes.rs b/actix-web-codegen/tests/routes.rs
index fb50d4ae0..1443f9a75 100644
--- a/actix-web-codegen/tests/routes.rs
+++ b/actix-web-codegen/tests/routes.rs
@@ -136,7 +136,7 @@ async fn routes_overlapping_inaccessible_test(req: HttpRequest) -> impl Responde
 }
 
 #[get("/custom_resource_name", name = "custom")]
-async fn custom_resource_name_test<'a>(req: HttpRequest) -> impl Responder {
+async fn custom_resource_name_test(req: HttpRequest) -> impl Responder {
     assert!(req.url_for_static("custom").is_ok());
     assert!(req.url_for_static("custom_resource_name_test").is_err());
     HttpResponse::Ok()
@@ -145,7 +145,7 @@ async fn custom_resource_name_test<'a>(req: HttpRequest) -> impl Responder {
 mod guard_module {
     use actix_web::{guard::GuardContext, http::header};
 
-    pub fn guard(ctx: &GuardContext) -> bool {
+    pub fn guard(ctx: &GuardContext<'_>) -> bool {
         ctx.header::<header::Accept>()
             .map(|h| h.preference() == "image/*")
             .unwrap_or(false)
diff --git a/actix-web-codegen/tests/scopes.rs b/actix-web-codegen/tests/scopes.rs
index 4ee6db16f..b8c832682 100644
--- a/actix-web-codegen/tests/scopes.rs
+++ b/actix-web-codegen/tests/scopes.rs
@@ -1,7 +1,7 @@
 use actix_web::{guard::GuardContext, http, http::header, web, App, HttpResponse, Responder};
 use actix_web_codegen::{delete, get, post, route, routes, scope};
 
-pub fn image_guard(ctx: &GuardContext) -> bool {
+pub fn image_guard(ctx: &GuardContext<'_>) -> bool {
     ctx.header::<header::Accept>()
         .map(|h| h.preference() == "image/*")
         .unwrap_or(false)
diff --git a/actix-web-codegen/tests/trybuild.rs b/actix-web-codegen/tests/trybuild.rs
index 91073cf3b..0150d56f2 100644
--- a/actix-web-codegen/tests/trybuild.rs
+++ b/actix-web-codegen/tests/trybuild.rs
@@ -1,4 +1,4 @@
-#[rustversion::stable(1.72)] // MSRV
+#[rustversion_msrv::msrv]
 #[test]
 fn compile_macros() {
     let t = trybuild::TestCases::new();
diff --git a/actix-web-codegen/tests/trybuild/route-custom-lowercase.stderr b/actix-web-codegen/tests/trybuild/route-custom-lowercase.stderr
index c2a51d005..34c79efea 100644
--- a/actix-web-codegen/tests/trybuild/route-custom-lowercase.stderr
+++ b/actix-web-codegen/tests/trybuild/route-custom-lowercase.stderr
@@ -13,14 +13,14 @@ error[E0277]: the trait bound `fn() -> impl std::future::Future<Output = String>
    |                                               required by a bound introduced by this call
    |
    = help: the following other types implement trait `HttpServiceFactory`:
-             Resource<T>
-             actix_web::Scope<T>
-             Vec<T>
-             Redirect
-             (A,)
              (A, B)
              (A, B, C)
              (A, B, C, D)
+             (A, B, C, D, E)
+             (A, B, C, D, E, F)
+             (A, B, C, D, E, F, G)
+             (A, B, C, D, E, F, G, H)
+             (A, B, C, D, E, F, G, H, I)
            and $N others
 note: required by a bound in `App::<T>::service`
   --> $WORKSPACE/actix-web/src/app.rs
diff --git a/actix-web-codegen/tests/trybuild/route-duplicate-method-fail.stderr b/actix-web-codegen/tests/trybuild/route-duplicate-method-fail.stderr
index ae18f347f..7b176e5b8 100644
--- a/actix-web-codegen/tests/trybuild/route-duplicate-method-fail.stderr
+++ b/actix-web-codegen/tests/trybuild/route-duplicate-method-fail.stderr
@@ -13,14 +13,14 @@ error[E0277]: the trait bound `fn() -> impl std::future::Future<Output = String>
    |                                               required by a bound introduced by this call
    |
    = help: the following other types implement trait `HttpServiceFactory`:
-             Resource<T>
-             actix_web::Scope<T>
-             Vec<T>
-             Redirect
-             (A,)
              (A, B)
              (A, B, C)
              (A, B, C, D)
+             (A, B, C, D, E)
+             (A, B, C, D, E, F)
+             (A, B, C, D, E, F, G)
+             (A, B, C, D, E, F, G, H)
+             (A, B, C, D, E, F, G, H, I)
            and $N others
 note: required by a bound in `App::<T>::service`
   --> $WORKSPACE/actix-web/src/app.rs
diff --git a/actix-web-codegen/tests/trybuild/route-missing-method-fail.stderr b/actix-web-codegen/tests/trybuild/route-missing-method-fail.stderr
index 37d8354c9..e8814b9b1 100644
--- a/actix-web-codegen/tests/trybuild/route-missing-method-fail.stderr
+++ b/actix-web-codegen/tests/trybuild/route-missing-method-fail.stderr
@@ -15,14 +15,14 @@ error[E0277]: the trait bound `fn() -> impl std::future::Future<Output = String>
    |                                               required by a bound introduced by this call
    |
    = help: the following other types implement trait `HttpServiceFactory`:
-             Resource<T>
-             actix_web::Scope<T>
-             Vec<T>
-             Redirect
-             (A,)
              (A, B)
              (A, B, C)
              (A, B, C, D)
+             (A, B, C, D, E)
+             (A, B, C, D, E, F)
+             (A, B, C, D, E, F, G)
+             (A, B, C, D, E, F, G, H)
+             (A, B, C, D, E, F, G, H, I)
            and $N others
 note: required by a bound in `App::<T>::service`
   --> $WORKSPACE/actix-web/src/app.rs
diff --git a/actix-web-codegen/tests/trybuild/routes-missing-args-fail.stderr b/actix-web-codegen/tests/trybuild/routes-missing-args-fail.stderr
index 40b19fc77..77d53fa90 100644
--- a/actix-web-codegen/tests/trybuild/routes-missing-args-fail.stderr
+++ b/actix-web-codegen/tests/trybuild/routes-missing-args-fail.stderr
@@ -29,14 +29,14 @@ error[E0277]: the trait bound `fn() -> impl std::future::Future<Output = String>
    |                                               required by a bound introduced by this call
    |
    = help: the following other types implement trait `HttpServiceFactory`:
-             Resource<T>
-             actix_web::Scope<T>
-             Vec<T>
-             Redirect
-             (A,)
              (A, B)
              (A, B, C)
              (A, B, C, D)
+             (A, B, C, D, E)
+             (A, B, C, D, E, F)
+             (A, B, C, D, E, F, G)
+             (A, B, C, D, E, F, G, H)
+             (A, B, C, D, E, F, G, H, I)
            and $N others
 note: required by a bound in `App::<T>::service`
   --> $WORKSPACE/actix-web/src/app.rs
diff --git a/actix-web-codegen/tests/trybuild/routes-missing-method-fail.stderr b/actix-web-codegen/tests/trybuild/routes-missing-method-fail.stderr
index ff7f00b3b..9c1c3e23b 100644
--- a/actix-web-codegen/tests/trybuild/routes-missing-method-fail.stderr
+++ b/actix-web-codegen/tests/trybuild/routes-missing-method-fail.stderr
@@ -15,14 +15,14 @@ error[E0277]: the trait bound `fn() -> impl std::future::Future<Output = String>
    |                                               required by a bound introduced by this call
    |
    = help: the following other types implement trait `HttpServiceFactory`:
-             Resource<T>
-             actix_web::Scope<T>
-             Vec<T>
-             Redirect
-             (A,)
              (A, B)
              (A, B, C)
              (A, B, C, D)
+             (A, B, C, D, E)
+             (A, B, C, D, E, F)
+             (A, B, C, D, E, F, G)
+             (A, B, C, D, E, F, G, H)
+             (A, B, C, D, E, F, G, H, I)
            and $N others
 note: required by a bound in `App::<T>::service`
   --> $WORKSPACE/actix-web/src/app.rs
diff --git a/actix-web/CHANGES.md b/actix-web/CHANGES.md
index 54c7045ae..a12ab110c 100644
--- a/actix-web/CHANGES.md
+++ b/actix-web/CHANGES.md
@@ -2,6 +2,59 @@
 
 ## Unreleased
 
+- Minimum supported Rust version (MSRV) is now 1.82.
+
+## 4.12.1
+
+- Correct `actix-http` dependency requirement.
+
+## 4.12.0
+
+- `actix_web::response::builder::HttpResponseBuilder::streaming()` now sets `Content-Type` to `application/octet-stream` if `Content-Type` does not exist.
+- `actix_web::response::builder::HttpResponseBuilder::streaming()` now calls `actix_web::response::builder::HttpResponseBuilder::no_chunking()` and returns `SizedStream` if `Content-Length` is set by user.
+- Add `ws` crate feature (on-by-default) which forwards to `actix-http` and guards some of its `ResponseError` impls.
+- Add public export for `EitherExtractError` in `error` module.
+
+## 4.11.0
+
+- Add `Logger::log_level()` method.
+- Improve handling of non-UTF-8 header values in `Logger` middleware.
+- Add `HttpServer::shutdown_signal()` method.
+- Mark `HttpServer` as `#[must_use]`.
+- Allow SVG images to be compressed by the `Compress` middleware.
+- Ignore `Host` header in `Host` guard when connection protocol is HTTP/2.
+- Re-export `mime` dependency.
+- Update `brotli` dependency to `8`.
+
+## 4.10.2
+
+- No significant changes since `4.10.1`.
+
+## 4.10.1
+
+- No significant changes since `4.10.0`.
+
+## 4.10.0
+
+### Added
+
+- Implement `Responder` for `Result<(), E: Into<Error>>`. Returning `Ok(())` responds with HTTP 204 No Content.
+
+### Changed
+
+- On Windows, an error is now returned from `HttpServer::bind()` (or TLS variants) when binding to a socket that's already in use.
+- Update `brotli` dependency to `7`.
+- Minimum supported Rust version (MSRV) is now 1.75.
+
+## 4.9.0
+
+### Added
+
+- Add `middleware::from_fn()` helper.
+- Add `web::ThinData` extractor.
+
+## 4.8.0
+
 ### Added
 
 - Add `web::Html` responder.
@@ -9,8 +62,9 @@
 
 ### Fixed
 
-- `ConnectionInfo::realip_remote_addr()` now handles IPv6 addresses from `Forwarded` header correctly. Previously, it sometimes returned the forwarded port as well.
+- Always remove port from return value of `ConnectionInfo::realip_remote_addr()` when handling IPv6 addresses. from the `Forwarded` header.
 - The `UrlencodedError::ContentType` variant (relevant to the `Form` extractor) now uses the 415 (Media Type Unsupported) status code in it's `ResponseError` implementation.
+- Apply `HttpServer::max_connection_rate()` setting when using rustls v0.22 or v0.23.
 
 ## 4.7.0
 
diff --git a/actix-web/Cargo.toml b/actix-web/Cargo.toml
index 3827d4400..cc02f197c 100644
--- a/actix-web/Cargo.toml
+++ b/actix-web/Cargo.toml
@@ -1,17 +1,14 @@
 [package]
 name = "actix-web"
-version = "4.7.0"
+version = "4.12.1"
 description = "Actix Web is a powerful, pragmatic, and extremely fast web framework for Rust"
-authors = [
-    "Nikolay Kim <fafhrd91@gmail.com>",
-    "Rob Ede <robjtede@icloud.com>",
-]
+authors = ["Nikolay Kim <fafhrd91@gmail.com>", "Rob Ede <robjtede@icloud.com>"]
 keywords = ["actix", "http", "web", "framework", "async"]
 categories = [
-    "network-programming",
-    "asynchronous",
-    "web-programming::http-server",
-    "web-programming::websocket"
+  "network-programming",
+  "asynchronous",
+  "web-programming::http-server",
+  "web-programming::websocket",
 ]
 homepage = "https://actix.rs"
 repository = "https://github.com/actix/actix-web"
@@ -20,57 +17,56 @@ edition.workspace = true
 rust-version.workspace = true
 
 [package.metadata.docs.rs]
-rustdoc-args = ["--cfg", "docsrs"]
 features = [
-    "macros",
-    "openssl",
-    "rustls-0_20",
-    "rustls-0_21",
-    "rustls-0_22",
-    "rustls-0_23",
-    "compress-brotli",
-    "compress-gzip",
-    "compress-zstd",
-    "cookies",
-    "secure-cookies",
+  "macros",
+  "openssl",
+  "rustls-0_20",
+  "rustls-0_21",
+  "rustls-0_22",
+  "rustls-0_23",
+  "compress-brotli",
+  "compress-gzip",
+  "compress-zstd",
+  "cookies",
+  "secure-cookies",
 ]
 
 [package.metadata.cargo_check_external_types]
 allowed_external_types = [
-    "actix_http::*",
-    "actix_router::*",
-    "actix_rt::*",
-    "actix_server::*",
-    "actix_service::*",
-    "actix_utils::*",
-    "actix_web_codegen::*",
-    "bytes::*",
-    "cookie::*",
-    "cookie",
-    "futures_core::*",
-    "http::*",
-    "language_tags::*",
-    "mime::*",
-    "openssl::*",
-    "rustls::*",
-    "serde_json::*",
-    "serde_urlencoded::*",
-    "serde::*",
-    "serde::*",
-    "tokio::*",
-    "url::*",
+  "actix_http::*",
+  "actix_router::*",
+  "actix_rt::*",
+  "actix_server::*",
+  "actix_service::*",
+  "actix_utils::*",
+  "actix_web_codegen::*",
+  "bytes::*",
+  "cookie::*",
+  "cookie",
+  "futures_core::*",
+  "http::*",
+  "language_tags::*",
+  "mime::*",
+  "openssl::*",
+  "rustls::*",
+  "serde_json::*",
+  "serde_urlencoded::*",
+  "serde::*",
+  "tokio::*",
+  "url::*",
 ]
 
 [features]
 default = [
-    "macros",
-    "compress-brotli",
-    "compress-gzip",
-    "compress-zstd",
-    "cookies",
-    "http2",
-    "unicode",
-    "compat",
+  "macros",
+  "compress-brotli",
+  "compress-gzip",
+  "compress-zstd",
+  "cookies",
+  "http2",
+  "unicode",
+  "compat",
+  "ws",
 ]
 
 # Brotli algorithm content-encoding support
@@ -89,22 +85,25 @@ cookies = ["dep:cookie"]
 # Secure & signed cookies
 secure-cookies = ["cookies", "cookie/secure"]
 
-# HTTP/2 support (including h2c).
+# HTTP/2 support (including h2c)
 http2 = ["actix-http/http2"]
 
+# WebSocket support
+ws = ["actix-http/ws"]
+
 # TLS via OpenSSL
-openssl = ["http2", "actix-http/openssl", "actix-tls/accept", "actix-tls/openssl"]
+openssl = ["__tls", "http2", "actix-http/openssl", "actix-tls/accept", "actix-tls/openssl"]
 
 # TLS via Rustls v0.20
 rustls = ["rustls-0_20"]
 # TLS via Rustls v0.20
-rustls-0_20 = ["http2", "actix-http/rustls-0_20", "actix-tls/accept", "actix-tls/rustls-0_20"]
+rustls-0_20 = ["__tls", "http2", "actix-http/rustls-0_20", "actix-tls/accept", "actix-tls/rustls-0_20"]
 # TLS via Rustls v0.21
-rustls-0_21 = ["http2", "actix-http/rustls-0_21", "actix-tls/accept", "actix-tls/rustls-0_21"]
+rustls-0_21 = ["__tls", "http2", "actix-http/rustls-0_21", "actix-tls/accept", "actix-tls/rustls-0_21"]
 # TLS via Rustls v0.22
-rustls-0_22 = ["http2", "actix-http/rustls-0_22", "actix-tls/accept", "actix-tls/rustls-0_22"]
+rustls-0_22 = ["__tls", "http2", "actix-http/rustls-0_22", "actix-tls/accept", "actix-tls/rustls-0_22"]
 # TLS via Rustls v0.23
-rustls-0_23 = ["http2", "actix-http/rustls-0_23", "actix-tls/accept", "actix-tls/rustls-0_23"]
+rustls-0_23 = ["__tls", "http2", "actix-http/rustls-0_23", "actix-tls/accept", "actix-tls/rustls-0_23"]
 
 # Full unicode support
 unicode = ["dep:regex", "actix-router/unicode"]
@@ -113,13 +112,15 @@ unicode = ["dep:regex", "actix-router/unicode"]
 # Don't rely on these whatsoever. They may disappear at anytime.
 __compress = []
 
+# Internal (PRIVATE!) features used to aid checking feature status.
+# Don't rely on these whatsoever. They may disappear at anytime.
+__tls = []
+
 # io-uring feature only available for Linux OSes.
 experimental-io-uring = ["actix-server/io-uring"]
 
 # Feature group which, when disabled, helps migrate code to v5.0.
-compat = [
-    "compat-routing-macros-force-pub",
-]
+compat = ["compat-routing-macros-force-pub"]
 
 # Opt-out forwards-compatibility for handler visibility inheritance fix.
 compat-routing-macros-force-pub = ["actix-web-codegen?/compat-routing-macros-force-pub"]
@@ -128,29 +129,30 @@ compat-routing-macros-force-pub = ["actix-web-codegen?/compat-routing-macros-for
 actix-codec = "0.5"
 actix-macros = { version = "0.2.3", optional = true }
 actix-rt = { version = "2.6", default-features = false }
-actix-server = "2"
+actix-server = "2.6"
 actix-service = "2"
-actix-utils = "3"
 actix-tls = { version = "3.4", default-features = false, optional = true }
+actix-utils = "3"
 
-actix-http = { version = "3.7", features = ["ws"] }
+actix-http = "3.11.2"
 actix-router = { version = "0.5.3", default-features = false, features = ["http"] }
 actix-web-codegen = { version = "4.3", optional = true, default-features = false }
 
-ahash = "0.8"
 bytes = "1"
 bytestring = "1"
 cfg-if = "1"
 cookie = { version = "0.16", features = ["percent-encode"], optional = true }
-derive_more = "0.99.8"
+derive_more = { version = "2", features = ["as_ref", "deref", "deref_mut", "display", "error", "from"] }
 encoding_rs = "0.8"
+foldhash = "0.1"
 futures-core = { version = "0.3.17", default-features = false }
 futures-util = { version = "0.3.17", default-features = false }
+impl-more = "0.1.4"
 itoa = "1"
 language-tags = "0.3"
 log = "0.4"
 mime = "0.3"
-once_cell = "1.5"
+once_cell = "1.21"
 pin-project-lite = "0.2.7"
 regex = { version = "1.5.5", optional = true }
 regex-lite = "0.1"
@@ -158,32 +160,37 @@ serde = "1.0"
 serde_json = "1.0"
 serde_urlencoded = "0.7"
 smallvec = "1.6.1"
-socket2 = "0.5"
+socket2 = "0.6"
 time = { version = "0.3", default-features = false, features = ["formatting"] }
-url = "2.1"
+tracing = "0.1.30"
+url = "2.5.4"
 
 [dev-dependencies]
 actix-files = "0.6"
 actix-test = { version = "0.1", features = ["openssl", "rustls-0_23"] }
 awc = { version = "3", features = ["openssl"] }
 
-brotli = "6"
-const-str = "0.5"
+brotli = "8"
+const-str = "0.5" # TODO(MSRV 1.77): update to 0.6
 core_affinity = "0.8"
 criterion = { version = "0.5", features = ["html_reports"] }
 env_logger = "0.11"
 flate2 = "1.0.13"
 futures-util = { version = "0.3.17", default-features = false, features = ["std"] }
-rand = "0.8"
+rand = "0.9"
 rcgen = "0.13"
 rustls-pemfile = "2"
-serde = { version = "1.0", features = ["derive"] }
+serde = { version = "1", features = ["derive"] }
 static_assertions = "1"
 tls-openssl = { package = "openssl", version = "0.10.55" }
 tls-rustls = { package = "rustls", version = "0.23" }
-tokio = { version = "1.24.2", features = ["rt-multi-thread", "macros"] }
+tokio = { version = "1.38.2", features = ["rt-multi-thread", "macros"] }
+tokio-util = "0.7"
 zstd = "0.13"
 
+[lints]
+workspace = true
+
 [[test]]
 name = "test_server"
 required-features = ["compress-brotli", "compress-gzip", "compress-zstd", "cookies"]
diff --git a/actix-web/MIGRATION-3.0.md b/actix-web/MIGRATION-3.0.md
index 89255e434..5596c4929 100644
--- a/actix-web/MIGRATION-3.0.md
+++ b/actix-web/MIGRATION-3.0.md
@@ -3,7 +3,6 @@
 - The return type for `ServiceRequest::app_data::<T>()` was changed from returning a `Data<T>` to simply a `T`. To access a `Data<T>` use `ServiceRequest::app_data::<Data<T>>()`.
 
 - Cookie handling has been offloaded to the `cookie` crate:
-
   - `USERINFO_ENCODE_SET` is no longer exposed. Percent-encoding is still supported; check docs.
   - Some types now require lifetime parameters.
 
diff --git a/actix-web/MIGRATION-4.0.md b/actix-web/MIGRATION-4.0.md
index 08c89635a..1574ce724 100644
--- a/actix-web/MIGRATION-4.0.md
+++ b/actix-web/MIGRATION-4.0.md
@@ -115,7 +115,7 @@ An alternative [path param type with public field but no `Deref` impl is availab
 
 ## Rustls Crate Upgrade
 
-Actix Web now depends on version 0.20 of `rustls`. As a result, the server config builder has changed. [See the updated example project.](https://github.com/actix/examples/tree/master/https-tls/rustls/)
+Actix Web now depends on version 0.20 of `rustls`. As a result, the server config builder has changed. [See the updated example project.](https://github.com/actix/examples/tree/main/https-tls/rustls/)
 
 ## Removed `awc` Client Re-export
 
diff --git a/actix-web/README.md b/actix-web/README.md
index 3f9d3e0d5..51ee9d5ff 100644
--- a/actix-web/README.md
+++ b/actix-web/README.md
@@ -8,13 +8,13 @@
 <!-- prettier-ignore-start -->
 
 [![crates.io](https://img.shields.io/crates/v/actix-web?label=latest)](https://crates.io/crates/actix-web)
-[![Documentation](https://docs.rs/actix-web/badge.svg?version=4.7.0)](https://docs.rs/actix-web/4.7.0)
+[![Documentation](https://docs.rs/actix-web/badge.svg?version=4.12.1)](https://docs.rs/actix-web/4.12.1)
 ![MSRV](https://img.shields.io/badge/rustc-1.72+-ab6000.svg)
 ![MIT or Apache 2.0 licensed](https://img.shields.io/crates/l/actix-web.svg)
-[![Dependency Status](https://deps.rs/crate/actix-web/4.7.0/status.svg)](https://deps.rs/crate/actix-web/4.7.0)
+[![Dependency Status](https://deps.rs/crate/actix-web/4.12.1/status.svg)](https://deps.rs/crate/actix-web/4.12.1)
 <br />
 [![CI](https://github.com/actix/actix-web/actions/workflows/ci.yml/badge.svg)](https://github.com/actix/actix-web/actions/workflows/ci.yml)
-[![codecov](https://codecov.io/gh/actix/actix-web/branch/master/graph/badge.svg)](https://codecov.io/gh/actix/actix-web)
+[![codecov](https://codecov.io/gh/actix/actix-web/graph/badge.svg?token=dSwOnp9QCv)](https://codecov.io/gh/actix/actix-web)
 ![downloads](https://img.shields.io/crates/d/actix-web.svg)
 [![Chat on Discord](https://img.shields.io/discord/771444961383153695?label=chat&logo=discord)](https://discord.gg/NWpN5mmg3x)
 
@@ -44,7 +44,7 @@
 - [Website & User Guide](https://actix.rs)
 - [Examples Repository](https://github.com/actix/examples)
 - [API Documentation](https://docs.rs/actix-web)
-- [API Documentation (master branch)](https://actix.rs/actix-web/actix_web)
+- [API Documentation (mainranch)](https://actix.rs/actix-web/actix_web)
 
 ## Example
 
@@ -78,23 +78,23 @@ async fn main() -> std::io::Result<()> {
 
 ### More Examples
 
-- [Hello World](https://github.com/actix/examples/tree/master/basics/hello-world)
-- [Basic Setup](https://github.com/actix/examples/tree/master/basics/basics)
-- [Application State](https://github.com/actix/examples/tree/master/basics/state)
-- [JSON Handling](https://github.com/actix/examples/tree/master/json/json)
-- [Multipart Streams](https://github.com/actix/examples/tree/master/forms/multipart)
-- [MongoDB Integration](https://github.com/actix/examples/tree/master/databases/mongodb)
-- [Diesel Integration](https://github.com/actix/examples/tree/master/databases/diesel)
-- [SQLite Integration](https://github.com/actix/examples/tree/master/databases/sqlite)
-- [Postgres Integration](https://github.com/actix/examples/tree/master/databases/postgres)
-- [Tera Templates](https://github.com/actix/examples/tree/master/templating/tera)
-- [Askama Templates](https://github.com/actix/examples/tree/master/templating/askama)
-- [HTTPS using Rustls](https://github.com/actix/examples/tree/master/https-tls/rustls)
-- [HTTPS using OpenSSL](https://github.com/actix/examples/tree/master/https-tls/openssl)
-- [Simple WebSocket](https://github.com/actix/examples/tree/master/websockets)
-- [WebSocket Chat](https://github.com/actix/examples/tree/master/websockets/chat)
+- [Hello World](https://github.com/actix/examples/tree/main/basics/hello-world)
+- [Basic Setup](https://github.com/actix/examples/tree/main/basics/basics)
+- [Application State](https://github.com/actix/examples/tree/main/basics/state)
+- [JSON Handling](https://github.com/actix/examples/tree/main/json/json)
+- [Multipart Streams](https://github.com/actix/examples/tree/main/forms/multipart)
+- [MongoDB Integration](https://github.com/actix/examples/tree/main/databases/mongodb)
+- [Diesel Integration](https://github.com/actix/examples/tree/main/databases/diesel)
+- [SQLite Integration](https://github.com/actix/examples/tree/main/databases/sqlite)
+- [Postgres Integration](https://github.com/actix/examples/tree/main/databases/postgres)
+- [Tera Templates](https://github.com/actix/examples/tree/main/templating/tera)
+- [Askama Templates](https://github.com/actix/examples/tree/main/templating/askama)
+- [HTTPS using Rustls](https://github.com/actix/examples/tree/main/https-tls/rustls)
+- [HTTPS using OpenSSL](https://github.com/actix/examples/tree/main/https-tls/openssl)
+- [Simple WebSocket](https://github.com/actix/examples/tree/main/websockets)
+- [WebSocket Chat](https://github.com/actix/examples/tree/main/websockets/chat)
 
-You may consider checking out [this directory](https://github.com/actix/examples/tree/master) for more examples.
+You may consider checking out [this directory](https://github.com/actix/examples/tree/main) for more examples.
 
 ## Benchmarks
 
diff --git a/actix-web/benches/responder.rs b/actix-web/benches/responder.rs
index c675eadff..489515e40 100644
--- a/actix-web/benches/responder.rs
+++ b/actix-web/benches/responder.rs
@@ -2,11 +2,9 @@ use std::{future::Future, time::Instant};
 
 use actix_http::body::BoxBody;
 use actix_utils::future::{ready, Ready};
-use actix_web::{
-    error, http::StatusCode, test::TestRequest, Error, HttpRequest, HttpResponse, Responder,
-};
+use actix_web::{http::StatusCode, test::TestRequest, Error, HttpRequest, HttpResponse, Responder};
 use criterion::{criterion_group, criterion_main, Criterion};
-use futures_util::future::{join_all, Either};
+use futures_util::future::join_all;
 
 // responder simulate the old responder trait.
 trait FutureResponder {
@@ -16,9 +14,6 @@ trait FutureResponder {
     fn future_respond_to(self, req: &HttpRequest) -> Self::Future;
 }
 
-// a simple option responder type.
-struct OptionResponder<T>(Option<T>);
-
 // a simple wrapper type around string
 struct StringResponder(String);
 
@@ -34,22 +29,6 @@ impl FutureResponder for StringResponder {
     }
 }
 
-impl<T> FutureResponder for OptionResponder<T>
-where
-    T: FutureResponder,
-    T::Future: Future<Output = Result<HttpResponse, Error>>,
-{
-    type Error = Error;
-    type Future = Either<T::Future, Ready<Result<HttpResponse, Self::Error>>>;
-
-    fn future_respond_to(self, req: &HttpRequest) -> Self::Future {
-        match self.0 {
-            Some(t) => Either::Left(t.future_respond_to(req)),
-            None => Either::Right(ready(Err(error::ErrorInternalServerError("err")))),
-        }
-    }
-}
-
 impl Responder for StringResponder {
     type Body = BoxBody;
 
@@ -60,17 +39,6 @@ impl Responder for StringResponder {
     }
 }
 
-impl<T: Responder> Responder for OptionResponder<T> {
-    type Body = BoxBody;
-
-    fn respond_to(self, req: &HttpRequest) -> HttpResponse<Self::Body> {
-        match self.0 {
-            Some(t) => t.respond_to(req).map_into_boxed_body(),
-            None => HttpResponse::from_error(error::ErrorInternalServerError("err")),
-        }
-    }
-}
-
 fn future_responder(c: &mut Criterion) {
     let rt = actix_rt::System::new();
     let req = TestRequest::default().to_http_request();
diff --git a/actix-web/examples/from_fn.rs b/actix-web/examples/from_fn.rs
new file mode 100644
index 000000000..a6006d23c
--- /dev/null
+++ b/actix-web/examples/from_fn.rs
@@ -0,0 +1,128 @@
+//! Shows a few of ways to use the `from_fn` middleware.
+
+use std::{collections::HashMap, io, rc::Rc, time::Duration};
+
+use actix_web::{
+    body::MessageBody,
+    dev::{Service, ServiceRequest, ServiceResponse, Transform},
+    http::header::{self, HeaderValue, Range},
+    middleware::{from_fn, Logger, Next},
+    web::{self, Header, Query},
+    App, Error, HttpResponse, HttpServer,
+};
+use tracing::info;
+
+async fn noop<B>(req: ServiceRequest, next: Next<B>) -> Result<ServiceResponse<B>, Error> {
+    next.call(req).await
+}
+
+async fn print_range_header<B>(
+    range_header: Option<Header<Range>>,
+    req: ServiceRequest,
+    next: Next<B>,
+) -> Result<ServiceResponse<B>, Error> {
+    if let Some(Header(range)) = range_header {
+        println!("Range: {range}");
+    } else {
+        println!("No Range header");
+    }
+
+    next.call(req).await
+}
+
+async fn mutate_body_type(
+    req: ServiceRequest,
+    next: Next<impl MessageBody + 'static>,
+) -> Result<ServiceResponse<impl MessageBody>, Error> {
+    let res = next.call(req).await?;
+    Ok(res.map_into_left_body::<()>())
+}
+
+async fn mutate_body_type_with_extractors(
+    string_body: String,
+    query: Query<HashMap<String, String>>,
+    req: ServiceRequest,
+    next: Next<impl MessageBody + 'static>,
+) -> Result<ServiceResponse<impl MessageBody>, Error> {
+    println!("body is: {string_body}");
+    println!("query string: {query:?}");
+
+    let res = next.call(req).await?;
+
+    Ok(res.map_body(move |_, _| string_body))
+}
+
+async fn timeout_10secs(
+    req: ServiceRequest,
+    next: Next<impl MessageBody + 'static>,
+) -> Result<ServiceResponse<impl MessageBody>, Error> {
+    match tokio::time::timeout(Duration::from_secs(10), next.call(req)).await {
+        Ok(res) => res,
+        Err(_err) => Err(actix_web::error::ErrorRequestTimeout("")),
+    }
+}
+
+struct MyMw(bool);
+
+impl MyMw {
+    async fn mw_cb(
+        &self,
+        req: ServiceRequest,
+        next: Next<impl MessageBody + 'static>,
+    ) -> Result<ServiceResponse<impl MessageBody>, Error> {
+        let mut res = match self.0 {
+            true => req.into_response("short-circuited").map_into_right_body(),
+            false => next.call(req).await?.map_into_left_body(),
+        };
+
+        res.headers_mut()
+            .insert(header::WARNING, HeaderValue::from_static("42"));
+
+        Ok(res)
+    }
+
+    pub fn into_middleware<S, B>(
+        self,
+    ) -> impl Transform<
+        S,
+        ServiceRequest,
+        Response = ServiceResponse<impl MessageBody>,
+        Error = Error,
+        InitError = (),
+    >
+    where
+        S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = Error> + 'static,
+        B: MessageBody + 'static,
+    {
+        let this = Rc::new(self);
+        from_fn(move |req, next| {
+            let this = Rc::clone(&this);
+            async move { Self::mw_cb(&this, req, next).await }
+        })
+    }
+}
+
+#[actix_web::main]
+async fn main() -> io::Result<()> {
+    env_logger::init_from_env(env_logger::Env::new().default_filter_or("info"));
+
+    let bind = ("127.0.0.1", 8080);
+    info!("staring server at http://{}:{}", &bind.0, &bind.1);
+
+    HttpServer::new(|| {
+        App::new()
+            .wrap(from_fn(noop))
+            .wrap(from_fn(print_range_header))
+            .wrap(from_fn(mutate_body_type))
+            .wrap(from_fn(mutate_body_type_with_extractors))
+            .wrap(from_fn(timeout_10secs))
+            // switch bool to true to observe early response
+            .wrap(MyMw(false).into_middleware())
+            .wrap(Logger::default())
+            .default_service(web::to(HttpResponse::Ok))
+    })
+    .workers(1)
+    .bind(bind)?
+    .run()
+    .await
+}
diff --git a/actix-web/examples/middleware_from_fn.rs b/actix-web/examples/middleware_from_fn.rs
new file mode 100644
index 000000000..da92ef05b
--- /dev/null
+++ b/actix-web/examples/middleware_from_fn.rs
@@ -0,0 +1,127 @@
+//! Shows a couple of ways to use the `from_fn` middleware.
+
+use std::{collections::HashMap, io, rc::Rc, time::Duration};
+
+use actix_web::{
+    body::MessageBody,
+    dev::{Service, ServiceRequest, ServiceResponse, Transform},
+    http::header::{self, HeaderValue, Range},
+    middleware::{from_fn, Logger, Next},
+    web::{self, Header, Query},
+    App, Error, HttpResponse, HttpServer,
+};
+
+async fn noop<B>(req: ServiceRequest, next: Next<B>) -> Result<ServiceResponse<B>, Error> {
+    next.call(req).await
+}
+
+async fn print_range_header<B>(
+    range_header: Option<Header<Range>>,
+    req: ServiceRequest,
+    next: Next<B>,
+) -> Result<ServiceResponse<B>, Error> {
+    if let Some(Header(range)) = range_header {
+        println!("Range: {range}");
+    } else {
+        println!("No Range header");
+    }
+
+    next.call(req).await
+}
+
+async fn mutate_body_type(
+    req: ServiceRequest,
+    next: Next<impl MessageBody + 'static>,
+) -> Result<ServiceResponse<impl MessageBody>, Error> {
+    let res = next.call(req).await?;
+    Ok(res.map_into_left_body::<()>())
+}
+
+async fn mutate_body_type_with_extractors(
+    string_body: String,
+    query: Query<HashMap<String, String>>,
+    req: ServiceRequest,
+    next: Next<impl MessageBody + 'static>,
+) -> Result<ServiceResponse<impl MessageBody>, Error> {
+    println!("body is: {string_body}");
+    println!("query string: {query:?}");
+
+    let res = next.call(req).await?;
+
+    Ok(res.map_body(move |_, _| string_body))
+}
+
+async fn timeout_10secs(
+    req: ServiceRequest,
+    next: Next<impl MessageBody + 'static>,
+) -> Result<ServiceResponse<impl MessageBody>, Error> {
+    match tokio::time::timeout(Duration::from_secs(10), next.call(req)).await {
+        Ok(res) => res,
+        Err(_err) => Err(actix_web::error::ErrorRequestTimeout("")),
+    }
+}
+
+struct MyMw(bool);
+
+impl MyMw {
+    async fn mw_cb(
+        &self,
+        req: ServiceRequest,
+        next: Next<impl MessageBody + 'static>,
+    ) -> Result<ServiceResponse<impl MessageBody>, Error> {
+        let mut res = match self.0 {
+            true => req.into_response("short-circuited").map_into_right_body(),
+            false => next.call(req).await?.map_into_left_body(),
+        };
+
+        res.headers_mut()
+            .insert(header::WARNING, HeaderValue::from_static("42"));
+
+        Ok(res)
+    }
+
+    pub fn into_middleware<S, B>(
+        self,
+    ) -> impl Transform<
+        S,
+        ServiceRequest,
+        Response = ServiceResponse<impl MessageBody>,
+        Error = Error,
+        InitError = (),
+    >
+    where
+        S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = Error> + 'static,
+        B: MessageBody + 'static,
+    {
+        let this = Rc::new(self);
+        from_fn(move |req, next| {
+            let this = Rc::clone(&this);
+            async move { Self::mw_cb(&this, req, next).await }
+        })
+    }
+}
+
+#[actix_web::main]
+async fn main() -> io::Result<()> {
+    env_logger::init_from_env(env_logger::Env::new().default_filter_or("info"));
+
+    let bind = ("127.0.0.1", 8080);
+    log::info!("staring server at http://{}:{}", &bind.0, &bind.1);
+
+    HttpServer::new(|| {
+        App::new()
+            .wrap(from_fn(noop))
+            .wrap(from_fn(print_range_header))
+            .wrap(from_fn(mutate_body_type))
+            .wrap(from_fn(mutate_body_type_with_extractors))
+            .wrap(from_fn(timeout_10secs))
+            // switch bool to true to observe early response
+            .wrap(MyMw(false).into_middleware())
+            .wrap(Logger::default())
+            .default_service(web::to(HttpResponse::Ok))
+    })
+    .workers(1)
+    .bind(bind)?
+    .run()
+    .await
+}
diff --git a/actix-web/examples/on-connect.rs b/actix-web/examples/on-connect.rs
index dc9273b46..ae337757c 100644
--- a/actix-web/examples/on-connect.rs
+++ b/actix-web/examples/on-connect.rs
@@ -2,7 +2,7 @@
 //! properties and pass them to a handler through request-local data.
 //!
 //! For an example of extracting a client TLS certificate, see:
-//! <https://github.com/actix/examples/tree/master/https-tls/rustls-client-cert>
+//! <https://github.com/actix/examples/tree/main/https-tls/rustls-client-cert>
 
 use std::{any::Any, io, net::SocketAddr};
 
diff --git a/actix-web/src/app.rs b/actix-web/src/app.rs
index 3d86d1f9b..f12d39979 100644
--- a/actix-web/src/app.rs
+++ b/actix-web/src/app.rs
@@ -39,7 +39,7 @@ impl App<AppEntry> {
         let factory_ref = Rc::new(RefCell::new(None));
 
         App {
-            endpoint: AppEntry::new(factory_ref.clone()),
+            endpoint: AppEntry::new(Rc::clone(&factory_ref)),
             data_factories: Vec::new(),
             services: Vec::new(),
             default: None,
@@ -234,7 +234,6 @@ where
     ///
     /// * *Resource* is an entry in resource table which corresponds to requested URL.
     /// * *Scope* is a set of resources with common root path.
-    /// * "StaticFiles" is a service for static files support
     pub fn service<F>(mut self, factory: F) -> Self
     where
         F: HttpServiceFactory + 'static,
@@ -270,9 +269,9 @@ where
             + 'static,
         U::InitError: fmt::Debug,
     {
-        let svc = svc
-            .into_factory()
-            .map_init_err(|e| log::error!("Can not construct default service: {:?}", e));
+        let svc = svc.into_factory().map_init_err(|err| {
+            log::error!("Can not construct default service: {err:?}");
+        });
 
         self.default = Some(Rc::new(boxed::factory(svc)));
 
diff --git a/actix-web/src/app_service.rs b/actix-web/src/app_service.rs
index 65a6ed87b..7aa16b790 100644
--- a/actix-web/src/app_service.rs
+++ b/actix-web/src/app_service.rs
@@ -71,7 +71,7 @@ where
         });
 
         // create App config to pass to child services
-        let mut config = AppService::new(config, default.clone());
+        let mut config = AppService::new(config, Rc::clone(&default));
 
         // register services
         mem::take(&mut *self.services.borrow_mut())
diff --git a/actix-web/src/config.rs b/actix-web/src/config.rs
index 5e8b056f1..0e856f574 100644
--- a/actix-web/src/config.rs
+++ b/actix-web/src/config.rs
@@ -68,7 +68,7 @@ impl AppService {
     pub(crate) fn clone_config(&self) -> Self {
         AppService {
             config: self.config.clone(),
-            default: self.default.clone(),
+            default: Rc::clone(&self.default),
             services: Vec::new(),
             root: false,
         }
@@ -81,7 +81,7 @@ impl AppService {
 
     /// Returns default handler factory.
     pub fn default_service(&self) -> Rc<BoxedHttpServiceFactory> {
-        self.default.clone()
+        Rc::clone(&self.default)
     }
 
     /// Register HTTP service.
diff --git a/actix-web/src/data.rs b/actix-web/src/data.rs
index acbb8e23a..088df55d2 100644
--- a/actix-web/src/data.rs
+++ b/actix-web/src/data.rs
@@ -184,7 +184,7 @@ impl<T: ?Sized + 'static> FromRequest for Data<T> {
 
 impl<T: ?Sized + 'static> DataFactory for Data<T> {
     fn create(&self, extensions: &mut Extensions) -> bool {
-        extensions.insert(Data(self.0.clone()));
+        extensions.insert(Data(Arc::clone(&self.0)));
         true
     }
 }
diff --git a/actix-web/src/error/mod.rs b/actix-web/src/error/mod.rs
index 25535332c..c25aa89da 100644
--- a/actix-web/src/error/mod.rs
+++ b/actix-web/src/error/mod.rs
@@ -21,6 +21,7 @@ mod response_error;
 
 pub(crate) use self::macros::{downcast_dyn, downcast_get_type_id};
 pub use self::{error::Error, internal::*, response_error::ResponseError};
+pub use crate::types::EitherExtractError;
 
 /// A convenience [`Result`](std::result::Result) for Actix Web operations.
 ///
@@ -29,7 +30,7 @@ pub type Result<T, E = Error> = std::result::Result<T, E>;
 
 /// An error representing a problem running a blocking task on a thread pool.
 #[derive(Debug, Display, Error)]
-#[display(fmt = "Blocking thread pool is shut down unexpectedly")]
+#[display("Blocking thread pool is shut down unexpectedly")]
 #[non_exhaustive]
 pub struct BlockingError;
 
@@ -40,15 +41,15 @@ impl ResponseError for crate::error::BlockingError {}
 #[non_exhaustive]
 pub enum UrlGenerationError {
     /// Resource not found.
-    #[display(fmt = "Resource not found")]
+    #[display("Resource not found")]
     ResourceNotFound,
 
     /// Not all URL parameters covered.
-    #[display(fmt = "Not all URL parameters covered")]
+    #[display("Not all URL parameters covered")]
     NotEnoughElements,
 
     /// URL parse error.
-    #[display(fmt = "{}", _0)]
+    #[display("{}", _0)]
     ParseError(UrlParseError),
 }
 
@@ -59,39 +60,39 @@ impl ResponseError for UrlGenerationError {}
 #[non_exhaustive]
 pub enum UrlencodedError {
     /// Can not decode chunked transfer encoding.
-    #[display(fmt = "Can not decode chunked transfer encoding.")]
+    #[display("Can not decode chunked transfer encoding.")]
     Chunked,
 
     /// Payload size is larger than allowed. (default limit: 256kB).
     #[display(
-        fmt = "URL encoded payload is larger ({} bytes) than allowed (limit: {} bytes).",
+        "URL encoded payload is larger ({} bytes) than allowed (limit: {} bytes).",
         size,
         limit
     )]
     Overflow { size: usize, limit: usize },
 
     /// Payload size is now known.
-    #[display(fmt = "Payload size is now known.")]
+    #[display("Payload size is now known.")]
     UnknownLength,
 
     /// Content type error.
-    #[display(fmt = "Content type error.")]
+    #[display("Content type error.")]
     ContentType,
 
     /// Parse error.
-    #[display(fmt = "Parse error: {}.", _0)]
+    #[display("Parse error: {}.", _0)]
     Parse(FormDeError),
 
     /// Encoding error.
-    #[display(fmt = "Encoding error.")]
+    #[display("Encoding error.")]
     Encoding,
 
     /// Serialize error.
-    #[display(fmt = "Serialize error: {}.", _0)]
+    #[display("Serialize error: {}.", _0)]
     Serialize(FormError),
 
     /// Payload error.
-    #[display(fmt = "Error that occur during reading payload: {}.", _0)]
+    #[display("Error that occur during reading payload: {}.", _0)]
     Payload(PayloadError),
 }
 
@@ -113,30 +114,30 @@ impl ResponseError for UrlencodedError {
 pub enum JsonPayloadError {
     /// Payload size is bigger than allowed & content length header set. (default: 2MB)
     #[display(
-        fmt = "JSON payload ({} bytes) is larger than allowed (limit: {} bytes).",
+        "JSON payload ({} bytes) is larger than allowed (limit: {} bytes).",
         length,
         limit
     )]
     OverflowKnownLength { length: usize, limit: usize },
 
     /// Payload size is bigger than allowed but no content length header set. (default: 2MB)
-    #[display(fmt = "JSON payload has exceeded limit ({} bytes).", limit)]
+    #[display("JSON payload has exceeded limit ({} bytes).", limit)]
     Overflow { limit: usize },
 
     /// Content type error
-    #[display(fmt = "Content type error")]
+    #[display("Content type error")]
     ContentType,
 
     /// Deserialize error
-    #[display(fmt = "Json deserialize error: {}", _0)]
+    #[display("Json deserialize error: {}", _0)]
     Deserialize(JsonError),
 
     /// Serialize error
-    #[display(fmt = "Json serialize error: {}", _0)]
+    #[display("Json serialize error: {}", _0)]
     Serialize(JsonError),
 
     /// Payload error
-    #[display(fmt = "Error that occur during reading payload: {}", _0)]
+    #[display("Error that occur during reading payload: {}", _0)]
     Payload(PayloadError),
 }
 
@@ -166,7 +167,7 @@ impl ResponseError for JsonPayloadError {
 #[non_exhaustive]
 pub enum PathError {
     /// Deserialize error
-    #[display(fmt = "Path deserialize error: {}", _0)]
+    #[display("Path deserialize error: {}", _0)]
     Deserialize(serde::de::value::Error),
 }
 
@@ -182,7 +183,7 @@ impl ResponseError for PathError {
 #[non_exhaustive]
 pub enum QueryPayloadError {
     /// Query deserialize error.
-    #[display(fmt = "Query deserialize error: {}", _0)]
+    #[display("Query deserialize error: {}", _0)]
     Deserialize(serde::de::value::Error),
 }
 
@@ -196,20 +197,20 @@ impl ResponseError for QueryPayloadError {
 #[derive(Debug, Display, Error, From)]
 #[non_exhaustive]
 pub enum ReadlinesError {
-    #[display(fmt = "Encoding error")]
+    #[display("Encoding error")]
     /// Payload size is bigger than allowed. (default: 256kB)
     EncodingError,
 
     /// Payload error.
-    #[display(fmt = "Error that occur during reading payload: {}", _0)]
+    #[display("Error that occur during reading payload: {}", _0)]
     Payload(PayloadError),
 
     /// Line limit exceeded.
-    #[display(fmt = "Line limit exceeded")]
+    #[display("Line limit exceeded")]
     LimitOverflow,
 
     /// ContentType error.
-    #[display(fmt = "Content-type error")]
+    #[display("Content-type error")]
     ContentTypeError(ContentTypeError),
 }
 
diff --git a/actix-web/src/error/response_error.rs b/actix-web/src/error/response_error.rs
index f5d8cf467..ab3ec59b4 100644
--- a/actix-web/src/error/response_error.rs
+++ b/actix-web/src/error/response_error.rs
@@ -7,7 +7,6 @@ use std::{
     io::{self, Write as _},
 };
 
-use actix_http::Response;
 use bytes::BytesMut;
 
 use crate::{
@@ -126,20 +125,24 @@ impl ResponseError for actix_http::error::PayloadError {
     }
 }
 
-impl ResponseError for actix_http::ws::ProtocolError {}
-
 impl ResponseError for actix_http::error::ContentTypeError {
     fn status_code(&self) -> StatusCode {
         StatusCode::BAD_REQUEST
     }
 }
 
+#[cfg(feature = "ws")]
 impl ResponseError for actix_http::ws::HandshakeError {
     fn error_response(&self) -> HttpResponse<BoxBody> {
-        Response::from(self).map_into_boxed_body().into()
+        actix_http::Response::from(self)
+            .map_into_boxed_body()
+            .into()
     }
 }
 
+#[cfg(feature = "ws")]
+impl ResponseError for actix_http::ws::ProtocolError {}
+
 #[cfg(test)]
 mod tests {
     use super::*;
diff --git a/actix-web/src/guard/host.rs b/actix-web/src/guard/host.rs
index a971a3e30..835662346 100644
--- a/actix-web/src/guard/host.rs
+++ b/actix-web/src/guard/host.rs
@@ -1,4 +1,4 @@
-use actix_http::{header, uri::Uri, RequestHead};
+use actix_http::{header, uri::Uri, RequestHead, Version};
 
 use super::{Guard, GuardContext};
 
@@ -66,6 +66,7 @@ fn get_host_uri(req: &RequestHead) -> Option<Uri> {
     req.headers
         .get(header::HOST)
         .and_then(|host_value| host_value.to_str().ok())
+        .filter(|_| req.version < Version::HTTP_2)
         .or_else(|| req.uri.host())
         .and_then(|host| host.parse().ok())
 }
@@ -123,6 +124,38 @@ mod tests {
     use super::*;
     use crate::test::TestRequest;
 
+    #[test]
+    fn host_not_from_header_if_http2() {
+        let req = TestRequest::default()
+            .uri("www.rust-lang.org")
+            .insert_header((
+                header::HOST,
+                header::HeaderValue::from_static("www.example.com"),
+            ))
+            .to_srv_request();
+
+        let host = Host("www.example.com");
+        assert!(host.check(&req.guard_ctx()));
+
+        let host = Host("www.rust-lang.org");
+        assert!(!host.check(&req.guard_ctx()));
+
+        let req = TestRequest::default()
+            .version(actix_http::Version::HTTP_2)
+            .uri("www.rust-lang.org")
+            .insert_header((
+                header::HOST,
+                header::HeaderValue::from_static("www.example.com"),
+            ))
+            .to_srv_request();
+
+        let host = Host("www.example.com");
+        assert!(!host.check(&req.guard_ctx()));
+
+        let host = Host("www.rust-lang.org");
+        assert!(host.check(&req.guard_ctx()));
+    }
+
     #[test]
     fn host_from_header() {
         let req = TestRequest::default()
diff --git a/actix-web/src/handler.rs b/actix-web/src/handler.rs
index 6e4e2250a..200858a93 100644
--- a/actix-web/src/handler.rs
+++ b/actix-web/src/handler.rs
@@ -19,7 +19,7 @@ use crate::{
 /// 1. It is an async function (or a function/closure that returns an appropriate future);
 /// 1. The function parameters (up to 12) implement [`FromRequest`];
 /// 1. The async function (or future) resolves to a type that can be converted into an
-///   [`HttpResponse`] (i.e., it implements the [`Responder`] trait).
+///    [`HttpResponse`] (i.e., it implements the [`Responder`] trait).
 ///
 ///
 /// # Compiler Errors
@@ -70,7 +70,7 @@ use crate::{
 /// This is the source code for the 2-parameter implementation of `Handler` to help illustrate the
 /// bounds of the handler call after argument extraction:
 /// ```ignore
-/// impl<Func, Arg1, Arg2, Fut> Handler<(Arg1, Arg2)> for Func
+/// impl<Func, Fut, Arg1, Arg2> Handler<(Arg1, Arg2)> for Func
 /// where
 ///     Func: Fn(Arg1, Arg2) -> Fut + Clone + 'static,
 ///     Fut: Future,
diff --git a/actix-web/src/helpers.rs b/actix-web/src/helpers.rs
index 1d2679fce..c7b33a083 100644
--- a/actix-web/src/helpers.rs
+++ b/actix-web/src/helpers.rs
@@ -10,7 +10,7 @@ use bytes::BufMut;
 /// perform a remaining length check before writing.
 pub(crate) struct MutWriter<'a, B>(pub(crate) &'a mut B);
 
-impl<'a, B> io::Write for MutWriter<'a, B>
+impl<B> io::Write for MutWriter<'_, B>
 where
     B: BufMut,
 {
diff --git a/actix-web/src/http/header/content_disposition.rs b/actix-web/src/http/header/content_disposition.rs
index 9725cd19b..c836b1073 100644
--- a/actix-web/src/http/header/content_disposition.rs
+++ b/actix-web/src/http/header/content_disposition.rs
@@ -154,7 +154,7 @@ impl DispositionParam {
     #[inline]
     pub fn as_name(&self) -> Option<&str> {
         match self {
-            DispositionParam::Name(ref name) => Some(name.as_str()),
+            DispositionParam::Name(name) => Some(name.as_str()),
             _ => None,
         }
     }
@@ -163,7 +163,7 @@ impl DispositionParam {
     #[inline]
     pub fn as_filename(&self) -> Option<&str> {
         match self {
-            DispositionParam::Filename(ref filename) => Some(filename.as_str()),
+            DispositionParam::Filename(filename) => Some(filename.as_str()),
             _ => None,
         }
     }
@@ -172,7 +172,7 @@ impl DispositionParam {
     #[inline]
     pub fn as_filename_ext(&self) -> Option<&ExtendedValue> {
         match self {
-            DispositionParam::FilenameExt(ref value) => Some(value),
+            DispositionParam::FilenameExt(value) => Some(value),
             _ => None,
         }
     }
@@ -206,11 +206,11 @@ impl DispositionParam {
     }
 }
 
-/// A *Content-Disposition* header. It is compatible to be used either as
-/// [a response header for the main body](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Disposition#as_a_response_header_for_the_main_body)
-/// as (re)defined in [RFC 6266](https://datatracker.ietf.org/doc/html/rfc6266), or as
-/// [a header for a multipart body](https://mdn.io/Content-Disposition#As_a_header_for_a_multipart_body)
-/// as (re)defined in [RFC 7587](https://datatracker.ietf.org/doc/html/rfc7578).
+/// `Content-Disposition` header.
+///
+/// It is compatible to be used either as [a response header for the main body][use_main_body]
+/// as (re)defined in [RFC 6266], or as [a header for a multipart body][use_multipart] as
+/// (re)defined in [RFC 7587].
 ///
 /// In a regular HTTP response, the *Content-Disposition* response header is a header indicating if
 /// the content is expected to be displayed *inline* in the browser, that is, as a Web page or as
@@ -267,7 +267,7 @@ impl DispositionParam {
 ///     parameters: vec![DispositionParam::FilenameExt(ExtendedValue {
 ///         charset: Charset::Iso_8859_1, // The character set for the bytes of the filename
 ///         language_tag: None, // The optional language tag (see `language-tag` crate)
-///         value: b"\xa9 Copyright 1989.txt".to_vec(), // the actual bytes of the filename
+///         value: b"\xA9 Ferris 2011.txt".to_vec(), // the actual bytes of the filename
 ///     })],
 /// };
 /// assert!(cd1.is_attachment());
@@ -305,6 +305,11 @@ impl DispositionParam {
 /// change to match local file system conventions if applicable, and do not use directory path
 /// information that may be present.
 /// See [RFC 2183 §2.3](https://datatracker.ietf.org/doc/html/rfc2183#section-2.3).
+///
+/// [use_main_body]: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Disposition#as_a_response_header_for_the_main_body
+/// [RFC 6266]: https://datatracker.ietf.org/doc/html/rfc6266
+/// [use_multipart]: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Disposition#as_a_header_for_a_multipart_body
+/// [RFC 7587]: https://datatracker.ietf.org/doc/html/rfc7578
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct ContentDisposition {
     /// The disposition type
@@ -493,7 +498,7 @@ impl Header for ContentDisposition {
     }
 
     fn parse<T: crate::HttpMessage>(msg: &T) -> Result<Self, crate::error::ParseError> {
-        if let Some(h) = msg.headers().get(&Self::name()) {
+        if let Some(h) = msg.headers().get(Self::name()) {
             Self::from_raw(h)
         } else {
             Err(crate::error::ParseError::Header)
diff --git a/actix-web/src/http/header/range.rs b/actix-web/src/http/header/range.rs
index 2326bb19c..4a5d95d93 100644
--- a/actix-web/src/http/header/range.rs
+++ b/actix-web/src/http/header/range.rs
@@ -107,16 +107,16 @@ impl ByteRangeSpec {
     /// satisfiable if they meet the following conditions:
     ///
     /// > If a valid byte-range-set includes at least one byte-range-spec with a first-byte-pos that
-    /// is less than the current length of the representation, or at least one
-    /// suffix-byte-range-spec with a non-zero suffix-length, then the byte-range-set
-    /// is satisfiable. Otherwise, the byte-range-set is unsatisfiable.
+    /// > is less than the current length of the representation, or at least one
+    /// > suffix-byte-range-spec with a non-zero suffix-length, then the byte-range-set is
+    /// > satisfiable. Otherwise, the byte-range-set is unsatisfiable.
     ///
     /// The function also computes remainder ranges based on the RFC:
     ///
     /// > If the last-byte-pos value is absent, or if the value is greater than or equal to the
-    /// current length of the representation data, the byte range is interpreted as the remainder
-    /// of the representation (i.e., the server replaces the value of last-byte-pos with a value
-    /// that is one less than the current length of the selected representation).
+    /// > current length of the representation data, the byte range is interpreted as the remainder
+    /// > of the representation (i.e., the server replaces the value of last-byte-pos with a value
+    /// > that is one less than the current length of the selected representation).
     ///
     /// [RFC 7233 §2.1]: https://datatracker.ietf.org/doc/html/rfc7233
     pub fn to_satisfiable_range(&self, full_length: u64) -> Option<(u64, u64)> {
@@ -270,7 +270,7 @@ impl Header for Range {
 
     #[inline]
     fn parse<T: HttpMessage>(msg: &T) -> Result<Self, ParseError> {
-        header::from_one_raw_str(msg.headers().get(&Self::name()))
+        header::from_one_raw_str(msg.headers().get(Self::name()))
     }
 }
 
diff --git a/actix-web/src/info.rs b/actix-web/src/info.rs
index 1b2e554f9..59d72b708 100644
--- a/actix-web/src/info.rs
+++ b/actix-web/src/info.rs
@@ -158,7 +158,7 @@ impl ConnectionInfo {
     /// The address is resolved through the following, in order:
     /// - `Forwarded` header
     /// - `X-Forwarded-For` header
-    /// - peer address of opened socket (same as [`remote_addr`](Self::remote_addr))
+    /// - peer address of opened socket (same as [`peer_addr`](Self::peer_addr))
     ///
     /// # Security
     /// Do not use this function for security purposes unless you can be sure that the `Forwarded`
@@ -235,7 +235,7 @@ impl FromRequest for ConnectionInfo {
 /// # let _svc = actix_web::web::to(handler);
 /// ```
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord, Display)]
-#[display(fmt = "{}", _0)]
+#[display("{}", _0)]
 pub struct PeerAddr(pub SocketAddr);
 
 impl PeerAddr {
@@ -247,7 +247,7 @@ impl PeerAddr {
 
 #[derive(Debug, Display, Error)]
 #[non_exhaustive]
-#[display(fmt = "Missing peer address")]
+#[display("Missing peer address")]
 pub struct MissingPeerAddr;
 
 impl ResponseError for MissingPeerAddr {}
diff --git a/actix-web/src/lib.rs b/actix-web/src/lib.rs
index 205391388..ee251320e 100644
--- a/actix-web/src/lib.rs
+++ b/actix-web/src/lib.rs
@@ -70,17 +70,15 @@
 //! - `rustls-0_23` - HTTPS support via `rustls` 0.23 crate, supports `HTTP/2`
 //! - `secure-cookies` - secure cookies support
 
-#![deny(rust_2018_idioms, nonstandard_style)]
-#![warn(future_incompatible)]
 #![doc(html_logo_url = "https://actix.rs/img/logo.png")]
 #![doc(html_favicon_url = "https://actix.rs/favicon.ico")]
-#![cfg_attr(docsrs, feature(doc_auto_cfg))]
+#![cfg_attr(docsrs, feature(doc_cfg))]
 
 pub use actix_http::{body, HttpMessage};
 #[cfg(feature = "cookies")]
 #[doc(inline)]
 pub use cookie;
-
+pub use mime;
 mod app;
 mod app_service;
 mod config;
@@ -106,6 +104,7 @@ mod scope;
 mod server;
 mod service;
 pub mod test;
+mod thin_data;
 pub(crate) mod types;
 pub mod web;
 
diff --git a/actix-web/src/middleware/authors-guide.md b/actix-web/src/middleware/authors-guide.md
index 64bad15c2..e073caf73 100644
--- a/actix-web/src/middleware/authors-guide.md
+++ b/actix-web/src/middleware/authors-guide.md
@@ -2,16 +2,79 @@
 
 ## What Is A Middleware?
 
+Middleware in Actix Web is a powerful mechanism that allows you to add additional behavior to request/response processing. It enables you to:
+
+- Pre-process incoming requests (e.g., path normalization, authentication)
+- Post-process outgoing responses (e.g., logging, compression)
+- Modify application state through ServiceRequest
+- Access external services (e.g., sessions, caching)
+
+Middleware is registered for each App, Scope, or Resource and executed in the reverse order of registration. This means the last registered middleware is the first to process the request.
+
 ## Middleware Traits
 
+Actix Web's middleware system is built on two main traits:
+
+1. `Transform<S, Req>`: The builder trait that creates the actual Service. It's responsible for:
+   - Creating new middleware instances
+   - Assembling the middleware chain
+   - Handling initialization errors
+
+2. `Service<Req>`: The trait that represents the actual middleware functionality. It:
+   - Processes requests and responses
+   - Can modify both request and response
+   - Can short-circuit request processing
+   - Must be implemented for the middleware to work
+
 ## Understanding Body Types
 
+When working with middleware, it's important to understand body types:
+
+- Middleware can work with different body types for requests and responses
+- The `MessageBody` trait is used to handle different body types
+- You can use `EitherBody` when you need to handle multiple body types
+- Be careful with body consumption - once a body is consumed, it cannot be read again
+
 ## Best Practices
 
+1. Keep middleware focused and single-purpose
+2. Handle errors appropriately and propagate them correctly
+3. Be mindful of performance impact
+4. Use appropriate body types and handle them correctly
+5. Consider middleware ordering carefully
+6. Document your middleware's behavior and requirements
+7. Test your middleware thoroughly
+
 ## Error Propagation
 
+Proper error handling is crucial in middleware:
+
+1. Always propagate errors from the inner service
+2. Use appropriate error types
+3. Handle initialization errors
+4. Consider using custom error types for specific middleware errors
+5. Document error conditions and handling
+
 ## When To (Not) Use Middleware
 
+Use middleware when you need to:
+
+- Add cross-cutting concerns
+- Modify requests/responses globally
+- Add authentication/authorization
+- Add logging or monitoring
+- Handle compression or caching
+
+Avoid middleware when:
+
+- The functionality is specific to a single route
+- The operation is better handled by a service
+- The overhead would be too high
+- The functionality can be implemented more simply
+
 ## Author's References
 
 - `EitherBody` + when is middleware appropriate: https://discord.com/channels/771444961383153695/952016890723729428
+- Actix Web Documentation: https://docs.rs/actix-web
+- Service Trait Documentation: https://docs.rs/actix-service
+- MessageBody Trait Documentation: https://docs.rs/actix-web/latest/actix_web/body/trait.MessageBody.html
diff --git a/actix-web/src/middleware/compress.rs b/actix-web/src/middleware/compress.rs
index 943868d21..7f0d8a4fb 100644
--- a/actix-web/src/middleware/compress.rs
+++ b/actix-web/src/middleware/compress.rs
@@ -191,8 +191,10 @@ where
                             None => true,
                             Some(hdr) => {
                                 match hdr.to_str().ok().and_then(|hdr| hdr.parse::<Mime>().ok()) {
-                                    Some(mime) if mime.type_().as_str() == "image" => false,
-                                    Some(mime) if mime.type_().as_str() == "video" => false,
+                                    Some(mime) if mime.type_() == mime::IMAGE => {
+                                        matches!(mime.subtype(), mime::SVG)
+                                    }
+                                    Some(mime) if mime.type_() == mime::VIDEO => false,
                                     _ => true,
                                 }
                             }
diff --git a/actix-web/src/middleware/default_headers.rs b/actix-web/src/middleware/default_headers.rs
index f21afe6eb..2669a047e 100644
--- a/actix-web/src/middleware/default_headers.rs
+++ b/actix-web/src/middleware/default_headers.rs
@@ -141,7 +141,7 @@ where
     actix_service::forward_ready!(service);
 
     fn call(&self, req: ServiceRequest) -> Self::Future {
-        let inner = self.inner.clone();
+        let inner = Rc::clone(&self.inner);
         let fut = self.service.call(req);
 
         DefaultHeaderFuture {
diff --git a/actix-web/src/middleware/err_handlers.rs b/actix-web/src/middleware/err_handlers.rs
index aa6d1c8a4..649c1a97a 100644
--- a/actix-web/src/middleware/err_handlers.rs
+++ b/actix-web/src/middleware/err_handlers.rs
@@ -8,7 +8,7 @@ use std::{
 };
 
 use actix_service::{Service, Transform};
-use ahash::AHashMap;
+use foldhash::HashMap as FoldHashMap;
 use futures_core::{future::LocalBoxFuture, ready};
 use pin_project_lite::pin_project;
 
@@ -185,7 +185,7 @@ pub struct ErrorHandlers<B> {
     handlers: Handlers<B>,
 }
 
-type Handlers<B> = Rc<AHashMap<StatusCode, Box<ErrorHandler<B>>>>;
+type Handlers<B> = Rc<FoldHashMap<StatusCode, Box<ErrorHandler<B>>>>;
 
 impl<B> Default for ErrorHandlers<B> {
     fn default() -> Self {
@@ -220,16 +220,20 @@ impl<B> ErrorHandlers<B> {
     /// [`.handler()`][ErrorHandlers::handler]) will fall back on this.
     ///
     /// Note that this will overwrite any default handlers previously set by calling
-    /// [`.default_handler_client()`][ErrorHandlers::default_handler_client] or
-    /// [`.default_handler_server()`][ErrorHandlers::default_handler_server], but not any set by
-    /// calling [`.handler()`][ErrorHandlers::handler].
+    /// [`default_handler_client()`] or [`.default_handler_server()`], but not any set by calling
+    /// [`.handler()`].
+    ///
+    /// [`default_handler_client()`]: ErrorHandlers::default_handler_client
+    /// [`.default_handler_server()`]: ErrorHandlers::default_handler_server
+    /// [`.handler()`]: ErrorHandlers::handler
     pub fn default_handler<F>(self, handler: F) -> Self
     where
         F: Fn(ServiceResponse<B>) -> Result<ErrorHandlerResponse<B>> + 'static,
     {
         let handler = Rc::new(handler);
+        let handler2 = Rc::clone(&handler);
         Self {
-            default_server: Some(handler.clone()),
+            default_server: Some(handler2),
             default_client: Some(handler),
             ..self
         }
@@ -288,7 +292,7 @@ where
     type Future = LocalBoxFuture<'static, Result<Self::Transform, Self::InitError>>;
 
     fn new_transform(&self, service: S) -> Self::Future {
-        let handlers = self.handlers.clone();
+        let handlers = Rc::clone(&self.handlers);
         let default_client = self.default_client.clone();
         let default_server = self.default_server.clone();
         Box::pin(async move {
@@ -323,7 +327,7 @@ where
     actix_service::forward_ready!(service);
 
     fn call(&self, req: ServiceRequest) -> Self::Future {
-        let handlers = self.handlers.clone();
+        let handlers = Rc::clone(&self.handlers);
         let default_client = self.default_client.clone();
         let default_server = self.default_server.clone();
         let fut = self.service.call(req);
diff --git a/actix-web/src/middleware/from_fn.rs b/actix-web/src/middleware/from_fn.rs
new file mode 100644
index 000000000..608833319
--- /dev/null
+++ b/actix-web/src/middleware/from_fn.rs
@@ -0,0 +1,349 @@
+use std::{future::Future, marker::PhantomData, rc::Rc};
+
+use actix_service::boxed::{self, BoxFuture, RcService};
+use actix_utils::future::{ready, Ready};
+use futures_core::future::LocalBoxFuture;
+
+use crate::{
+    body::MessageBody,
+    dev::{forward_ready, Service, ServiceRequest, ServiceResponse, Transform},
+    Error, FromRequest,
+};
+
+/// Wraps an async function to be used as a middleware.
+///
+/// # Examples
+///
+/// The wrapped function should have the following form:
+///
+/// ```
+/// # use actix_web::{
+/// #     App, Error,
+/// #     body::MessageBody,
+/// #     dev::{ServiceRequest, ServiceResponse, Service as _},
+/// # };
+/// use actix_web::middleware::{self, Next};
+///
+/// async fn my_mw(
+///     req: ServiceRequest,
+///     next: Next<impl MessageBody>,
+/// ) -> Result<ServiceResponse<impl MessageBody>, Error> {
+///     // pre-processing
+///     next.call(req).await
+///     // post-processing
+/// }
+/// # App::new().wrap(middleware::from_fn(my_mw));
+/// ```
+///
+/// Then use in an app builder like this:
+///
+/// ```
+/// use actix_web::{
+///     App, Error,
+///     dev::{ServiceRequest, ServiceResponse, Service as _},
+/// };
+/// use actix_web::middleware::from_fn;
+/// # use actix_web::middleware::Next;
+/// # async fn my_mw<B>(req: ServiceRequest, next: Next<B>) -> Result<ServiceResponse<B>, Error> {
+/// #     next.call(req).await
+/// # }
+///
+/// App::new()
+///     .wrap(from_fn(my_mw))
+/// # ;
+/// ```
+///
+/// It is also possible to write a middleware that automatically uses extractors, similar to request
+/// handlers, by declaring them as the first parameters. As usual, **take care with extractors that
+/// consume the body stream**, since handlers will no longer be able to read it again without
+/// putting the body "back" into the request object within your middleware.
+///
+/// ```
+/// # use std::collections::HashMap;
+/// # use actix_web::{
+/// #     App, Error,
+/// #     body::MessageBody,
+/// #     dev::{ServiceRequest, ServiceResponse},
+/// #     http::header::{Accept, Date},
+/// #     web::{Header, Query},
+/// # };
+/// use actix_web::middleware::Next;
+///
+/// async fn my_extracting_mw(
+///     accept: Header<Accept>,
+///     query: Query<HashMap<String, String>>,
+///     req: ServiceRequest,
+///     next: Next<impl MessageBody>,
+/// ) -> Result<ServiceResponse<impl MessageBody>, Error> {
+///     // pre-processing
+///     next.call(req).await
+///     // post-processing
+/// }
+/// # App::new().wrap(actix_web::middleware::from_fn(my_extracting_mw));
+pub fn from_fn<F, Es>(mw_fn: F) -> MiddlewareFn<F, Es> {
+    MiddlewareFn {
+        mw_fn: Rc::new(mw_fn),
+        _phantom: PhantomData,
+    }
+}
+
+/// Middleware transform for [`from_fn`].
+#[allow(missing_debug_implementations)]
+pub struct MiddlewareFn<F, Es> {
+    mw_fn: Rc<F>,
+    _phantom: PhantomData<Es>,
+}
+
+impl<S, F, Fut, B, B2> Transform<S, ServiceRequest> for MiddlewareFn<F, ()>
+where
+    S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = Error> + 'static,
+    F: Fn(ServiceRequest, Next<B>) -> Fut + 'static,
+    Fut: Future<Output = Result<ServiceResponse<B2>, Error>>,
+    B2: MessageBody,
+{
+    type Response = ServiceResponse<B2>;
+    type Error = Error;
+    type Transform = MiddlewareFnService<F, B, ()>;
+    type InitError = ();
+    type Future = Ready<Result<Self::Transform, Self::InitError>>;
+
+    fn new_transform(&self, service: S) -> Self::Future {
+        ready(Ok(MiddlewareFnService {
+            service: boxed::rc_service(service),
+            mw_fn: Rc::clone(&self.mw_fn),
+            _phantom: PhantomData,
+        }))
+    }
+}
+
+/// Middleware service for [`from_fn`].
+#[allow(missing_debug_implementations)]
+pub struct MiddlewareFnService<F, B, Es> {
+    service: RcService<ServiceRequest, ServiceResponse<B>, Error>,
+    mw_fn: Rc<F>,
+    _phantom: PhantomData<(B, Es)>,
+}
+
+impl<F, Fut, B, B2> Service<ServiceRequest> for MiddlewareFnService<F, B, ()>
+where
+    F: Fn(ServiceRequest, Next<B>) -> Fut,
+    Fut: Future<Output = Result<ServiceResponse<B2>, Error>>,
+    B2: MessageBody,
+{
+    type Response = ServiceResponse<B2>;
+    type Error = Error;
+    type Future = Fut;
+
+    forward_ready!(service);
+
+    fn call(&self, req: ServiceRequest) -> Self::Future {
+        (self.mw_fn)(
+            req,
+            Next::<B> {
+                service: Rc::clone(&self.service),
+            },
+        )
+    }
+}
+
+macro_rules! impl_middleware_fn_service {
+    ($($ext_type:ident),*) => {
+        impl<S, F, Fut, B, B2, $($ext_type),*> Transform<S, ServiceRequest> for MiddlewareFn<F, ($($ext_type),*,)>
+        where
+            S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = Error> + 'static,
+            F: Fn($($ext_type),*, ServiceRequest, Next<B>) -> Fut + 'static,
+            $($ext_type: FromRequest + 'static,)*
+            Fut: Future<Output = Result<ServiceResponse<B2>, Error>> + 'static,
+            B: MessageBody + 'static,
+            B2: MessageBody + 'static,
+        {
+            type Response = ServiceResponse<B2>;
+            type Error = Error;
+            type Transform = MiddlewareFnService<F, B, ($($ext_type,)*)>;
+            type InitError = ();
+            type Future = Ready<Result<Self::Transform, Self::InitError>>;
+
+            fn new_transform(&self, service: S) -> Self::Future {
+                ready(Ok(MiddlewareFnService {
+                    service: boxed::rc_service(service),
+                    mw_fn: Rc::clone(&self.mw_fn),
+                    _phantom: PhantomData,
+                }))
+            }
+        }
+
+        impl<F, $($ext_type),*, Fut, B: 'static, B2> Service<ServiceRequest>
+            for MiddlewareFnService<F, B, ($($ext_type),*,)>
+        where
+            F: Fn(
+                $($ext_type),*,
+                ServiceRequest,
+                Next<B>
+            ) -> Fut + 'static,
+            $($ext_type: FromRequest + 'static,)*
+            Fut: Future<Output = Result<ServiceResponse<B2>, Error>> + 'static,
+            B2: MessageBody + 'static,
+        {
+            type Response = ServiceResponse<B2>;
+            type Error = Error;
+            type Future = LocalBoxFuture<'static, Result<Self::Response, Self::Error>>;
+
+            forward_ready!(service);
+
+            #[allow(nonstandard_style)]
+            fn call(&self, mut req: ServiceRequest) -> Self::Future {
+                let mw_fn = Rc::clone(&self.mw_fn);
+                let service = Rc::clone(&self.service);
+
+                Box::pin(async move {
+                    let ($($ext_type,)*) = req.extract::<($($ext_type,)*)>().await?;
+
+                    (mw_fn)($($ext_type),*, req, Next::<B> { service }).await
+                })
+            }
+        }
+    };
+}
+
+impl_middleware_fn_service!(E1);
+impl_middleware_fn_service!(E1, E2);
+impl_middleware_fn_service!(E1, E2, E3);
+impl_middleware_fn_service!(E1, E2, E3, E4);
+impl_middleware_fn_service!(E1, E2, E3, E4, E5);
+impl_middleware_fn_service!(E1, E2, E3, E4, E5, E6);
+impl_middleware_fn_service!(E1, E2, E3, E4, E5, E6, E7);
+impl_middleware_fn_service!(E1, E2, E3, E4, E5, E6, E7, E8);
+impl_middleware_fn_service!(E1, E2, E3, E4, E5, E6, E7, E8, E9);
+
+/// Wraps the "next" service in the middleware chain.
+#[allow(missing_debug_implementations)]
+pub struct Next<B> {
+    service: RcService<ServiceRequest, ServiceResponse<B>, Error>,
+}
+
+impl<B> Next<B> {
+    /// Equivalent to `Service::call(self, req)`.
+    pub fn call(&self, req: ServiceRequest) -> <Self as Service<ServiceRequest>>::Future {
+        Service::call(self, req)
+    }
+}
+
+impl<B> Service<ServiceRequest> for Next<B> {
+    type Response = ServiceResponse<B>;
+    type Error = Error;
+    type Future = BoxFuture<Result<Self::Response, Self::Error>>;
+
+    forward_ready!(service);
+
+    fn call(&self, req: ServiceRequest) -> Self::Future {
+        self.service.call(req)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{
+        http::header::{self, HeaderValue},
+        middleware::{Compat, Logger},
+        test, web, App, HttpResponse,
+    };
+
+    async fn noop<B>(req: ServiceRequest, next: Next<B>) -> Result<ServiceResponse<B>, Error> {
+        next.call(req).await
+    }
+
+    async fn add_res_header<B>(
+        req: ServiceRequest,
+        next: Next<B>,
+    ) -> Result<ServiceResponse<B>, Error> {
+        let mut res = next.call(req).await?;
+        res.headers_mut()
+            .insert(header::WARNING, HeaderValue::from_static("42"));
+        Ok(res)
+    }
+
+    async fn mutate_body_type(
+        req: ServiceRequest,
+        next: Next<impl MessageBody + 'static>,
+    ) -> Result<ServiceResponse<impl MessageBody>, Error> {
+        let res = next.call(req).await?;
+        Ok(res.map_into_left_body::<()>())
+    }
+
+    struct MyMw(bool);
+
+    impl MyMw {
+        async fn mw_cb(
+            &self,
+            req: ServiceRequest,
+            next: Next<impl MessageBody + 'static>,
+        ) -> Result<ServiceResponse<impl MessageBody>, Error> {
+            let mut res = match self.0 {
+                true => req.into_response("short-circuited").map_into_right_body(),
+                false => next.call(req).await?.map_into_left_body(),
+            };
+            res.headers_mut()
+                .insert(header::WARNING, HeaderValue::from_static("42"));
+            Ok(res)
+        }
+
+        pub fn into_middleware<S, B>(
+            self,
+        ) -> impl Transform<
+            S,
+            ServiceRequest,
+            Response = ServiceResponse<impl MessageBody>,
+            Error = Error,
+            InitError = (),
+        >
+        where
+            S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = Error> + 'static,
+            B: MessageBody + 'static,
+        {
+            let this = Rc::new(self);
+            from_fn(move |req, next| {
+                let this = Rc::clone(&this);
+                async move { Self::mw_cb(&this, req, next).await }
+            })
+        }
+    }
+
+    #[actix_rt::test]
+    async fn compat_compat() {
+        let _ = App::new().wrap(Compat::new(from_fn(noop)));
+        let _ = App::new().wrap(Compat::new(from_fn(mutate_body_type)));
+    }
+
+    #[actix_rt::test]
+    async fn permits_different_in_and_out_body_types() {
+        let app = test::init_service(
+            App::new()
+                .wrap(from_fn(mutate_body_type))
+                .wrap(from_fn(add_res_header))
+                .wrap(Logger::default())
+                .wrap(from_fn(noop))
+                .default_service(web::to(HttpResponse::NotFound)),
+        )
+        .await;
+
+        let req = test::TestRequest::default().to_request();
+        let res = test::call_service(&app, req).await;
+        assert!(res.headers().contains_key(header::WARNING));
+    }
+
+    #[actix_rt::test]
+    async fn closure_capture_and_return_from_fn() {
+        let app = test::init_service(
+            App::new()
+                .wrap(Logger::default())
+                .wrap(MyMw(true).into_middleware())
+                .wrap(Logger::default()),
+        )
+        .await;
+
+        let req = test::TestRequest::default().to_request();
+        let res = test::call_service(&app, req).await;
+        assert!(res.headers().contains_key(header::WARNING));
+    }
+}
diff --git a/actix-web/src/middleware/logger.rs b/actix-web/src/middleware/logger.rs
index dc1b02399..e258775c8 100644
--- a/actix-web/src/middleware/logger.rs
+++ b/actix-web/src/middleware/logger.rs
@@ -16,7 +16,7 @@ use actix_service::{Service, Transform};
 use actix_utils::future::{ready, Ready};
 use bytes::Bytes;
 use futures_core::ready;
-use log::{debug, warn};
+use log::{debug, warn, Level};
 use pin_project_lite::pin_project;
 #[cfg(feature = "unicode")]
 use regex::Regex;
@@ -92,6 +92,7 @@ struct Inner {
     exclude: HashSet<String>,
     exclude_regex: Vec<Regex>,
     log_target: Cow<'static, str>,
+    log_level: Level,
 }
 
 impl Logger {
@@ -102,6 +103,7 @@ impl Logger {
             exclude: HashSet::new(),
             exclude_regex: Vec::new(),
             log_target: Cow::Borrowed(module_path!()),
+            log_level: Level::Info,
         }))
     }
 
@@ -139,6 +141,23 @@ impl Logger {
         self
     }
 
+    /// Sets the log level to `level`.
+    ///
+    /// By default, the log level is `Level::Info`.
+    ///
+    /// # Examples
+    /// Using `.log_level(Level::Debug)` would have this effect on request logs:
+    /// ```diff
+    /// - [2015-10-21T07:28:00Z INFO  actix_web::middleware::logger] 127.0.0.1 "GET / HTTP/1.1" 200 88 "-" "dmc/1.0" 0.001985
+    /// + [2015-10-21T07:28:00Z DEBUG  actix_web::middleware::logger] 127.0.0.1 "GET / HTTP/1.1" 200 88 "-" "dmc/1.0" 0.001985
+    ///                         ^^^^^^
+    /// ```
+    pub fn log_level(mut self, level: log::Level) -> Self {
+        let inner = Rc::get_mut(&mut self.0).unwrap();
+        inner.log_level = level;
+        self
+    }
+
     /// Register a function that receives a ServiceRequest and returns a String for use in the
     /// log line. The label passed as the first argument should match a replacement substring in
     /// the logger format like `%{label}xi`.
@@ -242,6 +261,7 @@ impl Default for Logger {
             exclude: HashSet::new(),
             exclude_regex: Vec::new(),
             log_target: Cow::Borrowed(module_path!()),
+            log_level: Level::Info,
         }))
     }
 }
@@ -276,7 +296,7 @@ where
 
         ready(Ok(LoggerMiddleware {
             service,
-            inner: self.0.clone(),
+            inner: Rc::clone(&self.0),
         }))
     }
 }
@@ -312,6 +332,7 @@ where
                 format: None,
                 time: OffsetDateTime::now_utc(),
                 log_target: Cow::Borrowed(""),
+                log_level: self.inner.log_level,
                 _phantom: PhantomData,
             }
         } else {
@@ -327,6 +348,7 @@ where
                 format: Some(format),
                 time: now,
                 log_target: self.inner.log_target.clone(),
+                log_level: self.inner.log_level,
                 _phantom: PhantomData,
             }
         }
@@ -344,6 +366,7 @@ pin_project! {
         time: OffsetDateTime,
         format: Option<Format>,
         log_target: Cow<'static, str>,
+        log_level: Level,
         _phantom: PhantomData<B>,
     }
 }
@@ -390,6 +413,7 @@ where
         let time = *this.time;
         let format = this.format.take();
         let log_target = this.log_target.clone();
+        let log_level = *this.log_level;
 
         Poll::Ready(Ok(res.map_body(move |_, body| StreamLog {
             body,
@@ -397,6 +421,7 @@ where
             format,
             size: 0,
             log_target,
+            log_level,
         })))
     }
 }
@@ -409,6 +434,7 @@ pin_project! {
         size: usize,
         time: OffsetDateTime,
         log_target: Cow<'static, str>,
+        log_level: Level
     }
 
     impl<B> PinnedDrop for StreamLog<B> {
@@ -421,8 +447,9 @@ pin_project! {
                     Ok(())
                 };
 
-                log::info!(
+                log::log!(
                     target: this.log_target.as_ref(),
+                    this.log_level,
                     "{}", FormatDisplay(&render)
                 );
             }
@@ -622,13 +649,9 @@ impl FormatText {
 
             FormatText::ResponseHeader(ref name) => {
                 let s = if let Some(val) = res.headers().get(name) {
-                    if let Ok(s) = val.to_str() {
-                        s
-                    } else {
-                        "-"
-                    }
+                    String::from_utf8_lossy(val.as_bytes()).into_owned()
                 } else {
-                    "-"
+                    "-".to_owned()
                 };
                 *self = FormatText::Str(s.to_string())
             }
@@ -670,15 +693,11 @@ impl FormatText {
             FormatText::RequestTime => *self = FormatText::Str(now.format(&Rfc3339).unwrap()),
             FormatText::RequestHeader(ref name) => {
                 let s = if let Some(val) = req.headers().get(name) {
-                    if let Ok(s) = val.to_str() {
-                        s
-                    } else {
-                        "-"
-                    }
+                    String::from_utf8_lossy(val.as_bytes()).into_owned()
                 } else {
-                    "-"
+                    "-".to_owned()
                 };
-                *self = FormatText::Str(s.to_string());
+                *self = FormatText::Str(s);
             }
             FormatText::RemoteAddr => {
                 let s = if let Some(peer) = req.connection_info().peer_addr() {
@@ -712,7 +731,7 @@ impl FormatText {
 /// Converter to get a String from something that writes to a Formatter.
 pub(crate) struct FormatDisplay<'a>(&'a dyn Fn(&mut fmt::Formatter<'_>) -> Result<(), fmt::Error>);
 
-impl<'a> fmt::Display for FormatDisplay<'a> {
+impl fmt::Display for FormatDisplay<'_> {
     fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
         (self.0)(fmt)
     }
diff --git a/actix-web/src/middleware/mod.rs b/actix-web/src/middleware/mod.rs
index 1c27b1110..4b5b3e896 100644
--- a/actix-web/src/middleware/mod.rs
+++ b/actix-web/src/middleware/mod.rs
@@ -15,10 +15,47 @@
 //! - Access external services (e.g., [sessions](https://docs.rs/actix-session), etc.)
 //!
 //! Middleware is registered for each [`App`], [`Scope`](crate::Scope), or
-//! [`Resource`](crate::Resource) and executed in opposite order as registration. In general, a
-//! middleware is a pair of types that implements the [`Service`] trait and [`Transform`] trait,
-//! respectively. The [`new_transform`] and [`call`] methods must return a [`Future`], though it
-//! can often be [an immediately-ready one](actix_utils::future::Ready).
+//! [`Resource`](crate::Resource) and executed in opposite order as registration.
+//!
+//! # Simple Middleware
+//!
+//! In many cases, you can model your middleware as an async function via the [`from_fn()`] helper
+//! that provides a natural interface for implementing your desired behaviors.
+//!
+//! ```
+//! # use actix_web::{
+//! #     App, Error,
+//! #     body::MessageBody,
+//! #     dev::{ServiceRequest, ServiceResponse, Service as _},
+//! # };
+//! use actix_web::middleware::{self, Next};
+//!
+//! async fn my_mw(
+//!     req: ServiceRequest,
+//!     next: Next<impl MessageBody>,
+//! ) -> Result<ServiceResponse<impl MessageBody>, Error> {
+//!     // pre-processing
+//!
+//!     // invoke the wrapped middleware or service
+//!     let res = next.call(req).await?;
+//!
+//!     // post-processing
+//!
+//!     Ok(res)
+//! }
+//!
+//! App::new()
+//!     .wrap(middleware::from_fn(my_mw));
+//! ```
+//!
+//! ## Complex Middleware
+//!
+//! In the more general ase, a middleware is a pair of types that implements the [`Service`] trait
+//! and [`Transform`] trait, respectively. The [`new_transform`] and [`call`] methods must return a
+//! [`Future`], though it can often be [an immediately-ready one](actix_utils::future::Ready).
+//!
+//! All the built-in middleware use this pattern with pairs of builder (`Transform`) +
+//! implementation (`Service`) types.
 //!
 //! # Ordering
 //!
@@ -67,7 +104,7 @@
 //!                   Response
 //! ```
 //! The request _first_ gets processed by the middleware specified _last_ - `MiddlewareC`. It passes
-//! the request (modified a modified one) to the next middleware - `MiddlewareB` - _or_ directly
+//! the request (possibly a modified one) to the next middleware - `MiddlewareB` - _or_ directly
 //! responds to the request (e.g. when the request was invalid or an error occurred). `MiddlewareB`
 //! processes the request as well and passes it to `MiddlewareA`, which then passes it to the
 //! [`Service`]. In the [`Service`], the extractors will run first. They don't pass the request on,
@@ -196,18 +233,6 @@
 //! # }
 //! ```
 //!
-//! # Simpler Middleware
-//!
-//! In many cases, you _can_ actually use an async function via a helper that will provide a more
-//! natural flow for your behavior.
-//!
-//! The experimental `actix_web_lab` crate provides a [`from_fn`][lab_from_fn] utility which allows
-//! an async fn to be wrapped and used in the same way as other middleware. See the
-//! [`from_fn`][lab_from_fn] docs for more info and examples of it's use.
-//!
-//! While [`from_fn`][lab_from_fn] is experimental currently, it's likely this helper will graduate
-//! to Actix Web in some form, so feedback is appreciated.
-//!
 //! [`Future`]: std::future::Future
 //! [`App`]: crate::App
 //! [`FromRequest`]: crate::FromRequest
@@ -215,7 +240,7 @@
 //! [`Transform`]: crate::dev::Transform
 //! [`call`]: crate::dev::Service::call()
 //! [`new_transform`]: crate::dev::Transform::new_transform()
-//! [lab_from_fn]: https://docs.rs/actix-web-lab/latest/actix_web_lab/middleware/fn.from_fn.html
+//! [`from_fn`]: crate
 
 mod compat;
 #[cfg(feature = "__compress")]
@@ -223,6 +248,7 @@ mod compress;
 mod condition;
 mod default_headers;
 mod err_handlers;
+mod from_fn;
 mod identity;
 mod logger;
 mod normalize;
@@ -234,6 +260,7 @@ pub use self::{
     condition::Condition,
     default_headers::DefaultHeaders,
     err_handlers::{ErrorHandlerResponse, ErrorHandlers},
+    from_fn::{from_fn, Next},
     identity::Identity,
     logger::Logger,
     normalize::{NormalizePath, TrailingSlash},
diff --git a/actix-web/src/request.rs b/actix-web/src/request.rs
index 47b3e3d88..a49a55bd0 100644
--- a/actix-web/src/request.rs
+++ b/actix-web/src/request.rs
@@ -264,8 +264,10 @@ impl HttpRequest {
     ///
     /// For expanded client connection information, use [`connection_info`] instead.
     ///
-    /// Will only return None when called in unit tests unless [`TestRequest::peer_addr`] is used.
+    /// Will only return `None` when server is listening on [UDS socket] or when called in unit
+    /// tests unless [`TestRequest::peer_addr`] is used.
     ///
+    /// [UDS socket]: crate::HttpServer::bind_uds
     /// [`TestRequest::peer_addr`]: crate::test::TestRequest::peer_addr
     /// [`connection_info`]: Self::connection_info
     #[inline]
diff --git a/actix-web/src/resource.rs b/actix-web/src/resource.rs
index 00555b7b2..aee0dff93 100644
--- a/actix-web/src/resource.rs
+++ b/actix-web/src/resource.rs
@@ -28,9 +28,9 @@ use crate::{
 ///
 /// Resource in turn has at least one route. Route consists of an handlers objects and list of
 /// guards (objects that implement `Guard` trait). Resources and routes uses builder-like pattern
-/// for configuration. During request handling, resource object iterate through all routes and check
-/// guards for specific route, if request matches all guards, route considered matched and route
-/// handler get called.
+/// for configuration. During request handling, the resource object iterates through all routes
+/// and checks guards for the specific route, if the request matches all the guards, then the route
+/// is considered matched and the route handler gets called.
 ///
 /// # Examples
 /// ```
@@ -62,14 +62,14 @@ pub struct Resource<T = ResourceEndpoint> {
 impl Resource {
     /// Constructs new resource that matches a `path` pattern.
     pub fn new<T: IntoPatterns>(path: T) -> Resource {
-        let fref = Rc::new(RefCell::new(None));
+        let factory_ref = Rc::new(RefCell::new(None));
 
         Resource {
             routes: Vec::new(),
             rdef: path.patterns(),
             name: None,
-            endpoint: ResourceEndpoint::new(fref.clone()),
-            factory_ref: fref,
+            endpoint: ResourceEndpoint::new(Rc::clone(&factory_ref)),
+            factory_ref,
             guards: Vec::new(),
             app_data: None,
             default: boxed::factory(fn_service(|req: ServiceRequest| async {
@@ -358,10 +358,9 @@ where
         U::InitError: fmt::Debug,
     {
         // create and configure default resource
-        self.default = boxed::factory(
-            f.into_factory()
-                .map_init_err(|e| log::error!("Can not construct default service: {:?}", e)),
-        );
+        self.default = boxed::factory(f.into_factory().map_init_err(|err| {
+            log::error!("Can not construct default service: {err:?}");
+        }));
 
         self
     }
diff --git a/actix-web/src/response/builder.rs b/actix-web/src/response/builder.rs
index 023842ee5..6ea23b42e 100644
--- a/actix-web/src/response/builder.rs
+++ b/actix-web/src/response/builder.rs
@@ -11,7 +11,7 @@ use futures_core::Stream;
 use serde::Serialize;
 
 use crate::{
-    body::{BodyStream, BoxBody, MessageBody},
+    body::{BodyStream, BoxBody, MessageBody, SizedStream},
     dev::Extensions,
     error::{Error, JsonPayloadError},
     http::{
@@ -318,13 +318,35 @@ impl HttpResponseBuilder {
     /// Set a streaming body and build the `HttpResponse`.
     ///
     /// `HttpResponseBuilder` can not be used after this call.
+    ///
+    /// If `Content-Type` is not set, then it is automatically set to `application/octet-stream`.
+    ///
+    /// If `Content-Length` is set, then [`no_chunking()`](Self::no_chunking) is automatically called.
     #[inline]
     pub fn streaming<S, E>(&mut self, stream: S) -> HttpResponse
     where
         S: Stream<Item = Result<Bytes, E>> + 'static,
         E: Into<BoxError> + 'static,
     {
-        self.body(BodyStream::new(stream))
+        // Set mime type to application/octet-stream if it is not set
+        if let Some(parts) = self.inner() {
+            if !parts.headers.contains_key(header::CONTENT_TYPE) {
+                self.insert_header((header::CONTENT_TYPE, mime::APPLICATION_OCTET_STREAM));
+            }
+        }
+
+        let content_length = self
+            .inner()
+            .and_then(|parts| parts.headers.get(header::CONTENT_LENGTH))
+            .and_then(|value| value.to_str().ok())
+            .and_then(|value| value.parse::<u64>().ok());
+
+        if let Some(len) = content_length {
+            self.no_chunking(len);
+            self.body(SizedStream::new(len, stream))
+        } else {
+            self.body(BodyStream::new(stream))
+        }
     }
 
     /// Set a JSON body and build the `HttpResponse`.
@@ -463,7 +485,7 @@ mod tests {
         // content type override
         let res = HttpResponse::Ok()
             .insert_header((CONTENT_TYPE, "text/json"))
-            .json(&vec!["v1", "v2", "v3"]);
+            .json(["v1", "v2", "v3"]);
         let ct = res.headers().get(CONTENT_TYPE).unwrap();
         assert_eq!(ct, HeaderValue::from_static("text/json"));
         assert_body_eq!(res, br#"["v1","v2","v3"]"#);
diff --git a/actix-web/src/response/http_codes.rs b/actix-web/src/response/http_codes.rs
index db5f392c9..1427ee16a 100644
--- a/actix-web/src/response/http_codes.rs
+++ b/actix-web/src/response/http_codes.rs
@@ -6,7 +6,8 @@ use crate::{HttpResponse, HttpResponseBuilder};
 
 macro_rules! static_resp {
     ($name:ident, $status:expr) => {
-        #[allow(non_snake_case, missing_docs)]
+        #[allow(non_snake_case)]
+        #[doc = concat!("Creates a new response builder with the status code `", stringify!($status), "`.")]
         pub fn $name() -> HttpResponseBuilder {
             HttpResponseBuilder::new($status)
         }
diff --git a/actix-web/src/response/responder.rs b/actix-web/src/response/responder.rs
index 90d8f6e52..82bc38d6b 100644
--- a/actix-web/src/response/responder.rs
+++ b/actix-web/src/response/responder.rs
@@ -131,6 +131,23 @@ where
     }
 }
 
+// Note: see https://github.com/actix/actix-web/issues/1108 for reasoning why Responder is not
+// implemented for `()`, and https://github.com/actix/actix-web/pull/3560 for discussion about this
+// impl and the decision not to include a similar one for `Option<()>`.
+impl<E> Responder for Result<(), E>
+where
+    E: Into<Error>,
+{
+    type Body = BoxBody;
+
+    fn respond_to(self, _req: &HttpRequest) -> HttpResponse {
+        match self {
+            Ok(()) => HttpResponse::new(StatusCode::NO_CONTENT),
+            Err(err) => HttpResponse::from_error(err.into()),
+        }
+    }
+}
+
 impl<R: Responder> Responder for (R, StatusCode) {
     type Body = R::Body;
 
diff --git a/actix-web/src/rmap.rs b/actix-web/src/rmap.rs
index 462f3b313..b445687ac 100644
--- a/actix-web/src/rmap.rs
+++ b/actix-web/src/rmap.rs
@@ -6,7 +6,7 @@ use std::{
 };
 
 use actix_router::ResourceDef;
-use ahash::AHashMap;
+use foldhash::HashMap as FoldHashMap;
 use url::Url;
 
 use crate::{error::UrlGenerationError, request::HttpRequest};
@@ -19,7 +19,7 @@ pub struct ResourceMap {
 
     /// Named resources within the tree or, for external resources, it points to isolated nodes
     /// outside the tree.
-    named: AHashMap<String, Rc<ResourceMap>>,
+    named: FoldHashMap<String, Rc<ResourceMap>>,
 
     parent: RefCell<Weak<ResourceMap>>,
 
@@ -32,7 +32,7 @@ impl ResourceMap {
     pub fn new(root: ResourceDef) -> Self {
         ResourceMap {
             pattern: root,
-            named: AHashMap::default(),
+            named: FoldHashMap::default(),
             parent: RefCell::new(Weak::new()),
             nodes: Some(Vec::new()),
         }
@@ -86,7 +86,7 @@ impl ResourceMap {
         } else {
             let new_node = Rc::new(ResourceMap {
                 pattern: pattern.clone(),
-                named: AHashMap::default(),
+                named: FoldHashMap::default(),
                 parent: RefCell::new(Weak::new()),
                 nodes: None,
             });
diff --git a/actix-web/src/route.rs b/actix-web/src/route.rs
index 261e6b9ae..e05e6be52 100644
--- a/actix-web/src/route.rs
+++ b/actix-web/src/route.rs
@@ -77,7 +77,7 @@ impl ServiceFactory<ServiceRequest> for Route {
 
     fn new_service(&self, _: ()) -> Self::Future {
         let fut = self.service.new_service(());
-        let guards = self.guards.clone();
+        let guards = Rc::clone(&self.guards);
 
         Box::pin(async move {
             let service = fut.await?;
diff --git a/actix-web/src/scope.rs b/actix-web/src/scope.rs
index adc9f75d3..e317349da 100644
--- a/actix-web/src/scope.rs
+++ b/actix-web/src/scope.rs
@@ -213,7 +213,6 @@ where
     ///
     /// * *Resource* is an entry in resource table which corresponds to requested URL.
     /// * *Scope* is a set of resources with common root path.
-    /// * "StaticFiles" is a service for static files support
     ///
     /// ```
     /// use actix_web::{web, App, HttpRequest};
@@ -279,7 +278,9 @@ where
     {
         // create and configure default resource
         self.default = Some(Rc::new(boxed::factory(f.into_factory().map_init_err(
-            |e| log::error!("Can not construct default service: {:?}", e),
+            |err| {
+                log::error!("Can not construct default service: {err:?}");
+            },
         ))));
 
         self
diff --git a/actix-web/src/server.rs b/actix-web/src/server.rs
index 33b1e1894..2bd7c4463 100644
--- a/actix-web/src/server.rs
+++ b/actix-web/src/server.rs
@@ -1,19 +1,15 @@
 use std::{
     any::Any,
-    cmp, fmt, io,
+    cmp, fmt,
+    future::Future,
+    io,
     marker::PhantomData,
     net,
     sync::{Arc, Mutex},
     time::Duration,
 };
 
-#[cfg(any(
-    feature = "openssl",
-    feature = "rustls-0_20",
-    feature = "rustls-0_21",
-    feature = "rustls-0_22",
-    feature = "rustls-0_23",
-))]
+#[cfg(feature = "__tls")]
 use actix_http::TlsAcceptorConfig;
 use actix_http::{body::MessageBody, Extensions, HttpService, KeepAlive, Request, Response};
 use actix_server::{Server, ServerBuilder};
@@ -35,6 +31,7 @@ struct Config {
     keep_alive: KeepAlive,
     client_request_timeout: Duration,
     client_disconnect_timeout: Duration,
+    h1_allow_half_closed: bool,
     #[allow(dead_code)] // only dead when no TLS features are enabled
     tls_handshake_timeout: Option<Duration>,
 }
@@ -70,6 +67,7 @@ struct Config {
 ///     .await
 /// }
 /// ```
+#[must_use]
 pub struct HttpServer<F, I, S, B>
 where
     F: Fn() -> I + Send + Clone + 'static,
@@ -119,6 +117,7 @@ where
                 keep_alive: KeepAlive::default(),
                 client_request_timeout: Duration::from_secs(5),
                 client_disconnect_timeout: Duration::from_secs(1),
+                h1_allow_half_closed: true,
                 tls_handshake_timeout: None,
             })),
             backlog: 1024,
@@ -190,7 +189,7 @@ where
     /// By default max connections is set to a 256.
     #[allow(unused_variables)]
     pub fn max_connection_rate(self, num: usize) -> Self {
-        #[cfg(any(feature = "rustls-0_20", feature = "rustls-0_21", feature = "openssl"))]
+        #[cfg(feature = "__tls")]
         actix_tls::accept::max_concurrent_tls_connect(num);
         self
     }
@@ -199,7 +198,7 @@ where
     ///
     /// One thread pool is set up **per worker**; not shared across workers.
     ///
-    /// By default set to 512 divided by the number of workers.
+    /// By default, set to 512 divided by [available parallelism](std::thread::available_parallelism()).
     pub fn worker_max_blocking_threads(mut self, num: usize) -> Self {
         self.builder = self.builder.worker_max_blocking_threads(num);
         self
@@ -243,13 +242,7 @@ where
     /// time, the connection is closed.
     ///
     /// By default, the handshake timeout is 3 seconds.
-    #[cfg(any(
-        feature = "openssl",
-        feature = "rustls-0_20",
-        feature = "rustls-0_21",
-        feature = "rustls-0_22",
-        feature = "rustls-0_23",
-    ))]
+    #[cfg(feature = "__tls")]
     pub fn tls_handshake_timeout(self, dur: Duration) -> Self {
         self.config
             .lock()
@@ -266,6 +259,18 @@ where
         self.client_disconnect_timeout(Duration::from_millis(dur))
     }
 
+    /// Sets whether HTTP/1 connections should support half-closures.
+    ///
+    /// Clients can choose to shutdown their writer-side of the connection after completing their
+    /// request and while waiting for the server response. Setting this to `false` will cause the
+    /// server to abort the connection handling as soon as it detects an EOF from the client.
+    ///
+    /// The default behavior is to allow, i.e. `true`
+    pub fn h1_allow_half_closed(self, allow: bool) -> Self {
+        self.config.lock().unwrap().h1_allow_half_closed = allow;
+        self
+    }
+
     /// Sets function that will be called once before each connection is handled.
     ///
     /// It will receive a `&std::any::Any`, which contains underlying connection type and an
@@ -284,19 +289,12 @@ where
     /// - `actix_web::rt::net::TcpStream` when no encryption is used.
     ///
     /// See the `on_connect` example for additional details.
-    pub fn on_connect<CB>(self, f: CB) -> HttpServer<F, I, S, B>
+    pub fn on_connect<CB>(mut self, f: CB) -> HttpServer<F, I, S, B>
     where
         CB: Fn(&dyn Any, &mut Extensions) + Send + Sync + 'static,
     {
-        HttpServer {
-            factory: self.factory,
-            config: self.config,
-            backlog: self.backlog,
-            sockets: self.sockets,
-            builder: self.builder,
-            on_connect_fn: Some(Arc::new(f)),
-            _phantom: PhantomData,
-        }
+        self.on_connect_fn = Some(Arc::new(f));
+        self
     }
 
     /// Sets server host name.
@@ -324,6 +322,37 @@ where
         self
     }
 
+    /// Specify shutdown signal from a future.
+    ///
+    /// Using this method will prevent OS signal handlers being set up.
+    ///
+    /// Typically, a `CancellationToken` will be used, but any future _can_ be.
+    ///
+    /// # Examples
+    ///
+    /// ```no_run
+    /// use actix_web::{App, HttpServer};
+    /// use tokio_util::sync::CancellationToken;
+    ///
+    /// # #[actix_web::main]
+    /// # async fn main() -> std::io::Result<()> {
+    /// let stop_signal = CancellationToken::new();
+    ///
+    /// HttpServer::new(move || App::new())
+    ///     .shutdown_signal(stop_signal.cancelled_owned())
+    ///     .bind(("127.0.0.1", 8080))?
+    ///     .run()
+    ///     .await
+    /// # }
+    /// ```
+    pub fn shutdown_signal<Fut>(mut self, shutdown_signal: Fut) -> Self
+    where
+        Fut: Future<Output = ()> + Send + 'static,
+    {
+        self.builder = self.builder.shutdown_signal(shutdown_signal);
+        self
+    }
+
     /// Sets timeout for graceful worker shutdown of workers.
     ///
     /// After receiving a stop signal, workers have this much time to finish serving requests.
@@ -522,7 +551,7 @@ where
     /// No changes are made to `lst`'s configuration. Ensure it is configured properly before
     /// passing ownership to `listen()`.
     pub fn listen(mut self, lst: net::TcpListener) -> io::Result<Self> {
-        let cfg = self.config.clone();
+        let cfg = Arc::clone(&self.config);
         let factory = self.factory.clone();
         let addr = lst.local_addr().unwrap();
 
@@ -543,6 +572,7 @@ where
                         .keep_alive(cfg.keep_alive)
                         .client_request_timeout(cfg.client_request_timeout)
                         .client_disconnect_timeout(cfg.client_disconnect_timeout)
+                        .h1_allow_half_closed(cfg.h1_allow_half_closed)
                         .local_addr(addr);
 
                     if let Some(handler) = on_connect_fn.clone() {
@@ -566,7 +596,7 @@ where
     /// Binds to existing listener for accepting incoming plaintext HTTP/1.x or HTTP/2 connections.
     #[cfg(feature = "http2")]
     pub fn listen_auto_h2c(mut self, lst: net::TcpListener) -> io::Result<Self> {
-        let cfg = self.config.clone();
+        let cfg = Arc::clone(&self.config);
         let factory = self.factory.clone();
         let addr = lst.local_addr().unwrap();
 
@@ -587,6 +617,7 @@ where
                         .keep_alive(cfg.keep_alive)
                         .client_request_timeout(cfg.client_request_timeout)
                         .client_disconnect_timeout(cfg.client_disconnect_timeout)
+                        .h1_allow_half_closed(cfg.h1_allow_half_closed)
                         .local_addr(addr);
 
                     if let Some(handler) = on_connect_fn.clone() {
@@ -644,7 +675,7 @@ where
         config: actix_tls::accept::rustls_0_20::reexports::ServerConfig,
     ) -> io::Result<Self> {
         let factory = self.factory.clone();
-        let cfg = self.config.clone();
+        let cfg = Arc::clone(&self.config);
         let addr = lst.local_addr().unwrap();
         self.sockets.push(Socket {
             addr,
@@ -662,6 +693,7 @@ where
                     let svc = HttpService::build()
                         .keep_alive(c.keep_alive)
                         .client_request_timeout(c.client_request_timeout)
+                        .h1_allow_half_closed(c.h1_allow_half_closed)
                         .client_disconnect_timeout(c.client_disconnect_timeout);
 
                     let svc = if let Some(handler) = on_connect_fn.clone() {
@@ -695,7 +727,7 @@ where
         config: actix_tls::accept::rustls_0_21::reexports::ServerConfig,
     ) -> io::Result<Self> {
         let factory = self.factory.clone();
-        let cfg = self.config.clone();
+        let cfg = Arc::clone(&self.config);
         let addr = lst.local_addr().unwrap();
         self.sockets.push(Socket {
             addr,
@@ -713,6 +745,7 @@ where
                     let svc = HttpService::build()
                         .keep_alive(c.keep_alive)
                         .client_request_timeout(c.client_request_timeout)
+                        .h1_allow_half_closed(c.h1_allow_half_closed)
                         .client_disconnect_timeout(c.client_disconnect_timeout);
 
                     let svc = if let Some(handler) = on_connect_fn.clone() {
@@ -761,7 +794,7 @@ where
         config: actix_tls::accept::rustls_0_22::reexports::ServerConfig,
     ) -> io::Result<Self> {
         let factory = self.factory.clone();
-        let cfg = self.config.clone();
+        let cfg = Arc::clone(&self.config);
         let addr = lst.local_addr().unwrap();
         self.sockets.push(Socket {
             addr,
@@ -779,6 +812,7 @@ where
                     let svc = HttpService::build()
                         .keep_alive(c.keep_alive)
                         .client_request_timeout(c.client_request_timeout)
+                        .h1_allow_half_closed(c.h1_allow_half_closed)
                         .client_disconnect_timeout(c.client_disconnect_timeout);
 
                     let svc = if let Some(handler) = on_connect_fn.clone() {
@@ -827,7 +861,7 @@ where
         config: actix_tls::accept::rustls_0_23::reexports::ServerConfig,
     ) -> io::Result<Self> {
         let factory = self.factory.clone();
-        let cfg = self.config.clone();
+        let cfg = Arc::clone(&self.config);
         let addr = lst.local_addr().unwrap();
         self.sockets.push(Socket {
             addr,
@@ -845,6 +879,7 @@ where
                     let svc = HttpService::build()
                         .keep_alive(c.keep_alive)
                         .client_request_timeout(c.client_request_timeout)
+                        .h1_allow_half_closed(c.h1_allow_half_closed)
                         .client_disconnect_timeout(c.client_disconnect_timeout);
 
                     let svc = if let Some(handler) = on_connect_fn.clone() {
@@ -892,8 +927,9 @@ where
         acceptor: SslAcceptor,
     ) -> io::Result<Self> {
         let factory = self.factory.clone();
-        let cfg = self.config.clone();
+        let cfg = Arc::clone(&self.config);
         let addr = lst.local_addr().unwrap();
+
         self.sockets.push(Socket {
             addr,
             scheme: "https",
@@ -911,6 +947,7 @@ where
                         .keep_alive(c.keep_alive)
                         .client_request_timeout(c.client_request_timeout)
                         .client_disconnect_timeout(c.client_disconnect_timeout)
+                        .h1_allow_half_closed(c.h1_allow_half_closed)
                         .local_addr(addr);
 
                     let svc = if let Some(handler) = on_connect_fn.clone() {
@@ -949,7 +986,7 @@ where
         use actix_rt::net::UnixStream;
         use actix_service::{fn_service, ServiceFactoryExt as _};
 
-        let cfg = self.config.clone();
+        let cfg = Arc::clone(&self.config);
         let factory = self.factory.clone();
         let socket_addr =
             net::SocketAddr::new(net::IpAddr::V4(net::Ipv4Addr::new(127, 0, 0, 1)), 8080);
@@ -979,6 +1016,7 @@ where
                         .keep_alive(c.keep_alive)
                         .client_request_timeout(c.client_request_timeout)
                         .client_disconnect_timeout(c.client_disconnect_timeout)
+                        .h1_allow_half_closed(c.h1_allow_half_closed)
                         .finish(map_config(fac, move |_| config.clone())),
                 )
             },
@@ -994,10 +1032,11 @@ where
         use actix_rt::net::UnixStream;
         use actix_service::{fn_service, ServiceFactoryExt as _};
 
-        let cfg = self.config.clone();
+        let cfg = Arc::clone(&self.config);
         let factory = self.factory.clone();
         let socket_addr =
             net::SocketAddr::new(net::IpAddr::V4(net::Ipv4Addr::new(127, 0, 0, 1)), 8080);
+
         self.sockets.push(Socket {
             scheme: "http",
             addr: socket_addr,
@@ -1019,6 +1058,7 @@ where
                 let mut svc = HttpService::build()
                     .keep_alive(c.keep_alive)
                     .client_request_timeout(c.client_request_timeout)
+                    .h1_allow_half_closed(c.h1_allow_half_closed)
                     .client_disconnect_timeout(c.client_disconnect_timeout);
 
                 if let Some(handler) = on_connect_fn.clone() {
@@ -1085,10 +1125,7 @@ fn bind_addrs(addrs: impl net::ToSocketAddrs, backlog: u32) -> io::Result<Vec<ne
     } else if let Some(err) = err.take() {
         Err(err)
     } else {
-        Err(io::Error::new(
-            io::ErrorKind::Other,
-            "Can not bind to address.",
-        ))
+        Err(io::Error::other("Could not bind to address"))
     }
 }
 
@@ -1097,7 +1134,10 @@ fn create_tcp_listener(addr: net::SocketAddr, backlog: u32) -> io::Result<net::T
     use socket2::{Domain, Protocol, Socket, Type};
     let domain = Domain::for_address(addr);
     let socket = Socket::new(domain, Type::STREAM, Some(Protocol::TCP))?;
-    socket.set_reuse_address(true)?;
+    #[cfg(not(windows))]
+    {
+        socket.set_reuse_address(true)?;
+    }
     socket.bind(&addr.into())?;
     // clamp backlog to max u32 that fits in i32 range
     let backlog = cmp::min(backlog, i32::MAX as u32) as i32;
diff --git a/actix-web/src/service.rs b/actix-web/src/service.rs
index a1672eba2..6c7f6f5c8 100644
--- a/actix-web/src/service.rs
+++ b/actix-web/src/service.rs
@@ -662,6 +662,7 @@ where
 /// ```
 #[macro_export]
 macro_rules! services {
+    () => {()};
     ($($x:expr),+ $(,)?) => {
         ($($x,)+)
     }
@@ -870,4 +871,40 @@ mod tests {
         let req = test::TestRequest::default().to_request();
         let _res = test::call_service(&app, req).await;
     }
+
+    #[test]
+    fn define_services_macro_with_multiple_arguments() {
+        let result = services!(1, 2, 3);
+        assert_eq!(result, (1, 2, 3));
+    }
+
+    #[test]
+    fn define_services_macro_with_single_argument() {
+        let result = services!(1);
+        assert_eq!(result, (1,));
+    }
+
+    #[test]
+    fn define_services_macro_with_no_arguments() {
+        let result = services!();
+        let () = result;
+    }
+
+    #[test]
+    fn define_services_macro_with_trailing_comma() {
+        let result = services!(1, 2, 3,);
+        assert_eq!(result, (1, 2, 3));
+    }
+
+    #[test]
+    fn define_services_macro_with_comments_in_arguments() {
+        let result = services!(
+            1, // First comment
+            2, // Second comment
+            3  // Third comment
+        );
+
+        // Assert that comments are ignored and it correctly returns a tuple.
+        assert_eq!(result, (1, 2, 3));
+    }
 }
diff --git a/actix-web/src/test/mod.rs b/actix-web/src/test/mod.rs
index 5e647956b..86cb60956 100644
--- a/actix-web/src/test/mod.rs
+++ b/actix-web/src/test/mod.rs
@@ -1,6 +1,6 @@
 //! Various helpers for Actix applications to use during testing.
 //!
-//! # Creating A Test Service
+//! # Initializing A Test Service
 //! - [`init_service`]
 //!
 //! # Off-The-Shelf Test Services
@@ -49,6 +49,7 @@ pub use self::{
 /// Must be used inside an async test. Works for both `ServiceRequest` and `HttpRequest`.
 ///
 /// # Examples
+///
 /// ```
 /// use actix_web::{http::StatusCode, HttpResponse};
 ///
diff --git a/actix-web/src/thin_data.rs b/actix-web/src/thin_data.rs
new file mode 100644
index 000000000..a9cd4e3a4
--- /dev/null
+++ b/actix-web/src/thin_data.rs
@@ -0,0 +1,121 @@
+use std::any::type_name;
+
+use actix_utils::future::{ready, Ready};
+
+use crate::{dev::Payload, error, FromRequest, HttpRequest};
+
+/// Application data wrapper and extractor for cheaply-cloned types.
+///
+/// Similar to the [`Data`] wrapper but for `Clone`/`Copy` types that are already an `Arc` internally,
+/// share state using some other means when cloned, or is otherwise static data that is very cheap
+/// to clone.
+///
+/// Unlike `Data`, this wrapper clones `T` during extraction. Therefore, it is the user's
+/// responsibility to ensure that clones of `T` do actually share the same state, otherwise state
+/// may be unexpectedly different across multiple requests.
+///
+/// Note that if your type is literally an `Arc<T>` then it's recommended to use the
+/// [`Data::from(arc)`][data_from_arc] conversion instead.
+///
+/// # Examples
+///
+/// ```
+/// use actix_web::{
+///     web::{self, ThinData},
+///     App, HttpResponse, Responder,
+/// };
+///
+/// // Use the `ThinData<T>` extractor to access a database connection pool.
+/// async fn index(ThinData(db_pool): ThinData<DbPool>) -> impl Responder {
+///     // database action ...
+///
+///     HttpResponse::Ok()
+/// }
+///
+/// # type DbPool = ();
+/// let db_pool = DbPool::default();
+///
+/// App::new()
+///     .app_data(ThinData(db_pool.clone()))
+///     .service(web::resource("/").get(index))
+/// # ;
+/// ```
+///
+/// [`Data`]: crate::web::Data
+/// [data_from_arc]: crate::web::Data#impl-From<Arc<T>>-for-Data<T>
+#[derive(Debug, Clone)]
+pub struct ThinData<T>(pub T);
+
+impl_more::impl_as_ref!(ThinData<T> => T);
+impl_more::impl_as_mut!(ThinData<T> => T);
+impl_more::impl_deref_and_mut!(<T> in ThinData<T> => T);
+
+impl<T: Clone + 'static> FromRequest for ThinData<T> {
+    type Error = crate::Error;
+    type Future = Ready<Result<Self, Self::Error>>;
+
+    #[inline]
+    fn from_request(req: &HttpRequest, _: &mut Payload) -> Self::Future {
+        ready(req.app_data::<Self>().cloned().ok_or_else(|| {
+            log::debug!(
+                "Failed to extract `ThinData<{}>` for `{}` handler. For the ThinData extractor to work \
+                correctly, wrap the data with `ThinData()` and pass it to `App::app_data()`. \
+                Ensure that types align in both the set and retrieve calls.",
+                type_name::<T>(),
+                req.match_name().unwrap_or(req.path())
+            );
+
+            error::ErrorInternalServerError(
+                "Requested application data is not configured correctly. \
+                View/enable debug logs for more details.",
+            )
+        }))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::sync::{Arc, Mutex};
+
+    use super::*;
+    use crate::{
+        http::StatusCode,
+        test::{call_service, init_service, TestRequest},
+        web, App, HttpResponse,
+    };
+
+    type TestT = Arc<Mutex<u32>>;
+
+    #[actix_rt::test]
+    async fn thin_data() {
+        let test_data = TestT::default();
+
+        let app = init_service(App::new().app_data(ThinData(test_data.clone())).service(
+            web::resource("/").to(|td: ThinData<TestT>| {
+                *td.lock().unwrap() += 1;
+                HttpResponse::Ok()
+            }),
+        ))
+        .await;
+
+        for _ in 0..3 {
+            let req = TestRequest::default().to_request();
+            let resp = call_service(&app, req).await;
+            assert_eq!(resp.status(), StatusCode::OK);
+        }
+
+        assert_eq!(*test_data.lock().unwrap(), 3);
+    }
+
+    #[actix_rt::test]
+    async fn thin_data_missing() {
+        let app = init_service(
+            App::new().service(web::resource("/").to(|_: ThinData<u32>| HttpResponse::Ok())),
+        )
+        .await;
+
+        let req = TestRequest::default().to_request();
+        let resp = call_service(&app, req).await;
+        assert_eq!(resp.status(), StatusCode::INTERNAL_SERVER_ERROR);
+    }
+}
diff --git a/actix-web/src/types/either.rs b/actix-web/src/types/either.rs
index 7883e89f6..d8b3f1180 100644
--- a/actix-web/src/types/either.rs
+++ b/actix-web/src/types/either.rs
@@ -238,7 +238,7 @@ where
                     match res {
                         Ok(bytes) => {
                             let fallback = bytes.clone();
-                            let left = L::from_request(this.req, &mut payload_from_bytes(bytes));
+                            let left = L::from_request(this.req, &mut dev::Payload::from(bytes));
                             EitherExtractState::Left { left, fallback }
                         }
                         Err(err) => break Err(EitherExtractError::Bytes(err)),
@@ -251,7 +251,7 @@ where
                         Err(left_err) => {
                             let right = R::from_request(
                                 this.req,
-                                &mut payload_from_bytes(mem::take(fallback)),
+                                &mut dev::Payload::from(mem::take(fallback)),
                             );
                             EitherExtractState::Right {
                                 left_err: Some(left_err),
@@ -276,12 +276,6 @@ where
     }
 }
 
-fn payload_from_bytes(bytes: Bytes) -> dev::Payload {
-    let (_, mut h1_payload) = actix_http::h1::Payload::create(true);
-    h1_payload.unread_data(bytes);
-    dev::Payload::from(h1_payload)
-}
-
 #[cfg(test)]
 mod tests {
     use serde::{Deserialize, Serialize};
diff --git a/actix-web/src/types/json.rs b/actix-web/src/types/json.rs
index 6b75c0cfe..58464f360 100644
--- a/actix-web/src/types/json.rs
+++ b/actix-web/src/types/json.rs
@@ -332,7 +332,7 @@ impl<T: DeserializeOwned> JsonBody<T> {
             (true, Ok(Some(mime))) => {
                 mime.subtype() == mime::JSON
                     || mime.suffix() == Some(mime::JSON)
-                    || ctype_fn.map_or(false, |predicate| predicate(mime))
+                    || ctype_fn.is_some_and(|predicate| predicate(mime))
             }
 
             // if content-type is expected but not parsable as mime type, bail
@@ -398,7 +398,7 @@ impl<T: DeserializeOwned> JsonBody<T> {
                     _res: PhantomData,
                 }
             }
-            JsonBody::Error(e) => JsonBody::Error(e),
+            JsonBody::Error(err) => JsonBody::Error(err),
         }
     }
 }
@@ -434,7 +434,7 @@ impl<T: DeserializeOwned> Future for JsonBody<T> {
                     }
                 }
             },
-            JsonBody::Error(e) => Poll::Ready(Err(e.take().unwrap())),
+            JsonBody::Error(err) => Poll::Ready(Err(err.take().unwrap())),
         }
     }
 }
@@ -616,7 +616,7 @@ mod tests {
             }
         ));
 
-        let (req, mut pl) = TestRequest::default()
+        let (mut req, mut pl) = TestRequest::default()
             .insert_header((
                 header::CONTENT_TYPE,
                 header::HeaderValue::from_static("application/json"),
@@ -624,6 +624,7 @@ mod tests {
             .set_payload(Bytes::from_static(&[0u8; 1000]))
             .to_http_parts();
 
+        req.head_mut().headers_mut().remove(header::CONTENT_LENGTH);
         let json = JsonBody::<MyObject>::new(&req, &mut pl, None, true)
             .limit(100)
             .await;
diff --git a/actix-web/src/types/mod.rs b/actix-web/src/types/mod.rs
index cabe53d6a..5334c46af 100644
--- a/actix-web/src/types/mod.rs
+++ b/actix-web/src/types/mod.rs
@@ -11,7 +11,7 @@ mod query;
 mod readlines;
 
 pub use self::{
-    either::Either,
+    either::{Either, EitherExtractError},
     form::{Form, FormConfig, UrlEncoded},
     header::Header,
     html::Html,
diff --git a/actix-web/src/types/path.rs b/actix-web/src/types/path.rs
index cc87bb80f..5f22568cc 100644
--- a/actix-web/src/types/path.rs
+++ b/actix-web/src/types/path.rs
@@ -89,8 +89,8 @@ where
                     );
 
                     if let Some(error_handler) = error_handler {
-                        let e = PathError::Deserialize(err);
-                        (error_handler)(e, req)
+                        let err = PathError::Deserialize(err);
+                        (error_handler)(err, req)
                     } else {
                         ErrorNotFound(err)
                     }
@@ -159,7 +159,7 @@ mod tests {
     use crate::{error, http, test::TestRequest, HttpResponse};
 
     #[derive(Deserialize, Debug, Display)]
-    #[display(fmt = "MyStruct({}, {})", key, value)]
+    #[display("MyStruct({}, {})", key, value)]
     struct MyStruct {
         key: String,
         value: String,
diff --git a/actix-web/src/types/query.rs b/actix-web/src/types/query.rs
index e71b886f2..e5505131e 100644
--- a/actix-web/src/types/query.rs
+++ b/actix-web/src/types/query.rs
@@ -2,7 +2,7 @@
 
 use std::{fmt, ops, sync::Arc};
 
-use actix_utils::future::{err, ok, Ready};
+use actix_utils::future::{ok, ready, Ready};
 use serde::de::DeserializeOwned;
 
 use crate::{dev::Payload, error::QueryPayloadError, Error, FromRequest, HttpRequest};
@@ -118,8 +118,8 @@ impl<T: DeserializeOwned> FromRequest for Query<T> {
 
         serde_urlencoded::from_str::<T>(req.query_string())
             .map(|val| ok(Query(val)))
-            .unwrap_or_else(move |e| {
-                let e = QueryPayloadError::Deserialize(e);
+            .unwrap_or_else(move |err| {
+                let err = QueryPayloadError::Deserialize(err);
 
                 log::debug!(
                     "Failed during Query extractor deserialization. \
@@ -127,13 +127,13 @@ impl<T: DeserializeOwned> FromRequest for Query<T> {
                     req.path()
                 );
 
-                let e = if let Some(error_handler) = error_handler {
-                    (error_handler)(e, req)
+                let err = if let Some(error_handler) = error_handler {
+                    (error_handler)(err, req)
                 } else {
-                    e.into()
+                    err.into()
                 };
 
-                err(e)
+                ready(Err(err))
             })
     }
 }
diff --git a/actix-web/src/web.rs b/actix-web/src/web.rs
index 204313752..92d05eb74 100644
--- a/actix-web/src/web.rs
+++ b/actix-web/src/web.rs
@@ -2,6 +2,7 @@
 //!
 //! # Request Extractors
 //! - [`Data`]: Application data item
+//! - [`ThinData`]: Cheap-to-clone application data item
 //! - [`ReqData`]: Request-local data item
 //! - [`Path`]: URL path parameters / dynamic segments
 //! - [`Query`]: URL query parameters
@@ -22,7 +23,8 @@ use actix_router::IntoPatterns;
 pub use bytes::{Buf, BufMut, Bytes, BytesMut};
 
 pub use crate::{
-    config::ServiceConfig, data::Data, redirect::Redirect, request_data::ReqData, types::*,
+    config::ServiceConfig, data::Data, redirect::Redirect, request_data::ReqData,
+    thin_data::ThinData, types::*,
 };
 use crate::{
     error::BlockingError, http::Method, service::WebService, FromRequest, Handler, Resource,
@@ -36,7 +38,7 @@ use crate::{
 ///
 /// A dynamic segment is specified in the form `{identifier}`, where the identifier can be used
 /// later in a request handler to access the matched value for that segment. This is done by looking
-/// up the identifier in the `Path` object returned by [`HttpRequest.match_info()`] method.
+/// up the identifier in the `Path` object returned by [`HttpRequest::match_info()`](crate::HttpRequest::match_info) method.
 ///
 /// By default, each segment matches the regular expression `[^{}/]+`.
 ///
diff --git a/actix-web/tests/test_httpserver.rs b/actix-web/tests/test_httpserver.rs
index 039c0ffbc..5fd7d7190 100644
--- a/actix-web/tests/test_httpserver.rs
+++ b/actix-web/tests/test_httpserver.rs
@@ -1,13 +1,10 @@
 #[cfg(feature = "openssl")]
 extern crate tls_openssl as openssl;
 
-#[cfg(any(unix, feature = "openssl"))]
-use {
-    actix_web::{web, App, HttpResponse, HttpServer},
-    std::{sync::mpsc, thread, time::Duration},
-};
+use std::{sync::mpsc, thread, time::Duration};
+
+use actix_web::{web, App, HttpResponse, HttpServer};
 
-#[cfg(unix)]
 #[actix_rt::test]
 async fn test_start() {
     let addr = actix_test::unused_addr();
@@ -53,6 +50,27 @@ async fn test_start() {
     let response = client.get(host.clone()).send().await.unwrap();
     assert!(response.status().is_success());
 
+    // Attempt to start a second server using the same address.
+    let result = HttpServer::new(|| {
+        App::new().service(
+            web::resource("/").route(web::to(|| async { HttpResponse::Ok().body("test") })),
+        )
+    })
+    .workers(1)
+    .backlog(1)
+    .max_connections(10)
+    .max_connection_rate(10)
+    .keep_alive(Duration::from_secs(10))
+    .client_request_timeout(Duration::from_secs(5))
+    .client_disconnect_timeout(Duration::ZERO)
+    .server_hostname("localhost")
+    .system_exit()
+    .disable_signals()
+    .bind(format!("{}", addr));
+
+    // This should fail: the address is in use.
+    assert!(result.is_err());
+
     srv.stop(false).await;
 }
 
diff --git a/actix-web/tests/test_server.rs b/actix-web/tests/test_server.rs
index 960cf1e2b..f13aa3cfd 100644
--- a/actix-web/tests/test_server.rs
+++ b/actix-web/tests/test_server.rs
@@ -25,7 +25,7 @@ use openssl::{
     ssl::{SslAcceptor, SslMethod},
     x509::X509,
 };
-use rand::{distributions::Alphanumeric, Rng as _};
+use rand::distr::{Alphanumeric, SampleString as _};
 
 mod utils;
 
@@ -188,11 +188,7 @@ async fn body_gzip_large() {
 
 #[actix_rt::test]
 async fn test_body_gzip_large_random() {
-    let data = rand::thread_rng()
-        .sample_iter(&Alphanumeric)
-        .take(70_000)
-        .map(char::from)
-        .collect::<String>();
+    let data = Alphanumeric.sample_string(&mut rand::rng(), 70_000);
     let srv_data = data.clone();
 
     let srv = actix_test::start_with(actix_test::config().h1(), move || {
@@ -432,11 +428,7 @@ async fn test_zstd_encoding() {
 
 #[actix_rt::test]
 async fn test_zstd_encoding_large() {
-    let data = rand::thread_rng()
-        .sample_iter(&Alphanumeric)
-        .take(320_000)
-        .map(char::from)
-        .collect::<String>();
+    let data = Alphanumeric.sample_string(&mut rand::rng(), 320_000);
 
     let srv = actix_test::start_with(actix_test::config().h1(), || {
         App::new().service(
@@ -529,11 +521,7 @@ async fn test_gzip_encoding_large() {
 
 #[actix_rt::test]
 async fn test_reading_gzip_encoding_large_random() {
-    let data = rand::thread_rng()
-        .sample_iter(&Alphanumeric)
-        .take(60_000)
-        .map(char::from)
-        .collect::<String>();
+    let data = Alphanumeric.sample_string(&mut rand::rng(), 60_000);
 
     let srv = actix_test::start_with(actix_test::config().h1(), || {
         App::new().service(web::resource("/").route(web::to(move |body: Bytes| async {
@@ -599,11 +587,7 @@ async fn test_reading_deflate_encoding_large() {
 
 #[actix_rt::test]
 async fn test_reading_deflate_encoding_large_random() {
-    let data = rand::thread_rng()
-        .sample_iter(&Alphanumeric)
-        .take(160_000)
-        .map(char::from)
-        .collect::<String>();
+    let data = Alphanumeric.sample_string(&mut rand::rng(), 160_000);
 
     let srv = actix_test::start_with(actix_test::config().h1(), || {
         App::new().service(web::resource("/").route(web::to(move |body: Bytes| async {
@@ -648,11 +632,7 @@ async fn test_brotli_encoding() {
 
 #[actix_rt::test]
 async fn test_brotli_encoding_large() {
-    let data = rand::thread_rng()
-        .sample_iter(&Alphanumeric)
-        .take(320_000)
-        .map(char::from)
-        .collect::<String>();
+    let data = Alphanumeric.sample_string(&mut rand::rng(), 320_000);
 
     let srv = actix_test::start_with(actix_test::config().h1(), || {
         App::new().service(
@@ -737,11 +717,7 @@ mod plus_rustls {
 
     #[actix_rt::test]
     async fn test_reading_deflate_encoding_large_random_rustls() {
-        let data = rand::thread_rng()
-            .sample_iter(&Alphanumeric)
-            .take(160_000)
-            .map(char::from)
-            .collect::<String>();
+        let data = Alphanumeric.sample_string(&mut rand::rng(), 160_000);
 
         let srv = actix_test::start_with(actix_test::config().rustls_0_23(tls_config()), || {
             App::new().service(web::resource("/").route(web::to(|bytes: Bytes| async {
diff --git a/actix-web/tests/test_streaming_response.rs b/actix-web/tests/test_streaming_response.rs
new file mode 100644
index 000000000..1c22da38b
--- /dev/null
+++ b/actix-web/tests/test_streaming_response.rs
@@ -0,0 +1,115 @@
+use std::{
+    pin::Pin,
+    task::{Context, Poll},
+};
+
+use actix_web::{
+    http::header::{self, HeaderValue},
+    HttpResponse,
+};
+use bytes::Bytes;
+use futures_core::Stream;
+
+struct FixedSizeStream {
+    data: Vec<u8>,
+    yielded: bool,
+}
+
+impl FixedSizeStream {
+    fn new(size: usize) -> Self {
+        Self {
+            data: vec![0u8; size],
+            yielded: false,
+        }
+    }
+}
+
+impl Stream for FixedSizeStream {
+    type Item = Result<Bytes, std::io::Error>;
+
+    fn poll_next(mut self: Pin<&mut Self>, _: &mut Context<'_>) -> Poll<Option<Self::Item>> {
+        if self.yielded {
+            Poll::Ready(None)
+        } else {
+            self.yielded = true;
+            let data = std::mem::take(&mut self.data);
+            Poll::Ready(Some(Ok(Bytes::from(data))))
+        }
+    }
+}
+
+#[actix_rt::test]
+async fn test_streaming_response_with_content_length() {
+    let stream = FixedSizeStream::new(100);
+
+    let resp = HttpResponse::Ok()
+        .append_header((header::CONTENT_LENGTH, "100"))
+        .streaming(stream);
+
+    assert_eq!(
+        resp.headers().get(header::CONTENT_LENGTH),
+        Some(&HeaderValue::from_static("100")),
+        "Content-Length should be preserved when explicitly set"
+    );
+
+    let has_chunked = resp
+        .headers()
+        .get(header::TRANSFER_ENCODING)
+        .map(|v| v.to_str().unwrap_or(""))
+        .unwrap_or("")
+        .contains("chunked");
+
+    assert!(
+        !has_chunked,
+        "chunked should not be used when Content-Length is provided"
+    );
+
+    assert_eq!(
+        resp.headers().get(header::CONTENT_TYPE),
+        Some(&HeaderValue::from_static("application/octet-stream")),
+        "Content-Type should default to application/octet-stream"
+    );
+}
+
+#[actix_rt::test]
+async fn test_streaming_response_default_content_type() {
+    let stream = FixedSizeStream::new(50);
+
+    let resp = HttpResponse::Ok().streaming(stream);
+
+    assert_eq!(
+        resp.headers().get(header::CONTENT_TYPE),
+        Some(&HeaderValue::from_static("application/octet-stream")),
+        "Content-Type should default to application/octet-stream"
+    );
+}
+
+#[actix_rt::test]
+async fn test_streaming_response_user_defined_content_type() {
+    let stream = FixedSizeStream::new(25);
+
+    let resp = HttpResponse::Ok()
+        .insert_header((header::CONTENT_TYPE, "text/plain"))
+        .streaming(stream);
+
+    assert_eq!(
+        resp.headers().get(header::CONTENT_TYPE),
+        Some(&HeaderValue::from_static("text/plain")),
+        "User-defined Content-Type should be preserved"
+    );
+}
+
+#[actix_rt::test]
+async fn test_streaming_response_empty_stream() {
+    let stream = FixedSizeStream::new(0);
+
+    let resp = HttpResponse::Ok()
+        .append_header((header::CONTENT_LENGTH, "0"))
+        .streaming(stream);
+
+    assert_eq!(
+        resp.headers().get(header::CONTENT_LENGTH),
+        Some(&HeaderValue::from_static("0")),
+        "Content-Length 0 should be preserved for empty streams"
+    );
+}
diff --git a/awc/CHANGES.md b/awc/CHANGES.md
index 54c5e9869..d4e96aab3 100644
--- a/awc/CHANGES.md
+++ b/awc/CHANGES.md
@@ -2,11 +2,37 @@
 
 ## Unreleased
 
+- Minimum supported Rust version (MSRV) is now 1.82.
+
+## 3.8.1
+
+- Fix a bug where `GO_AWAY` errors did not stop connections from returning to the pool.
+
+## 3.8.0
+
+- Add `hickory-dns` crate feature (off-by-default).
+- The `trust-dns` crate feature now delegates DNS resolution to `hickory-dns`.
+
+## 3.7.0
+
+- Update `brotli` dependency to `8`.
+
+## 3.6.0
+
+- Prevent panics on connection pool drop when Tokio runtime is shutdown early.
+- Do not send `Host` header on HTTP/2 requests, as it is not required, and some web servers may reject it.
+- Update `brotli` dependency to `7`.
+- Minimum supported Rust version (MSRV) is now 1.75.
+
+## 3.5.1
+
+- Fix WebSocket `Host` request header value when using a non-default port.
+
 ## 3.5.0
 
 - Add `rustls-0_23`, `rustls-0_23-webpki-roots`, and `rustls-0_23-native-roots` crate features.
 - Add `awc::Connector::rustls_0_23()` constructor.
-- Fix `rustls-0_22-native-roots` root store lookup
+- Fix `rustls-0_22-native-roots` root store lookup.
 - Update `brotli` dependency to `6`.
 - Minimum supported Rust version (MSRV) is now 1.72.
 
diff --git a/awc/Cargo.toml b/awc/Cargo.toml
index 4fc2057f6..05b0f4d7b 100644
--- a/awc/Cargo.toml
+++ b/awc/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "awc"
-version = "3.5.0"
+version = "3.8.1"
 authors = ["Nikolay Kim <fafhrd91@gmail.com>"]
 description = "Async HTTP and WebSocket client library"
 keywords = ["actix", "http", "framework", "async", "web"]
@@ -16,7 +16,6 @@ license = "MIT OR Apache-2.0"
 edition = "2021"
 
 [package.metadata.docs.rs]
-rustdoc-args = ["--cfg", "docsrs"]
 features = [
     "cookies",
     "openssl",
@@ -83,8 +82,10 @@ compress-zstd = ["actix-http/compress-zstd", "__compress"]
 # Cookie parsing and cookie jar
 cookies = ["dep:cookie"]
 
-# Use `trust-dns-resolver` crate as DNS resolver
-trust-dns = ["trust-dns-resolver"]
+# Use `hickory-dns-resolver` crate as DNS resolver
+hickory-dns = ["dep:hickory-resolver"]
+# Use `trust-dns-resolver` crate as DNS resolver (deprecated, use `hickory-dns`)
+trust-dns = ["hickory-dns"]
 
 # Internal (PRIVATE!) features used to aid testing and checking feature status.
 # Don't rely on these whatsoever. They may disappear at anytime.
@@ -97,30 +98,30 @@ dangerous-h2c = []
 
 [dependencies]
 actix-codec = "0.5"
-actix-service = "2"
-actix-http = { version = "3.7", features = ["http2", "ws"] }
+actix-http = { version = "3.10", features = ["http2", "ws"] }
 actix-rt = { version = "2.1", default-features = false }
+actix-service = "2"
 actix-tls = { version = "3.4", features = ["connect", "uri"] }
 actix-utils = "3"
 
 base64 = "0.22"
 bytes = "1"
 cfg-if = "1"
-derive_more = "0.99.5"
+derive_more = { version = "2", features = ["display", "error", "from"] }
 futures-core = { version = "0.3.17", default-features = false, features = ["alloc"] }
 futures-util = { version = "0.3.17", default-features = false, features = ["alloc", "sink"] }
-h2 = "0.3.26"
+h2 = "0.3.27"
 http = "0.2.7"
 itoa = "1"
-log =" 0.4"
+log = "0.4"
 mime = "0.3"
 percent-encoding = "2.1"
 pin-project-lite = "0.2"
-rand = "0.8"
+rand = "0.9"
 serde = "1.0"
 serde_json = "1.0"
 serde_urlencoded = "0.7"
-tokio = { version = "1.24.2", features = ["sync"] }
+tokio = { version = "1.38.2", features = ["sync"] }
 
 cookie = { version = "0.16", features = ["percent-encode"], optional = true }
 
@@ -130,7 +131,7 @@ tls-rustls-0_21 = { package = "rustls", version = "0.21", optional = true, featu
 tls-rustls-0_22 = { package = "rustls", version = "0.22", optional = true }
 tls-rustls-0_23 = { package = "rustls", version = "0.23", optional = true, default-features = false }
 
-trust-dns-resolver = { version = "0.23", optional = true }
+hickory-resolver = { version = "0.25", optional = true, features = ["system-config", "tokio"] }
 
 [dev-dependencies]
 actix-http = { version = "3.7", features = ["openssl"] }
@@ -141,18 +142,21 @@ actix-tls = { version = "3.4", features = ["openssl", "rustls-0_23"] }
 actix-utils = "3"
 actix-web = { version = "4", features = ["openssl"] }
 
-brotli = "6"
-const-str = "0.5"
+brotli = "8"
+const-str = "0.5" # TODO(MSRV 1.77): update to 0.6
 env_logger = "0.11"
 flate2 = "1.0.13"
 futures-util = { version = "0.3.17", default-features = false }
 static_assertions = "1.1"
 rcgen = "0.13"
 rustls-pemfile = "2"
-tokio = { version = "1.24.2", features = ["rt-multi-thread", "macros"] }
+tokio = { version = "1.38.2", features = ["rt-multi-thread", "macros"] }
 zstd = "0.13"
 tls-rustls-0_23 = { package = "rustls", version = "0.23" } # add rustls 0.23 with default features to make aws_lc_rs work in tests
 
 [[example]]
 name = "client"
 required-features = ["rustls-0_23-webpki-roots"]
+
+[lints]
+workspace = true
diff --git a/awc/README.md b/awc/README.md
index 8e7b42812..6e91eab3e 100644
--- a/awc/README.md
+++ b/awc/README.md
@@ -5,16 +5,16 @@
 <!-- prettier-ignore-start -->
 
 [![crates.io](https://img.shields.io/crates/v/awc?label=latest)](https://crates.io/crates/awc)
-[![Documentation](https://docs.rs/awc/badge.svg?version=3.5.0)](https://docs.rs/awc/3.5.0)
+[![Documentation](https://docs.rs/awc/badge.svg?version=3.8.1)](https://docs.rs/awc/3.8.1)
 ![MIT or Apache 2.0 licensed](https://img.shields.io/crates/l/awc)
-[![Dependency Status](https://deps.rs/crate/awc/3.5.0/status.svg)](https://deps.rs/crate/awc/3.5.0)
+[![Dependency Status](https://deps.rs/crate/awc/3.8.1/status.svg)](https://deps.rs/crate/awc/3.8.1)
 [![Chat on Discord](https://img.shields.io/discord/771444961383153695?label=chat&logo=discord)](https://discord.gg/NWpN5mmg3x)
 
 <!-- prettier-ignore-end -->
 
 ## Examples
 
-[Example project using TLS-enabled client →](https://github.com/actix/examples/tree/master/https-tls/awc-https)
+[Example project using TLS-enabled client →](https://github.com/actix/examples/tree/main/https-tls/awc-https)
 
 Basic usage:
 
diff --git a/awc/examples/client.rs b/awc/examples/client.rs
index 16ad330b8..b6eb919c7 100644
--- a/awc/examples/client.rs
+++ b/awc/examples/client.rs
@@ -1,23 +1,39 @@
-use std::error::Error as StdError;
+//! Demonstrates construction and usage of a TLS-capable HTTP client.
 
-#[tokio::main]
+extern crate tls_rustls_0_23 as rustls;
+
+use std::{error::Error as StdError, sync::Arc};
+
+use actix_tls::connect::rustls_0_23::webpki_roots_cert_store;
+use rustls::ClientConfig;
+
+#[actix_rt::main]
 async fn main() -> Result<(), Box<dyn StdError>> {
     env_logger::init_from_env(env_logger::Env::new().default_filter_or("info"));
 
-    // construct request builder
-    let client = awc::Client::new();
+    let mut config = ClientConfig::builder()
+        .with_root_certificates(webpki_roots_cert_store())
+        .with_no_client_auth();
+
+    let protos = vec![b"h2".to_vec(), b"http/1.1".to_vec()];
+    config.alpn_protocols = protos;
+
+    // construct request builder with TLS support
+    let client = awc::Client::builder()
+        .connector(awc::Connector::new().rustls_0_23(Arc::new(config)))
+        .finish();
 
     // configure request
     let request = client
         .get("https://www.rust-lang.org/")
-        .append_header(("User-Agent", "Actix-web"));
+        .append_header(("User-Agent", "awc/3.0"));
 
-    println!("Request: {:?}", request);
+    println!("Request: {request:?}");
 
     let mut response = request.send().await?;
 
     // server response head
-    println!("Response: {:?}", response);
+    println!("Response: {response:?}");
 
     // read response body
     let body = response.body().await?;
diff --git a/awc/src/any_body.rs b/awc/src/any_body.rs
index 08f5cc25e..ef0edfb9e 100644
--- a/awc/src/any_body.rs
+++ b/awc/src/any_body.rs
@@ -163,6 +163,7 @@ mod tests {
 
     use super::*;
 
+    #[allow(dead_code)]
     struct PinType(PhantomPinned);
 
     impl MessageBody for PinType {
diff --git a/awc/src/client/connector.rs b/awc/src/client/connector.rs
index f3d443070..0ce542365 100644
--- a/awc/src/client/connector.rs
+++ b/awc/src/client/connector.rs
@@ -89,9 +89,9 @@ impl Connector<()> {
     /// # Panics
     ///
     /// - When the `rustls-0_23-webpki-roots` or `rustls-0_23-native-roots` features are enabled
-    ///     and no default crypto provider has been loaded, this method will panic.
+    ///   and no default crypto provider has been loaded, this method will panic.
     /// - When the `rustls-0_23-native-roots` or `rustls-0_22-native-roots` features are enabled
-    ///     and the runtime system has no native root certificates, this method will panic.
+    ///   and the runtime system has no native root certificates, this method will panic.
     #[allow(clippy::new_ret_no_self, clippy::let_unit_value)]
     pub fn new() -> Connector<
         impl Service<
@@ -511,7 +511,8 @@ where
                         let h2 = sock
                             .ssl()
                             .selected_alpn_protocol()
-                            .map_or(false, |protos| protos.windows(2).any(|w| w == H2));
+                            .is_some_and(|protos| protos.windows(2).any(|w| w == H2));
+
                         if h2 {
                             (Box::new(sock), Protocol::Http2)
                         } else {
@@ -550,7 +551,8 @@ where
                             .get_ref()
                             .1
                             .alpn_protocol()
-                            .map_or(false, |protos| protos.windows(2).any(|w| w == H2));
+                            .is_some_and(|protos| protos.windows(2).any(|w| w == H2));
+
                         if h2 {
                             (Box::new(sock), Protocol::Http2)
                         } else {
@@ -584,7 +586,8 @@ where
                             .get_ref()
                             .1
                             .alpn_protocol()
-                            .map_or(false, |protos| protos.windows(2).any(|w| w == H2));
+                            .is_some_and(|protos| protos.windows(2).any(|w| w == H2));
+
                         if h2 {
                             (Box::new(sock), Protocol::Http2)
                         } else {
@@ -621,7 +624,8 @@ where
                             .get_ref()
                             .1
                             .alpn_protocol()
-                            .map_or(false, |protos| protos.windows(2).any(|w| w == H2));
+                            .is_some_and(|protos| protos.windows(2).any(|w| w == H2));
+
                         if h2 {
                             (Box::new(sock), Protocol::Http2)
                         } else {
@@ -655,7 +659,8 @@ where
                             .get_ref()
                             .1
                             .alpn_protocol()
-                            .map_or(false, |protos| protos.windows(2).any(|w| w == H2));
+                            .is_some_and(|protos| protos.windows(2).any(|w| w == H2));
+
                         if h2 {
                             (Box::new(sock), Protocol::Http2)
                         } else {
@@ -1032,7 +1037,7 @@ where
     }
 }
 
-#[cfg(not(feature = "trust-dns"))]
+#[cfg(not(feature = "hickory-dns"))]
 mod resolver {
     use super::*;
 
@@ -1041,24 +1046,25 @@ mod resolver {
     }
 }
 
-#[cfg(feature = "trust-dns")]
+#[cfg(feature = "hickory-dns")]
 mod resolver {
-    use std::{cell::RefCell, net::SocketAddr};
+    use std::{cell::OnceCell, net::SocketAddr};
 
     use actix_tls::connect::Resolve;
-    use trust_dns_resolver::{
+    use hickory_resolver::{
         config::{ResolverConfig, ResolverOpts},
+        name_server::TokioConnectionProvider,
         system_conf::read_system_conf,
-        TokioAsyncResolver,
+        TokioResolver,
     };
 
     use super::*;
 
     pub(super) fn resolver() -> Resolver {
         // new type for impl Resolve trait for TokioAsyncResolver.
-        struct TrustDnsResolver(TokioAsyncResolver);
+        struct HickoryDnsResolver(TokioResolver);
 
-        impl Resolve for TrustDnsResolver {
+        impl Resolve for HickoryDnsResolver {
             fn lookup<'a>(
                 &'a self,
                 host: &'a str,
@@ -1080,34 +1086,29 @@ mod resolver {
 
         // resolver struct is cached in thread local so new clients can reuse the existing instance
         thread_local! {
-            static TRUST_DNS_RESOLVER: RefCell<Option<Resolver>> = const { RefCell::new(None) };
+            static HICKORY_DNS_RESOLVER: OnceCell<Resolver> = const { OnceCell::new() };
         }
 
-        // get from thread local or construct a new trust-dns resolver.
-        TRUST_DNS_RESOLVER.with(|local| {
-            let resolver = local.borrow().as_ref().map(Clone::clone);
-
-            match resolver {
-                Some(resolver) => resolver,
-
-                None => {
+        // get from thread local or construct a new hickory dns resolver.
+        HICKORY_DNS_RESOLVER.with(|local| {
+            local
+                .get_or_init(|| {
                     let (cfg, opts) = match read_system_conf() {
                         Ok((cfg, opts)) => (cfg, opts),
                         Err(err) => {
-                            log::error!("Trust-DNS can not load system config: {err}");
+                            log::error!("Hickory DNS can not load system config: {err}");
                             (ResolverConfig::default(), ResolverOpts::default())
                         }
                     };
 
-                    let resolver = TokioAsyncResolver::tokio(cfg, opts);
+                    let resolver =
+                        TokioResolver::builder_with_config(cfg, TokioConnectionProvider::default())
+                            .with_options(opts)
+                            .build();
 
-                    // box trust dns resolver and put it in thread local.
-                    let resolver = Resolver::custom(TrustDnsResolver(resolver));
-                    *local.borrow_mut() = Some(resolver.clone());
-
-                    resolver
-                }
-            }
+                    Resolver::custom(HickoryDnsResolver(resolver))
+                })
+                .clone()
         })
     }
 }
diff --git a/awc/src/client/error.rs b/awc/src/client/error.rs
index d351e1067..6cb595770 100644
--- a/awc/src/client/error.rs
+++ b/awc/src/client/error.rs
@@ -12,40 +12,40 @@ use crate::BoxError;
 #[non_exhaustive]
 pub enum ConnectError {
     /// SSL feature is not enabled
-    #[display(fmt = "SSL is not supported")]
+    #[display("SSL is not supported")]
     SslIsNotSupported,
 
     /// SSL error
     #[cfg(feature = "openssl")]
-    #[display(fmt = "{}", _0)]
+    #[display("{}", _0)]
     SslError(OpensslError),
 
     /// Failed to resolve the hostname
-    #[display(fmt = "Failed resolving hostname: {}", _0)]
+    #[display("Failed resolving hostname: {}", _0)]
     Resolver(Box<dyn std::error::Error>),
 
     /// No dns records
-    #[display(fmt = "No DNS records found for the input")]
+    #[display("No DNS records found for the input")]
     NoRecords,
 
     /// Http2 error
-    #[display(fmt = "{}", _0)]
+    #[display("{}", _0)]
     H2(h2::Error),
 
     /// Connecting took too long
-    #[display(fmt = "Timeout while establishing connection")]
+    #[display("Timeout while establishing connection")]
     Timeout,
 
     /// Connector has been disconnected
-    #[display(fmt = "Internal error: connector has been disconnected")]
+    #[display("Internal error: connector has been disconnected")]
     Disconnected,
 
     /// Unresolved host name
-    #[display(fmt = "Connector received `Connect` method with unresolved host")]
+    #[display("Connector received `Connect` method with unresolved host")]
     Unresolved,
 
     /// Connection io error
-    #[display(fmt = "{}", _0)]
+    #[display("{}", _0)]
     Io(io::Error),
 }
 
@@ -54,11 +54,11 @@ impl std::error::Error for ConnectError {}
 impl From<actix_tls::connect::ConnectError> for ConnectError {
     fn from(err: actix_tls::connect::ConnectError) -> ConnectError {
         match err {
-            actix_tls::connect::ConnectError::Resolver(e) => ConnectError::Resolver(e),
+            actix_tls::connect::ConnectError::Resolver(err) => ConnectError::Resolver(err),
             actix_tls::connect::ConnectError::NoRecords => ConnectError::NoRecords,
             actix_tls::connect::ConnectError::InvalidInput => panic!(),
             actix_tls::connect::ConnectError::Unresolved => ConnectError::Unresolved,
-            actix_tls::connect::ConnectError::Io(e) => ConnectError::Io(e),
+            actix_tls::connect::ConnectError::Io(err) => ConnectError::Io(err),
         }
     }
 }
@@ -66,16 +66,16 @@ impl From<actix_tls::connect::ConnectError> for ConnectError {
 #[derive(Debug, Display, From)]
 #[non_exhaustive]
 pub enum InvalidUrl {
-    #[display(fmt = "Missing URL scheme")]
+    #[display("Missing URL scheme")]
     MissingScheme,
 
-    #[display(fmt = "Unknown URL scheme")]
+    #[display("Unknown URL scheme")]
     UnknownScheme,
 
-    #[display(fmt = "Missing host name")]
+    #[display("Missing host name")]
     MissingHost,
 
-    #[display(fmt = "URL parse error: {}", _0)]
+    #[display("URL parse error: {}", _0)]
     HttpError(http::Error),
 }
 
@@ -86,11 +86,11 @@ impl std::error::Error for InvalidUrl {}
 #[non_exhaustive]
 pub enum SendRequestError {
     /// Invalid URL
-    #[display(fmt = "Invalid URL: {}", _0)]
+    #[display("Invalid URL: {}", _0)]
     Url(InvalidUrl),
 
     /// Failed to connect to host
-    #[display(fmt = "Failed to connect to host: {}", _0)]
+    #[display("Failed to connect to host: {}", _0)]
     Connect(ConnectError),
 
     /// Error sending request
@@ -100,26 +100,26 @@ pub enum SendRequestError {
     Response(ParseError),
 
     /// Http error
-    #[display(fmt = "{}", _0)]
+    #[display("{}", _0)]
     Http(HttpError),
 
     /// Http2 error
-    #[display(fmt = "{}", _0)]
+    #[display("{}", _0)]
     H2(h2::Error),
 
     /// Response took too long
-    #[display(fmt = "Timeout while waiting for response")]
+    #[display("Timeout while waiting for response")]
     Timeout,
 
     /// Tunnels are not supported for HTTP/2 connection
-    #[display(fmt = "Tunnels are not supported for http2 connection")]
+    #[display("Tunnels are not supported for http2 connection")]
     TunnelNotSupported,
 
     /// Error sending request body
     Body(BoxError),
 
     /// Other errors that can occur after submitting a request.
-    #[display(fmt = "{:?}: {}", _1, _0)]
+    #[display("{:?}: {}", _1, _0)]
     Custom(BoxError, Box<dyn fmt::Debug>),
 }
 
@@ -130,15 +130,15 @@ impl std::error::Error for SendRequestError {}
 #[non_exhaustive]
 pub enum FreezeRequestError {
     /// Invalid URL
-    #[display(fmt = "Invalid URL: {}", _0)]
+    #[display("Invalid URL: {}", _0)]
     Url(InvalidUrl),
 
     /// HTTP error
-    #[display(fmt = "{}", _0)]
+    #[display("{}", _0)]
     Http(HttpError),
 
     /// Other errors that can occur after submitting a request.
-    #[display(fmt = "{:?}: {}", _1, _0)]
+    #[display("{:?}: {}", _1, _0)]
     Custom(BoxError, Box<dyn fmt::Debug>),
 }
 
diff --git a/awc/src/client/h2proto.rs b/awc/src/client/h2proto.rs
index c3f801f20..2e0da2e4f 100644
--- a/awc/src/client/h2proto.rs
+++ b/awc/src/client/h2proto.rs
@@ -12,7 +12,7 @@ use h2::{
     SendStream,
 };
 use http::{
-    header::{HeaderValue, CONNECTION, CONTENT_LENGTH, TRANSFER_ENCODING},
+    header::{HeaderValue, CONNECTION, CONTENT_LENGTH, HOST, TRANSFER_ENCODING},
     request::Request,
     Method, Version,
 };
@@ -97,7 +97,7 @@ where
             // TODO: consider skipping other headers according to:
             //       https://datatracker.ietf.org/doc/html/rfc7540#section-8.1.2.2
             // omit HTTP/1.x only headers
-            CONNECTION | TRANSFER_ENCODING => continue,
+            CONNECTION | TRANSFER_ENCODING | HOST => continue,
             CONTENT_LENGTH if skip_len => continue,
             // DATE => has_date = true,
             _ => {}
@@ -107,7 +107,7 @@ where
 
     let res = poll_fn(|cx| io.poll_ready(cx)).await;
     if let Err(err) = res {
-        io.on_release(err.is_io());
+        io.on_release(err.is_io() || err.is_go_away());
         return Err(SendRequestError::from(err));
     }
 
@@ -121,7 +121,7 @@ where
             fut.await.map_err(SendRequestError::from)?
         }
         Err(err) => {
-            io.on_release(err.is_io());
+            io.on_release(err.is_io() || err.is_go_away());
             return Err(err.into());
         }
     };
diff --git a/awc/src/client/pool.rs b/awc/src/client/pool.rs
index 2938353fd..29b15ee2d 100644
--- a/awc/src/client/pool.rs
+++ b/awc/src/client/pool.rs
@@ -31,7 +31,7 @@ use super::{
     Connect,
 };
 
-#[derive(Hash, Eq, PartialEq, Clone, Debug)]
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct Key {
     authority: Authority,
 }
@@ -42,8 +42,8 @@ impl From<Authority> for Key {
     }
 }
 
+/// Connections pool to reuse I/O per [`Authority`].
 #[doc(hidden)]
-/// Connections pool for reuse Io type for certain [`http::uri::Authority`] as key.
 pub struct ConnectionPool<S, Io>
 where
     Io: AsyncWrite + Unpin + 'static,
@@ -52,7 +52,7 @@ where
     inner: ConnectionPoolInner<Io>,
 }
 
-/// wrapper type for check the ref count of Rc.
+/// Wrapper type for check the ref count of Rc.
 pub struct ConnectionPoolInner<Io>(Rc<ConnectionPoolInnerPriv<Io>>)
 where
     Io: AsyncWrite + Unpin + 'static;
@@ -63,7 +63,7 @@ where
 {
     fn new(config: ConnectorConfig) -> Self {
         let permits = Arc::new(Semaphore::new(config.limit));
-        let available = RefCell::new(HashMap::default());
+        let available = RefCell::new(HashMap::new());
 
         Self(Rc::new(ConnectionPoolInnerPriv {
             config,
@@ -72,11 +72,13 @@ where
         }))
     }
 
-    /// spawn a async for graceful shutdown h1 Io type with a timeout.
+    /// Spawns a graceful shutdown task for the underlying I/O with a timeout.
     fn close(&self, conn: ConnectionInnerType<Io>) {
         if let Some(timeout) = self.config.disconnect_timeout {
             if let ConnectionInnerType::H1(io) = conn {
-                actix_rt::spawn(CloseConnection::new(io, timeout));
+                if tokio::runtime::Handle::try_current().is_ok() {
+                    actix_rt::spawn(CloseConnection::new(io, timeout));
+                }
             }
         }
     }
@@ -173,12 +175,14 @@ where
             };
 
             // acquire an owned permit and carry it with connection
-            let permit = inner.permits.clone().acquire_owned().await.map_err(|_| {
-                ConnectError::Io(io::Error::new(
-                    io::ErrorKind::Other,
-                    "failed to acquire semaphore on client connection pool",
-                ))
-            })?;
+            let permit = Arc::clone(&inner.permits)
+                .acquire_owned()
+                .await
+                .map_err(|_| {
+                    ConnectError::Io(io::Error::other(
+                        "Failed to acquire semaphore on client connection pool",
+                    ))
+                })?;
 
             let conn = {
                 let mut conn = None;
diff --git a/awc/src/error.rs b/awc/src/error.rs
index 0104e5fe8..d2d6d71c4 100644
--- a/awc/src/error.rs
+++ b/awc/src/error.rs
@@ -18,35 +18,35 @@ pub use crate::client::{ConnectError, FreezeRequestError, InvalidUrl, SendReques
 #[derive(Debug, Display, From)]
 pub enum WsClientError {
     /// Invalid response status
-    #[display(fmt = "Invalid response status")]
+    #[display("Invalid response status")]
     InvalidResponseStatus(StatusCode),
 
     /// Invalid upgrade header
-    #[display(fmt = "Invalid upgrade header")]
+    #[display("Invalid upgrade header")]
     InvalidUpgradeHeader,
 
     /// Invalid connection header
-    #[display(fmt = "Invalid connection header")]
+    #[display("Invalid connection header")]
     InvalidConnectionHeader(HeaderValue),
 
     /// Missing Connection header
-    #[display(fmt = "Missing Connection header")]
+    #[display("Missing Connection header")]
     MissingConnectionHeader,
 
     /// Missing Sec-Websocket-Accept header
-    #[display(fmt = "Missing Sec-Websocket-Accept header")]
+    #[display("Missing Sec-Websocket-Accept header")]
     MissingWebSocketAcceptHeader,
 
     /// Invalid challenge response
-    #[display(fmt = "Invalid challenge response")]
+    #[display("Invalid challenge response")]
     InvalidChallengeResponse([u8; 28], HeaderValue),
 
     /// Protocol error
-    #[display(fmt = "{}", _0)]
+    #[display("{}", _0)]
     Protocol(WsProtocolError),
 
     /// Send request error
-    #[display(fmt = "{}", _0)]
+    #[display("{}", _0)]
     SendRequest(SendRequestError),
 }
 
@@ -68,13 +68,13 @@ impl From<HttpError> for WsClientError {
 #[derive(Debug, Display, From)]
 pub enum JsonPayloadError {
     /// Content type error
-    #[display(fmt = "Content type error")]
+    #[display("Content type error")]
     ContentType,
     /// Deserialize error
-    #[display(fmt = "Json deserialize error: {}", _0)]
+    #[display("Json deserialize error: {}", _0)]
     Deserialize(JsonError),
     /// Payload error
-    #[display(fmt = "Error that occur during reading payload: {}", _0)]
+    #[display("Error that occur during reading payload: {}", _0)]
     Payload(PayloadError),
 }
 
diff --git a/awc/src/frozen.rs b/awc/src/frozen.rs
index 8f3244997..862405234 100644
--- a/awc/src/frozen.rs
+++ b/awc/src/frozen.rs
@@ -49,7 +49,7 @@ impl FrozenClientRequest {
     where
         B: MessageBody + 'static,
     {
-        RequestSender::Rc(self.head.clone(), None).send_body(
+        RequestSender::Rc(Rc::clone(&self.head), None).send_body(
             self.addr,
             self.response_decompress,
             self.timeout,
@@ -60,7 +60,7 @@ impl FrozenClientRequest {
 
     /// Send a json body.
     pub fn send_json<T: Serialize>(&self, value: &T) -> SendClientRequest {
-        RequestSender::Rc(self.head.clone(), None).send_json(
+        RequestSender::Rc(Rc::clone(&self.head), None).send_json(
             self.addr,
             self.response_decompress,
             self.timeout,
@@ -71,7 +71,7 @@ impl FrozenClientRequest {
 
     /// Send an urlencoded body.
     pub fn send_form<T: Serialize>(&self, value: &T) -> SendClientRequest {
-        RequestSender::Rc(self.head.clone(), None).send_form(
+        RequestSender::Rc(Rc::clone(&self.head), None).send_form(
             self.addr,
             self.response_decompress,
             self.timeout,
@@ -86,7 +86,7 @@ impl FrozenClientRequest {
         S: Stream<Item = Result<Bytes, E>> + 'static,
         E: Into<BoxError> + 'static,
     {
-        RequestSender::Rc(self.head.clone(), None).send_stream(
+        RequestSender::Rc(Rc::clone(&self.head), None).send_stream(
             self.addr,
             self.response_decompress,
             self.timeout,
@@ -97,7 +97,7 @@ impl FrozenClientRequest {
 
     /// Send an empty body.
     pub fn send(&self) -> SendClientRequest {
-        RequestSender::Rc(self.head.clone(), None).send(
+        RequestSender::Rc(Rc::clone(&self.head), None).send(
             self.addr,
             self.response_decompress,
             self.timeout,
@@ -147,8 +147,8 @@ impl FrozenSendBuilder {
 
     /// Complete request construction and send a body.
     pub fn send_body(self, body: impl MessageBody + 'static) -> SendClientRequest {
-        if let Some(e) = self.err {
-            return e.into();
+        if let Some(err) = self.err {
+            return err.into();
         }
 
         RequestSender::Rc(self.req.head, Some(self.extra_headers)).send_body(
@@ -177,8 +177,8 @@ impl FrozenSendBuilder {
 
     /// Complete request construction and send an urlencoded body.
     pub fn send_form(self, value: impl Serialize) -> SendClientRequest {
-        if let Some(e) = self.err {
-            return e.into();
+        if let Some(err) = self.err {
+            return err.into();
         }
 
         RequestSender::Rc(self.req.head, Some(self.extra_headers)).send_form(
@@ -196,8 +196,8 @@ impl FrozenSendBuilder {
         S: Stream<Item = Result<Bytes, E>> + 'static,
         E: Into<BoxError> + 'static,
     {
-        if let Some(e) = self.err {
-            return e.into();
+        if let Some(err) = self.err {
+            return err.into();
         }
 
         RequestSender::Rc(self.req.head, Some(self.extra_headers)).send_stream(
@@ -211,8 +211,8 @@ impl FrozenSendBuilder {
 
     /// Complete request construction and send an empty body.
     pub fn send(self) -> SendClientRequest {
-        if let Some(e) = self.err {
-            return e.into();
+        if let Some(err) = self.err {
+            return err.into();
         }
 
         RequestSender::Rc(self.req.head, Some(self.extra_headers)).send(
diff --git a/awc/src/lib.rs b/awc/src/lib.rs
index 460480994..360b3db0e 100644
--- a/awc/src/lib.rs
+++ b/awc/src/lib.rs
@@ -100,8 +100,6 @@
 //! # }
 //! ```
 
-#![deny(rust_2018_idioms, nonstandard_style)]
-#![warn(future_incompatible)]
 #![allow(unknown_lints)] // temp: #[allow(non_local_definitions)]
 #![allow(
     clippy::type_complexity,
@@ -110,7 +108,7 @@
 )]
 #![doc(html_logo_url = "https://actix.rs/img/logo.png")]
 #![doc(html_favicon_url = "https://actix.rs/favicon.ico")]
-#![cfg_attr(docsrs, feature(doc_auto_cfg))]
+#![cfg_attr(docsrs, feature(doc_cfg))]
 
 pub use actix_http::body;
 #[cfg(feature = "cookies")]
diff --git a/awc/src/middleware/redirect.rs b/awc/src/middleware/redirect.rs
index 0ea5f174e..b2cf9c45b 100644
--- a/awc/src/middleware/redirect.rs
+++ b/awc/src/middleware/redirect.rs
@@ -78,7 +78,7 @@ where
                 RedirectServiceFuture::Tunnel { fut }
             }
             ConnectRequest::Client(head, body, addr) => {
-                let connector = self.connector.clone();
+                let connector = Rc::clone(&self.connector);
                 let max_redirect_times = self.max_redirect_times;
 
                 // backup the uri and method for reuse schema and authority.
diff --git a/awc/src/request.rs b/awc/src/request.rs
index 28ed8b5f5..5f42f67ec 100644
--- a/awc/src/request.rs
+++ b/awc/src/request.rs
@@ -415,8 +415,8 @@ impl ClientRequest {
 
     // allow unused mut when cookies feature is disabled
     fn prep_for_sending(#[allow(unused_mut)] mut self) -> Result<Self, PrepForSendingError> {
-        if let Some(e) = self.err {
-            return Err(e.into());
+        if let Some(err) = self.err {
+            return Err(err.into());
         }
 
         // validate uri
diff --git a/awc/src/sender.rs b/awc/src/sender.rs
index 8de1033a3..0015743bd 100644
--- a/awc/src/sender.rs
+++ b/awc/src/sender.rs
@@ -54,8 +54,8 @@ impl From<PrepForSendingError> for FreezeRequestError {
 impl From<PrepForSendingError> for SendRequestError {
     fn from(err: PrepForSendingError) -> SendRequestError {
         match err {
-            PrepForSendingError::Url(e) => SendRequestError::Url(e),
-            PrepForSendingError::Http(e) => SendRequestError::Http(e),
+            PrepForSendingError::Url(err) => SendRequestError::Url(err),
+            PrepForSendingError::Http(err) => SendRequestError::Http(err),
             PrepForSendingError::Json(err) => {
                 SendRequestError::Custom(Box::new(err), Box::new("json serialization error"))
             }
@@ -156,20 +156,20 @@ impl Future for SendClientRequest {
 }
 
 impl From<SendRequestError> for SendClientRequest {
-    fn from(e: SendRequestError) -> Self {
-        SendClientRequest::Err(Some(e))
+    fn from(err: SendRequestError) -> Self {
+        SendClientRequest::Err(Some(err))
     }
 }
 
 impl From<HttpError> for SendClientRequest {
-    fn from(e: HttpError) -> Self {
-        SendClientRequest::Err(Some(e.into()))
+    fn from(err: HttpError) -> Self {
+        SendClientRequest::Err(Some(err.into()))
     }
 }
 
 impl From<PrepForSendingError> for SendClientRequest {
-    fn from(e: PrepForSendingError) -> Self {
-        SendClientRequest::Err(Some(e.into()))
+    fn from(err: PrepForSendingError) -> Self {
+        SendClientRequest::Err(Some(err.into()))
     }
 }
 
diff --git a/awc/src/test.rs b/awc/src/test.rs
index 126583179..a7ed3faf0 100644
--- a/awc/src/test.rs
+++ b/awc/src/test.rs
@@ -65,9 +65,7 @@ impl TestResponse {
 
     /// Set response's payload
     pub fn set_payload<B: Into<Bytes>>(mut self, data: B) -> Self {
-        let (_, mut payload) = h1::Payload::create(true);
-        payload.unread_data(data.into());
-        self.payload = Some(payload.into());
+        self.payload = Some(Payload::from(data.into()));
         self
     }
 
diff --git a/awc/src/ws.rs b/awc/src/ws.rs
index c3340206d..3ce1d286a 100644
--- a/awc/src/ws.rs
+++ b/awc/src/ws.rs
@@ -253,12 +253,13 @@ impl WebsocketsRequest {
     pub async fn connect(
         mut self,
     ) -> Result<(ClientResponse, Framed<BoxedSocket, Codec>), WsClientError> {
-        if let Some(e) = self.err.take() {
-            return Err(e.into());
+        if let Some(err) = self.err.take() {
+            return Err(err.into());
         }
 
-        // validate uri
+        // validate URI
         let uri = &self.head.uri;
+
         if uri.host().is_none() {
             return Err(InvalidUrl::MissingHost.into());
         } else if uri.scheme().is_none() {
@@ -273,9 +274,12 @@ impl WebsocketsRequest {
         }
 
         if !self.head.headers.contains_key(header::HOST) {
+            let hostname = uri.host().unwrap();
+            let port = uri.port();
+
             self.head.headers.insert(
                 header::HOST,
-                HeaderValue::from_str(uri.host().unwrap()).unwrap(),
+                HeaderValue::from_str(&Host { hostname, port }.to_string()).unwrap(),
             );
         }
 
@@ -322,7 +326,7 @@ impl WebsocketsRequest {
 
         // Generate a random key for the `Sec-WebSocket-Key` header which is a base64-encoded
         // (see RFC 4648 §4) value that, when decoded, is 16 bytes in length (RFC 6455 §1.3).
-        let sec_key: [u8; 16] = rand::random();
+        let sec_key = rand::random::<[u8; 16]>();
         let key = BASE64_STANDARD.encode(sec_key);
 
         self.head.headers.insert(
@@ -434,6 +438,25 @@ impl fmt::Debug for WebsocketsRequest {
     }
 }
 
+/// Formatter for host (hostname+port) header values.
+struct Host<'a> {
+    hostname: &'a str,
+    port: Option<http::uri::Port<&'a str>>,
+}
+
+impl fmt::Display for Host<'_> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str(self.hostname)?;
+
+        if let Some(port) = &self.port {
+            f.write_str(":")?;
+            f.write_str(port.as_str())?;
+        }
+
+        Ok(())
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
diff --git a/awc/tests/test_client.rs b/awc/tests/test_client.rs
index 73254249f..6fd56823f 100644
--- a/awc/tests/test_client.rs
+++ b/awc/tests/test_client.rs
@@ -20,7 +20,7 @@ use base64::prelude::*;
 use bytes::Bytes;
 use cookie::Cookie;
 use futures_util::stream;
-use rand::Rng;
+use rand::distr::{Alphanumeric, SampleString as _};
 
 mod utils;
 
@@ -516,11 +516,7 @@ async fn client_gzip_encoding_large() {
 #[cfg(feature = "compress-gzip")]
 #[actix_rt::test]
 async fn client_gzip_encoding_large_random() {
-    let data = rand::thread_rng()
-        .sample_iter(&rand::distributions::Alphanumeric)
-        .take(100_000)
-        .map(char::from)
-        .collect::<String>();
+    let data = Alphanumeric.sample_string(&mut rand::rng(), 100_000);
 
     let srv = actix_test::start(|| {
         App::new().service(web::resource("/").route(web::to(|data: Bytes| async {
@@ -562,11 +558,7 @@ async fn client_brotli_encoding() {
 #[cfg(feature = "compress-brotli")]
 #[actix_rt::test]
 async fn client_brotli_encoding_large_random() {
-    let data = rand::thread_rng()
-        .sample_iter(&rand::distributions::Alphanumeric)
-        .take(70_000)
-        .map(char::from)
-        .collect::<String>();
+    let data = Alphanumeric.sample_string(&mut rand::rng(), 70_000);
 
     let srv = actix_test::start(|| {
         App::new().service(web::resource("/").route(web::to(|data: Bytes| async {
@@ -607,11 +599,7 @@ async fn client_deflate_encoding() {
 
 #[actix_rt::test]
 async fn client_deflate_encoding_large_random() {
-    let data = rand::thread_rng()
-        .sample_iter(rand::distributions::Alphanumeric)
-        .map(char::from)
-        .take(70_000)
-        .collect::<String>();
+    let data = Alphanumeric.sample_string(&mut rand::rng(), 70_000);
 
     let srv = actix_test::start(|| {
         App::new().default_service(web::to(|body: Bytes| async {
diff --git a/deny.toml b/deny.toml
new file mode 100644
index 000000000..f775089f4
--- /dev/null
+++ b/deny.toml
@@ -0,0 +1,45 @@
+[licenses]
+confidence-threshold = 0.90
+allow = [
+    "Apache-2.0",
+    "MIT",
+    "Unicode-3.0",
+    "ISC",
+    "CDLA-Permissive-2.0",
+    "BSD-3-Clause",
+    "Zlib",
+    "OpenSSL",
+    "MPL-2.0"
+]
+private = { ignore = true }
+
+# FIXME: old rustls introduces old ring which is not set license field properly.
+[[licenses.clarify]]
+crate = "ring"
+expression = "MIT AND ISC AND OpenSSL"
+license-files = [
+    { path = "LICENSE", hash = 0xbd0eed23 }
+]
+
+# FIXME: webpki is almost unmaintained and is not set license field properly.
+# rustls has its own fork now so removing old rustls should resolve the issue.
+[[licenses.clarify]]
+crate = "webpki"
+expression = "ISC"
+license-files = [
+    { path = "LICENSE", hash = 0x001c7e6c }
+]
+
+[bans]
+multiple-versions = "allow"
+
+[bans.build]
+executables = "deny"
+
+[advisories]
+# because of old rustls support:
+ignore = [
+    "RUSTSEC-2024-0336",
+    "RUSTSEC-2025-0009",
+    "RUSTSEC-2025-0010"
+]
diff --git a/justfile b/justfile
index 646c6b44d..0cd74f21d 100644
--- a/justfile
+++ b/justfile
@@ -1,15 +1,18 @@
 _list:
     @just --list
 
+toolchain := ""
+
 # Format workspace.
 fmt:
+    just --unstable --fmt
     cargo +nightly fmt
     fd --hidden --type=file --extension=md --extension=yml --exec-batch npx -y prettier --write
 
-# Downgrade dev-dependencies necessary to run MSRV checks/tests.
+# Downgrade dependencies necessary to run MSRV checks/tests.
 [private]
 downgrade-for-msrv:
-    cargo update -p=clap --precise=4.4.18
+    # no downgrades currently needed
 
 msrv := ```
     cargo metadata --format-version=1 \
@@ -17,66 +20,80 @@ msrv := ```
     | sed -E 's/^1\.([0-9]{2})$/1\.\1\.0/'
 ```
 msrv_rustup := "+" + msrv
-
 non_linux_all_features_list := ```
     cargo metadata --format-version=1 \
     | jq '.packages[] | select(.source == null) | .features | keys' \
     | jq -r --slurp \
-        --arg exclusions "tokio-uring,io-uring,experimental-io-uring" \
+        --arg exclusions "__tls,__compress,tokio-uring,io-uring,experimental-io-uring" \
         'add | unique | . - ($exclusions | split(",")) | join(",")'
 ```
+all_crate_features := if os() == "linux" { "--all-features" } else { "--features='" + non_linux_all_features_list + "'" }
 
-all_crate_features := if os() == "linux" {
-    "--all-features"
-} else {
-    "--features='" + non_linux_all_features_list + "'"
-}
+[private]
+check-min:
+    cargo hack --workspace check --no-default-features
+
+[private]
+check-default:
+    cargo hack --workspace check
+
+# Check workspace.
+check: && clippy
+    fd --hidden --type=file --extension=md --extension=yml --exec-batch npx -y prettier --check
 
 # Run Clippy over workspace.
-clippy toolchain="":
+clippy:
     cargo {{ toolchain }} clippy --workspace --all-targets {{ all_crate_features }}
 
-# Test workspace using MSRV.
-test-msrv: downgrade-for-msrv (test msrv_rustup)
+# Run Clippy over workspace using MSRV.
+clippy-msrv: downgrade-for-msrv
+    @just toolchain={{ msrv_rustup }} clippy
 
 # Test workspace code.
-test toolchain="":
+test:
     cargo {{ toolchain }} test --lib --tests -p=actix-web-codegen --all-features
     cargo {{ toolchain }} test --lib --tests -p=actix-multipart-derive --all-features
-    cargo {{ toolchain }} nextest run -p=actix-router --no-default-features
-    cargo {{ toolchain }} nextest run --workspace --exclude=actix-web-codegen --exclude=actix-multipart-derive {{ all_crate_features }} --filter-expr="not test(test_reading_deflate_encoding_large_random_rustls)"
+    cargo {{ toolchain }} nextest run --no-tests=warn -p=actix-router --no-default-features
+    cargo {{ toolchain }} nextest run --no-tests=warn --workspace --exclude=actix-web-codegen --exclude=actix-multipart-derive {{ all_crate_features }} --filter-expr="not test(test_reading_deflate_encoding_large_random_rustls)"
+
+# Test workspace using MSRV.
+test-msrv: downgrade-for-msrv
+    @just toolchain={{ msrv_rustup }} test
 
 # Test workspace docs.
-test-docs toolchain="": && doc
+test-docs: && doc
     cargo {{ toolchain }} test --doc --workspace {{ all_crate_features }} --no-fail-fast -- --nocapture
 
 # Test workspace.
-test-all toolchain="": (test toolchain) (test-docs toolchain)
+test-all: test test-docs
 
 # Test workspace and collect coverage info.
 [private]
-test-coverage toolchain="":
-    cargo {{ toolchain }} llvm-cov nextest --no-report {{ all_crate_features }}
+test-coverage:
+    cargo {{ toolchain }} llvm-cov nextest --no-tests=warn --no-report {{ all_crate_features }}
     cargo {{ toolchain }} llvm-cov --doc --no-report {{ all_crate_features }}
 
 # Test workspace and generate Codecov report.
-test-coverage-codecov toolchain="": (test-coverage toolchain)
+test-coverage-codecov: test-coverage
     cargo {{ toolchain }} llvm-cov report --doctests --codecov --output-path=codecov.json
 
 # Test workspace and generate LCOV report.
-test-coverage-lcov toolchain="": (test-coverage toolchain)
+test-coverage-lcov: test-coverage
     cargo {{ toolchain }} llvm-cov report --doctests --lcov --output-path=lcov.info
 
 # Document crates in workspace.
+# FIXME: Re-add `RUSTDOCFLAGS="--cfg=docsrs -Dwarnings"` once crypto-related crates are updated.
 doc *args: && doc-set-workspace-crates
-    RUSTDOCFLAGS="--cfg=docsrs -Dwarnings" cargo +nightly doc --workspace {{ all_crate_features }} {{ args }}
+    rm -f "$(cargo metadata --format-version=1 | jq -r '.target_directory')/doc/crates.js"
+    cargo +nightly doc --workspace {{ all_crate_features }} {{ args }}
 
 [private]
 doc-set-workspace-crates:
     #!/usr/bin/env bash
     (
         echo "window.ALL_CRATES ="
-        cargo metadata --format-version=1 | jq '[.packages[] | select(.source == null) | .name]'
+        cargo metadata --format-version=1 \
+        | jq '[.packages[] | select(.source == null) | .targets | map(select(.doc) | .name)] | flatten'
         echo ";"
     ) > "$(cargo metadata --format-version=1 | jq -r '.target_directory')/doc/crates.js"
 
@@ -93,13 +110,22 @@ update-readmes: && fmt
     cd ./actix-multipart && cargo rdme --force
     cd ./actix-test && cargo rdme --force
 
+feature_combo_skip_list := if os() == "linux" { "__tls,__compress" } else { "__tls,__compress,experimental-io-uring" }
+
+# Checks compatibility of feature combinations.
+check-feature-combinations:
+    cargo hack --workspace \
+        --feature-powerset --depth=4 \
+        --skip={{ feature_combo_skip_list }} \
+        check
+
 # Check for unintentional external type exposure on all crates in workspace.
 check-external-types-all toolchain="+nightly":
     #!/usr/bin/env bash
     set -euo pipefail
     exit=0
     for f in $(find . -mindepth 2 -maxdepth 2 -name Cargo.toml | grep -vE "\-codegen/|\-derive/|\-macros/"); do
-        if ! just check-external-types-manifest "$f" {{toolchain}}; then exit=1; fi
+        if ! just check-external-types-manifest "$f" {{ toolchain }}; then exit=1; fi
         echo
         echo
     done
@@ -112,9 +138,9 @@ check-external-types-all-table toolchain="+nightly":
     for f in $(find . -mindepth 2 -maxdepth 2 -name Cargo.toml | grep -vE "\-codegen/|\-derive/|\-macros/"); do
         echo
         echo "Checking for $f"
-        just check-external-types-manifest "$f" {{toolchain}} --output-format=markdown-table
+        just check-external-types-manifest "$f" {{ toolchain }} --output-format=markdown-table
     done
 
 # Check for unintentional external type exposure on a crate.
 check-external-types-manifest manifest_path toolchain="+nightly" *extra_args="":
-    cargo {{toolchain}} check-external-types --manifest-path "{{manifest_path}}" {{extra_args}}
+    cargo {{ toolchain }} check-external-types --manifest-path "{{ manifest_path }}" {{ extra_args }}
diff --git a/scripts/bump b/scripts/bump
index 6fd879eae..0b16466b4 100755
--- a/scripts/bump
+++ b/scripts/bump
@@ -1,4 +1,4 @@
-#!/bin/bash
+#!/usr/bin/env bash
 
 # developed on macOS and probably doesn't work on Linux yet due to minor
 # differences in flags on sed
@@ -169,3 +169,5 @@ if [ "$GH_RELEASE" = 'y' ] || [ "$GH_RELEASE" = 'Y' ]; then
 fi
 
 echo
+
+cargo update >/dev/null 2>&1 || true
diff --git a/scripts/ci-test b/scripts/ci-test
deleted file mode 100755
index bdea1283a..000000000
--- a/scripts/ci-test
+++ /dev/null
@@ -1,38 +0,0 @@
-#!/bin/sh
-
-# run tests matching what CI does for non-linux feature sets
-
-set -x
-
-EXIT=0
-
-save_exit_code() {
-    eval $@
-    local CMD_EXIT=$?
-    [ "$CMD_EXIT" = "0" ] || EXIT=$CMD_EXIT
-}
-
-save_exit_code cargo test --lib --tests -p=actix-router --all-features -- --nocapture
-save_exit_code cargo test --lib --tests -p=actix-http --all-features -- --nocapture
-save_exit_code cargo test --lib --tests -p=actix-web --features=rustls,openssl -- --nocapture
-save_exit_code cargo test --lib --tests -p=actix-web-codegen --all-features -- --nocapture
-save_exit_code cargo test --lib --tests -p=awc --all-features -- --nocapture
-save_exit_code cargo test --lib --tests -p=actix-http-test --all-features -- --nocapture
-save_exit_code cargo test --lib --tests -p=actix-test --all-features -- --nocapture
-save_exit_code cargo test --lib --tests -p=actix-files -- --nocapture
-save_exit_code cargo test --lib --tests -p=actix-multipart --all-features -- --nocapture
-save_exit_code cargo test --lib --tests -p=actix-web-actors --all-features -- --nocapture
-
-save_exit_code cargo test --workspace --doc
-
-if [ "$EXIT" = "0" ]; then
-    PASSED="All tests passed!"
-
-    if [ "$(command -v figlet)" ]; then
-        figlet "$PASSED"
-    else
-        echo "$PASSED"
-    fi
-fi
-
-exit $EXIT
diff --git a/scripts/publish b/scripts/publish
new file mode 100755
index 000000000..7d7347cdb
--- /dev/null
+++ b/scripts/publish
@@ -0,0 +1,25 @@
+#!/usr/bin/env bash
+
+set -Euo pipefail
+
+for dir in $@; do
+    cd "$dir"
+    
+    cargo publish --dry-run
+
+    read -p "Look okay? "
+    read -p "Sure? "
+    
+    cargo publish
+
+    if [ $? -ne 0 ]; then
+        echo
+        read -p "Was the above error caused by cyclic dev-deps? Choosing yes will publish without a git backreference. (y/N) " publish_no_dev_deps
+
+        if [[ "$publish_no_dev_deps" == "y" || "$publish_no_dev_deps" == "Y" ]]; then
+            cargo hack --no-dev-deps publish --allow-dirty
+        fi
+    fi
+
+    cd ..
+done