Adds a buffer that has a tolerance.

2026-01-19 16:52:08 +00:00 · 2023-08-07 21:29:31 +02:00
224 changed files with 13501 additions and 31131 deletions
--- a/.clang-format
+++ b/.clang-format
@@ -1,176 +0,0 @@
---
-Language: Cpp
-ColumnLimit: 100
-IndentWidth: 3
-BreakBeforeBraces: Custom
-BraceWrapping:
-  AfterCaseLabel: true
-  AfterClass: false
-  AfterControlStatement: false
-  AfterEnum: true
-  AfterFunction: true
-  AfterNamespace: false
-  AfterStruct: false
-  AfterUnion: false
-  AfterExternBlock: false
-  BeforeCatch: false
-  BeforeElse: false
-  IndentBraces: false
-  SplitEmptyFunction: false
-  SplitEmptyRecord: false
-  SplitEmptyNamespace: true
-AccessModifierOffset: -3
-BinPackArguments: false
-BinPackParameters: false
-AlignAfterOpenBracket: AlwaysBreak
-PointerAlignment: Left
-IncludeBlocks: Regroup
-IncludeCategories:
-  - Regex: '^<boost/redis.*>|<boost/redis/.*>'
-    Priority: -10
-    SortPriority: 1
-  - Regex: '^<boost/.*>'
-    Priority: -8
-    SortPriority: 3
-  - Regex: "^<.*"
-    Priority: -6
-    SortPriority: 5
-  - Regex: ".*"
-    Priority: -5
-    SortPriority: 4
-IndentCaseLabels: true
-AllowShortCaseLabelsOnASingleLine: true
-AllowAllArgumentsOnNextLine: false
-AllowAllParametersOfDeclarationOnNextLine: false
-AllowShortIfStatementsOnASingleLine: Never
-AllowShortLoopsOnASingleLine: false
-AlignArrayOfStructures: Left
-DerivePointerAlignment: false
-PenaltyBreakAssignment: 2000000
-PenaltyBreakBeforeFirstCallParameter: 0
-PenaltyBreakOpenParenthesis: 0
-PenaltyBreakComment: 300
-PenaltyBreakFirstLessLess: 120
-PenaltyBreakString: 1000
-PenaltyBreakTemplateDeclaration: 10
-PenaltyExcessCharacter: 1000000
-PenaltyBreakScopeResolution: 1000000
-PenaltyReturnTypeOnItsOwnLine: 200000000
-
-# Defaults (based on Google)
-AlignConsecutiveMacros: false
-AlignConsecutiveAssignments: false
-AlignConsecutiveDeclarations: false
-AlignEscapedNewlines: Left
-AlignOperands: true
-AlignTrailingComments: true
-AllowAllConstructorInitializersOnNextLine: true
-AllowShortBlocksOnASingleLine: Never
-AllowShortFunctionsOnASingleLine: All
-AllowShortLambdasOnASingleLine: Empty
-AlwaysBreakAfterDefinitionReturnType: None
-AlwaysBreakAfterReturnType: ExceptShortType
-AlwaysBreakBeforeMultilineStrings: true
-AlwaysBreakTemplateDeclarations: Yes
-BreakTemplateDeclarations: Leave
-BreakBeforeBinaryOperators: None
-BreakBeforeInheritanceComma: false
-BreakInheritanceList: BeforeColon
-BreakBeforeTernaryOperators: true
-BreakConstructorInitializersBeforeComma: true
-BreakConstructorInitializers: BeforeColon
-BreakAfterJavaFieldAnnotations: false
-BreakStringLiterals: true
-CommentPragmas: '(^ IWYU pragma:)|(^\\copydoc )|(^ ?\\n)'
-CompactNamespaces: false
-ConstructorInitializerAllOnOneLineOrOnePerLine: false
-ConstructorInitializerIndentWidth: 0
-ContinuationIndentWidth: 3
-Cpp11BracedListStyle: true
-DeriveLineEnding: true
-DisableFormat: false
-ExperimentalAutoDetectBinPacking: false
-FixNamespaceComments: true
-ForEachMacros:
-  - foreach
-  - Q_FOREACH
-  - BOOST_FOREACH
-IncludeIsMainRegex: null
-IncludeIsMainSourceRegex: ""
-IndentGotoLabels: false
-IndentPPDirectives: None
-IndentWrappedFunctionNames: false
-JavaScriptQuotes: Leave
-JavaScriptWrapImports: true
-KeepEmptyLinesAtTheStartOfBlocks: false
-MacroBlockBegin: ""
-MacroBlockEnd: ""
-MaxEmptyLinesToKeep: 1
-NamespaceIndentation: None
-ObjCBinPackProtocolList: Never
-ObjCBlockIndentWidth: 2
-ObjCSpaceAfterProperty: false
-ObjCSpaceBeforeProtocolList: true
-RawStringFormats:
-  - Language: Cpp
-    Delimiters:
-      - cc
-      - CC
-      - cpp
-      - Cpp
-      - CPP
-      - "c++"
-      - "C++"
-    CanonicalDelimiter: ""
-    BasedOnStyle: google
-  - Language: TextProto
-    Delimiters:
-      - pb
-      - PB
-      - proto
-      - PROTO
-    EnclosingFunctions:
-      - EqualsProto
-      - EquivToProto
-      - PARSE_PARTIAL_TEXT_PROTO
-      - PARSE_TEST_PROTO
-      - PARSE_TEXT_PROTO
-      - ParseTextOrDie
-      - ParseTextProtoOrDie
-    CanonicalDelimiter: ""
-    BasedOnStyle: google
-ReflowComments: false
-SortIncludes: true
-SortUsingDeclarations: false
-SpaceAfterCStyleCast: false
-SpaceAfterLogicalNot: false
-SpaceAfterTemplateKeyword: true
-SpaceBeforeAssignmentOperators: true
-SpaceBeforeCtorInitializerColon: true
-SpaceBeforeInheritanceColon: true
-SpaceBeforeParens: ControlStatements
-SpaceBeforeRangeBasedForLoopColon: true
-SpaceInEmptyBlock: true
-SpaceInEmptyParentheses: false
-SpacesBeforeTrailingComments: 2
-SpacesInAngles: false
-SpacesInConditionalStatement: false
-SpacesInContainerLiterals: true
-SpacesInCStyleCastParentheses: false
-SpacesInParentheses: false
-SpacesInSquareBrackets: false
-SpaceBeforeSquareBrackets: false
-Standard: Auto
-StatementMacros:
-  - Q_UNUSED
-  - QT_REQUIRE_VERSION
-TabWidth: 8
-UseCRLF: false
-UseTab: Never
-AlignConsecutiveShortCaseStatements:
-  Enabled: true
-  AcrossEmptyLines: false
-  AcrossComments: true
-  AlignCaseColons: false
---
-
--- a/.codecov.yml
+++ b/.codecov.yml
@@ -7,7 +7,7 @@ codecov:

 ignore:
  - "benchmarks/cpp/asio/*"
-  - "example/*"
+  - "examples/*"
  - "tests/*"
  - "/usr/*"
  - "**/boost/*"
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -1,18 +1,10 @@
-# CI script to verify that CMake and B2 builds work.
-# B2 builds include only tests that don't require a DB server, to avoid race conditions.
-# CMake tests include the actual project tests and all the CMake integration workflows
-#   recommended by Boost.CI.
-# Windows CMake jobs build the code but don't run the tests,
-#   since we don't have a way to set up a Redis server on Windows (yet).
-# Subcommands are implemented by the tools/ci.py script in a platform-independent manner.
-
 name: CI

 on: [push, pull_request]

 jobs:
-  windows-cmake:
-    name: "CMake ${{matrix.toolset}} ${{matrix.build-type}} C++${{matrix.cxxstd}}"
+  windows:
+    name: "${{matrix.generator}} ${{matrix.toolset}} Boost ${{matrix.boost_version}} ${{matrix.build_type}} ${{matrix.name_args}}"
    runs-on: ${{matrix.os}}
    defaults:
      run:
@@ -20,109 +12,84 @@ jobs:
    strategy:
      fail-fast: false
      matrix:
-        include:
-          #- { toolset: msvc-14.2, os: windows-2019, generator: "Visual Studio 16 2019", cxxstd: '17', build-type: 'Debug',   build-shared-libs: 1 }
-          #- { toolset: msvc-14.2, os: windows-2019, generator: "Visual Studio 16 2019", cxxstd: '17', build-type: 'Release', build-shared-libs: 0 }
-          - { toolset: msvc-14.3, os: windows-2022, generator: "Visual Studio 17 2022", cxxstd: '20', build-type: 'Debug',   build-shared-libs: 0 }
-          - { toolset: msvc-14.3, os: windows-2022, generator: "Visual Studio 17 2022", cxxstd: '20', build-type: 'Release', build-shared-libs: 1 }
-    env:
-      CMAKE_BUILD_PARALLEL_LEVEL: 4
+        boost_version: ["1.81.0"]
+        os: [windows-2019, windows-2022]
+        toolset: [v142, v143]
+        build_type: [Release]
+        generator: ["Visual Studio 16 2019", "Visual Studio 17 2022"]
+        config_args: [""]
+        build_args: [""]
+        name_args: [""]
+        exclude:
+          - { os: windows-2019, toolset: v143 }
+          - { os: windows-2019, generator: "Visual Studio 17 2022" }
+          - { os: windows-2022, generator: "Visual Studio 16 2019" }
+          # The following combinations are not available through install-boost
+          - { boost_version: "1.81.0", toolset: v143 }
+
    steps:
    - name: Checkout
-      uses: actions/checkout@v4
+      uses: actions/checkout@v3
+      with:
+        fetch-depth: 0

-    - name: Setup Boost
-      run: python3 tools/ci.py setup-boost --source-dir=$(pwd)
+    - name: Add boost toolset to environment
+      if: contains(fromJson('["1.81.0"]'), matrix.boost_version)
+      run: echo BOOST_TOOLSET=$(echo "msvc") >> $GITHUB_ENV

-    - name: Build a Boost distribution using B2
+    # The platform_version passed to boost-install determines the msvc toolset version for which static libs are installed.
+    - name: Add boost platform version to environment
      run: |
-        python3 tools/ci.py build-b2-distro \
-          --toolset ${{ matrix.toolset }}
+        declare -A toolset_to_platform_version=( [v142]="2019" [v143]="2022" )
+        key=$(echo "${{matrix.toolset}}")
+        echo BOOST_PLATFORM_VERSION="${toolset_to_platform_version[$key]}" >> $GITHUB_ENV

-    - name: Build a Boost distribution using CMake
+    - name: Add boost install path to environment
+      run: echo BOOST_INSTALL_PATH="${GITHUB_WORKSPACE}/boost-${{matrix.boost_version}}${BOOST_TOOLSET}${BOOST_PLATFORM_VERSION}" >> $GITHUB_ENV
+
+    - name: Add build type configuration to environment
+      run: echo BUILD_CONFIG_ARG="--config ${{matrix.build_type}}" >> $GITHUB_ENV
+
+    - name: Cache Boost installation
+      id: cache-boost
+      uses: actions/cache@v3
+      with:
+        path: ${{env.BOOST_INSTALL_PATH}}
+        key: ${{matrix.boost_version}}${{env.BOOST_TOOLSET}}${{env.BOOST_PLATFORM_VERSION}}
+
+    - name: Install Boost
+      if: steps.cache-boost.outputs.cache-hit != 'true'
+      uses: MarkusJx/install-boost@v2.4.1
+      with:
+        boost_version: ${{matrix.boost_version}}
+        toolset: ${{env.BOOST_TOOLSET}}
+        boost_install_dir: ${{env.BOOST_INSTALL_PATH}}
+        platform_version: ${{env.BOOST_PLATFORM_VERSION}}
+        arch: null
+
+    - name: Install openssl
+      run: choco install openssl
+
+    - name: Create build directory
+      run: mkdir build
+
+    - name: Configure
+      working-directory: build
      run: |
-        python3 tools/ci.py build-cmake-distro \
-          --build-type ${{ matrix.build-type }} \
-          --cxxstd ${{ matrix.cxxstd }} \
-          --toolset ${{ matrix.toolset }} \
-          --generator "${{ matrix.generator }}" \
-          --build-shared-libs ${{ matrix.build-shared-libs }}
-        
-    - name: Build the project tests
+        cmake -T "${{matrix.toolset}}" \
+              -G "${{matrix.generator}}" \
+              ${{matrix.config_args}} \
+              ${BOOST_COMPILER_ARG}\
+              "${GITHUB_WORKSPACE}"
+      env:
+        BOOST_ROOT: ${{env.BOOST_INSTALL_PATH}}/boost
+
+    - name: Build
+      working-directory: build
      run: |
-        python3 tools/ci.py build-cmake-standalone-tests \
-          --build-type ${{ matrix.build-type }} \
-          --cxxstd ${{ matrix.cxxstd }} \
-          --toolset ${{ matrix.toolset }} \
-          --generator "${{ matrix.generator }}" \
-          --build-shared-libs ${{ matrix.build-shared-libs }}
+        cmake --build . ${BUILD_CONFIG_ARG} ${{matrix.build_args}}

-    # # TODO: re-enable this when a Redis server is available for this job
-    # - name: Run the project tests
-    #   run: |
-    #     python3 tools/ci.py run-cmake-standalone-tests \
-    #       --build-type ${{ matrix.build-type }}
-
-    - name: Run add_subdirectory tests
-      run: |
-        python3 tools/ci.py run-cmake-add-subdirectory-tests \
-          --build-type ${{ matrix.build-type }} \
-          --cxxstd ${{ matrix.cxxstd }} \
-          --toolset ${{ matrix.toolset }} \
-          --generator "${{ matrix.generator }}" \
-          --build-shared-libs ${{ matrix.build-shared-libs }}
-
-    - name: Run find_package tests with the built cmake distribution
-      run: |
-        python3 tools/ci.py run-cmake-find-package-tests \
-          --build-type ${{ matrix.build-type }} \
-          --cxxstd ${{ matrix.cxxstd }} \
-          --toolset ${{ matrix.toolset }} \
-          --generator "${{ matrix.generator }}" \
-          --build-shared-libs ${{ matrix.build-shared-libs }}
-
-    - name: Run find_package tests with the built b2 distribution
-      run: |
-        python3 tools/ci.py run-cmake-b2-find-package-tests \
-          --build-type ${{ matrix.build-type }} \
-          --cxxstd ${{ matrix.cxxstd }} \
-          --toolset ${{ matrix.toolset }} \
-          --generator "${{ matrix.generator }}" \
-          --build-shared-libs ${{ matrix.build-shared-libs }}
-
-  windows-b2:
-    name: "B2 ${{matrix.toolset}}"
-    runs-on: ${{matrix.os}}
-    defaults:
-      run:
-        shell: bash
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          #- { toolset: msvc-14.2, os: windows-2019 }
-          - { toolset: msvc-14.3, os: windows-2022 }
-    env:
-      OPENSSL_ROOT: "C:\\Program Files\\OpenSSL"
-    steps:
-    - name: Checkout
-      uses: actions/checkout@v4
-
-    - name: Setup user-config.jam
-      run: cp tools/user-config.jam "${HOMEDRIVE}${HOMEPATH}/"
-
-    - name: Setup Boost
-      run: python3 tools/ci.py setup-boost --source-dir=$(pwd)
-    
-    - name: Build and run project tests using B2
-      run: |
-        python3 tools/ci.py run-b2-tests \
-          --toolset ${{ matrix.toolset }} \
-          --cxxstd 17,20 \
-          --variant debug,release
-
-  posix-cmake:
-    name: "CMake ${{ matrix.toolset }} ${{ matrix.cxxstd }} ${{ matrix.build-type }} ${{ matrix.cxxflags }}"
+  posix:
    defaults:
      run:
        shell: bash
@@ -131,238 +98,39 @@ jobs:
      fail-fast: false
      matrix:
        include:
-          - toolset: gcc-11
-            install: g++-11
-            container: ubuntu:22.04
-            cxxstd: '17'
-            build-type: 'Debug'
-            ldflags: ''
-            server: "redis:7.4.5-alpine"
-
-          - toolset: gcc-11
-            install: g++-11
-            container: ubuntu:22.04
-            cxxstd: '20'
-            build-type: 'Release'
-            ldflags: ''
-            server: "redis:7.4.5-alpine"
-
-          - toolset: clang-11
-            install: clang-11
-            container: ubuntu:22.04
-            cxxstd: '17'
-            build-type: 'Debug'
-            ldflags: ''
-            server: "redis:7.4.5-alpine"
-
-          - toolset: clang-11
-            install: clang-11
-            container: ubuntu:22.04
-            cxxstd: '20'
-            build-type: 'Debug'
-            ldflags: ''
-            server: "redis:7.4.5-alpine"
-
-          - toolset: clang-13
-            install: clang-13
-            container: ubuntu:22.04
-            cxxstd: '17'
-            build-type: 'Release'
-            ldflags: ''
-            server: "redis:8.2.1-alpine"
-
-          - toolset: clang-13
-            install: clang-13
-            container: ubuntu:22.04
-            cxxstd: '20'
-            build-type: 'Release'
-            ldflags: ''
-            server: "redis:8.2.1-alpine"
-
-          - toolset: clang-14
-            install: 'clang-14 libc++-14-dev libc++abi-14-dev'
-            container: ubuntu:22.04
-            cxxstd: '17'
-            build-type: 'Debug'
-            cxxflags: '-stdlib=libc++'
-            ldflags: '-lc++'
-            server: "redis:8.2.1-alpine"
-
-          - toolset: clang-14
-            install: 'clang-14 libc++-14-dev libc++abi-14-dev'
-            container: ubuntu:22.04
-            cxxstd: '20'
-            build-type: 'Release'
-            cxxflags: '-stdlib=libc++'
-            ldflags: '-lc++'
-            server: "redis:8.2.1-alpine"
-          
-          - toolset: clang-19
-            install: 'clang-19'
-            container: ubuntu:24.04
-            cxxstd: '23'
-            build-type: 'Debug'
-            cxxflags: '-fsanitize=address -fsanitize=undefined -fno-sanitize-recover=all'
-            ldflags: '-fsanitize=address -fsanitize=undefined'
-            server: "redis:8.2.1-alpine"
-
-          - toolset: gcc-14
-            install: 'g++-14'
-            container: ubuntu:24.04
-            cxxstd: '23'
-            build-type: 'Debug'
-            cxxflags: '-DBOOST_ASIO_DISABLE_LOCAL_SOCKETS=1' # If a system had no UNIX socket support, we build correctly
-            server: "valkey/valkey:8.1.3-alpine"
-          
-          - toolset: gcc-14
-            install: 'g++-14'
-            container: ubuntu:24.04
-            cxxstd: '23'
-            build-type: 'Debug'
-            cxxflags: '-fsanitize=address -fsanitize=undefined -fno-sanitize-recover=all'
-            ldflags: '-fsanitize=address -fsanitize=undefined'
-            server: "valkey/valkey:8.1.3-alpine"
-
-    runs-on: ubuntu-latest
-    env:
-      CXXFLAGS: ${{matrix.cxxflags}} -Wall -Wextra
-      LDFLAGS:  ${{matrix.ldflags}}
-      CMAKE_BUILD_PARALLEL_LEVEL: 4
-    
-    steps:
-    - name: Checkout
-      uses: actions/checkout@v4
-    
-    - name: Set up the required containers
-      run: |
-        BUILDER_IMAGE=${{ matrix.container }} SERVER_IMAGE=${{ matrix.server }} docker compose -f tools/docker-compose.yml up -d --wait || (docker compose logs; exit 1)
-      
-    - name: Install dependencies
-      run: |
-        docker exec builder apt-get update
-        docker exec builder apt-get -y --no-install-recommends install \
-          git \
-          g++ \
-          libssl-dev \
-          make \
-          ca-certificates \
-          cmake \
-          protobuf-compiler \
-          python3 \
-          ${{ matrix.install }}
-
-    - name: Setup Boost
-      run: docker exec builder /boost-redis/tools/ci.py setup-boost --source-dir=/boost-redis
-
-    - name: Build a Boost distribution using B2
-      run: |
-        docker exec builder /boost-redis/tools/ci.py build-b2-distro \
-          --toolset ${{ matrix.toolset }}
-
-    - name: Build a Boost distribution using CMake
-      run: |
-        docker exec builder /boost-redis/tools/ci.py build-cmake-distro \
-          --build-type ${{ matrix.build-type }} \
-          --cxxstd ${{ matrix.cxxstd }} \
-          --toolset ${{ matrix.toolset }}
-
-    - name: Build the project tests
-      run: |
-        docker exec builder /boost-redis/tools/ci.py build-cmake-standalone-tests \
-          --build-type ${{ matrix.build-type }} \
-          --cxxstd ${{ matrix.cxxstd }} \
-          --toolset ${{ matrix.toolset }}
-  
-    - name: Run the project tests
-      run: |
-        docker exec builder /boost-redis/tools/ci.py run-cmake-standalone-tests \
-          --build-type ${{ matrix.build-type }}
-
-    - name: Run add_subdirectory tests
-      run: |
-        docker exec builder /boost-redis/tools/ci.py run-cmake-add-subdirectory-tests \
-          --build-type ${{ matrix.build-type }} \
-          --cxxstd ${{ matrix.cxxstd }} \
-          --toolset ${{ matrix.toolset }}
-
-    - name: Run find_package tests with the built cmake distribution
-      run: |
-        docker exec builder /boost-redis/tools/ci.py run-cmake-find-package-tests \
-          --build-type ${{ matrix.build-type }} \
-          --cxxstd ${{ matrix.cxxstd }} \
-          --toolset ${{ matrix.toolset }}
-
-    - name: Run find_package tests with the built b2 distribution
-      run: |
-        docker exec builder /boost-redis/tools/ci.py run-cmake-b2-find-package-tests \
-          --build-type ${{ matrix.build-type }} \
-          --cxxstd ${{ matrix.cxxstd }} \
-          --toolset ${{ matrix.toolset }}
-
-  posix-b2:
-    name: "B2 ${{ matrix.toolset }}"
-    defaults:
-      run:
-        shell: bash
-
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          - toolset: gcc-11
-            install: g++-11
-            cxxstd: "11,17,20" # Having C++11 shouldn't break the build
-            os: ubuntu-latest
-            container: ubuntu:22.04
-          - toolset: clang-14
-            install: clang-14
-            os: ubuntu-latest
-            container: ubuntu:22.04
-            cxxstd: "17,20"
+          - { toolset: gcc,   compiler: g++-11,     install: g++-11,   os: ubuntu-22.04, cxxflags: '-std=c++17', ldflags: '' }
+          - { toolset: gcc,   compiler: g++-11,     install: g++-11,   os: ubuntu-22.04, cxxflags: '-std=c++20', ldflags: '' }
+          - { toolset: clang, compiler: clang++-11, install: clang-11, os: ubuntu-22.04, cxxflags: '-std=c++17', ldflags: '' }
+          - { toolset: clang, compiler: clang++-11, install: clang-11, os: ubuntu-22.04, cxxflags: '-std=c++20', ldflags: '' }
+          - { toolset: clang, compiler: clang++-13, install: clang-13, os: ubuntu-22.04, cxxflags: '-std=c++17', ldflags: '' }
+          - { toolset: clang, compiler: clang++-13, install: clang-13, os: ubuntu-22.04, cxxflags: '-std=c++20', ldflags: '' }
+          - { toolset: clang, compiler: clang++-14, install: 'clang-14 libc++-14-dev libc++abi-14-dev', os: ubuntu-22.04, cxxflags: '-std=c++17 -stdlib=libc++', ldflags: '-lc++' }
+          - { toolset: clang, compiler: clang++-14, install: 'clang-14 libc++-14-dev libc++abi-14-dev', os: ubuntu-22.04, cxxflags: '-std=c++20 -stdlib=libc++', ldflags: '-lc++' }
    runs-on: ${{ matrix.os }}
-    container: ${{matrix.container}}
+    env:
+      CXXFLAGS: -g -O0 ${{matrix.cxxflags}} -Wall -Wextra
+      LDFLAGS:  ${{matrix.ldflags}}
    steps:
    - name: Checkout
-      uses: actions/checkout@v4
-
-    - name: Setup container environment
-      if: matrix.container
+      uses: actions/checkout@v3
+    - name: Install CMake
+      run: sudo apt-get -y install cmake
+    - name: Install protobuf
+      run: sudo apt-get -y install protobuf-compiler
+    - name: Install compiler
+      run: sudo apt-get install -y ${{ matrix.install }}
+    - name: Install Redis
+      run: sudo apt-get install -y redis-server
+    - name: Install boost
+      uses: MarkusJx/install-boost@v2.4.1
+      id: install-boost
+      with:
+        boost_version: 1.81.0
+        platform_version: 22.04
+    - name: Run CMake
      run: |
-        apt-get update
-        apt-get -y install sudo python3 git g++ libssl-dev
-
-    - name: Install dependencies
-      run: |
-        sudo apt-get update
-        sudo apt-get -y install python3 ${{ matrix.install }}
-
-    - name: Setup Boost
-      run: ./tools/ci.py setup-boost --source-dir=$(pwd)
-    
-    - name: Build and run project tests using B2
-      run: |
-        python3 tools/ci.py run-b2-tests \
-          --toolset ${{ matrix.toolset }} \
-          --cxxstd ${{ matrix.cxxstd }} \
-          --variant debug,release
-
-  # Checks that we don't have any errors in docs
-  check-docs:
-    name: Check docs
-    defaults:
-      run:
-        shell: bash
-
-    runs-on: ubuntu-latest
-    steps:
-    - name: Checkout
-      uses: actions/checkout@v4
-
-    - name: Setup Boost
-      run: ./tools/ci.py setup-boost --source-dir=$(pwd)
-    
-    - name: Build docs
-      run: |
-        cd ~/boost-root
-        ./b2 libs/redis/doc
-        [ -f ~/boost-root/libs/redis/doc/html/index.html ]
+        BOOST_ROOT=${{steps.install-boost.outputs.BOOST_ROOT}} cmake -DCMAKE_CXX_COMPILER="${{matrix.compiler}}" -DCMAKE_CXX_FLAGS="${{env.CXXFLAGS}}"  -DCMAKE_EXE_LINKER_FLAGS="${{env.LDFLAGS}}"
+    - name: Build
+      run: make
+    - name: Check
+      run: ctest --output-on-failure
--- a/.github/workflows/coverage.yml
+++ b/.github/workflows/coverage.yml
@@ -0,0 +1,47 @@
+name: Coverage
+
+on:
+  push:
+    branches:
+      - develop
+jobs:
+  posix:
+    defaults:
+      run:
+        shell: bash
+
+    runs-on: ubuntu-22.04
+    env:
+      CXX: g++-11
+      CXXFLAGS: -g -O0 -std=c++20 --coverage -fkeep-inline-functions -fkeep-static-functions
+      LDFLAGS: --coverage
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v3
+    - name: Install CMake
+      run: sudo apt-get -y install cmake
+    - name: Install lcov
+      run: sudo apt-get -y install lcov
+    - name: Install compiler
+      run: sudo apt-get -y install g++-11
+    - name: Install Redis
+      run: sudo apt-get -y install redis-server
+    - name: Install boost
+      uses: MarkusJx/install-boost@v2.4.1
+      id: install-boost
+      with:
+        boost_version: 1.81.0
+        platform_version: 22.04
+    - name: Run CMake
+      run: |
+        BOOST_ROOT=${{steps.install-boost.outputs.BOOST_ROOT}} cmake --preset coverage .
+    - name: Build
+      run: cmake --build --preset coverage
+    - name: Test
+      run: ctest --preset coverage
+    - name: Make the coverage file
+      run: cmake --build --preset coverage --target coverage
+    - name: Upload to codecov
+      run: |
+        bash <(curl -s https://codecov.io/bash) -f ./build/coverage/coverage.info || echo "Codecov did not collect coverage reports"
+
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,142 +1,264 @@
-cmake_minimum_required(VERSION 3.8...3.20)
+cmake_minimum_required(VERSION 3.14)
+
+#set_property(GLOBAL PROPERTY RULE_LAUNCH_COMPILE "${CMAKE_COMMAND} -E time")

 # determine whether it's main/root project
 # or being built under another project.
 if (NOT DEFINED BOOST_REDIS_MAIN_PROJECT)
-  set(BOOST_REDIS_MAIN_PROJECT OFF)
-  if (CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_SOURCE_DIR)
-    set(BOOST_REDIS_MAIN_PROJECT ON)
-  endif()
+   set(BOOST_REDIS_MAIN_PROJECT OFF)
+   if (CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_SOURCE_DIR)
+      set(BOOST_REDIS_MAIN_PROJECT ON)
+   endif()
 endif()

-project(boost_redis VERSION "${BOOST_SUPERPROJECT_VERSION}" LANGUAGES CXX)
+project(
+    boost_redis
+    VERSION 1.4.1
+    DESCRIPTION "A redis client library"
+    HOMEPAGE_URL "https://boostorg.github.io/redis/"
+    LANGUAGES CXX
+)
+
+option(BOOST_REDIS_INSTALL "Generate install targets." ${BOOST_REDIS_MAIN_PROJECT})
+option(BOOST_REDIS_TESTS "Build tests." ${BOOST_REDIS_MAIN_PROJECT})
+option(BOOST_REDIS_EXAMPLES "Build examples." ${BOOST_REDIS_MAIN_PROJECT})
+option(BOOST_REDIS_BENCHMARKS "Build benchmarks." ${BOOST_REDIS_MAIN_PROJECT})
+option(BOOST_REDIS_DOC "Generate documentations." ${BOOST_REDIS_MAIN_PROJECT})

-# Library
 add_library(boost_redis INTERFACE)
 add_library(Boost::redis ALIAS boost_redis)
-target_include_directories(boost_redis INTERFACE include)
+target_include_directories(boost_redis INTERFACE
+    $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}/include>
+    $<INSTALL_INTERFACE:include>
+)
+
+target_link_libraries(
+  boost_redis
+  INTERFACE
+    Boost::asio
+    Boost::assert
+    Boost::config
+    Boost::core
+    Boost::mp11
+    Boost::system
+    Boost::utility
+)
+
 target_compile_features(boost_redis INTERFACE cxx_std_17)

-# Dependencies
-if (BOOST_REDIS_MAIN_PROJECT)
-  # TODO: Understand why we have to list all dependencies below
-  # instead of
-  #set(BOOST_INCLUDE_LIBRARIES redis)
-  #set(BOOST_EXCLUDE_LIBRARIES redis)
-  #add_subdirectory(../.. boostorg/boost EXCLUDE_FROM_ALL)
+# Asio bases C++ feature detection on __cplusplus. Make MSVC
+# define it correctly
+if (MSVC)
+  target_compile_options(boost_redis INTERFACE /Zc:__cplusplus)
+endif()

-  set(deps
-    system
-    assert
-    config
-    throw_exception
-    asio
-    variant2
-    mp11
-    winapi
-    predef
-    align
-    context
-    core
-    static_assert
-    pool
-    date_time
-    smart_ptr
-    exception
-    integer
-    move
-    type_traits
-    algorithm
-    utility
-    io
-    lexical_cast
-    numeric/conversion
-    mpl
-    range
-    tokenizer
-    tuple
-    array
-    bind
-    concept_check
-    function
-    iterator
-    regex
-    unordered
-    preprocessor
-    container
-    conversion
-    container_hash
-    detail
-    optional
-    function_types
-    fusion
-    intrusive
-    describe
-    typeof
-    functional
-    test
-    json
-    endian
-    compat
-  )
+find_package(Boost 1.80 REQUIRED)

-  foreach(dep IN LISTS deps)
-    add_subdirectory(../${dep} boostorg/${dep})
-  endforeach()
+include_directories(${Boost_INCLUDE_DIRS})

-  find_package(Threads REQUIRED)
-  find_package(OpenSSL REQUIRED)
-  target_link_libraries(boost_redis
-    INTERFACE
-      Boost::system
-      Boost::asio
-      Threads::Threads
-      OpenSSL::Crypto
-      OpenSSL::SSL
-  )
-else()
-  # If we're in the superproject or called from add_subdirectory,
-  # Boost dependencies should be already available.
-  # If other dependencies are not found, we bail out
-  find_package(Threads)
-  if(NOT Threads_FOUND)
-    message(STATUS "Boost.Redis has been disabled, because the required package Threads hasn't been found")
-    return()
-  endif()
-  find_package(OpenSSL)
-  if(NOT OpenSSL_FOUND)
-    message(STATUS "Boost.Redis has been disabled, because the required package OpenSSL hasn't been found")
-    return()
+find_package(OpenSSL REQUIRED)
+
+include_directories(include)
+
+# Common
+#=======================================================================
+
+add_library(boost_redis_project_options INTERFACE)
+target_link_libraries(boost_redis_project_options INTERFACE OpenSSL::Crypto OpenSSL::SSL)
+if (MSVC)
+   target_compile_options(boost_redis_project_options INTERFACE /bigobj)
+   target_compile_definitions(boost_redis_project_options INTERFACE _WIN32_WINNT=0x0601)
+endif()
+
+add_library(boost_redis_src STATIC examples/boost_redis.cpp)
+target_compile_features(boost_redis_src PRIVATE cxx_std_17)
+target_link_libraries(boost_redis_src PRIVATE boost_redis_project_options)
+
+# Executables
+#=======================================================================
+
+if (BOOST_REDIS_BENCHMARKS)
+  add_library(benchmarks_options INTERFACE)
+  target_link_libraries(benchmarks_options INTERFACE boost_redis_src)
+  target_link_libraries(benchmarks_options INTERFACE boost_redis_project_options)
+  target_compile_features(benchmarks_options INTERFACE cxx_std_20)
+
+  add_executable(echo_server_client benchmarks/cpp/asio/echo_server_client.cpp)
+  target_link_libraries(echo_server_client PRIVATE benchmarks_options)
+
+  add_executable(echo_server_direct benchmarks/cpp/asio/echo_server_direct.cpp)
+  target_link_libraries(echo_server_direct PRIVATE benchmarks_options)
+endif()
+
+if (BOOST_REDIS_EXAMPLES)
+  add_library(examples_main STATIC examples/main.cpp)
+  target_compile_features(examples_main PRIVATE cxx_std_20)
+  target_link_libraries(examples_main PRIVATE boost_redis_project_options)
+
+  macro(make_example EXAMPLE_NAME STANDARD)
+    add_executable(${EXAMPLE_NAME} examples/${EXAMPLE_NAME}.cpp)
+    target_link_libraries(${EXAMPLE_NAME} PRIVATE boost_redis_src)
+    target_link_libraries(${EXAMPLE_NAME} PRIVATE boost_redis_project_options)
+    target_compile_features(${EXAMPLE_NAME} PRIVATE cxx_std_${STANDARD})
+    if (${STANDARD} STREQUAL "20")
+      target_link_libraries(${EXAMPLE_NAME} PRIVATE examples_main)
+    endif()
+  endmacro()
+
+  macro(make_testable_example EXAMPLE_NAME STANDARD)
+    make_example(${EXAMPLE_NAME} ${STANDARD})
+    add_test(${EXAMPLE_NAME} ${EXAMPLE_NAME})
+  endmacro()
+
+  make_testable_example(cpp17_intro 17)
+  make_testable_example(cpp17_intro_sync 17)
+
+  make_testable_example(cpp20_intro 20)
+  make_testable_example(cpp20_containers 20)
+  make_testable_example(cpp20_json 20)
+  make_testable_example(cpp20_intro_tls 20)
+
+  make_example(cpp20_subscriber 20)
+  make_example(cpp20_streams 20)
+  make_example(cpp20_echo_server 20)
+  make_example(cpp20_resolve_with_sentinel 20)
+
+  # We test the protobuf example only on gcc.
+  if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
+    find_package(Protobuf)
+    if (Protobuf_FOUND)
+       protobuf_generate_cpp(PROTO_SRCS PROTO_HDRS examples/person.proto)
+       make_testable_example(cpp20_protobuf 20)
+       target_sources(cpp20_protobuf PUBLIC ${PROTO_SRCS} ${PROTO_HDRS})
+       target_link_libraries(cpp20_protobuf PRIVATE  ${Protobuf_LIBRARIES})
+       target_include_directories(cpp20_protobuf PUBLIC ${Protobuf_INCLUDE_DIRS} ${CMAKE_CURRENT_BINARY_DIR})
+    endif()
  endif()

-  # This is generated by boostdep
-  target_link_libraries(boost_redis
-    INTERFACE
-      Boost::asio
-      Boost::assert
-      Boost::core
-      Boost::mp11
-      Boost::system
-      Boost::throw_exception
-      Threads::Threads
-      OpenSSL::Crypto
-      OpenSSL::SSL
+  if (NOT MSVC)
+     make_example(cpp20_chat_room 20)
+  endif()
+endif()
+
+if (BOOST_REDIS_TESTS)
+  enable_testing()
+
+  add_library(tests_common STATIC tests/common.cpp)
+  target_compile_features(tests_common PRIVATE cxx_std_17)
+  target_link_libraries(tests_common PRIVATE boost_redis_project_options)
+
+  macro(make_test TEST_NAME STANDARD)
+    add_executable(${TEST_NAME} tests/${TEST_NAME}.cpp)
+    target_link_libraries(${TEST_NAME} PRIVATE boost_redis_src tests_common)
+    target_link_libraries(${TEST_NAME} PRIVATE boost_redis_project_options)
+    target_compile_features(${TEST_NAME} PRIVATE cxx_std_${STANDARD})
+    add_test(${TEST_NAME} ${TEST_NAME})
+  endmacro()
+
+  make_test(test_conn_quit 17)
+  make_test(test_conn_tls 17)
+  make_test(test_low_level 17)
+  make_test(test_conn_exec_retry 17)
+  make_test(test_conn_exec_error 17)
+  make_test(test_request 17)
+  make_test(test_run 17)
+  make_test(test_low_level_sync 17)
+  make_test(test_low_level_sync_sans_io 17)
+  make_test(test_conn_check_health 17)
+
+  make_test(test_conn_exec 20)
+  make_test(test_conn_push 20)
+  make_test(test_conn_reconnect 20)
+  make_test(test_conn_exec_cancel 20)
+  make_test(test_conn_exec_cancel2 20)
+  make_test(test_conn_echo_stress 20)
+  make_test(test_low_level_async 20)
+  make_test(test_conn_run_cancel 20)
+  make_test(test_issue_50 20)
+endif()
+
+# Install
+#=======================================================================
+
+if (BOOST_REDIS_INSTALL)
+  install(TARGETS boost_redis
+      EXPORT boost_redis
+      PUBLIC_HEADER DESTINATION include COMPONENT Development
+  )
+  
+  include(CMakePackageConfigHelpers)
+  
+  configure_package_config_file(
+     "${PROJECT_SOURCE_DIR}/cmake/BoostRedisConfig.cmake.in"
+     "${PROJECT_BINARY_DIR}/BoostRedisConfig.cmake"
+      INSTALL_DESTINATION lib/cmake/boost/redis
+  )
+  
+  install(EXPORT boost_redis DESTINATION lib/cmake/boost/redis)
+  install(FILES "${PROJECT_BINARY_DIR}/BoostRedisConfigVersion.cmake"
+     "${PROJECT_BINARY_DIR}/BoostRedisConfig.cmake"
+       DESTINATION lib/cmake/boost/redis)
+  
+  install(DIRECTORY ${PROJECT_SOURCE_DIR}/include/ DESTINATION include)
+
+  include(CMakePackageConfigHelpers)
+  write_basic_package_version_file(
+    "${PROJECT_BINARY_DIR}/BoostRedisConfigVersion.cmake"
+    COMPATIBILITY AnyNewerVersion
+  )
+
+  include(CPack)
+endif()
+
+# Doxygen
+#=======================================================================
+
+if (BOOST_REDIS_DOC)
+  set(DOXYGEN_OUTPUT_DIRECTORY "${PROJECT_BINARY_DIR}/doc")
+  configure_file(doc/Doxyfile.in doc/Doxyfile @ONLY)
+  
+  add_custom_target(
+      doc
+      COMMAND doxygen "${PROJECT_BINARY_DIR}/doc/Doxyfile"
+      COMMENT "Building documentation using Doxygen"
+      WORKING_DIRECTORY "${PROJECT_SOURCE_DIR}"
+      VERBATIM
  )
 endif()

-# Enable testing. If we're being called from the superproject, this has already been done
-if (BOOST_REDIS_MAIN_PROJECT)
-  include(CTest)
-endif()
+# Coverage
+#=======================================================================

-# Most tests require a running Redis server, so we only run them if we're the main project
-if(BOOST_REDIS_MAIN_PROJECT AND BUILD_TESTING)
-  # Tests and common utilities
-  add_subdirectory(test)
+set(
+    COVERAGE_TRACE_COMMAND
+    lcov --capture
+    -output-file "${PROJECT_BINARY_DIR}/coverage.info"
+    --directory "${PROJECT_BINARY_DIR}"
+    --include "${PROJECT_SOURCE_DIR}/include/*"
+)

-  # Benchmarks. Build them with tests to prevent code rotting
-  add_subdirectory(benchmarks)
+set(
+    COVERAGE_HTML_COMMAND
+    genhtml --legend -f -q
+    "${PROJECT_BINARY_DIR}/coverage.info"
+    --prefix "${PROJECT_SOURCE_DIR}"
+    --output-directory "${PROJECT_BINARY_DIR}/coverage_html"
+)
+
+add_custom_target(
+    coverage
+    COMMAND ${COVERAGE_TRACE_COMMAND}
+    COMMAND ${COVERAGE_HTML_COMMAND}
+    COMMENT "Generating coverage report"
+    VERBATIM
+)
+
+# TODO
+#=======================================================================
+
+#.PHONY: bench
+#bench:
+#	pdflatex --jobname=echo-f0 benchmarks/benchmarks.tex
+#	pdflatex --jobname=echo-f1 benchmarks/benchmarks.tex
+# pdftoppm {input.pdf} {output.file} -png

-  # Examples
-  add_subdirectory(example)
-endif()
--- a/CMakePresets.json
+++ b/CMakePresets.json
@@ -0,0 +1,165 @@
+{
+  "version": 2,
+  "cmakeMinimumRequired": {
+    "major": 3,
+    "minor": 14,
+    "patch": 0
+  },
+  "configurePresets": [
+    {
+      "name": "cmake-pedantic",
+      "hidden": true,
+      "warnings": {
+        "dev": true,
+        "deprecated": true,
+        "uninitialized": true,
+        "unusedCli": true,
+        "systemVars": false
+      },
+      "errors": {
+        "dev": true,
+        "deprecated": true
+      }
+    },
+    {
+      "name": "coverage",
+      "generator": "Unix Makefiles",
+      "hidden": false,
+      "inherits": ["cmake-pedantic"],
+      "binaryDir": "${sourceDir}/build/coverage",
+      "cacheVariables": {
+        "CMAKE_BUILD_TYPE": "Coverage",
+        "CMAKE_CXX_EXTENSIONS": "OFF",
+        "CMAKE_CXX_FLAGS": "-Wall -Wextra",
+        "CMAKE_CXX_FLAGS_COVERAGE": "-Og -g --coverage -fkeep-inline-functions -fkeep-static-functions",
+        "CMAKE_CXX_STANDARD_REQUIRED": "ON",
+        "CMAKE_EXE_LINKER_FLAGS_COVERAGE": "--coverage",
+        "CMAKE_SHARED_LINKER_FLAGS_COVERAGE": "--coverage",
+        "PROJECT_BINARY_DIR": "${sourceDir}/build/coverage",
+        "COVERAGE_HTML_COMMAND": ""
+      }
+    },
+    {
+      "name": "g++-11",
+      "generator": "Unix Makefiles",
+      "hidden": false,
+      "inherits": ["cmake-pedantic"],
+      "binaryDir": "${sourceDir}/build/g++-11",
+      "cacheVariables": {
+        "CMAKE_BUILD_TYPE": "Debug",
+        "CMAKE_CXX_EXTENSIONS": "OFF",
+        "CMAKE_CXX_FLAGS": "-Wall -Wextra -fsanitize=address",
+        "CMAKE_CXX_COMPILER": "g++-11",
+        "CMAKE_SHARED_LINKER_FLAGS": "-fsanitize=address",
+        "CMAKE_CXX_STANDARD_REQUIRED": "ON",
+        "PROJECT_BINARY_DIR": "${sourceDir}/build/g++-11",
+        "DOXYGEN_OUTPUT_DIRECTORY": "${sourceDir}/build/g++-11/doc/"
+      }
+    },
+    {
+      "name": "g++-11-release",
+      "generator": "Unix Makefiles",
+      "hidden": false,
+      "inherits": ["cmake-pedantic"],
+      "binaryDir": "${sourceDir}/build/g++-11-release",
+      "cacheVariables": {
+        "CMAKE_BUILD_TYPE": "Release",
+        "CMAKE_CXX_EXTENSIONS": "OFF",
+        "CMAKE_CXX_FLAGS": "-Wall -Wextra",
+        "CMAKE_CXX_COMPILER": "g++-11",
+        "CMAKE_SHARED_LINKER_FLAGS": "",
+        "CMAKE_CXX_STANDARD_REQUIRED": "ON",
+        "PROJECT_BINARY_DIR": "${sourceDir}/build/g++-11-release",
+        "DOXYGEN_OUTPUT_DIRECTORY": "${sourceDir}/build/g++-11-release/doc/"
+      }
+    },
+    {
+      "name": "clang++-13",
+      "generator": "Unix Makefiles",
+      "hidden": false,
+      "inherits": ["cmake-pedantic"],
+      "binaryDir": "${sourceDir}/build/clang++-13",
+      "cacheVariables": {
+        "CMAKE_BUILD_TYPE": "Debug",
+        "CMAKE_CXX_EXTENSIONS": "OFF",
+        "CMAKE_CXX_FLAGS": "-Wall -Wextra -fsanitize=address",
+        "CMAKE_CXX_COMPILER": "clang++-13",
+        "CMAKE_SHARED_LINKER_FLAGS": "-fsanitize=address",
+        "CMAKE_CXX_STANDARD_REQUIRED": "ON",
+        "PROJECT_BINARY_DIR": "${sourceDir}/build/clang++-13",
+        "DOXYGEN_OUTPUT_DIRECTORY": "${sourceDir}/build/clang++-13/doc/"
+      }
+    },
+    {
+      "name": "libc++-14-cpp17",
+      "generator": "Unix Makefiles",
+      "hidden": false,
+      "inherits": ["cmake-pedantic"],
+      "binaryDir": "${sourceDir}/build/libc++-14-cpp17",
+      "cacheVariables": {
+        "CMAKE_BUILD_TYPE": "Debug",
+        "CMAKE_CXX_EXTENSIONS": "OFF",
+        "CMAKE_CXX_FLAGS": "-Wall -Wextra -stdlib=libc++ -std=c++17",
+        "CMAKE_EXE_LINKER_FLAGS": "-lc++",
+        "CMAKE_CXX_COMPILER": "clang++-14",
+        "CMAKE_SHARED_LINKER_FLAGS": "",
+        "CMAKE_CXX_STANDARD_REQUIRED": "ON",
+        "PROJECT_BINARY_DIR": "${sourceDir}/build/libc++-14-cpp17",
+        "DOXYGEN_OUTPUT_DIRECTORY": "${sourceDir}/build/libc++-14-cpp17/doc/"
+      }
+    },
+    {
+      "name": "libc++-14-cpp20",
+      "generator": "Unix Makefiles",
+      "hidden": false,
+      "inherits": ["cmake-pedantic"],
+      "binaryDir": "${sourceDir}/build/libc++-14-cpp20",
+      "cacheVariables": {
+        "CMAKE_BUILD_TYPE": "Debug",
+        "CMAKE_CXX_EXTENSIONS": "OFF",
+        "CMAKE_CXX_FLAGS": "-Wall -Wextra -stdlib=libc++ -std=c++17",
+        "CMAKE_EXE_LINKER_FLAGS": "-lc++",
+        "CMAKE_CXX_COMPILER": "clang++-14",
+        "CMAKE_SHARED_LINKER_FLAGS": "",
+        "CMAKE_CXX_STANDARD_REQUIRED": "ON",
+        "PROJECT_BINARY_DIR": "${sourceDir}/build/libc++-14-cpp20",
+        "DOXYGEN_OUTPUT_DIRECTORY": "${sourceDir}/build/libc++-14-cpp20/doc/"
+      }
+    },
+    {
+      "name": "clang-tidy",
+      "generator": "Unix Makefiles",
+      "hidden": false,
+      "inherits": ["g++-11"],
+      "binaryDir": "${sourceDir}/build/clang-tidy",
+      "cacheVariables": {
+        "CMAKE_CXX_CLANG_TIDY": "clang-tidy;--header-filter=${sourceDir}/include/*",
+        "CMAKE_CXX_STANDARD": "20"
+      }
+    }
+  ],
+  "buildPresets": [
+     { "name": "coverage", "configurePreset": "coverage" },
+     { "name": "g++-11", "configurePreset": "g++-11" },
+     { "name": "g++-11-release", "configurePreset": "g++-11-release" },
+     { "name": "clang++-13", "configurePreset": "clang++-13" },
+     { "name": "libc++-14-cpp17", "configurePreset": "libc++-14-cpp17" },
+     { "name": "libc++-14-cpp20", "configurePreset": "libc++-14-cpp20" },
+     { "name": "clang-tidy", "configurePreset": "clang-tidy" }
+  ],
+  "testPresets": [
+     {
+       "name": "test",
+       "hidden": true,
+       "output": {"outputOnFailure": true},
+       "execution": {"noTestsAction": "error", "stopOnFailure": true}
+     },
+     { "name": "coverage",        "configurePreset": "coverage",         "inherits": ["test"] },
+     { "name": "g++-11",          "configurePreset": "g++-11",           "inherits": ["test"] },
+     { "name": "g++-11-release",  "configurePreset": "g++-11-release",   "inherits": ["test"] },
+     { "name": "clang++-13",      "configurePreset": "clang++-13",       "inherits": ["test"] },
+     { "name": "libc++-14-cpp17", "configurePreset": "libc++-14-cpp17",  "inherits": ["test"] },
+     { "name": "libc++-14-cpp20", "configurePreset": "libc++-14-cpp20",  "inherits": ["test"] },
+     { "name": "clang-tidy",      "configurePreset": "clang-tidy",       "inherits": ["test"] }
+  ]
+}
--- a/README.md
+++ b/README.md
--- a/benchmarks/CMakeLists.txt
+++ b/benchmarks/CMakeLists.txt
@@ -1,20 +0,0 @@
-
-add_library(benchmarks_options INTERFACE)
-target_link_libraries(benchmarks_options INTERFACE boost_redis_src)
-target_link_libraries(benchmarks_options INTERFACE boost_redis_project_options)
-target_compile_features(benchmarks_options INTERFACE cxx_std_20)
-
-add_executable(echo_server_client cpp/asio/echo_server_client.cpp)
-target_link_libraries(echo_server_client PRIVATE benchmarks_options)
-
-add_executable(echo_server_direct cpp/asio/echo_server_direct.cpp)
-target_link_libraries(echo_server_direct PRIVATE benchmarks_options)
-
-# TODO
-#=======================================================================
-
-#.PHONY: bench
-#bench:
-#	pdflatex --jobname=echo-f0 benchmarks/benchmarks.tex
-#	pdflatex --jobname=echo-f1 benchmarks/benchmarks.tex
-# pdftoppm {input.pdf} {output.file} -png
--- a/benchmarks/cpp/asio/echo_server_client.cpp
+++ b/benchmarks/cpp/asio/echo_server_client.cpp
@@ -4,9 +4,8 @@
 * accompanying file LICENSE.txt)
 */

-#include <boost/asio.hpp>
-
 #include <iostream>
+#include <boost/asio.hpp>
 #if defined(BOOST_ASIO_HAS_CO_AWAIT)

 namespace net = boost::asio;
@@ -27,9 +26,9 @@ auto example(boost::asio::ip::tcp::endpoint ep, std::string msg, int n) -> net::
      auto dbuffer = net::dynamic_buffer(buffer);
      for (int i = 0; i < n; ++i) {
         co_await net::async_write(socket, net::buffer(msg));
-         auto bytes_read = co_await net::async_read_until(socket, dbuffer, "\n");
+         auto n = co_await net::async_read_until(socket, dbuffer, "\n");
         //std::printf("> %s", buffer.data());
-         dbuffer.consume(bytes_read);
+         dbuffer.consume(n);
      }

      //std::printf("Ok: %s", msg.data());
@@ -63,10 +62,6 @@ int main(int argc, char* argv[])
      std::cerr << e.what() << std::endl;
   }
 }
-#else   // defined(BOOST_ASIO_HAS_CO_AWAIT)
-auto main() -> int
-{
-   std::cout << "Requires coroutine support." << std::endl;
-   return 1;
-}
-#endif  // defined(BOOST_ASIO_HAS_CO_AWAIT)
+#else // defined(BOOST_ASIO_HAS_CO_AWAIT)
+auto main() -> int {std::cout << "Requires coroutine support." << std::endl; return 1;}
+#endif // defined(BOOST_ASIO_HAS_CO_AWAIT)
--- a/benchmarks/cpp/asio/echo_server_direct.cpp
+++ b/benchmarks/cpp/asio/echo_server_direct.cpp
@@ -8,10 +8,9 @@
 // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
 //

-#include <boost/asio.hpp>
-
 #include <cstdio>
 #include <iostream>
+#include <boost/asio.hpp>
 #if defined(BOOST_ASIO_HAS_CO_AWAIT)

 namespace net = boost::asio;
@@ -28,41 +27,37 @@ constexpr net::use_awaitable_t<executor_type> use_awaitable;

 awaitable_type echo(tcp_socket socket)
 {
-   try {
-      char data[1024];
-      for (;;) {
-         std::size_t n = co_await socket.async_read_some(net::buffer(data), use_awaitable);
-         co_await async_write(socket, net::buffer(data, n), use_awaitable);
-      }
-   } catch (std::exception const&) {
-      //std::printf("echo Exception: %s\n", e.what());
-   }
+  try {
+     char data[1024];
+     for (;;) {
+        std::size_t n = co_await socket.async_read_some(net::buffer(data), use_awaitable);
+        co_await async_write(socket, net::buffer(data, n), use_awaitable);
+     }
+  } catch (std::exception const&) {
+     //std::printf("echo Exception: %s\n", e.what());
+  }
 }

 awaitable_type listener()
 {
-   auto ex = co_await this_coro::executor;
-   tcp_acceptor acceptor(ex, {tcp::v4(), 55555});
-   for (;;) {
-      tcp_socket socket = co_await acceptor.async_accept(use_awaitable);
-      co_spawn(ex, echo(std::move(socket)), detached);
-   }
+  auto ex = co_await this_coro::executor;
+  tcp_acceptor acceptor(ex, {tcp::v4(), 55555});
+  for (;;) {
+     tcp_socket socket = co_await acceptor.async_accept(use_awaitable);
+     co_spawn(ex, echo(std::move(socket)), detached);
+  }
 }

 int main()
 {
-   try {
-      net::io_context io_context{BOOST_ASIO_CONCURRENCY_HINT_UNSAFE_IO};
-      co_spawn(io_context, listener(), detached);
-      io_context.run();
-   } catch (std::exception const& e) {
-      std::printf("Exception: %s\n", e.what());
-   }
+  try {
+     net::io_context io_context{BOOST_ASIO_CONCURRENCY_HINT_UNSAFE_IO};
+     co_spawn(io_context, listener(), detached);
+     io_context.run();
+  } catch (std::exception const& e) {
+     std::printf("Exception: %s\n", e.what());
+  }
 }
-#else   // defined(BOOST_ASIO_HAS_CO_AWAIT)
-auto main() -> int
-{
-   std::cout << "Requires coroutine support." << std::endl;
-   return 1;
-}
-#endif  // defined(BOOST_ASIO_HAS_CO_AWAIT)
+#else // defined(BOOST_ASIO_HAS_CO_AWAIT)
+auto main() -> int {std::cout << "Requires coroutine support." << std::endl; return 1;}
+#endif // defined(BOOST_ASIO_HAS_CO_AWAIT)
--- a/build.jam
+++ b/build.jam
@@ -1,28 +0,0 @@
-# Copyright René Ferdinand Rivera Morell 2024
-# Distributed under the Boost Software License, Version 1.0.
-# (See accompanying file LICENSE_1_0.txt or copy at
-# http://www.boost.org/LICENSE_1_0.txt)
-
-require-b2 5.2 ;
-
-constant boost_dependencies :
-    /boost/asio//boost_asio
-    /boost/assert//boost_assert
-    /boost/core//boost_core
-    /boost/mp11//boost_mp11
-    /boost/system//boost_system
-    /boost/throw_exception//boost_throw_exception ;
-
-project /boost/redis
-    : common-requirements
-        <include>include
-    ;
-
-explicit
-    [ alias boost_redis : : : : <library>$(boost_dependencies) ]
-    [ alias all : boost_redis test ]
-    ;
-
-call-if : boost-library redis
-    ;
-
--- a/cmake/BoostRedisConfig.cmake.in
+++ b/cmake/BoostRedisConfig.cmake.in
@@ -0,0 +1,4 @@
+@PACKAGE_INIT@
+
+include("${CMAKE_CURRENT_LIST_DIR}/Aedis.cmake")
+check_required_components("@PROJECT_NAME@")
--- a/doc/CMakeLists.txt
+++ b/doc/CMakeLists.txt
@@ -1,26 +0,0 @@
-#
-# Copyright (c) 2025 Ruben Perez Hidalgo (rubenperez038 at gmail dot com)
-#
-# Distributed under the Boost Software License, Version 1.0. (See accompanying
-# file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-#
-
-# Root CMakeLists.txt so MrDocs knows how to build our code
-cmake_minimum_required(VERSION 3.8...3.22)
-
-# Project
-project(boost_redis_mrdocs LANGUAGES CXX)
-
-# MrDocs forces CMAKE_EXPORT_COMPILE_COMMANDS=ON, incorrectly
-# causing all targets to be dumped to the compilation database.
-# Disable this setting so we can set EXPORT_COMPILE_COMMANDS
-# only to our target of interest
-set(CMAKE_EXPORT_COMPILE_COMMANDS OFF)
-
-# Add Boost
-add_subdirectory($ENV{BOOST_SRC_DIR} deps/boost)
-
-# Add the target for mrdocs to analyze
-add_executable(mrdocs mrdocs.cpp)
-target_link_libraries(mrdocs PRIVATE Boost::redis)
-set_target_properties(mrdocs PROPERTIES EXPORT_COMPILE_COMMANDS ON)
--- a/doc/Doxyfile.in
+++ b/doc/Doxyfile.in
--- a/doc/DoxygenLayout.xml
+++ b/doc/DoxygenLayout.xml
@@ -0,0 +1,226 @@
+<doxygenlayout version="1.0">
+  <!-- Generated by doxygen 1.9.1 -->
+  <!-- Navigation index tabs for HTML output -->
+  <navindex>
+    <tab type="mainpage" visible="yes" title="Contents"/>
+    <tab type="pages" visible="yes" title="" intro=""/>
+    <tab type="modules" visible="no" title="Reference" intro=""/>
+    <tab type="namespaces" visible="no" title="">
+      <tab type="namespacelist" visible="yes" title="" intro=""/>
+      <tab type="namespacemembers" visible="yes" title="" intro=""/>
+    </tab>
+    <tab type="interfaces" visible="no" title="">
+      <tab type="interfacelist" visible="yes" title="" intro=""/>
+      <tab type="interfaceindex" visible="$ALPHABETICAL_INDEX" title=""/> 
+      <tab type="interfacehierarchy" visible="yes" title="" intro=""/>
+    </tab>
+    <tab type="classes" visible="no" title="">
+      <tab type="classlist" visible="no" title="" intro=""/>
+      <tab type="classindex" visible="$ALPHABETICAL_INDEX" title=""/> 
+      <tab type="hierarchy" visible="no" title="" intro=""/>
+      <tab type="classmembers" visible="no" title="" intro=""/>
+    </tab>
+    <tab type="structs" visible="no" title="">
+      <tab type="structlist" visible="no" title="" intro=""/>
+      <tab type="structindex" visible="$ALPHABETICAL_INDEX" title=""/> 
+    </tab>
+    <tab type="exceptions" visible="no" title="">
+      <tab type="exceptionlist" visible="no" title="" intro=""/>
+      <tab type="exceptionindex" visible="$ALPHABETICAL_INDEX" title=""/> 
+      <tab type="exceptionhierarchy" visible="yes" title="" intro=""/>
+    </tab>
+    <tab type="files" visible="no" title="">
+      <tab type="filelist" visible="no" title="" intro=""/>
+      <tab type="globals" visible="no" title="" intro=""/>
+    </tab>
+    <tab type="examples" visible="yes" title="" intro=""/>  
+  </navindex>
+
+  <!-- Layout definition for a class page -->
+  <class>
+    <briefdescription visible="yes"/>
+    <includes visible="$SHOW_INCLUDE_FILES"/>
+    <inheritancegraph visible="$CLASS_GRAPH"/>
+    <collaborationgraph visible="$COLLABORATION_GRAPH"/>
+    <memberdecl>
+      <nestedclasses visible="yes" title=""/>
+      <publictypes title=""/>
+      <services title=""/>
+      <interfaces title=""/>
+      <publicslots title=""/>
+      <signals title=""/>
+      <publicmethods title=""/>
+      <publicstaticmethods title=""/>
+      <publicattributes title=""/>
+      <publicstaticattributes title=""/>
+      <protectedtypes title=""/>
+      <protectedslots title=""/>
+      <protectedmethods title=""/>
+      <protectedstaticmethods title=""/>
+      <protectedattributes title=""/>
+      <protectedstaticattributes title=""/>
+      <packagetypes title=""/>
+      <packagemethods title=""/>
+      <packagestaticmethods title=""/>
+      <packageattributes title=""/>
+      <packagestaticattributes title=""/>
+      <properties title=""/>
+      <events title=""/>
+      <privatetypes title=""/>
+      <privateslots title=""/>
+      <privatemethods title=""/>
+      <privatestaticmethods title=""/>
+      <privateattributes title=""/>
+      <privatestaticattributes title=""/>
+      <friends title=""/>
+      <related title="" subtitle=""/>
+      <membergroups visible="yes"/>
+    </memberdecl>
+    <detaileddescription title=""/>
+    <memberdef>
+      <inlineclasses title=""/>
+      <typedefs title=""/>
+      <enums title=""/>
+      <services title=""/>
+      <interfaces title=""/>
+      <constructors title=""/>
+      <functions title=""/>
+      <related title=""/>
+      <variables title=""/>
+      <properties title=""/>
+      <events title=""/>
+    </memberdef>
+    <allmemberslink visible="yes"/>
+    <usedfiles visible="$SHOW_USED_FILES"/>
+    <authorsection visible="yes"/>
+  </class>
+
+  <!-- Layout definition for a namespace page -->
+  <namespace>
+    <briefdescription visible="yes"/>
+    <memberdecl>
+      <nestednamespaces visible="yes" title=""/>
+      <constantgroups visible="yes" title=""/>
+      <interfaces visible="yes" title=""/>
+      <classes visible="yes" title=""/>
+      <structs visible="yes" title=""/>
+      <exceptions visible="yes" title=""/>
+      <typedefs title=""/>
+      <sequences title=""/>
+      <dictionaries title=""/>
+      <enums title=""/>
+      <functions title=""/>
+      <variables title=""/>
+      <membergroups visible="yes"/>
+    </memberdecl>
+    <detaileddescription title=""/>
+    <memberdef>
+      <inlineclasses title=""/>
+      <typedefs title=""/>
+      <sequences title=""/>
+      <dictionaries title=""/>
+      <enums title=""/>
+      <functions title=""/>
+      <variables title=""/>
+    </memberdef>
+    <authorsection visible="yes"/>
+  </namespace>
+
+  <!-- Layout definition for a file page -->
+  <file>
+    <briefdescription visible="yes"/>
+    <includes visible="$SHOW_INCLUDE_FILES"/>
+    <includegraph visible="$INCLUDE_GRAPH"/>
+    <includedbygraph visible="$INCLUDED_BY_GRAPH"/>
+    <sourcelink visible="yes"/>
+    <memberdecl>
+      <interfaces visible="yes" title=""/>
+      <classes visible="yes" title=""/>
+      <structs visible="yes" title=""/>
+      <exceptions visible="yes" title=""/>
+      <namespaces visible="yes" title=""/>
+      <constantgroups visible="yes" title=""/>
+      <defines title=""/>
+      <typedefs title=""/>
+      <sequences title=""/>
+      <dictionaries title=""/>
+      <enums title=""/>
+      <functions title=""/>
+      <variables title=""/>
+      <membergroups visible="yes"/>
+    </memberdecl>
+    <detaileddescription title=""/>
+    <memberdef>
+      <inlineclasses title=""/>
+      <defines title=""/>
+      <typedefs title=""/>
+      <sequences title=""/>
+      <dictionaries title=""/>
+      <enums title=""/>
+      <functions title=""/>
+      <variables title=""/>
+    </memberdef>
+    <authorsection/>
+  </file>
+
+  <!-- Layout definition for a group page -->
+  <group>
+    <briefdescription visible="yes"/>
+    <groupgraph visible="$GROUP_GRAPHS"/>
+    <memberdecl>
+      <nestedgroups visible="yes" title=""/>
+      <dirs visible="yes" title=""/>
+      <files visible="yes" title=""/>
+      <namespaces visible="yes" title=""/>
+      <classes visible="yes" title=""/>
+      <defines title=""/>
+      <typedefs title=""/>
+      <sequences title=""/>
+      <dictionaries title=""/>
+      <enums title=""/>
+      <enumvalues title=""/>
+      <functions title=""/>
+      <variables title=""/>
+      <signals title=""/>
+      <publicslots title=""/>
+      <protectedslots title=""/>
+      <privateslots title=""/>
+      <events title=""/>
+      <properties title=""/>
+      <friends title=""/>
+      <membergroups visible="yes"/>
+    </memberdecl>
+    <detaileddescription title=""/>
+    <memberdef>
+      <pagedocs/>
+      <inlineclasses title=""/>
+      <defines title=""/>
+      <typedefs title=""/>
+      <sequences title=""/>
+      <dictionaries title=""/>
+      <enums title=""/>
+      <enumvalues title=""/>
+      <functions title=""/>
+      <variables title=""/>
+      <signals title=""/>
+      <publicslots title=""/>
+      <protectedslots title=""/>
+      <privateslots title=""/>
+      <events title=""/>
+      <properties title=""/>
+      <friends title=""/>
+    </memberdef>
+    <authorsection visible="yes"/>
+  </group>
+
+  <!-- Layout definition for a directory page -->
+  <directory>
+    <briefdescription visible="yes"/>
+    <directorygraph visible="yes"/>
+    <memberdecl>
+      <dirs visible="yes"/>
+      <files visible="yes"/>
+    </memberdecl>
+    <detaileddescription title=""/>
+  </directory>
+</doxygenlayout>
--- a/doc/Jamfile
+++ b/doc/Jamfile
@@ -1,24 +0,0 @@
-#
-# Copyright (c) 2025 Ruben Perez Hidalgo (rubenperez038 at gmail dot com)
-#
-# Distributed under the Boost Software License, Version 1.0. (See accompanying
-# file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-#
-
-# Adapted from Boost.Unordered
-make html/index.html : build_antora.sh : @run-script ;
-
-# Runs the Antora script
-actions run-script
-{
-    bash -x $(>)
-}
-
-# These are used to inform the build system of the
-# means to build the integrated and stand-alone docs.
-
-alias boostdoc ;
-explicit boostdoc ;
-
-alias boostrelease : html/index.html ;
-explicit boostrelease ;
--- a/doc/antora.yml
+++ b/doc/antora.yml
@@ -1,15 +0,0 @@
-#
-# Copyright (c) 2025 Ruben Perez Hidalgo (rubenperez038 at gmail dot com)
-#
-# Distributed under the Boost Software License, Version 1.0. (See accompanying
-# file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-#
-
-name: redis
-title: Boost.Redis
-version: ~
-nav:
-  - modules/ROOT/nav.adoc
-ext:
-  cpp-reference:
-    config: doc/mrdocs.yml
--- a/doc/build_antora.sh
+++ b/doc/build_antora.sh
@@ -1,19 +0,0 @@
-#!/bin/bash
-#
-# Copyright (c) 2025 Ruben Perez Hidalgo (rubenperez038 at gmail dot com)
-#
-# Distributed under the Boost Software License, Version 1.0. (See accompanying
-# file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-#
-
-set -e
-
-SCRIPT_DIR=$( cd -- "$( dirname -- "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )
-cd "$SCRIPT_DIR"
-
-# Required by our CMake.
-# Prevents Antora from cloning Boost again
-export BOOST_SRC_DIR=$(realpath $SCRIPT_DIR/../../..)
-
-npm ci
-npx antora --log-format=pretty --stacktrace --log-level info redis-playbook.yml
--- a/doc/doxygen-awesome-sidebar-only.css
+++ b/doc/doxygen-awesome-sidebar-only.css
@@ -0,0 +1,115 @@
+/**
+
+Doxygen Awesome
+https://github.com/jothepro/doxygen-awesome-css
+
+MIT License
+
+Copyright (c) 2021 jothepro
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+ */
+
+html {
+    /* side nav width. MUST be = `TREEVIEW_WIDTH`.
+     * Make sure it is wide enough to contain the page title (logo + title + version)
+     */
+    --side-nav-fixed-width: 335px;
+    --menu-display: none;
+
+    --top-height: 120px;
+    --toc-sticky-top: -25px;
+    --toc-max-height: calc(100vh - 2 * var(--spacing-medium) - 25px);
+}
+
+#projectname {
+    white-space: nowrap;
+}
+
+
+@media screen and (min-width: 768px) {
+    html {
+        --searchbar-background: var(--page-background-color);
+    }
+
+    #side-nav {
+        min-width: var(--side-nav-fixed-width);
+        max-width: var(--side-nav-fixed-width);
+        top: var(--top-height);
+        overflow: visible;
+    }
+
+    #nav-tree, #side-nav {
+        height: calc(100vh - var(--top-height)) !important;
+    }
+
+    #nav-tree {
+        padding: 0;
+    }
+
+    #top {
+        display: block;
+        border-bottom: none;
+        height: var(--top-height);
+        margin-bottom: calc(0px - var(--top-height));
+        max-width: var(--side-nav-fixed-width);
+        overflow: hidden;
+        background: var(--side-nav-background);
+    }
+    #main-nav {
+        float: left;
+        padding-right: 0;
+    }
+
+    .ui-resizable-handle {
+        cursor: default;
+        width: 1px !important;
+        box-shadow: 0 calc(-2 * var(--top-height)) 0 0 var(--separator-color);
+    }
+
+    #nav-path {
+        position: fixed;
+        right: 0;
+        left: var(--side-nav-fixed-width);
+        bottom: 0;
+        width: auto;
+    }
+
+    #doc-content {
+        height: calc(100vh - 31px) !important;
+        padding-bottom: calc(3 * var(--spacing-large));
+        padding-top: calc(var(--top-height) - 80px);
+        box-sizing: border-box;
+        margin-left: var(--side-nav-fixed-width) !important;
+    }
+
+    #MSearchBox {
+        width: calc(var(--side-nav-fixed-width) - calc(2 * var(--spacing-medium)));
+    }
+
+    #MSearchField {
+        width: calc(var(--side-nav-fixed-width) - calc(2 * var(--spacing-medium)) - 65px);
+    }
+
+    #MSearchResultsWindow {
+        left: var(--spacing-medium) !important;
+        right: auto;
+    }
+}
--- a/doc/doxygen-awesome.css
+++ b/doc/doxygen-awesome.css
--- a/doc/modules/ROOT/nav.adoc
+++ b/doc/modules/ROOT/nav.adoc
@@ -1,12 +0,0 @@
-* xref:index.adoc[Introduction]
-* xref:requests_responses.adoc[]
-* xref:cancellation.adoc[]
-* xref:serialization.adoc[]
-* xref:logging.adoc[]
-* xref:sentinel.adoc[]
-* xref:benchmarks.adoc[]
-* xref:comparison.adoc[]
-* xref:examples.adoc[]
-* xref:reference.adoc[Reference]
-* xref:acknowledgements.adoc[]
-* xref:changelog.adoc[]
--- a/doc/modules/ROOT/pages/acknowledgements.adoc
+++ b/doc/modules/ROOT/pages/acknowledgements.adoc
@@ -1,37 +0,0 @@
-//
-// Copyright (c) 2025 Marcelo Zimbres Silva (mzimbres@gmail.com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-= Acknowledgements
-
-Acknowledgement to people that helped shape Boost.Redis
-
-* Richard Hodges (https://github.com/madmongo1[madmongo1]): For very helpful support with Asio, the design of asynchronous programs, etc.
-* Vinícius dos Santos Oliveira (https://github.com/vinipsmaker[vinipsmaker]): For useful discussion about how Boost.Redis consumes buffers in the read operation.
-* Petr Dannhofer (https://github.com/Eddie-cz[Eddie-cz]): For helping me understand how the `AUTH` and `HELLO` command can influence each other.
-* Mohammad Nejati (https://github.com/ashtum[ashtum]): For pointing out scenarios where calls to `async_exec` should fail when the connection is lost.
-* Klemens Morgenstern (https://github.com/klemens-morgenstern[klemens-morgenstern]): For useful discussion about timeouts, cancellation, synchronous interfaces and general help with Asio.
-* Vinnie Falco (https://github.com/vinniefalco[vinniefalco]): For general suggestions about how to improve the code and the documentation.
-* Bram Veldhoen (https://github.com/bveldhoen[bveldhoen]): For contributing a Redis-streams example.
-
-Also many thanks to all individuals that participated in the Boost
-review
-
-* Zach Laine: https://lists.boost.org/Archives/boost/2023/01/253883.php
-* Vinnie Falco: https://lists.boost.org/Archives/boost/2023/01/253886.php
-* Christian Mazakas: https://lists.boost.org/Archives/boost/2023/01/253900.php
-* Ruben Perez: https://lists.boost.org/Archives/boost/2023/01/253915.php
-* Dmitry Arkhipov: https://lists.boost.org/Archives/boost/2023/01/253925.php
-* Alan de Freitas: https://lists.boost.org/Archives/boost/2023/01/253927.php
-* Mohammad Nejati: https://lists.boost.org/Archives/boost/2023/01/253929.php
-* Sam Hartsfield: https://lists.boost.org/Archives/boost/2023/01/253931.php
-* Miguel Portilla: https://lists.boost.org/Archives/boost/2023/01/253935.php
-* Robert A.H. Leahy: https://lists.boost.org/Archives/boost/2023/01/253928.php
-
-The Reviews can be found at:
-https://lists.boost.org/Archives/boost/2023/01/date.php. The thread
-with the ACCEPT from the review manager can be found here:
-https://lists.boost.org/Archives/boost/2023/01/253944.php.
--- a/doc/modules/ROOT/pages/benchmarks.adoc
+++ b/doc/modules/ROOT/pages/benchmarks.adoc
@@ -1,95 +0,0 @@
-//
-// Copyright (c) 2025 Marcelo Zimbres Silva (mzimbres@gmail.com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-= Echo server benchmark
-
-This document benchmarks the performance of TCP echo servers I
-implemented in different languages using different Redis clients.  The
-main motivations for choosing an echo server are
-
-   * Simple to implement and does not require expertise level in most languages.
-   * I/O bound: Echo servers have very low CPU consumption in general
-     and  therefore are excellent to  measure how a program handles concurrent requests.
-   * It simulates very well a typical backend in regard to concurrency.
-
-I also imposed some constraints on the implementations
-
-   * It should be simple enough and not require writing too much code.
-   * Favor the use standard idioms and avoid optimizations that require expert level.
-   * Avoid the use of complex things like connection and thread pool.
-
-To reproduce these results run one of the echo-server programs in one
-terminal and the
-https://github.com/boostorg/redis/blob/42880e788bec6020dd018194075a211ad9f339e8/benchmarks/cpp/asio/echo_server_client.cpp[echo-server-client] in another.
-
-== Without Redis
-
-First I tested a pure TCP echo server, i.e. one that sends the messages
-directly to the client without interacting with Redis. The result can
-be seen below
-
-image::https://boostorg.github.io/redis/tcp-echo-direct.png[]
-
-The tests were performed with a 1000 concurrent TCP connections on the
-localhost where latency is 0.07ms on average on my machine. On higher
-latency networks the difference among libraries is expected to
-decrease. 
-
-   * I expected Libuv to have similar performance to Asio and Tokio.
-   * I did expect nodejs to come a little behind given it is is
-     javascript code. Otherwise I did expect it to have similar
-     performance to libuv since it is the framework behind it.
-   * Go did surprise me: faster than nodejs and libuv!
-
-The code used in the benchmarks can be found at
-
-   * https://github.com/boostorg/redis/blob/3fb018ccc6138d310ac8b73540391cdd8f2fdad6/benchmarks/cpp/asio/echo_server_direct.cpp[Asio]: A variation of https://github.com/chriskohlhoff/asio/blob/4915cfd8a1653c157a1480162ae5601318553eb8/asio/src/examples/cpp20/coroutines/echo_server.cpp[this Asio example].
-   * https://github.com/boostorg/redis/tree/835a1decf477b09317f391eddd0727213cdbe12b/benchmarks/c/libuv[Libuv]: Taken from https://github.com/libuv/libuv/blob/06948c6ee502862524f233af4e2c3e4ca876f5f6/docs/code/tcp-echo-server/main.c[this Libuv example].
-   * https://github.com/boostorg/redis/tree/3fb018ccc6138d310ac8b73540391cdd8f2fdad6/benchmarks/rust/echo_server_direct[Tokio]: Taken from https://docs.rs/tokio/latest/tokio/[here].
-   * https://github.com/boostorg/redis/tree/3fb018ccc6138d310ac8b73540391cdd8f2fdad6/benchmarks/nodejs/echo_server_direct[Nodejs]
-   * https://github.com/boostorg/redis/blob/3fb018ccc6138d310ac8b73540391cdd8f2fdad6/benchmarks/go/echo_server_direct.go[Go]
-
-== With Redis
-
-This is similar to the echo server described above but messages are
-echoed by Redis and not by the echo-server itself, which acts
-as a proxy between the client and the Redis server. The results
-can be seen below
-
-image::https://boostorg.github.io/redis/tcp-echo-over-redis.png[]
-
-The tests were performed on a network where latency is 35ms on
-average, otherwise it uses the same number of TCP connections
-as the previous example.
-
-As the reader can see, the Libuv and the Rust test are not depicted
-in the graph, the reasons are
-
-   * https://github.com/redis-rs/redis-rs[redis-rs]: This client
-     comes so far behind that it can't even be represented together
-     with the other benchmarks without making them look insignificant.
-     I don't know for sure why it is so slow, I suppose it has
-     something to do with its lack of automatic
-     https://redis.io/docs/manual/pipelining/[pipelining] support.
-     In fact, the more TCP connections I launch the worse its
-     performance gets.
-
-   * Libuv: I left it out because it would require me writing to much
-     c code. More specifically, I would have to use hiredis and
-     implement support for pipelines manually.
-
-The code used in the benchmarks can be found at
-
-   * https://github.com/boostorg/redis[Boost.Redis]: https://github.com/boostorg/redis/blob/3fb018ccc6138d310ac8b73540391cdd8f2fdad6/examples/echo_server.cpp[code]
-   * https://github.com/redis/node-redis[node-redis]: https://github.com/boostorg/redis/tree/3fb018ccc6138d310ac8b73540391cdd8f2fdad6/benchmarks/nodejs/echo_server_over_redis[code]
-   * https://github.com/go-redis/redis[go-redis]: https://github.com/boostorg/redis/blob/3fb018ccc6138d310ac8b73540391cdd8f2fdad6/benchmarks/go/echo_server_over_redis.go[code]
-
-
-== Conclusion
-
-Redis clients have to support automatic pipelining to have competitive performance. For updates to this document follow https://github.com/boostorg/redis[].
-
--- a/doc/modules/ROOT/pages/cancellation.adoc
+++ b/doc/modules/ROOT/pages/cancellation.adoc
@@ -1,79 +0,0 @@
-//
-// Copyright (c) 2025 Marcelo Zimbres Silva (mzimbres@gmail.com),
-// Ruben Perez Hidalgo (rubenperez038 at gmail dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-= Cancellation and timeouts
-
-By default, running a request with xref:reference:boost/redis/basic_connection/async_exec-02.adoc[`async_exec`]
-will wait until a connection to the Redis server is established by `async_run`.
-This may take a very long time if the server is down.
-
-For this reason, it is usually a good idea to set a timeout to `async_exec`
-operations using the
-https://www.boost.org/doc/libs/latest/doc/html/boost_asio/reference/cancel_after.html[`asio::cancel_after`]
-completion token:
-
-
-[source,cpp]
----
-using namespace std::chrono_literals;
-
-// Compose a request with a SET command
-request req;
-req.push("SET", "my_key", 42);
-
-// If the request hasn't completed after 10 seconds, it will be cancelled
-// and an exception will be thrown.
-co_await conn.async_exec(req, ignore, asio::cancel_after(10s));
----
-
-See our {site-url}/example/cpp20_timeouts.cpp[example on timeouts]
-for a full code listing.
-
-You can also use `cancel_after` with other completion styles, like
-callbacks and futures.
-
-`cancel_after` works because `async_exec` supports the per-operation
-cancellation mechanism. This is used by Boost.Asio to implement features
-like `cancel_after` and parallel groups. All asynchronous operations
-in the library support this mechanism. Please consult the documentation
-for individual operations for more info.
-
-
-== Retrying idempotent requests
-
-We mentioned that `async_exec` waits until the server is up
-before sending the request. But what happens if there is a communication
-error after sending the request, but before receiving a response?
-
-In this situation there is no way to know if the request was processed by the server or not.
-By default, the library will consider the request as failed,
-and `async_exec` will complete with an `asio::error::operation_aborted`
-error code.
-
-Some requests can be executed several times and result in the same outcome
-as executing them only once. We say that these requests are _idempotent_.
-The `SET` command is idempotent, while `INCR` is not.
-
-If you know that a `request` object contains only idempotent commands,
-you can instruct Boost.Redis to retry the request on failure, even
-if the library is unsure about the server having processed the request or not.
-You can do so by setting `cancel_if_unresponded`
-in xref:reference:boost/redis/request/config.adoc[`request::config`]
-to false:
-
-[source,cpp]
----
-// Compose a request
-request req;
-req.push("SET", "my_key", 42); // idempotent
-req.get_config().cancel_if_unresponded = false; // Retry the request even if it was written but not responded
-
-// Makes sure that the key is set, even in the presence of network errors.
-// This may suspend for an unspecified period of time if the server is down.
-co_await conn.async_exec(req, ignore);
----
--- a/doc/modules/ROOT/pages/changelog.adoc
+++ b/doc/modules/ROOT/pages/changelog.adoc
@@ -1,537 +0,0 @@
-//
-// Copyright (c) 2025 Marcelo Zimbres Silva (mzimbres@gmail.com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-= Changelog
-
-== Boost 1.90
-
-
-* (Pull request https://github.com/boostorg/redis/pull/310[310])
-  Improves the per-operation support in `async_exec()`. Requests can now
-  be cancelled at any point, and cancellations don't interfere with other
-  requests anyhow. In previous versions, a cancellation could cause
-  `async_run()` to be cancelled, making cancellations unpredictable.
-* (Issue https://github.com/boostorg/redis/issues/226[226])
-  Added support for the `asio::cancel_after` and `asio::cancel_at`
-  completion tokens in `async_exec()` and `async_run()`.
-* (Issue https://github.com/boostorg/redis/issues/319[319])
-  Added support for per-operation cancellation in `async_run()`.
-* (Pull request https://github.com/boostorg/redis/pull/329[329]
-  and https://github.com/boostorg/redis/pull/334[334])
-  The `cancel_on_connection_lost` and `cancel_if_not_connected`
-  flags in `request::config` have been deprecated, and will be removed
-  in subsequent releases. To limit the time span that `async_exec`
-  might take, use `asio::cancel_after`, instead.
-  `cancel_on_connection_lost` default has been changed to `false`.
-  This shouldn't cause much impact, since `cancel_on_connection_lost`
-  is not a reliable way to limit the time span that `async_exec` might take.
-* (Pull request https://github.com/boostorg/redis/pull/321[321])
-  Calling `cancel` with `operation::resolve`, `operation::connect`,
-  `operation::ssl_handshake`, `operation::reconnection` and
-  `operation::health_check` is now deprecated.
-  These enumerators will be removed in subsequent releases.
-  Users should employ `cancel(operation::run)`, instead.
-* (Issue github.com/boostorg/redis/issues/302[302] and
-  pull request https://github.com/boostorg/redis/pull/303[303])
-  Added support for custom setup requests using `config::setup`
-  and `config::use_setup`. When setting these fields, users can
-  replace the library-generated `HELLO` request by any other arbitrary request.
-  This request is executed every time a new physical connection with the server
-  is established. This feature can be used to interact with systems that don't
-  support `HELLO`, to handle authentication and to connect to replicas.
-* (Pull request https://github.com/boostorg/redis/pull/305[305])
-  `request::config::hello_with_priority` and `request::has_hello_priority()` have
-  been deprecated and will be removed in subsequent releases.
-  This flag is not well specified and should only be used by the library.
-  If you need to execute a request before any other, use `config::setup`, instead.
-* (Issue https://github.com/boostorg/redis/issues/296[296])
-  Valkey long-term support: we guarantee Valkey compatibility
-  starting with this release. Previous releases may also work,
-  but have not been tested with this database system.
-* (Issue https://github.com/boostorg/redis/issues/341[341])
-  Adds a `request::append()` function, to concatenate request objects.
-* (Issue https://github.com/boostorg/redis/issues/104[104])
-  The health checker algorithm has been redesigned to avoid
-  false positives under heavy loads. `PING` commands are now
-  only issued when the connection is idle, instead of periodically.
-* (Pull request https://github.com/boostorg/redis/pull/283[283])
-  Added `config::read_buffer_append_size`, which allows to control
-  the expansion of the connection's read buffer.
-* (Pull request https://github.com/boostorg/redis/pull/311[311])
-  Added `usage::bytes_rotated`, which measures data copying when
-  reading and parsing data from the server.
-* (Issue https://github.com/boostorg/redis/issues/298[298])
-  Added support for authenticating users with an empty password
-  but a non-default username.
-* (Issue https://github.com/boostorg/redis/issues/318[318])
-  Fixed a number of race conditions in the `cancel()` function
-  of `connection` and `basic_connection` that could cause
-  cancellations to be ignored.
-* (Issue https://github.com/boostorg/redis/issues/290[290])
-  Fixed a problem that could cause an error during `HELLO`
-  to make subsequent `HELLO` attempts during reconnection to fail.
-* (Issue https://github.com/boostorg/redis/issues/297[297])
-  Errors during `HELLO` are now correctly logged.
-* (Issue https://github.com/boostorg/redis/issues/287[287])
-  Fixed a bug causing an exception to be thrown when parsing
-  a response that contains an intermediate error into a `generic_response`.
-
-
-== Boost 1.89
-
-* (Pull request https://github.com/boostorg/redis/pull/256[256],
-   https://github.com/boostorg/redis/pull/266[266] and
-   https://github.com/boostorg/redis/pull/273[273])
-  The following members in `connection` and `basic_connection` are now deprecated
-  and will be removed in subsequent releases:
-  * `next_layer()` and `next_layer_type`: there is no reason to access the underlying stream object directly.
-    Connection member functions should be used, instead.
-  * `get_ssl_context()`: SSL contexts should never be modified after an `asio::ssl::stream`
-    object has been created from them. Properties should be set before passing the context
-    to the constructor. There is no reason to access the SSL context after that.
-  * `reset_stream()`: connection internals have been refactored to reset the SSL stream
-    automatically when required. This function is now a no-op.
-  * The `async_run()` overload taking no parameters: use the `async_run`
-    overload taking a `config` object explicitly, instead.
-* (Issue https://github.com/boostorg/redis/issues/213[213])
-  The logging interface has been re-written:
-  * Logging can now be customized by passing a function object
-    to the `logger` constructor. This allows integration with
-    third-party logging libraries, like spdlog.
-    This new logging interface is public and will be maintained long-term.
-  * The old, unstable interface consisting of `logger::on_xxx` functions has been removed.
-  * `connection` and `basic_connection` constructors now accept a `logger` object.
-    This is now the preferred way to configure logging.
-    The `async_run()` overload taking a `logger` object is now deprecated, and will
-    be removed in subsequent releases.
-  * `config::log_prefix` is now deprecated, and will
-    be removed in subsequent releases. Users can achieve the same effect
-    by passing a custom logging function to the `logger` constructor.
-  * The default logging function, which prints to `stderr`,
-    is now based on `printf` and is thus thread-safe.
-    The old function used `std::cerr` and could result to interleaved
-    output in multi-threaded programs.
-  * The default log level is now `logger::level::info`,
-    down from `logger::level::debug`. This results in less verbose output by default.
-* (Issue https://github.com/boostorg/redis/issues/272[272])
-  Added support for connecting to Redis using UNIX domain sockets.
-  This feature can be accessed using `config::unix_socket`.
-* (Issue https://github.com/boostorg/redis/issues/255[255])
-  Fixed an issue that caused `async_run` to complete when a connection
-  establishment error is encountered, even if `config::reconnect_wait_interval`
-  specified reconnection.
-* (Issue https://github.com/boostorg/redis/issues/265[265])
-  `connection::async_exec` now uses `ignore` as the default response,
-  rather than having no default response. This matches
-  `basic_connection::async_exec` behavior.
-* (Issue https://github.com/boostorg/redis/issues/260[260])
-  Fixed a memory corruption affecting the logger's prefix
-  configured in `config::log_prefix`.
-* (Pull request https://github.com/boostorg/redis/pull/254[254])
-  Fixed some warnings regarding unused variables, name shadowing
-  and narrowing conversions.
-* (Issue https://github.com/boostorg/redis/issues/252[252])
-  Fixed a bug that causes reconnection to ignore the reconnection
-  wait time configured in `config::reconnect_wait_interval`.
-* (Issue https://github.com/boostorg/redis/issues/238[238])
-  Fixed a bug introduced in Boost 1.88 that caused `response<T>` to
-  not compile for some integral types.
-* (Issue https://github.com/boostorg/redis/issues/247[247])
-  The documentation has been modernized, and a more complete
-  reference section has been added.
-* Part of the internals have been refactored to allow for better
-  testing and reduce compile times.
-
-
-== Boost 1.88
-
-* (Issue https://github.com/boostorg/redis/issues/233[233])
-  To deal with keys that might not exits in the Redis server, the
-  library supports `std::optional`, for example
-  `response<std::optional<std::vector<std::string>>>`. In some cases
-  however, such as the https://redis.io/docs/latest/commands/mget/[MGET] command,
-  each element in the vector might be non exiting, now it is possible
-  to specify a response as `response<std::optional<std::vector<std::optional<std::string>>>>`.
-
-* (Issue https://github.com/boostorg/redis/issues/225[225])
-  Use `deferred` as the connection default completion token.
-
-* (Issue https://github.com/boostorg/redis/issues/128[128])
-  Adds a new `async_exec` overload that allows passing response
-  adapters. This makes it possible to receive Redis responses directly
-  in custom data structures thereby avoiding unnecessary data copying.
-  Thanks to Ruben Perez (@anarthal) for implementing this feature.
-
-* There are also other multiple small improvements in this release,
-  users can refer to the git history for more details.
-
-== Boost 1.87
-
-* (Issue https://github.com/boostorg/redis/issues/205[205])
-  Improves reaction time to disconnection by using `wait_for_one_error`
-  instead of `wait_for_all`. The function `connection::async_run` was
-  also changed to return EOF to the user when that error is received
-  from the server. That is a breaking change.
-
-* (Issue https://github.com/boostorg/redis/issues/210[210])
-  Fixes the adapter of empty nested responses.
-
-* (Issues https://github.com/boostorg/redis/issues/211[211] and https://github.com/boostorg/redis/issues/212[212])
-  Fixes the reconnect loop that would hang under certain conditions,
-  see the linked issues for more details.
-
-* (Issue https://github.com/boostorg/redis/issues/219[219])
-  Changes the default log level from `disabled` to `debug`.
-
-== Boost 1.85
-
-* (Issue https://github.com/boostorg/redis/issues/170[170])
-  Under load and on low-latency networks it is possible to start
-  receiving responses before the write operation completed and while
-  the request is still marked as staged and not written. This messes
-  up with the heuristics that classifies responses as unsolicited or
-  not.
-
-* (Issue https://github.com/boostorg/redis/issues/168[168]).
-  Provides a way of passing a custom SSL context to the connection.
-  The design here differs from that of Boost.Beast and Boost.MySql
-  since in Boost.Redis the connection owns the context instead of only
-  storing a reference to a user provided one. This is ok so because
-  apps need only one connection for their entire application, which
-  makes the overhead of one ssl-context per connection negligible.
-
-* (Issue https://github.com/boostorg/redis/issues/181[181]).
-  See a detailed description of this bug in
-  https://github.com/boostorg/redis/issues/181#issuecomment-1913346983[this comment].
-
-* (Issue https://github.com/boostorg/redis/issues/182[182]).
-  Sets `"default"` as the default value of `config::username`. This
-  makes it simpler to use the `requirepass` configuration in Redis.
-
-* (Issue https://github.com/boostorg/redis/issues/189[189]).
-  Fixes narrowing conversion by using `std::size_t` instead of
-  `std::uint64_t` for the sizes of bulks and aggregates. The code
-  relies now on `std::from_chars` returning an error if a value
-  greater than 32 is received on platforms on which the size
-  of `std::size_t` is 32.
-
-
-== Boost 1.84 (First release in Boost)
-
-* Deprecates the `async_receive` overload that takes a response. Users
-  should now first call `set_receive_response` to avoid constantly and
-  unnecessarily setting the same response.
-
-* Uses `std::function` to type erase the response adapter. This change
-  should not influence users in any way but allowed important
-  simplification in the connections internals. This resulted in
-  massive performance improvement.
-
-* The connection has a new member `get_usage()` that returns the
-  connection usage information, such as number of bytes written,
-  received etc.
-
-* There are massive performance improvements in the consuming of
-  server pushes which are now communicated with an `asio::channel` and
-  therefore can be buffered which avoids blocking the socket read-loop.
-  Batch reads are also supported by means of `channel.try_send` and
-  buffered messages can be consumed synchronously with
-  `connection::receive`. The function `boost::redis::cancel_one` has
-  been added to simplify processing multiple server pushes contained
-  in the same `generic_response`.  *IMPORTANT*: These changes may
-  result in more than one push in the response when
-  `connection::async_receive` resumes. The user must therefore be
-  careful when calling `resp.clear()`: either ensure that all message
-  have been processed or just use `consume_one`.
-
-== v1.4.2 (incorporates changes to conform the boost review and more)
-
-* Adds `boost::redis::config::database_index` to make it possible to
-  choose a database before starting running commands e.g. after an
-  automatic reconnection.
-
-* Massive performance improvement. One of my tests went from
-  140k req/s to 390k/s. This was possible after a parser
-  simplification that reduced the number of reschedules and buffer
-  rotations.
-
-* Adds Redis stream example.
-
-* Renames the project to Boost.Redis and moves the code into namespace
-  `boost::redis`.
-
-* As pointed out in the reviews the `to_bulk` and `from_bulk` names were too
-  generic for ADL customization points. They gained the prefix `boost_redis_`.
-
-* Moves `boost::redis::resp3::request` to `boost::redis::request`.
-
-* Adds new typedef `boost::redis::response` that should be used instead of
-  `std::tuple`.
-
-* Adds new typedef `boost::redis::generic_response` that should be used instead
-  of `std::vector<resp3::node<std::string>>`.
-
-* Renames `redis::ignore` to `redis::ignore_t`.
-
-* Changes `async_exec` to receive a `redis::response` instead of an adapter,
-  namely, instead of passing `adapt(resp)` users should pass `resp` directly.
-
-* Introduces `boost::redis::adapter::result` to store responses to commands
-  including possible resp3 errors without losing the error diagnostic part. To
-  access values now use `std::get<N>(resp).value()` instead of
-  `std::get<N>(resp)`.
-
-* Implements full-duplex communication. Before these changes the connection
-  would wait for a response to arrive before sending the next one. Now requests
-  are continuously coalesced and written to the socket. `request::coalesce`
-  became unnecessary and was removed. I could measure significative performance
-  gains with these changes.
-
-* Improves serialization examples using Boost.Describe to serialize to JSON and protobuf. See
-  cpp20_json.cpp and cpp20_protobuf.cpp for more details.
-
-* Upgrades to Boost 1.81.0.
-
-* Fixes build with pass:[libc++].
-
-* Adds high-level functionality to the connection classes. For
-  example, `boost::redis::connection::async_run` will automatically
-  resolve, connect, reconnect and perform health checks.
-
-== v1.4.0-1
-
-* Renames `retry_on_connection_lost` to `cancel_if_unresponded`.  (v1.4.1)
-* Removes dependency on Boost.Hana, `boost::string_view`, Boost.Variant2 and Boost.Spirit.
-* Fixes build and setup CI on windows.
-
-== v1.3.0-1
-
-* Upgrades to Boost 1.80.0
-
-* Removes automatic sending of the `HELLO` command. This can't be
-  implemented properly without bloating the connection class. It is
-  now a user responsibility to send HELLO. Requests that contain it have
-  priority over other requests and will be moved to the front of the
-  queue, see `aedis::request::config` 
-
-* Automatic name resolving and connecting have been removed from
-  `aedis::connection::async_run`. Users have to do this step manually
-  now. The reason for this change is that having them built-in doesn't
-  offer enough flexibility that is need for boost users.
-
-* Removes healthy checks and idle timeout. This functionality must now
-  be implemented by users, see the examples. This is
-  part of making Aedis useful to a larger audience and suitable for
-  the Boost review process.
-
-* The `aedis::connection` is now using a typeddef to a
-  `net::ip::tcp::socket` and  `aedis::ssl::connection` to
-  `net::ssl::stream<net::ip::tcp::socket>`.  Users that need to use
-  other stream type must now specialize `aedis::basic_connection`.
-
-* Adds a low level example of async code.
-
-== v1.2.0
-
-* `aedis::adapt` supports now tuples created with `std::tie`.
-  `aedis::ignore` is now an alias to the type of `std::ignore`.
-
-* Provides allocator support for the internal queue used in the
-  `aedis::connection` class.
-
-* Changes the behaviour of `async_run` to complete with success if
-  asio::error::eof is received. This makes it easier to  write
-  composed operations with awaitable operators.
-
-* Adds allocator support in the `aedis::request` (a
-  contribution from Klemens Morgenstern).
-
-* Renames `aedis::request::push_range2` to `push_range`. The
-  suffix 2 was used for disambiguation. Klemens fixed it with SFINAE.
-
-* Renames `fail_on_connection_lost` to
-  `aedis::request::config::cancel_on_connection_lost`. Now, it will
-  only cause connections to be canceled when `async_run` completes.
-
-* Introduces `aedis::request::config::cancel_if_not_connected` which will
-  cause a request to be canceled if `async_exec` is called before a
-  connection has been established.
-
-* Introduces new request flag `aedis::request::config::retry` that if
-  set to true will cause the request to not be canceled when it was
-  sent to Redis but remained unresponded after `async_run` completed.
-  It provides a way to avoid executing commands twice.
-
-* Removes the `aedis::connection::async_run` overload that takes
-  request and adapter as parameters.
-
-* Changes the way `aedis::adapt()` behaves with
-  `std::vector<aedis::resp3::node<T>>`. Receiving RESP3 simple errors,
-  blob errors or null won't causes an error but will be treated as
-  normal response.  It is the user responsibility to check the content
-  in the vector.
-
-* Fixes a bug in `connection::cancel(operation::exec)`. Now this
-  call will only cancel non-written requests.
-
-* Implements per-operation implicit cancellation support for
-  `aedis::connection::async_exec`. The following call will `co_await (conn.async_exec(...) || timer.async_wait(...))`
-  will cancel the request as long as it has not been written.
-
-* Changes `aedis::connection::async_run` completion signature to
-  `f(error_code)`. This is how is was in the past, the second
-  parameter was not helpful.
-
-* Renames `operation::receive_push` to `aedis::operation::receive`.
-
-== v1.1.0-1
-
-* Removes `coalesce_requests` from the `aedis::connection::config`, it
-  became a request property now, see `aedis::request::config::coalesce`.
-
-* Removes `max_read_size` from the `aedis::connection::config`. The maximum
-  read size can be specified now as a parameter of the
-  `aedis::adapt()` function.
-
-* Removes `aedis::sync` class, see intro_sync.cpp for how to perform
-  synchronous and thread safe calls. This is possible in Boost. 1.80
-  only as it requires `boost::asio::deferred`. 
-
-* Moves from `boost::optional` to `std::optional`. This is part of
-  moving to pass:[C++17].
-
-* Changes the behaviour of the second `aedis::connection::async_run` overload
-  so that it always returns an error when the connection is lost.
-
-* Adds TLS support, see intro_tls.cpp.
-
-* Adds an example that shows how to resolve addresses over sentinels,
-  see subscriber_sentinel.cpp.
-
-* Adds a `aedis::connection::timeouts::resp3_handshake_timeout`. This is
-  timeout used to send the `HELLO` command.
-
-* Adds `aedis::endpoint` where in addition to host and port, users can
-  optionally provide username, password and the expected server role
-  (see `aedis::error::unexpected_server_role`).
-
-* `aedis::connection::async_run` checks whether the server role received in
-  the hello command is equal to the expected server role specified in
-  `aedis::endpoint`. To skip this check let the role variable empty.
-
-* Removes reconnect functionality from `aedis::connection`. It
-  is possible in simple reconnection strategies but bloats the class
-  in more complex scenarios, for example, with sentinel,
-  authentication and TLS. This is trivial to implement in a separate
-  coroutine. As a result the `enum event` and `async_receive_event`
-  have been removed from the class too.
-
-* Fixes a bug in `connection::async_receive_push` that prevented
-  passing any response adapter other that `adapt(std::vector<node>)`.
-
-* Changes the behaviour of `aedis::adapt()` that caused RESP3 errors
-  to be ignored. One consequence of it is that `connection::async_run`
-  would not exit with failure in servers that required authentication.
-
-* Changes the behaviour of `connection::async_run` that would cause it
-  to complete with success when an error in the
-  `connection::async_exec` occurred.
-
-* Ports the buildsystem from autotools to CMake.
-
-== v1.0.0
-
-* Adds experimental cmake support for windows users.
-
-* Adds new class `aedis::sync` that wraps an `aedis::connection` in
-  a thread-safe and synchronous API.  All free functions from the
-  `sync.hpp` are now member functions of `aedis::sync`.
-
-* Split `aedis::connection::async_receive_event` in two functions, one
-  to receive events and another for server side pushes, see
-  `aedis::connection::async_receive_push`.
-
-* Removes collision between `aedis::adapter::adapt` and
-  `aedis::adapt`.
-
-* Adds `connection::operation` enum to replace `cancel_*` member
-  functions with a single cancel function that gets the operations
-  that should be cancelled as argument.
-
-* Bugfix: a bug on reconnect from a state where the `connection` object
-  had unsent commands. It could cause `async_exec` to never
-  complete under certain conditions.
-
-* Bugfix: Documentation of `adapt()` functions were missing from
-  Doxygen.
-
-== v0.3.0
-
-* Adds `experimental::exec` and `receive_event` functions to offer a
-  thread safe and synchronous way of executing requests across
-  threads. See `intro_sync.cpp` and `subscriber_sync.cpp` for
-  examples.
-
-* `connection::async_read_push` was renamed to `async_receive_event`.
-
-* `connection::async_receive_event` is now being used to communicate
-  internal events to the user, such as resolve, connect, push etc. For
-  examples see cpp20_subscriber.cpp and `connection::event`.
-
-* The `aedis` directory has been moved to `include` to look more
-  similar to Boost libraries. Users should now replace `-I/aedis-path`
-  with `-I/aedis-path/include` in the compiler flags.
-
-* The `AUTH` and `HELLO` commands are now sent automatically. This change was
-  necessary to implement reconnection. The username and password
-  used in `AUTH` should be provided by the user on
-  `connection::config`.
-
-* Adds support for reconnection. See `connection::enable_reconnect`.
-
-* Fixes a bug in the `connection::async_run(host, port)` overload
-  that was causing crashes on reconnection.
-
-* Fixes the executor usage in the connection class. Before these
-  changes it was imposing `any_io_executor` on users.
-
-* `connection::async_receiver_event` is not cancelled anymore when
-  `connection::async_run` exits. This change makes user code simpler.
-
-* `connection::async_exec` with host and port overload has been
-  removed. Use the other `connection::async_run` overload.
-
-* The host and port parameters from `connection::async_run` have been
-  move to `connection::config` to better support authentication and
-  failover.
-
-* Many simplifications in the `chat_room` example.
-
-* Fixes build in clang the compilers and makes some improvements in
-  the documentation.
-
-== v0.2.0-1
-
-* Fixes a bug that happens on very high load. (v0.2.1) 
-* Major rewrite of the high-level API. There is no more need to use the low-level API anymore.
-* No more callbacks: Sending requests follows the ASIO asynchronous model.
-* Support for reconnection: Pending requests are not canceled when a connection is lost and are re-sent when a new one is established.
-* The library is not sending HELLO-3 on user behalf anymore. This is important to support AUTH properly.
-
-== v0.1.0-2
-
-* Adds reconnect coroutine in the `echo_server` example. (v0.1.2)
-* Corrects `client::async_wait_for_data` with `make_parallel_group` to launch operation. (v0.1.2)
-* Improvements in the documentation. (v0.1.2)
-* Avoids dynamic memory allocation in the client class after reconnection. (v0.1.2)
-* Improves the documentation and adds some features to the high-level client. (v.0.1.1)
-* Improvements in the design and documentation.
-
-== v0.0.1
-
-* First release to collect design feedback.
-
--- a/doc/modules/ROOT/pages/comparison.adoc
+++ b/doc/modules/ROOT/pages/comparison.adoc
@@ -1,121 +0,0 @@
-//
-// Copyright (c) 2025 Marcelo Zimbres Silva (mzimbres@gmail.com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-= Comparison with other Redis clients
-
-## Comparison
-
-The main reason for why I started writing Boost.Redis was to have a client
-compatible with the Asio asynchronous model. As I made progresses I could
-also address what I considered weaknesses in other libraries.  Due to
-time constraints I won't be able to give a detailed comparison with
-each client listed in the
-https://redis.io/docs/clients/#cpp[official list].
-Instead, I will focus on the most popular pass:[C++] client on github in number of stars, namely:
-
-https://github.com/sewenew/redis-plus-plus[]
-
-### Boost.Redis vs Redis-plus-plus
-
-Before we start it is important to mention some of the things
-redis-plus-plus does not support
-
-* The latest version of the communication protocol RESP3. Without that it is impossible to support some important Redis features like client side caching, among other things.
-* Coroutines.
-* Reading responses directly in user data structures to avoid creating temporaries.
-* Error handling with support for error-code.
-* Cancellation.
-
-The remaining points will be addressed individually.  Let us first
-have a look at what sending a command a pipeline and a transaction
-look like
-
-[source,cpp]
----
-auto redis = Redis("tcp://127.0.0.1:6379");
-
-// Send commands
-redis.set("key", "val");
-auto val = redis.get("key"); // val is of type OptionalString.
-if (val)
-    std::cout << *val << std::endl;
-
-// Sending pipelines
-auto pipe = redis.pipeline();
-auto pipe_replies = pipe.set("key", "value")
-                        .get("key")
-                        .rename("key", "new-key")
-                        .rpush("list", {"a", "b", "c"})
-                        .lrange("list", 0, -1)
-                        .exec();
-
-// Parse reply with reply type and index.
-auto set_cmd_result = pipe_replies.get<bool>(0);
-// ...
-
-// Sending a transaction
-auto tx = redis.transaction();
-auto tx_replies = tx.incr("num0")
-                    .incr("num1")
-                    .mget({"num0", "num1"})
-                    .exec();
-
-auto incr_result0 = tx_replies.get<long long>(0);
-// ...
----
-
-Some of the problems with this API are
-
-* Heterogeneous treatment of commands, pipelines and transaction. This makes auto-pipelining impossible.
-* Any Api that sends individual commands has a very restricted scope of usability and should be avoided for performance reasons.
-* The API imposes exceptions on users, no error-code overload is provided.
-* No way to reuse the buffer for new calls to e.g. redis.get in order to avoid further dynamic memory allocations.
-* Error handling of resolve and connection not clear.
-
-According to the documentation, pipelines in redis-plus-plus have
-the following characteristics
-
-> +NOTE+: By default, creating a Pipeline object is NOT cheap, since
-> it creates a new connection.
-
-This is clearly a downside in the API as pipelines should be the
-default way of communicating and not an exception, paying such a
-high price for each pipeline imposes a severe cost in performance.
-Transactions also suffer from the very same problem:
-
-> +NOTE+: Creating a Transaction object is NOT cheap, since it
-> creates a new connection.
-
-In Boost.Redis there is no difference between sending one command, a
-pipeline or a transaction because requests are decoupled
-from the I/O objects.
-
-> redis-plus-plus also supports async interface, however, async
-> support for Transaction and Subscriber is still on the way.
-> 
-> The async interface depends on third-party event library, and so
-> far, only libuv is supported.
-
-Async code in redis-plus-plus looks like the following
-
-[source,cpp]
----
-auto async_redis = AsyncRedis(opts, pool_opts);
-
-Future<string> ping_res = async_redis.ping();
-
-cout << ping_res.get() << endl;
----
-
-As the reader can see, the async interface is based on futures
-which is also known to have a bad performance.  The biggest
-problem however with this async design is that it makes it
-impossible to write asynchronous programs correctly since it
-starts an async operation on every command sent instead of
-enqueueing a message and triggering a write when it can be sent.
-It is also not clear how are pipelines realised with this design
-(if at all).
--- a/doc/modules/ROOT/pages/examples.adoc
+++ b/doc/modules/ROOT/pages/examples.adoc
@@ -1,27 +0,0 @@
-//
-// Copyright (c) 2025 Marcelo Zimbres Silva (mzimbres@gmail.com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-= Examples
-
-The examples below show how to use the features discussed throughout this documentation:
-
-* {site-url}/example/cpp20_intro.cpp[cpp20_intro.cpp]: Does not use awaitable operators.
-* {site-url}/example/cpp20_intro_tls.cpp[cpp20_intro_tls.cpp]: Communicates over TLS.
-* {site-url}/example/cpp20_unix_sockets.cpp[cpp20_unix_sockets.cpp]: Communicates over UNIX domain sockets.
-* {site-url}/example/cpp20_containers.cpp[cpp20_containers.cpp]: Shows how to send and receive STL containers and how to use transactions.
-* {site-url}/example/cpp20_json.cpp[cpp20_json.cpp]: Shows how to serialize types using Boost.Json.
-* {site-url}/example/cpp20_protobuf.cpp[cpp20_protobuf.cpp]: Shows how to serialize types using protobuf.
-* {site-url}/example/cpp20_sentinel.cpp[cpp20_sentinel.cpp]: Shows how to use the library with a Sentinel deployment.
-* {site-url}/example/cpp20_subscriber.cpp[cpp20_subscriber.cpp]: Shows how to implement pubsub with reconnection re-subscription.
-* {site-url}/example/cpp20_echo_server.cpp[cpp20_echo_server.cpp]: A simple TCP echo server.
-* {site-url}/example/cpp20_chat_room.cpp[cpp20_chat_room.cpp]: A command line chat built on Redis pubsub.
-* {site-url}/example/cpp17_intro.cpp[cpp17_intro.cpp]: Uses callbacks and requires pass:[C++17].
-* {site-url}/example/cpp17_intro_sync.cpp[cpp17_intro_sync.cpp]: Runs `async_run` in a separate thread and performs synchronous calls to `async_exec`.
-* {site-url}/example/cpp17_spdlog.cpp[cpp17_spdlog.cpp]: Shows how to use third-party logging libraries like `spdlog` with Boost.Redis.
-
-The main function used in some async examples has been factored out in
-the {site-url}/example/main.cpp[main.cpp] file.
--- a/doc/modules/ROOT/pages/index.adoc
+++ b/doc/modules/ROOT/pages/index.adoc
@@ -1,154 +0,0 @@
-//
-// Copyright (c) 2025 Marcelo Zimbres Silva (mzimbres@gmail.com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-[#intro]
-= Introduction
-
-Boost.Redis is a high-level https://redis.io/[Redis] and https://valkey.io/[Valkey]
-client library built on top of
-https://www.boost.org/doc/libs/latest/doc/html/boost_asio.html[Boost.Asio]
-that implements the Redis protocol
-https://github.com/redis/redis-specifications/blob/master/protocol/RESP3.md[RESP3].
-
-== Requirements
-
-The requirements for using Boost.Redis are:
-
-* Boost 1.84 or higher. Boost.Redis is included in Boost installations since Boost 1.84.
-* pass:[C++17] or higher. Supported compilers include gcc 11 and later, clang 11 and later, and Visual Studio 16 (2019) and later.
-* Redis 6 or higher, or Valkey (any version). The database server must support RESP3.
-  We intend to maintain compatibility with both Redis and Valkey in the long-run.
-* OpenSSL.
-
-The documentation assumes basic-level knowledge about https://redis.io/docs/[Redis] and https://www.boost.org/doc/libs/latest/doc/html/boost_asio.html[Boost.Asio].
-
-== Building the library
-
-To use the library it is necessary to include the following:
-
-[source,cpp]
----
-#include <boost/redis/src.hpp>
----
-
-in exactly one source file in your applications. Otherwise, the library is header-only.
-
-Boost.Redis unconditionally requires OpenSSL. Targets using Boost.Redis need to link
-to the OpenSSL libraries.
-
-== Tutorial
-
-The code below uses a short-lived connection to
-https://redis.io/commands/ping/[ping] a Redis server:
-
-
-[source,cpp]
----
-#include <boost/redis/connection.hpp>
-#include <boost/asio/co_spawn.hpp>
-#include <boost/asio/consign.hpp>
-#include <boost/asio/detached.hpp>
-#include <iostream>
-
-namespace net = boost::asio;
-using boost::redis::request;
-using boost::redis::response;
-using boost::redis::config;
-using boost::redis::connection;
-
-auto co_main(config const& cfg) -> net::awaitable<void>
-{
-   auto conn = std::make_shared<connection>(co_await net::this_coro::executor);
-   conn->async_run(cfg, {}, net::consign(net::detached, conn));
-
-   // A request containing only a ping command.
-   request req;
-   req.push("PING", "Hello world");
-
-   // Response object.
-   response<std::string> resp;
-
-   // Executes the request.
-   co_await conn->async_exec(req, resp);
-   conn->cancel();
-
-   std::cout << "PING: " << std::get<0>(resp).value() << std::endl;
-}
----
-
-The roles played by the `async_run` and `async_exec` functions are:
-
-* xref:reference:boost/redis/basic_connection/async_exec-02.adoc[`connection::async_exec`]: executes the commands contained in the
-  request and stores the individual responses in the response object. Can
-  be called from multiple places in your code concurrently.
-* xref:reference:boost/redis/basic_connection/async_run-04.adoc[`connection::async_run`]: keeps the connection healthy. It takes care of hostname resolution, session establishment, health-checks, reconnection and coordination of low-level read and write operations. It should be called only once per connection, regardless of the number of requests to execute.
-
-== Server pushes
-
-Redis servers can also send a variety of pushes to the client. Some of
-them are:
-
-* https://redis.io/docs/manual/pubsub/[Pubsub messages].
-* https://redis.io/docs/manual/keyspace-notifications/[Keyspace notifications].
-* https://redis.io/docs/manual/client-side-caching/[Client-side caching].
-
-The connection class supports server pushes by means of the
-xref:reference:boost/redis/basic_connection/async_receive.adoc[`connection::async_receive2`] function, which can be
-called in the same connection that is being used to execute commands.
-The coroutine below shows how to use it
-
-
-[source,cpp]
----
-auto receiver(std::shared_ptr<connection> conn) -> asio::awaitable<void>
-{
-   generic_flat_response resp;
-   conn->set_receive_response(resp);
-
-   // Subscribe to the channel 'mychannel'. You can add any number of channels here.
-   request req;
-   req.subscribe({"mychannel"});
-   co_await conn->async_exec(req);
-
-   // You're now subscribed to 'mychannel'. Pushes sent over this channel will be stored
-   // in resp. If the connection encounters a network error and reconnects to the server,
-   // it will automatically subscribe to 'mychannel' again. This is transparent to the user.
-   // You need to use specialized request::subscribe() function (instead of request::push)
-   // to enable this behavior.
-
-   // Loop to read Redis push messages.
-   while (conn->will_reconnect()) {
-      // Wait for pushes
-      auto [ec] = co_await conn->async_receive2(asio::as_tuple);
-
-      // Check for errors and cancellations
-      if (ec) {
-         std::cerr << "Error during receive: " << ec << std::endl;
-         break;
-      }
-
-      // The response must be consumed without suspending the
-      // coroutine i.e. without the use of async operations.
-      for (auto const& elem : resp.value())
-         std::cout << elem.value << "\n";
-
-      std::cout << std::endl;
-
-      resp.value().clear();
-   }
-}
----
-
-== Further reading
-
-Here is a list of topics that you might be interested in:
-
-* xref:cancellation.adoc[Setting timeouts to requests and managing cancellation].
-* xref:requests_responses.adoc[More on requests and responses].
-* xref:serialization.adoc[Serializing and parsing into custom types].
-* xref:logging.adoc[Configuring logging].
-* xref:examples.adoc[Examples].
--- a/doc/modules/ROOT/pages/logging.adoc
+++ b/doc/modules/ROOT/pages/logging.adoc
@@ -1,45 +0,0 @@
-//
-// Copyright (c) 2025 Marcelo Zimbres Silva (mzimbres@gmail.com),
-// Ruben Perez Hidalgo (rubenperez038 at gmail dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-= Logging
-
-xref:reference:boost/redis/basic_connection/async_run-04.adoc[`connection::async_run`]
-is a complex algorithm, with features like built-in reconnection.
-This can make configuration problems, like a misconfigured hostname, difficult to debug -
-Boost.Redis will keep retrying to connect to the same hostname over and over.
-For this reason, Boost.Redis incorporates a lightweight logging solution, and
-*will log some status messages to stderr by default*.
-
-Logging can be customized by passing a
-xref:reference:boost/redis/logger.adoc[`logger`] object to the connection's constructor. For example, logging can be disabled by writing:
-
-[source,cpp]
----
-asio::io_context ioc;
-connection conn {ioc, logger{logger::level::disabled}};
----
-
-Every message logged by the library is attached a
-https://en.wikipedia.org/wiki/Syslog#Severity_level[syslog-like severity]
-tag (a xref:reference:boost/redis/logger/level.adoc[`logger::level`]).
-You can filter messages by severity by creating a `logger` with a specific level:
-
-[source,cpp]
----
-asio::io_context ioc;
-
-// Logs to stderr messages with severity >= level::error.
-// This will hide all informational output.
-connection conn {ioc, logger{logger::level::error}};
----
-
-The `logger` constructor accepts a `std::function<void(logger::level, std::string_view)>`
-as second argument. If supplied, Boost.Redis will call this function when logging
-instead of printing to stderr. This can be used to integrate third-party logging
-libraries. See our {site-url}/example/cpp17_spdlog.cpp[spdlog integration example]
-for sample code.
--- a/doc/modules/ROOT/pages/reference.adoc
+++ b/doc/modules/ROOT/pages/reference.adoc
@@ -1,104 +0,0 @@
-//
-// Copyright (c) 2025 Marcelo Zimbres Silva (mzimbres@gmail.com),
-// Ruben Perez Hidalgo (rubenperez038 at gmail dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-[#reference]
-= Reference
-
-[width=100%,cols="5*"]
-|===
-
-| *Connections*
-| *Requests and responses*
-| *Adapters*
-| *RESP3 protocol*
-| *Unstable low-level APIs*
-
-|
-xref:reference:boost/redis/connection.adoc[`connection`]
-
-xref:reference:boost/redis/basic_connection.adoc[`basic_connection`]
-
-xref:reference:boost/redis/address.adoc[`address`]
-
-xref:reference:boost/redis/role.adoc[`role`]
-
-xref:reference:boost/redis/config.adoc[`config`]
-
-xref:reference:boost/redis/sentinel_config.adoc[`sentinel_config`]
-
-xref:reference:boost/redis/error.adoc[`error`]
-
-xref:reference:boost/redis/logger.adoc[`logger`]
-
-xref:reference:boost/redis/logger/level.adoc[`logger::level`]
-
-xref:reference:boost/redis/operation.adoc[`operation`]
-
-xref:reference:boost/redis/usage.adoc[`usage`]
-
-
-|
-xref:reference:boost/redis/ignore_t.adoc[`ignore_t`]
-
-xref:reference:boost/redis/ignore.adoc[`ignore`]
-
-xref:reference:boost/redis/request.adoc[`request`]
-
-xref:reference:boost/redis/request/config.adoc[`request::config`]
-
-xref:reference:boost/redis/response.adoc[`response`]
-
-xref:reference:boost/redis/generic_response.adoc[`generic_response`]
-
-xref:reference:boost/redis/generic_flat_response.adoc[`generic_flat_response`]
-
-xref:reference:boost/redis/consume_one-08.adoc[`consume_one`]
-
-
-|
-xref:reference:boost/redis/adapter/boost_redis_adapt.adoc[`boost_redis_adapt`]
-
-xref:reference:boost/redis/adapter/ignore.adoc[`adapter::ignore`]
-
-xref:reference:boost/redis/adapter/error.adoc[`adapter::error`]
-
-xref:reference:boost/redis/adapter/result.adoc[`adapter::result`]
-
-xref:reference:boost/redis/any_adapter.adoc[`any_adapter`]
-
-|
-xref:reference:boost/redis/resp3/basic_node.adoc[`resp3::basic_node`]
-
-xref:reference:boost/redis/resp3/node.adoc[`resp3::node`]
-
-xref:reference:boost/redis/resp3/node_view.adoc[`resp3::node_view`]
-
-xref:reference:boost/redis/resp3/basic_tree.adoc[`resp3::basic_tree`]
-
-xref:reference:boost/redis/resp3/tree.adoc[`resp3::tree`]
-
-xref:reference:boost/redis/resp3/view_tree.adoc[`resp3::view_tree`]
-
-xref:reference:boost/redis/resp3/flat_tree.adoc[`resp3::flat_tree`]
-
-xref:reference:boost/redis/resp3/boost_redis_to_bulk-08.adoc[`boost_redis_to_bulk`]
-
-xref:reference:boost/redis/resp3/type.adoc[`resp3::type`]
-
-xref:reference:boost/redis/resp3/is_aggregate.adoc[`resp3::is_aggregate`]
-
-
-|
-
-xref:reference:boost/redis/adapter/adapt2.adoc[`adapter::adapt2`]
-
-xref:reference:boost/redis/resp3/parser.adoc[`resp3::parser`]
-
-xref:reference:boost/redis/resp3/parse.adoc[`resp3::parse`]
-
-|===
--- a/doc/modules/ROOT/pages/requests_responses.adoc
+++ b/doc/modules/ROOT/pages/requests_responses.adoc
@@ -1,303 +0,0 @@
-//
-// Copyright (c) 2025 Marcelo Zimbres Silva (mzimbres@gmail.com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-= Requests and responses
-
-== Requests
-
-Redis requests are composed of one or more commands. In the
-Redis documentation, requests are called
-https://redis.io/topics/pipelining[pipelines]. For example:
-
-[source,cpp]
----
-// Some example containers.
-std::list<std::string> list {...};
-std::map<std::string, mystruct> map { ...};
-
-// The request can contain multiple commands.
-request req;
-
-// Command with variable length of arguments.
-req.push("SET", "key", "some value", "EX", "2");
-
-// Pushes a list.
-req.push_range("SUBSCRIBE", list);
-
-// Same as above but as an iterator range.
-req.push_range("SUBSCRIBE", std::cbegin(list), std::cend(list));
-
-// Pushes a map.
-req.push_range("HSET", "key", map);
----
-
-Sending a request to Redis is performed by
-xref:reference:boost/redis/basic_connection/async_exec-02.adoc[`connection::async_exec`]
-as already stated. Requests accept a xref:reference:boost/redis/request/config.adoc[`boost::redis::request::config`]
-object when constructed that dictates how requests are handled in situations like
-reconnection. The reader is advised to read it carefully.
-
-## Responses
-
-Boost.Redis uses the following strategy to deal with Redis responses:
-
-* xref:reference:boost/redis/response.adoc[`boost::redis::response`] should be used
-  when the request's number of commands is known at compile-time.
-* xref:reference:boost/redis/generic_response.adoc[`boost::redis::generic_response`] should be
-  used when the number of commands is dynamic.
-
-For example, the request below has three commands:
-
-[source,cpp]
----
-request req;
-req.push("PING");
-req.push("INCR", "key");
-req.push("QUIT");
----
-
-Therefore, its response will also contain three elements.
-The following response object can be used:
-
-[source,cpp]
----
-response<std::string, int, std::string>
----
-
-The response behaves as a `std::tuple` and must
-have as many elements as the request has commands (exceptions below).
-It is also necessary that each tuple element is capable of storing the
-response to the command it refers to, otherwise an error will occur.
-
-To ignore responses to individual commands in the request use the tag
-xref:reference:boost/redis/ignore_t.adoc[`boost::redis::ignore_t`]. For example:
-
-[source,cpp]
----
-// Ignore the second and last responses.
-response<std::string, ignore_t, std::string, ignore_t>
----
-
-The following table provides the RESP3-types returned by some Redis
-commands:
-
-[cols="3*"]
-|===
-
-| *Command* | *RESP3 type* | *Documentation*
-
-| `lpush`    | Number                              | https://redis.io/commands/lpush[]
-| `lrange`   | Array                               | https://redis.io/commands/lrange[]
-| `set`      | Simple-string, null or blob-string  | https://redis.io/commands/set[]
-| `get`      | Blob-string                         | https://redis.io/commands/get[]
-| `smembers` | Set                                 | https://redis.io/commands/smembers[]
-| `hgetall`  | Map                                 | https://redis.io/commands/hgetall[]
-
-|===
-
-To map these RESP3 types into a pass:[C++] data structure use the table below:
-
-[cols="3*"]
-|===
-
-| *RESP3 type*   | *Possible pass:[C++] type*                                        | *Type*
-
-| Simple-string  | `std::string`                                              | Simple
-| Simple-error   | `std::string`                                              | Simple
-| Blob-string    | `std::string`, `std::vector`                               | Simple
-| Blob-error     | `std::string`, `std::vector`                               | Simple
-| Number         | `long long`, `int`, `std::size_t`, `std::string`           | Simple
-| Double         | `double`, `std::string`                                    | Simple
-| Null           | `std::optional<T>`                                         | Simple
-| Array          | `std::vector`, `std::list`, `std::array`, `std::deque`     | Aggregate
-| Map            | `std::vector`, `std::map`, `std::unordered_map`            | Aggregate
-| Set            | `std::vector`, `std::set`, `std::unordered_set`            | Aggregate
-| Push           | `std::vector`, `std::map`, `std::unordered_map`            | Aggregate
-
-|===
-
-For example, the response to the request
-
-[source,cpp]
----
-request req;
-req.push("HELLO", 3);
-req.push_range("RPUSH", "key1", vec);
-req.push_range("HSET", "key2", map);
-req.push("LRANGE", "key3", 0, -1);
-req.push("HGETALL", "key4");
-req.push("QUIT");
----
-
-Can be read in the following response object:
-
-[source,cpp]
----
-response<
-   redis::ignore_t,  // hello
-   int,              // rpush
-   int,              // hset
-   std::vector<T>,   // lrange
-   std::map<U, V>,   // hgetall
-   std::string       // quit
-> resp;
----
-
-To execute the request and read the response use
-xref:reference:boost/redis/basic_connection/async_exec-02.adoc[`async_exec`]:
-
-[source,cpp]
----
-co_await conn->async_exec(req, resp);
----
-
-If the intention is to ignore responses altogether, use
-xref:reference:boost/redis/ignore.adoc[`ignore`]:
-
-[source,cpp]
----
-// Ignores the response
-co_await conn->async_exec(req, ignore);
----
-
-Responses that contain nested aggregates or heterogeneous data
-types will be given special treatment later in xref:#the-general-case[the general case].  As
-of this writing, not all RESP3 types are used by the Redis server,
-which means in practice users will be concerned with a reduced
-subset of the RESP3 specification.
-
-### Pushes
-
-Commands that have no response, like
-
-* `"SUBSCRIBE"`
-* `"PSUBSCRIBE"`
-* `"UNSUBSCRIBE"`
-
-must **NOT** be included in the response tuple. For example, the following request
-
-[source,cpp]
----
-request req;
-req.push("PING");
-req.subscribe({"channel"});
-req.push("QUIT");
----
-
-must be read in the response object `response<std::string, std::string>`.
-
-### Null
-
-It is not uncommon for apps to access keys that do not exist or that
-have already expired in the Redis server. To deal with these use cases,
-wrap the type within a `std::optional`:
-
-[source,cpp]
----
-response<
-   std::optional<A>,
-   std::optional<B>,
-   ...
-   > resp;
----
-
-Everything else stays the same.
-
-### Transactions
-
-To read responses to transactions we must first observe that Redis
-will queue the transaction commands and send their individual
-responses as elements of an array. The array itself is the response to
-the `EXEC` command.  For example, to read the response to this request
-
-[source,cpp]
----
-req.push("MULTI");
-req.push("GET", "key1");
-req.push("LRANGE", "key2", 0, -1);
-req.push("HGETALL", "key3");
-req.push("EXEC");
----
-
-Use the following response type:
-
-[source,cpp]
----
-response<
-   ignore_t,  // multi
-   ignore_t,  // QUEUED
-   ignore_t,  // QUEUED
-   ignore_t,  // QUEUED
-   response<
-      std::optional<std::string>, // get
-      std::optional<std::vector<std::string>>, // lrange
-      std::optional<std::map<std::string, std::string>> // hgetall
-   > // exec
-> resp;
----
-
-For a complete example, see {site-url}/example/cpp20_containers.cpp[cpp20_containers.cpp].
-
-[#the-general-case]
-### The general case
-
-There are cases where responses to Redis
-commands won't fit in the model presented above. Some examples are:
-
-* Commands (like `set`) whose responses don't have a fixed
-  RESP3 type. Expecting an `int` and receiving a blob-string
-  results in an error.
-* RESP3 aggregates that contain nested aggregates can't be read in STL containers.
-* Transactions with a dynamic number of commands can't be read in a `response`.
-
-To deal with these cases Boost.Redis provides the xref:reference:boost/redis/resp3/node.adoc[`boost::redis::resp3::node`] type
-abstraction, that is the most general form of an element in a
-response, be it a simple RESP3 type or the element of an aggregate. It
-is defined like:
-
-[source,cpp]
----
-template <class String>
-struct basic_node {
-   // The RESP3 type of the data in this node.
-   type data_type;
-
-   // The number of elements of an aggregate (or 1 for simple data).
-   std::size_t aggregate_size;
-
-   // The depth of this node in the response tree.
-   std::size_t depth;
-
-   // The actual data. For aggregate types this is always empty.
-   String value;
-};
----
-
-Any response to a Redis command can be parsed into a
-xref:reference:boost/redis/generic_response.adoc[boost::redis::generic_response]
-and its counterpart xref:reference:boost/redis/generic_flat_response.adoc[boost::redis::generic_flat_response].
-The vector can be seen as a pre-order view of the response tree.
-Using it is not different than using other types:
-
-[source,cpp]
----
-// Receives any RESP3 simple or aggregate data type.
-boost::redis::generic_response resp;
-co_await conn->async_exec(req, resp);
----
-
-For example, suppose we want to retrieve a hash data structure
-from Redis with `HGETALL`, some of the options are
-
-* `boost::redis::generic_response` and `boost::redis::generic_flat_response`: always works.
-* `std::vector<std::string>`: efficient and flat, all elements as string.
-* `std::map<std::string, std::string>`: efficient if you need the data as a `std::map`.
-* `std::map<U, V>`: efficient if you are storing serialized data. Avoids temporaries and requires `boost_redis_from_bulk` for `U` and `V`.
-
-In addition to the above users can also use unordered versions of the
-containers. The same reasoning applies to sets e.g. `SMEMBERS`
-and other data structures in general.
--- a/doc/modules/ROOT/pages/sentinel.adoc
+++ b/doc/modules/ROOT/pages/sentinel.adoc
@@ -1,152 +0,0 @@
-//
-// Copyright (c) 2025 Marcelo Zimbres Silva (mzimbres@gmail.com),
-// Ruben Perez Hidalgo (rubenperez038 at gmail dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-= Sentinel
-
-Boost.Redis supports Redis Sentinel deployments. Sentinel handling
-in `connection` is built-in: xref:reference:boost/redis/basic_connection/async_run-04.adoc[`async_run`]
-automatically connects to Sentinels, resolves the master's address, and connects to the master.
-
-Configuration is done using xref:reference:boost/redis/sentinel_config.adoc[`config::sentinel`]:
-
-[source,cpp]
----
-config cfg;
-
-// To enable Sentinel, set this field to a non-empty list
-// of (hostname, port) pairs where Sentinels are listening
-cfg.sentinel.addresses = {
-    {"sentinel1.example.com", "26379"},
-    {"sentinel2.example.com", "26379"},
-    {"sentinel3.example.com", "26379"},
-};
-
-// Set master_name to the identifier that you configured
-// in the "sentinel monitor" statement of your sentinel.conf file
-cfg.sentinel.master_name = "mymaster";
----
-
-Once set, the connection object can be used normally. See our
-our {site-url}/example/cpp20_sentinel.cpp[Sentinel example]
-for a full program.
-
-== Connecting to replicas
-
-By default, the library connects to the Redis master.
-You can connect to one of its replicas by using
-xref:reference:boost/redis/sentinel_config/server_role.adoc[`config::sentinel::server_role`].
-This can be used to balance load, if all your commands read data from
-the server and never write to it. The particular replica will be chosen randomly.
-
-[source,cpp]
----
-config cfg;
-
-// Set up Sentinel
-cfg.sentinel.addresses = {
-    {"sentinel1.example.com", "26379"},
-    {"sentinel2.example.com", "26379"},
-    {"sentinel3.example.com", "26379"},
-};
-cfg.sentinel.master_name = "mymaster";
-
-// Ask the library to connect to a random replica of 'mymaster', rather than the master node
-cfg.sentinel.server_role = role::replica;
----
-
-
-== Sentinel authentication
-
-If your Sentinels require authentication, 
-you can use xref:reference:boost/redis/sentinel_config/setup.adoc[`config::sentinel::setup`]
-to provide credentials.
-This request is executed immediately after connecting to Sentinels, and
-before any other command:
-
-[source,cpp]
----
-// Set up Sentinel
-config cfg;
-cfg.sentinel.addresses = {
-    {"sentinel1.example.com", "26379"},
-    {"sentinel2.example.com", "26379"},
-    {"sentinel3.example.com", "26379"},
-};
-cfg.sentinel.master_name = "mymaster";
-
-// By default, setup contains a 'HELLO 3' command.
-// Override it to add an AUTH clause to it with out credentials.
-cfg.sentinel.setup.clear();
-cfg.sentinel.setup.push("HELLO", 3, "AUTH", "sentinel_user", "sentinel_password");
-
-// cfg.sentinel.setup applies to Sentinels, only.
-// Use cfg.setup to authenticate to masters/replicas.
-cfg.use_setup = true; // Required for cfg.setup to be used, for historic reasons
-cfg.setup.clear();
-cfg.setup.push("HELLO", 3, "AUTH", "master_user", "master_password");
----
-
-== Using TLS with Sentinels
-
-You might use TLS with Sentinels only, masters/replicas only, or both by adjusting
-xref:reference:boost/redis/sentinel_config/use_ssl.adoc[`config::sentinel::use_ssl`]
-and xref:reference:boost/redis/config/use_ssl.adoc[`config::use_ssl`]:
-
-[source,cpp]
----
-// Set up Sentinel
-config cfg;
-cfg.sentinel.addresses = {
-    {"sentinel1.example.com", "26379"},
-    {"sentinel2.example.com", "26379"},
-    {"sentinel3.example.com", "26379"},
-};
-cfg.sentinel.master_name = "mymaster";
-
-// Adjust these switches to enable/disable TLS
-cfg.use_ssl = true;          // Applies to masters and replicas
-cfg.sentinel.use_ssl = true; // Applies to Sentinels
----
-
-== Sentinel algorithm
-
-This section details how `async_run` interacts with Sentinel.
-Most of the algorithm follows
-https://redis.io/docs/latest/develop/reference/sentinel-clients/[the official Sentinel client guidelines].
-Some of these details may vary between library versions.
-
-* Connections maintain an internal list of Sentinels, bootstrapped from
-  xref:reference:boost/redis/sentinel_config/addresses.adoc[`config::sentinel::addresses`].
-* The first Sentinel in the list is contacted by performing the following:
-** A physical connection is established.
-** The setup request is executed.
-** The master's address is resolved using
-   https://redis.io/docs/latest/operate/oss_and_stack/management/sentinel/#sentinel-api[`SENTINEL GET-MASTER-NAME-BY-ADDR`].
-** If `config::sentinel::server_role` is `role::replica`, replica addresses are obtained using
-   https://redis.io/docs/latest/operate/oss_and_stack/management/sentinel/#sentinel-api[`SENTINEL REPLICAS`].
-   One replica is chosen randomly.
-** The address of other Sentinels also monitoring this master are retrieved using
-   https://redis.io/docs/latest/operate/oss_and_stack/management/sentinel/#sentinel-api[`SENTINEL SENTINELS`].
-* If a Sentinel is unreachable, doesn't know about the configured master,
-  or returns an error while executing the above requests, the next Sentinel in the list is tried.
-* If all Sentinels have been tried without success, `config::reconnect_wait_interval`
-  is waited, and the process starts again.
-* After a successful Sentinel response, the internal Sentinel list is updated
-  with any newly discovered Sentinels.
-  Sentinels in `config::sentinel::addresses` are always kept in the list,
-  even if they weren't present in the output of `SENTINEL SENTINELS`.
-* The retrieved address is used
-  to establish a connection with the master or replica.
-  A `ROLE` command is added at the end of the setup request.
-  This is used to detect situations where a Sentinel returns outdated
-  information due to a failover in process. If `ROLE` doesn't output
-  the expected role (`"master"` or `"slave"`, depending on `config::sentinel::server_role`)
-  `config::reconnect_wait_interval` is waited and Sentinel is contacted again.
-* The connection to the master/replica is run like any other connection.
-  If network errors or timeouts happen, `config::reconnect_wait_interval`
-  is waited and Sentinel is contacted again.
--- a/doc/modules/ROOT/pages/serialization.adoc
+++ b/doc/modules/ROOT/pages/serialization.adoc
@@ -1,26 +0,0 @@
-//
-// Copyright (c) 2025 Marcelo Zimbres Silva (mzimbres@gmail.com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-= Serializing and parsing into custom types
-
-Boost.Redis supports serialization of user defined types by means of
-the following customization points
-
-[source,cpp]
----
-// Serialize
-void boost_redis_to_bulk(std::string& to, mystruct const& obj);
-
-// Deserialize
-void boost_redis_from_bulk(mystruct& u, node_view const& node, boost::system::error_code&);
----
-
-These functions are accessed over ADL and therefore they must be
-imported in the global namespace by the user. The following examples might be of interest:
-
-* {site-url}/example/cpp20_json.cpp[cpp20_json.cpp]: serializes and parses JSON objects.
-* {site-url}/example/cpp20_protobuf.cpp[cpp20_protobuf.cpp]: serializes and parses https://protobuf.dev/[protobuf] objects.
--- a/doc/mrdocs.cpp
+++ b/doc/mrdocs.cpp
@@ -1,10 +0,0 @@
-//
-// Copyright (c) 2025 Ruben Perez Hidalgo (rubenperez038 at gmail dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#define BOOST_ALLOW_DEPRECATED  // avoid mrdocs errors with the BOOST_DEPRECATED macro
-
-#include <boost/redis.hpp>
--- a/doc/mrdocs.yml
+++ b/doc/mrdocs.yml
@@ -1,31 +0,0 @@
-#
-# Copyright (c) 2025 Ruben Perez Hidalgo (rubenperez038 at gmail dot com)
-#
-# Distributed under the Boost Software License, Version 1.0. (See accompanying
-# file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-#
-
-source-root: ../include
-compilation-database: ./CMakeLists.txt
-include-symbols:
-  - "boost::redis::**"
-exclude-symbols:
-  - "boost::redis::detail::**"
-  - "boost::redis::adapter::detail::**"
-  - "boost::redis::resp3::detail::**"
-  - "boost::redis::basic_connection::run_is_canceled"
-  - "boost::redis::basic_connection::this_type"
-  - "boost::redis::any_adapter::impl_t"
-  - "boost::redis::any_adapter::fn_type"
-  - "boost::redis::any_adapter::create_impl"
-  - "boost::redis::any_adapter::impl_"
-  - "boost::redis::request::payload"
-  - "boost::redis::request::has_hello_priority"
-see-below:
-  - "boost::redis::adapter::ignore"
-sort-members: false
-base-url: https://github.com/boostorg/redis/blob/master/include/
-use-system-libc: true
-warn-as-error: true
-warn-if-undocumented: false
-warn-no-paramdoc: false
--- a/doc/on-the-costs-of-async-abstractions.md
+++ b/doc/on-the-costs-of-async-abstractions.md
@@ -1,671 +0,0 @@
-# On the costs of asynchronous abstractions
-
-The biggest force behind the evolution of
-[Boost.Redis](https://github.com/boostorg/redis) was my struggling in
-coming up with a high-level connection abstraction that was capable of
-multiplexing Redis commands from independent sources while
-concurrently handling server pushes. This journey taught me many
-important lessons, many of which are related to the design and
-performance of asynchronous programs based on Boost.Asio.
-
-In this article I will share some of the lessons learned, specially
-those related to the performance costs of _abstractions_ such as
-`async_read_until` that tend to overschedule into the event-loop. In
-this context I will also briefly comment on how the topics discussed
-here influenced my views on the proposed
-[P2300](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2023/p2300r7.html)
-(a.k.a. Senders and Receivers), which is likely to become the basis of
-networking in upcoming C++ standards.
-
-Although the analysis presented in this article uses the Redis communication
-protocol for illustration I expect it to be useful in general since
-[RESP3](https://github.com/antirez/RESP3/blob/master/spec.md) shares
-many similarities with other widely used protocols such as HTTP. 
-
-## Parsing `\r\n`-delimited messages
-
-The Redis server communicates with its clients by exchanging data
-serialized in
-[RESP3](https://github.com/antirez/RESP3/blob/master/spec.md) format.
-Among the data types supported by this specification, the
-`\r\n`-delimited messages are some of the most frequent in a typical
-session. The table below shows some examples
-
-  Command  | Response | Wire format   | RESP3 name
-  ---------|----------|---------------|---------------------
-  PING     |  PONG    | `+PONG\r\n`   | simple-string
-  INCR     |  42      | `:42\r\n`     | number
-  GET      |  null    | `_\r\n`       | null
-
-Redis also supports command pipelines, which provide a way of
-optimizing round-trip times by batching commands. A pipeline composed
-by the commands shown in the previous table look like this
-
-```
-                       |   Sent in a     |
-                       |   single write  |
-+--------+             |                 |              +-------+
-|        | -------->    PING + INCR + GET     --------> |       |
-|        |                                              |       |
-| Client |                                              | Redis |
-|        |                                              |       |
-|        | <-------- "+PONG\r\n:42\r\n_\r\n"  <-------- |       |
-+--------+            |<------>|<---->|<-->|            +-------+
-                      |                    |
-                      |     Responses      |
-```
-
-Messages that use delimiters are so common in networking that a
-facility called `async_read_until` for reading them incrementally from
-a socket is already part of Boost.Asio. The coroutine below uses it to
-print message contents to the screen
-
-```cpp
-awaitable<void> parse_resp3_simple_msgs(tcp::socket socket)
-{
-  for (std::string buffer;;) {
-     auto n = co_await async_read_until(socket, dynamic_buffer(buffer), "\r\n");
-
-     std::cout << buffer.substr(1, n - 3) << std::endl;
-
-     // Consume the buffer.
-     buffer.erase(0, n);
-  }
-}
-```
-
-If we pay attention to the buffer content as it is parsed by the code
-above we can see it is rotated fairly often, for example
-
-```
-   "+PONG\r\n:100\r\n+OK\r\n_\r\n"
-   ":100\r\n+OK\r\n_\r\n"
-   "+OK\r\n_\r\n"
-   "_\r\n"
-   ""
-```
-
-When I first realized these, apparently excessive, buffer rotations I
-was concerned they would impact the performance of Boost.Redis in a
-severe way.  To measure the magnitude of this impact I came up with an
-experimental implementation of Asio's `dynamic_buffer` that consumed
-the buffer less eagerly than the `std::string::erase` function used
-above. For that, the implementation increased a buffer offset up
-to a certain threshold and only then triggered a (larger) rotation.
-This is illustrated in the diagram below
-
-```
-    |<---- offset threshold ---->|
-    |                            |
-   "+PONG\r\n:100\r\n+OK\r\n_\r\n+PONG\r\n"
-    |                                       # Initial offset
-
-   "+PONG\r\n:100\r\n+OK\r\n_\r\n+PONG\r\n"
-    |<------>|                              # After 1st message
-
-   "+PONG\r\n:100\r\n+OK\r\n_\r\n+PONG\r\n"
-    |<-------------->|                      # After 2nd message
-
-   "+PONG\r\n:100\r\n+OK\r\n_\r\n+PONG\r\n"
-    |<--------------------->|               # After 3rd message
-
-   "+PONG\r\n:100\r\n+OK\r\n_\r\n+PONG\r\n"
-    |<-------------------------->|          # Threshold crossed after the 4th message
-
-   "+PONG\r\n"
-    |                                       # After rotation
-```
-
-After comparing the performance differences between the two versions I
-was surprised there wasn't any! But that was also very suspicious
-since some RESP3 aggregate types contain a considerable number of
-separators.  For example, a map with two pairs `[(key1, value1),
-(key2, value2)]` encoded in RESP3 requires ten rotations in total
-
-```
-   "%2\r\n$4\r\nkey1\r\n$6\r\nvalue1\r\n$4\r\nkey2\r\n$6\r\nvalue2\r\n"
-   "$4\r\nkey1\r\n$6\r\nvalue1\r\n$4\r\nkey2\r\n$6\r\nvalue2\r\n"
-   "key1\r\n$6\r\nvalue1\r\n$4\r\nkey2\r\n$6\r\nvalue2\r\n"
-   "$6\r\nvalue1\r\n$4\r\nkey2\r\n$6\r\nvalue2\r\n"
-   ...
-```
-
-It was evident something more costly was shadowing the buffer
-rotations. But it couldn't be the search for the separator since it
-performs equivalently to rotations. It is also easy to show that the
-overhead is not related to any IO operation since the problem persists
-if the buffer is never consumed (which causes the function to be
-called with the same string repeatedly).  Once these two factors
-are removed from the table, we are driven into the conclusion that
-calling `async_read_until` has an intrinsic cost, let us see what
-that is.
-
-### Async operations that complete synchronously considered harmful
-
-Assume the scenario described earlier where `async_read_until` is used
-to parse multiple `\r\n`-delimited messages. The following is a
-detailed description of what happens behind the scenes
-
-   1. `async_read_until` calls `socket.async_read_some` repeatedly
-      until the separator `\r\n` shows up in the buffer
-
-```
-   "<read1>"                                # Read 1: needs more data.
-   "<read1><read2>"                         # Read 2: needs more data.
-   "<read1><read2>"                         # Read 3: needs more data.
-   "<read1><read2><read3>"                  # Read 4: needs more data.
-   "<read1><read2><read3>\r\n<bonus bytes>" # separator found, done.
-```
-
-   2. The last call to `socket.async_read_some` happens to read past
-      the separator `\r\n` (depicted as `<bonus bytes>` above),
-      resulting in bonus (maybe incomplete) messages in the buffer
-
-```
-    | 1st async_read_some  |         2nd async_read_some            |
-    |                      |                                        |
-    "+message content here \r\n:100\r\n+OK\r\n_\r\n+incomplete respo"
-    |                          |                   |                |
-    |      Message wanted      |<-- bonus msgs --->|<--incomplete-->|
-    |                          |                         msg        |
-    |                          |                                    |
-    |                          |<---------- bonus bytes ----------->|
-```
-
-   3. The buffer is consumed and `async_read_until` is called again.
-      However, since the buffer already contains the next message this
-      is an IO-less call
-
-```
-   ":100\r\n+OK\r\n_\r\n+not enough byt"
-    |                   |              |
-    |  No IO required   | Need more    |
-    |  to parse these   | data         |   
-    |  messages.        |              |
-```
-
-The fact that step 3. doesn't perform any IO implies the operation can
-complete synchronously, but because this is an asynchronous function
-Boost.Asio by default won't call the continuation before the
-function returns. The implementation must therefore enqueue it for
-execution, as depicted below
-
-```
-   OP5 ---> OP4 ---> OP3 ---> OP2 ---> OP1    # Reschedules the continuation
-                                        |
-       OP1 schedules its continuation   |
-    +-----------------------------------+
-    |
-    |
-   OP6 ---> OP5 ---> OP4 ---> OP3 ---> OP2    # Reschedules the continuation
-                                        |
-       OP2 schedules its continuation   |
-    +-----------------------------------+
-    |
-    |
-   OP7 ---> OP6 ---> OP5 ---> OP4 ---> OP3    
-```
-
-When summed up, the excessive rescheduling of continuations lead to
-performance degradation at scale. But since this is an event-loop
-there is no way around rescheduling as doing otherwise would mean
-allowing a task to monopolize the event-loop, preventing other tasks
-from making progress. The best that can be done is to avoid
-_overscheduling_, so let us determine how much rescheduling is too
-much.
-
-## The intrinsic latency of an event-loop 
-
-An event-loop is a design pattern originally used to handle events
-external to the application, such as GUIs, networking and other forms
-of IO.  If we take this literally, it becomes evident that the way
-`async_read_until` works is incompatible with an event-loop since
-_searching for the separator_ is not an external event and as such
-should not have to be enqueued for execution.
-
-Once we constrain ourselves to events that have an external origin,
-such as anything related to IO and including any form of IPC, the
-scheduling overhead is reduced considerably since the latency
-of the transport layer eclipses whatever time it takes to schedule the
-continuation, for example, according to
-[these](https://www.boost.org/doc/libs/develop/libs/cobalt/doc/html/index.html#posting_to_an_executor)
-benchmarks, the time it takes to schedule a task in the
-`asio::io_context ` is approximately `50ns`.
-
-To give the reader an idea about the magnitude of this number, if
-rescheduling alone were to account for 1% of the runtime of an app
-that uses asynchronous IO to move around data in chunks of size 128kb,
-then this app would have a throughput of approximately 24Gbs.  At such
-high throughput multiple other factors kick in before any scheduling
-overhead even starts to manifest.
-
-It is therefore safe to say that only asynchronous operations that
-don't perform or are not bound to any IO are ever likely to
-overschedule in the sense described above. Those cases can be usually
-avoided, this is what worked for Boost.Redis
-
-  1. `async_read_until` was replaced with calls to
-     `socket.async_read_some` and an incremental parser that does not
-     do any IO.
-
-  2. Channel `try_` functions are used to check if send and receive
-     operations can be called without suspension. For example,
-     `try_send` before `async_send` and `try_receive` before
-     `async_receive` ([see also](https://github.com/chriskohlhoff/asio/commit/fe4fd7acf145335eeefdd19708483c46caeb45e5)
-     `try_send_via_dispatch` for a more aggressive optimization).
-
-  3. Coalescing of individual requests into a single payload to reduce
-     the number of necessary writes on the socket, this is only
-     possible because Redis supports pipelining (good protocols
-     help!).
-
-  4. Increased the socket read sizes to 4kb to reduce the number of
-     reads (which is outweighed by the costs of rotating data in the
-     buffer).
-
-  5. Dropped the `resp3::async_read` abstraction. When I started
-     developing Boost.Redis there was convincing precedent for having
-     a `resp3::async_read` function to read complete RESP3 messages
-     from a socket
-
-     Name                                   | Description
-     ---------------------------------------|-------------------
-     `asio::ip::tcp::async_read`            | Reads `n` bytes from a stream.
-     `beast::http::async_read`              | Reads a complete HTTP message.
-     `beast::websocket::stream::async_read` | Reads a complete Websocket message.
-     `redis::async_read`                    | Reads a complete RESP3 message.
-
-     It turns out however that this function is also vulnerable to
-     immediate completions since in command pipelines multiple
-     responses show up in the buffer after a call to
-     `socket.async_read_some`. When that happens each call to
-     `resp3::async_read` is IO-less.
-   
-Sometimes it is not possible to avoid asynchronous operations that
-complete synchronously, in the following sections we will see how to
-favor throughput over fairness in Boost.Asio.
-
-### Calling the continuation inline
-
-In Boost.Asio it is possible to customize how an algorithm executes
-the continuation when an immediate completion occurs, this includes
-the ability of calling it inline, thereby avoiding the costs of
-excessive rescheduling.  Here is how it works
-
-```cpp
-// (default) The continuation is enqueued for execution, regardless of
-// whether it is immediate or not.
-async_read_until(socket, buffer, "\r\n", continuation);
-
-// Immediate completions are executed in exec2 (otherwise equal to the
-// version above). The completion is called inline if exec2 is the
-// same executor that is running the operation.
-async_read_until(socket, buffer, "\r\n", bind_immediate_executor(exec2, completion));
-```
-
-To compare the performance of both cases I have written a small
-function that calls `async_read_until` in a loop with a buffer that is
-never consumed so that all completions are immediate.  The version
-below uses the default behaviour
-
-```cpp
-void read_safe(tcp::socket& s, std::string& buffer)
-{
-   auto continuation = [&s, &buffer](auto ec, auto n)
-   {
-      read_safe(s, buffer); // Recursive call
-   };
-
-   // This won't cause stack exhaustion because the continuation is 
-   // not called inline but posted in the event loop.
-   async_read_until(s, dynamic_buffer(buffer), "\r\n", continuation);
-}
-```
-
-To optimize away some of the rescheduling the version below uses the
-`bind_immediate_executor` customization to call the continuation
-reentrantly and then breaks the stack from time to time to avoid
-exhausting it
-
-```cpp
-void read_reentrant(tcp::socket& s, std::string& buffer)
-{
-   auto cont = [&](auto, auto)
-   {
-      read_reentrant(s, buffer); // Recursive call
-   };
-
-   // Breaks the callstack after 16 inline calls.
-   if (counter % 16 == 0) {
-      post(s.get_executor(), [cont](){cont({}, 0);});
-      return;
-   }
-
-   // Continuation called reentrantly.
-   async_read_until(s, dynamic_buffer(buffer), "\r\n",
-      bind_immediate_executor(s.get_executor(), cont));
-}
-```
-
-The diagram below shows what the reentrant chain of calls in the code
-above look like from the event-loop point of view
-
-```
-   OP5 ---> OP4 ---> OP3 ---> OP2 ---> OP1a    # Completes immediately
-                                        |
-                                        |      
-                 ...                    |
-                                       OP1b    # Completes immediately
-                                        |
-           Waiting for OP5 to           |      
-             reschedule its             |
-             continuation              OP1c    # Completes immediately
-                                        |
-                                        |      
-                 ...                    |
-                                       OP1d    # Break the call-stack
-                                        |
-    +-----------------------------------+     
-    |
-   OP6 ---> OP5 ---> OP4 ---> OP3 ---> OP2
-```
-
-Unsurprisingly, the reentrant code is 3x faster than the one that
-relies on the default behaviour (don't forget that this is a best case
-scenario, in the general case not all completions are immediate).
-Although faster, this strategy has some downsides
-
-   - The overall operation is not as fast as possible since it still
-     has to reschedule from time to time to break the call stack.  The
-     less it reschedules the higher the risk of exhausting it.
-
-   - It is too easy to forget to break the stack. For example, the
-     programmer might decide to branch somewhere into another chain of
-     asynchronous calls that also use this strategy.  To avoid
-     exhaustion all such branches would have to be safeguarded with a
-     manual rescheduling i.e. `post`.
-
-   - Requires additional layers of complexity such as
-     `bind_immediate_executor` in addition to `bind_executor`.
-   
-  - Non-compliat with more strict
-    [guidelines](https://en.wikipedia.org/wiki/The_Power_of_10:_Rules_for_Developing_Safety-Critical_Code)
-    that prohibits reentrat code.
-
-   - There is no simple way of choosing the maximum allowed number of
-     reentrant calls for each function in a way that covers different
-     use cases and users. Library writers and users would be tempted
-     into using a small value reducing the performance advantage.
-
-   - If the socket is always ready for reading the task will
-     monopolize IO for up to `16` interactions which might cause
-     stutter in unrelated tasks as depicted below
-
-```
-                                 Unfairness
-
-          +----+----+----+    +----+----+----+    +----+----+----+
-Socket-1  |    |    |    |    |    |    |    |    |    |    |    |
-          +----+----+----+----+----+----+----+----+----+----+----+----+     
-Socket-2                 |    |              |    |              |    | 
-                         +----+              +----+              +----+
-```
-
-From the aesthetic point of view the code above is also unpleasant as
-it breaks the function asynchronous contract by injecting a reentrant
-behaviour. It gives me the same kind of feeling I have about
-[recursive
-mutexes](http://www.zaval.org/resources/library/butenhof1.html).
-
-Note: It is worth mentioning here that a similar
-[strategy](https://github.com/NVIDIA/stdexec/blob/6f23dd5b1d523541ce28af32fc2603403ebd36ed/include/exec/trampoline_scheduler.hpp#L52)
-is used to break the call stack of repeating algorithms in
-[stdexec](https://github.com/NVIDIA/stdexec), but in this time
-based on
-[P2300](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2023/p2300r7.html)
-and not on Boost.Asio.
-
-### Coroutine tail-calls
-
-In the previous section we have seen how to avoid overscheduling by
-instructing the asynchronous operation to call the completion inline
-on immediate completion.  It turns out however that coroutine support
-for _tail-calls_ provide a way to completely sidestep this problem.
-This feature is described by
-[Lewis Baker](https://lewissbaker.github.io/2020/05/11/understanding_symmetric_transfer)
-as follows
-
-> A tail-call is one where the current stack-frame is popped before
-> the call and the current function’s return address becomes the
-> return-address for the callee. ie. the callee will return directly
-> the the [sic] caller of this function.
-
-This means (at least in principle) that a library capable of using
-tail-calls when an immediate completion occurs neither has to
-reschedule the continuation nor call it inline. To test how this
-feature compares to the other styles I have used Boost.Cobalt. The
-code looks as follows
-
-```cpp
-// Warning: risks unfairness and starvation of other tasks.
-task<void> read_until_unfair()
-{
-    for (int i = 0; i != repeat; ++i) {
-        co_await async_read_until(s, dynamic_buffer(buffer), "\r\n", cobalt::use_op);
-    }
-}
-```
-
-The result of this comparison as listed in the table below
-
-Time/s | Style     | Configuration               | Library     
-------|-----------|-----------------------------|-------------
- 1,0   | Coroutine | `await_ready` optimization  | Boost.Cobalt
- 4.8   | Callback  | Reentant                    | Boost.Asio  
-10.3   | Coroutine | `use_op`                    | Boost.Cobalt
-14.9   | Callback  | Regular                     | Boost.Asio  
-15.6   | Coroutine | `asio::deferred`            | Boost.Asio  
-
-As the reader can see, `cobalt::use_op` ranks 3rd and is considerably
-faster (10.3 vs 15.6) than the Asio equivalent that uses
-default-rescheduling. However, by trading rescheduling with tail-calls
-the code above can now monopolize the event-loop, resulting in
-unfairness if the socket happens to receive data at a higher rate
-than other tasks. If by chance data is received continuously
-on a socket that is always ready for reading, other tasks will starve
-
-```
-                                 Starvation
-
-          +----+----+----+----+----+----+----+----+----+----+----+----+
-Socket-1  |    |    |    |    |    |    |    |    |    |    |    |    |
-          +----+----+----+----+----+----+----+----+----+----+----+----+     
-
-Socket-2          Starving ...                                          
-                                                                       
-```
-
-To avoid this problem the programmer is forced to reschedule from time
-to time, in the same way we did for the reentrant calls
-
-```cpp
-task<void> read_until_fair()
-{
-    for (int i = 0; i != repeat; ++i) {
-        if (repeat % 16 == 0) {
-            // Reschedules to address unfairness and starvation of 
-            // other tasks.
-            co_await post(cobalt::use_op);
-            continue;
-        }
-        
-        co_await async_read_until(s, dynamic_buffer(buffer), "\r\n", cobalt::use_op);
-    }
-}
-```
-
-Delegating fairness-safety to applications is a dangerous game.
-This is a
-[problem](https://tokio.rs/blog/2020-04-preemption) the Tokio
-community had to deal with before Tokio runtime started enforcing
-rescheduling (after 256 successful operations)
-
-> If data is received faster than it can be processed, it is possible
-> that more data will have already been received by the time the
-> processing of a data chunk completes. In this case, .await will
-> never yield control back to the scheduler, other tasks will not be
-> scheduled, resulting in starvation and large latency variance.
-
-> Currently, the answer to this problem is that the user of Tokio is
-> responsible for adding yield points in both the application and
-> libraries. In practice, very few actually do this and end up being
-> vulnerable to this sort of problem.
-
-### Safety in P2300 (Senders and Receivers)
-
-As of this writing, the C++ standards committee (WG21) has been
-pursuing the standardization of a networking library for almost 20
-years. One of the biggest obstacles that prevented it from happening
-was a disagreement on what the _asynchronous model_ that underlies
-networking should look like. Until 2021 that model was basically
-Boost.Asio _executors_,  but in this
-[poll](https://www.reddit.com/r/cpp/comments/q6tgod/c_committee_polling_results_for_asynchronous/)
-the committee decided to abandon that front and concentrate efforts on
-the new [P2300](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2023/p2300r7.html)
-proposal, also known as _senders and receivers_. The decision was
-quite [abrupt](https://isocpp.org/files/papers/P2464R0.html)
-
-> The original plan about a week earlier than the actual writing of
-> this paper was to write a paper that makes a case for standardizing
-> the Networking TS.
-
-and opinions turned out to be very strong against Boost.Asio (see
-[this](https://api.csswg.org/bikeshed/?force=1&url=https://raw.githubusercontent.com/brycelelbach/wg21_p2459_2022_january_library_evolution_poll_outcomes/main/2022_january_library_evolution_poll_outcomes.bs)
-for how each voter backed their vote)
-
-> The whole concept is completely useless, there's no composed code
-> you can write with it.
-
-The part of that debate that interests us most here is stated in
-[P2471](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2021/p2471r1.pdf),
-that compares Boost.Asio with P2300
-
-> Yes, default rescheduling each operation and default not
-> rescheduling each operation, is a poor trade off. IMO both options
-> are poor. The one good option that I know of that can prevent stack
-> exhaustion is first-class tail-recursion in library or language
-
-> ASIO has chosen to require that every async operation must schedule
-> the completion on a scheduler (every read, every write, etc..).
-
-> sender/receiver has not decided to
-> require that the completion be scheduled. 
-
-> This is why I consider tail-call the only good solution. Scheduling
-> solutions are all inferior (give thanks to Lewis for this shift in
-> my understanding :) ).
-
-Although tail-calls solve the problem of stack-exhaustion as we have
-seen above, it makes the code vulnerable to unfairness and starvation
-and therefore it is not an alternative to default-rescheduling as the
-quotation above is implying.  To deal with the lack of
-default-rescheduling, libraries and applications built on top of P2300
-have to address the aforementioned problems, layer after layer. For
-example,
-[stdexec](https://github.com/NVIDIA/stdexec) has invented something
-called
-_[trampoline-scheduler](https://github.com/NVIDIA/stdexec/blob/e7cd275273525dbc693f4bf5f6dc4d4181b639e4/include/exec/trampoline_scheduler.hpp)_
-to protect repeating algorithms such as `repeat_effect_until` from
-exhausting the stack. This construct however is built around
-reentracy, allowing
-[sixteen](https://github.com/NVIDIA/stdexec/blob/83cdb92d316e8b3bca1357e2cf49fc39e9bed403/include/exec/trampoline_scheduler.hpp#L52)
-levels of inline calls by default. While in Boost.Asio it is possible to use
-reentracy as an optimization for a corner cases, here it is made its
-_modus operandi_, the downsides of this approach have already been stated in a
-previous section so I won't repeat it here.
-
-Also the fact that a special scheduler is needed by specific
-algorithms is a problem on its own since it contradicts one of the
-main selling points of P2300 which is that of being _generic_. For
-example, [P2464R0](https://isocpp.org/files/papers/P2464R0.html) uses
-the code below as an example
-
-```cpp
-void
-run_that_io_operation(
-    scheduler auto sched,
-    sender_of<network_buffer> auto wrapping_continuation)
-{
-   // snip
-}
-```
-
-and states
-
-> I have no idea what the sched's concrete type is. I have no idea
-> what the wrapping_continuation's concrete type is. They're none of
-> my business, ...
-
-Hence, by being generic, the algorithms built on top of P2300 are also
-unsafe (against stack-exhaustion, unfairness and starvation).  Otherwise,
-if library writers require a specific scheduler to ensure safety, then
-the algorithms become automatically non-generic, pick your poison!
-
-The proposers of P2300 claim that it doesn't address safety because it
-should be seen as the low-level building blocks of asynchronous
-programming and that its the role of higher-level libraries, to deal
-with that. This claim however does not hold since, as we have just
-seen, Boost.Asio also provides those building blocks but does so in a
-safe way.  In fact during the whole development of Boost.Redis I never
-had to think about these kinds of problems because safety is built
-from the ground up.
-
-### Avoiding coroutine suspension with `await_ready`
-
-Now let us get back to the first place in the table above, which uses
-the `await_ready` optimization from Boost.Cobalt. This API provides
-users with the ability to avoid coroutine suspension altogether in
-case the separator is already present in the buffer.  It works by
-defining a `struct` with the following interface
-
-```cpp
-struct read_until : cobalt::op<error_code, std::size_t> {
-   ...
-
-   void ready(cobalt::handler<error_code, std::size_t> handler) override
-   {
-      // Search for the separator in buffer and call the handler if found
-   }
-
-   void initiate(cobalt::completion_handler<error_code, std::size_t> complete) override
-   {
-      // Regular call to async_read_until.
-      async_read_until(socket, buffer, delim, std::move(complete));
-   }
-};
-```
-
-and the code that uses it
-
-```cpp
-for (int i = 0; i != repeat; ++i) {
-    co_await read_until(socket, dynamic_buffer(buffer));
-}
-```
-
-In essence, what the code above does is to skip a call to
-`async_read_unil` by first checking with the ready function whether
-the forthcoming operation is going to complete immediately.  The
-nice thing about it is that the programmer can use this optimization
-only when a performance bottleneck is detected, without planing for it
-in advance.  The drawback however is that it requires reimplementing
-the search for the separator in the body of the `ready` function,
-defeating the purpose of using `async_read_until` in first place as
-(again) it would have been simpler to reformulate the operation in
-terms of `socket.async_read_some` directly.
-
-## Acknowledgements
-
-Thanks to Klemens Morgenstern for answering questions about
-Boost.Cobalt.
-
--- a/doc/package-lock.json
+++ b/doc/package-lock.json
--- a/doc/package.json
+++ b/doc/package.json
@@ -1,6 +0,0 @@
-{
-  "dependencies": {
-    "@cppalliance/antora-cpp-reference-extension": "^0.0.6",
-    "antora": "^3.1.10"
-  }
-}
--- a/doc/redis-playbook.yml
+++ b/doc/redis-playbook.yml
@@ -1,45 +0,0 @@
-#
-# Copyright (c) 2025 Ruben Perez Hidalgo (rubenperez038 at gmail dot com)
-#
-# Distributed under the Boost Software License, Version 1.0. (See accompanying
-# file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-#
-
-site:
-  url: https://github.com/boostorg/redis/blob/master
-  title: Boost.Redis
-  robots: allow
-  start_page: redis::index.adoc
-
-antora:
-  extensions:
-    - require: '@cppalliance/antora-cpp-reference-extension'
-      dependencies:
-        - name: 'boost'
-          repo: 'https://github.com/boostorg/boost.git'
-          tag: 'develop'
-          variable: 'BOOST_SRC_DIR'
-          system-env: 'BOOST_SRC_DIR'
-
-asciidoc:
-  attributes:
-    # Scrolling problems appear without this
-    page-pagination: ''
-
-content:
-  sources:
-    - url: ..
-      start_path: doc
-
-ui: 
-  bundle:
-    url: https://github.com/boostorg/website-v2-docs/releases/download/ui-master/ui-bundle.zip
-    snapshot: true
-  output_dir: _
-
-output:
-  dir: html
-
-runtime:
-  log:
-    failure_level: error
--- a/example/CMakeLists.txt
+++ b/example/CMakeLists.txt
@@ -1,61 +0,0 @@
-add_library(examples_main STATIC main.cpp)
-target_compile_features(examples_main PRIVATE cxx_std_20)
-target_link_libraries(examples_main PRIVATE boost_redis_project_options)
-
-macro(make_example EXAMPLE_NAME STANDARD)
-  add_executable(${EXAMPLE_NAME} ${EXAMPLE_NAME}.cpp)
-  target_link_libraries(${EXAMPLE_NAME} PRIVATE boost_redis_src)
-  target_link_libraries(${EXAMPLE_NAME} PRIVATE boost_redis_project_options)
-  target_compile_features(${EXAMPLE_NAME} PRIVATE cxx_std_${STANDARD})
-  if (${STANDARD} STREQUAL "20")
-    target_link_libraries(${EXAMPLE_NAME} PRIVATE examples_main)
-  endif()
-  if (${EXAMPLE_NAME} STREQUAL "cpp20_json")
-    target_link_libraries(${EXAMPLE_NAME} PRIVATE Boost::json Boost::container_hash)
-  endif()
-endmacro()
-
-macro(make_testable_example EXAMPLE_NAME STANDARD)
-  make_example(${EXAMPLE_NAME} ${STANDARD})
-  add_test(${EXAMPLE_NAME} ${EXAMPLE_NAME} $ENV{BOOST_REDIS_TEST_SERVER} 6379)
-endmacro()
-
-make_testable_example(cpp17_intro 17)
-make_testable_example(cpp17_intro_sync 17)
-
-make_testable_example(cpp20_intro 20)
-make_testable_example(cpp20_containers 20)
-make_testable_example(cpp20_json 20)
-make_testable_example(cpp20_unix_sockets 20)
-make_testable_example(cpp20_timeouts 20)
-make_testable_example(cpp20_sentinel 20)
-
-make_example(cpp20_subscriber 20)
-make_example(cpp20_streams 20)
-make_example(cpp20_echo_server 20)
-make_example(cpp20_intro_tls 20)
-
-# We test the protobuf example only on gcc.
-if (CMAKE_CXX_COMPILER_ID STREQUAL "GNU")
-  find_package(Protobuf)
-  if (Protobuf_FOUND)
-    protobuf_generate_cpp(PROTO_SRCS PROTO_HDRS person.proto)
-    make_testable_example(cpp20_protobuf 20)
-    target_sources(cpp20_protobuf PUBLIC ${PROTO_SRCS} ${PROTO_HDRS})
-    target_link_libraries(cpp20_protobuf PRIVATE  ${Protobuf_LIBRARIES})
-    target_include_directories(cpp20_protobuf PUBLIC ${Protobuf_INCLUDE_DIRS} ${CMAKE_CURRENT_BINARY_DIR})
-  endif()
-endif()
-
-if (NOT MSVC)
-  make_example(cpp20_chat_room 20)
-endif()
-
-# We build and test the spdlog integration example only if the library is found
-find_package(spdlog)
-if (spdlog_FOUND)
-  make_testable_example(cpp17_spdlog 17)
-  target_link_libraries(cpp17_spdlog PRIVATE spdlog::spdlog)
-else()
-  message(STATUS "Skipping the spdlog example because the spdlog package couldn't be found")
-endif()
--- a/example/cpp17_spdlog.cpp
+++ b/example/cpp17_spdlog.cpp
@@ -1,99 +0,0 @@
-//
-// Copyright (c) 2025 Marcelo Zimbres Silva (mzimbres@gmail.com),
-// Ruben Perez Hidalgo (rubenperez038 at gmail dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <boost/redis/connection.hpp>
-#include <boost/redis/logger.hpp>
-
-#include <boost/asio/detached.hpp>
-#include <boost/system/error_code.hpp>
-
-#include <cstddef>
-#include <iostream>
-#include <spdlog/spdlog.h>
-#include <string_view>
-
-namespace asio = boost::asio;
-namespace redis = boost::redis;
-
-// Maps a Boost.Redis log level to a spdlog log level
-static spdlog::level::level_enum to_spdlog_level(redis::logger::level lvl)
-{
-   switch (lvl) {
-      // spdlog doesn't include the emerg and alert syslog levels,
-      // so we convert them to the highest supported level.
-      // Similarly, notice is similar to info
-      case redis::logger::level::emerg:
-      case redis::logger::level::alert:
-      case redis::logger::level::crit:    return spdlog::level::critical;
-      case redis::logger::level::err:     return spdlog::level::err;
-      case redis::logger::level::warning: return spdlog::level::warn;
-      case redis::logger::level::notice:
-      case redis::logger::level::info:    return spdlog::level::info;
-      case redis::logger::level::debug:
-      default:                            return spdlog::level::debug;
-   }
-}
-
-// This function glues Boost.Redis logging and spdlog.
-// It should have the signature shown here. It will be invoked
-// by Boost.Redis whenever a message is to be logged.
-static void do_log(redis::logger::level level, std::string_view msg)
-{
-   spdlog::log(to_spdlog_level(level), "(Boost.Redis) {}", msg);
-}
-
-auto main(int argc, char** argv) -> int
-{
-   try {
-      // Create an execution context, required to create any I/O objects
-      asio::io_context ioc;
-
-      // Create a connection to connect to Redis, and pass it a custom logger.
-      // Boost.Redis will call do_log whenever it needs to log a message.
-      // Note that the function will only be called for messages with level >= info
-      // (i.e. filtering is done by Boost.Redis).
-      redis::connection conn{
-         ioc,
-         redis::logger{redis::logger::level::info, do_log}
-      };
-
-      // Configuration to connect to the server. Adjust as required
-      redis::config cfg;
-      if (argc == 3) {
-         cfg.addr.host = argv[1];
-         cfg.addr.port = argv[2];
-      }
-
-      // Run the connection with the specified configuration.
-      // This will establish the connection and keep it healthy
-      conn.async_run(cfg, asio::detached);
-
-      // Execute a request
-      redis::request req;
-      req.push("PING", "Hello world");
-
-      redis::response<std::string> resp;
-
-      conn.async_exec(req, resp, [&](boost::system::error_code ec, std::size_t /* bytes_read*/) {
-         if (ec) {
-            spdlog::error("Request failed: {}", ec.what());
-            exit(1);
-         } else {
-            spdlog::info("PING: {}", std::get<0>(resp).value());
-         }
-         conn.cancel();
-      });
-
-      // Actually run our example. Nothing will happen until we call run()
-      ioc.run();
-
-   } catch (std::exception const& e) {
-      spdlog::error("Error: {}", e.what());
-      return 1;
-   }
-}
--- a/example/cpp20_chat_room.cpp
+++ b/example/cpp20_chat_room.cpp
@@ -1,123 +0,0 @@
-/* Copyright (c) 2018-2025 Marcelo Zimbres Silva (mzimbres@gmail.com)
- *
- * Distributed under the Boost Software License, Version 1.0. (See
- * accompanying file LICENSE.txt)
- */
-
-#include <boost/redis/connection.hpp>
-
-#include <boost/asio/as_tuple.hpp>
-#include <boost/asio/co_spawn.hpp>
-#include <boost/asio/consign.hpp>
-#include <boost/asio/detached.hpp>
-#include <boost/asio/posix/stream_descriptor.hpp>
-#include <boost/asio/read_until.hpp>
-#include <boost/asio/signal_set.hpp>
-
-#include <exception>
-#include <iostream>
-#include <unistd.h>
-
-#if defined(BOOST_ASIO_HAS_CO_AWAIT)
-#if defined(BOOST_ASIO_HAS_POSIX_STREAM_DESCRIPTOR)
-
-namespace asio = boost::asio;
-using asio::posix::stream_descriptor;
-using asio::signal_set;
-using boost::asio::async_read_until;
-using boost::asio::awaitable;
-using boost::asio::co_spawn;
-using boost::asio::consign;
-using boost::asio::detached;
-using boost::asio::dynamic_buffer;
-using boost::redis::config;
-using boost::redis::connection;
-using boost::redis::generic_flat_response;
-using boost::redis::request;
-using boost::system::error_code;
-using namespace std::chrono_literals;
-
-// Chat over Redis pubsub. To test, run this program from multiple
-// terminals and type messages to stdin.
-
-namespace {
-
-auto rethrow_on_error = [](std::exception_ptr exc) {
-   if (exc)
-      std::rethrow_exception(exc);
-};
-
-auto receiver(std::shared_ptr<connection> conn) -> awaitable<void>
-{
-   // Set the receive response, so pushes are stored in resp
-   generic_flat_response resp;
-   conn->set_receive_response(resp);
-
-   // Subscribe to the channel 'channel'. Using request::subscribe()
-   // (instead of request::push()) makes the connection re-subscribe
-   // to 'channel' whenever it re-connects to the server.
-   request req;
-   req.subscribe({"channel"});
-   co_await conn->async_exec(req);
-
-   while (conn->will_reconnect()) {
-      // Wait for pushes
-      auto [ec] = co_await conn->async_receive2(asio::as_tuple);
-
-      // Check for errors and cancellations
-      if (ec) {
-         std::cerr << "Error during receive: " << ec << std::endl;
-         break;
-      }
-
-      // The response must be consumed without suspending the
-      // coroutine i.e. without the use of async operations.
-      for (auto const& elem : resp.value())
-         std::cout << elem.value << "\n";
-
-      std::cout << std::endl;
-
-      resp.value().clear();
-   }
-}
-
-// Publishes stdin messages to a Redis channel.
-auto publisher(std::shared_ptr<stream_descriptor> in, std::shared_ptr<connection> conn)
-   -> awaitable<void>
-{
-   for (std::string msg;;) {
-      auto n = co_await async_read_until(*in, dynamic_buffer(msg, 1024), "\n");
-      request req;
-      req.push("PUBLISH", "channel", msg);
-      co_await conn->async_exec(req);
-      msg.erase(0, n);
-   }
-}
-
-}  // namespace
-
-// Called from the main function (see main.cpp)
-auto co_main(config cfg) -> awaitable<void>
-{
-   auto ex = co_await asio::this_coro::executor;
-   auto conn = std::make_shared<connection>(ex);
-   auto stream = std::make_shared<stream_descriptor>(ex, ::dup(STDIN_FILENO));
-
-   co_spawn(ex, receiver(conn), rethrow_on_error);
-   co_spawn(ex, publisher(stream, conn), rethrow_on_error);
-   conn->async_run(cfg, consign(detached, conn));
-
-   signal_set sig_set{ex, SIGINT, SIGTERM};
-   co_await sig_set.async_wait();
-   conn->cancel();
-   stream->cancel();
-}
-
-#else   // defined(BOOST_ASIO_HAS_POSIX_STREAM_DESCRIPTOR)
-auto co_main(config const&) -> awaitable<void>
-{
-   std::cout << "Requires support for posix streams." << std::endl;
-   co_return;
-}
-#endif  // defined(BOOST_ASIO_HAS_POSIX_STREAM_DESCRIPTOR)
-#endif  // defined(BOOST_ASIO_HAS_CO_AWAIT)
--- a/example/cpp20_containers.cpp
+++ b/example/cpp20_containers.cpp
@@ -1,146 +0,0 @@
-/* Copyright (c) 2018-2025 Marcelo Zimbres Silva (mzimbres@gmail.com)
- *
- * Distributed under the Boost Software License, Version 1.0. (See
- * accompanying file LICENSE.txt)
- */
-
-#include <boost/redis/connection.hpp>
-
-#include <boost/asio/co_spawn.hpp>
-#include <boost/asio/consign.hpp>
-#include <boost/asio/detached.hpp>
-
-#include <iostream>
-#include <map>
-#include <vector>
-
-#if defined(BOOST_ASIO_HAS_CO_AWAIT)
-
-namespace asio = boost::asio;
-using boost::redis::request;
-using boost::redis::response;
-using boost::redis::ignore_t;
-using boost::redis::ignore;
-using boost::redis::config;
-using boost::redis::connection;
-using boost::asio::awaitable;
-using boost::asio::detached;
-using boost::asio::consign;
-
-template <class T>
-std::ostream& operator<<(std::ostream& os, std::optional<T> const& opt)
-{
-   if (opt.has_value())
-      std::cout << opt.value();
-   else
-      std::cout << "null";
-
-   return os;
-}
-
-void print(std::map<std::string, std::string> const& cont)
-{
-   for (auto const& e : cont)
-      std::cout << e.first << ": " << e.second << "\n";
-}
-
-template <class T>
-void print(std::vector<T> const& cont)
-{
-   for (auto const& e : cont)
-      std::cout << e << " ";
-   std::cout << "\n";
-}
-
-// Stores the content of some STL containers in Redis.
-auto store(std::shared_ptr<connection> conn) -> awaitable<void>
-{
-   std::vector<int> vec{1, 2, 3, 4, 5, 6};
-
-   std::map<std::string, std::string> map{
-      {"key1", "value1"},
-      {"key2", "value2"},
-      {"key3", "value3"}
-   };
-
-   request req;
-   req.push_range("RPUSH", "rpush-key", vec);
-   req.push_range("HSET", "hset-key", map);
-   req.push("SET", "key", "value");
-
-   co_await conn->async_exec(req, ignore);
-}
-
-auto hgetall(std::shared_ptr<connection> conn) -> awaitable<void>
-{
-   // A request contains multiple commands.
-   request req;
-   req.push("HGETALL", "hset-key");
-
-   // Responses as tuple elements.
-   response<std::map<std::string, std::string>> resp;
-
-   // Executes the request and reads the response.
-   co_await conn->async_exec(req, resp);
-
-   print(std::get<0>(resp).value());
-}
-
-auto mget(std::shared_ptr<connection> conn) -> awaitable<void>
-{
-   // A request contains multiple commands.
-   request req;
-   req.push("MGET", "key", "non-existing-key");
-
-   // Responses as tuple elements.
-   response<std::vector<std::optional<std::string>>> resp;
-
-   // Executes the request and reads the response.
-   co_await conn->async_exec(req, resp);
-
-   print(std::get<0>(resp).value());
-}
-
-// Retrieves in a transaction.
-auto transaction(std::shared_ptr<connection> conn) -> awaitable<void>
-{
-   request req;
-   req.push("MULTI");
-   req.push("LRANGE", "rpush-key", 0, -1);  // Retrieves
-   req.push("HGETALL", "hset-key");         // Retrieves
-   req.push("MGET", "key", "non-existing-key");
-   req.push("EXEC");
-
-   response<
-      ignore_t,  // multi
-      ignore_t,  // lrange
-      ignore_t,  // hgetall
-      ignore_t,  // mget
-      response<
-         std::optional<std::vector<int>>,
-         std::optional<std::map<std::string, std::string>>,
-         std::optional<std::vector<std::optional<std::string>>>>  // exec
-      >
-      resp;
-
-   co_await conn->async_exec(req, resp);
-
-   print(std::get<0>(std::get<4>(resp).value()).value().value());
-   print(std::get<1>(std::get<4>(resp).value()).value().value());
-   print(std::get<2>(std::get<4>(resp).value()).value().value());
-}
-
-// Called from the main function (see main.cpp)
-awaitable<void> co_main(config cfg)
-{
-   auto conn = std::make_shared<connection>(co_await asio::this_coro::executor);
-   conn->async_run(cfg, consign(detached, conn));
-
-   co_await store(conn);
-   co_await transaction(conn);
-   co_await hgetall(conn);
-   co_await mget(conn);
-   conn->cancel();
-}
-
-#endif  // defined(BOOST_ASIO_HAS_CO_AWAIT)
--- a/example/cpp20_sentinel.cpp
+++ b/example/cpp20_sentinel.cpp
@@ -1,60 +0,0 @@
-//
-// Copyright (c) 2025 Marcelo Zimbres Silva (mzimbres@gmail.com),
-// Ruben Perez Hidalgo (rubenperez038 at gmail dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <boost/redis/connection.hpp>
-
-#include <boost/asio/co_spawn.hpp>
-#include <boost/asio/consign.hpp>
-#include <boost/asio/detached.hpp>
-
-#include <iostream>
-
-#if defined(BOOST_ASIO_HAS_CO_AWAIT)
-
-namespace asio = boost::asio;
-using boost::redis::request;
-using boost::redis::response;
-using boost::redis::config;
-using boost::redis::connection;
-
-// Called from the main function (see main.cpp)
-auto co_main(config cfg) -> asio::awaitable<void>
-{
-   // Boost.Redis has built-in support for Sentinel deployments.
-   // To enable it, set the fields in config shown here.
-   // sentinel.addresses should contain a list of (hostname, port) pairs
-   // where Sentinels are listening. IPs can also be used.
-   cfg.sentinel.addresses = {
-      {"localhost", "26379"},
-      {"localhost", "26380"},
-      {"localhost", "26381"},
-   };
-
-   // Set master_name to the identifier that you configured
-   // in the "sentinel monitor" statement of your sentinel.conf file
-   cfg.sentinel.master_name = "mymaster";
-
-   // async_run will contact the Sentinels, obtain the master address,
-   // connect to it and keep the connection healthy. If a failover happens,
-   // the address will be resolved again and the new elected master will be contacted.
-   auto conn = std::make_shared<connection>(co_await asio::this_coro::executor);
-   conn->async_run(cfg, asio::consign(asio::detached, conn));
-
-   // You can now use the connection normally, as you would use a connection to a single master.
-   request req;
-   req.push("PING", "Hello world");
-   response<std::string> resp;
-
-   // Execute the request.
-   co_await conn->async_exec(req, resp);
-   conn->cancel();
-
-   std::cout << "PING: " << std::get<0>(resp).value() << std::endl;
-}
-
-#endif  // defined(BOOST_ASIO_HAS_CO_AWAIT)
--- a/example/cpp20_streams.cpp
+++ b/example/cpp20_streams.cpp
@@ -1,97 +0,0 @@
-/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
- *
- * Distributed under the Boost Software License, Version 1.0. (See
- * accompanying file LICENSE.txt)
- */
-
-#include <boost/redis/connection.hpp>
-
-#include <boost/asio/awaitable.hpp>
-#include <boost/asio/co_spawn.hpp>
-#include <boost/asio/consign.hpp>
-#include <boost/asio/detached.hpp>
-#include <boost/asio/signal_set.hpp>
-
-#include <iostream>
-
-#if defined(BOOST_ASIO_HAS_CO_AWAIT)
-
-#include <memory>
-#include <string>
-#include <thread>
-#include <vector>
-
-namespace net = boost::asio;
-using boost::redis::config;
-using boost::redis::generic_response;
-using boost::redis::operation;
-using boost::redis::request;
-using boost::redis::connection;
-using net::signal_set;
-
-auto stream_reader(std::shared_ptr<connection> conn) -> net::awaitable<void>
-{
-   std::string redisStreamKey_;
-   request req;
-   generic_response resp;
-
-   std::string stream_id{"$"};
-   std::string const field = "myfield";
-
-   for (;;) {
-      req.push("XREAD", "BLOCK", "0", "STREAMS", "test-topic", stream_id);
-      co_await conn->async_exec(req, resp);
-
-      //std::cout << "Response: ";
-      //for (auto i = 0UL; i < resp->size(); ++i) {
-      //    std::cout << resp->at(i).value << ", ";
-      //}
-      //std::cout << std::endl;
-
-      // The following approach was taken in order to be able to
-      // deal with the responses, as generated by redis in the case
-      // that there are multiple stream 'records' within a single
-      // generic_response.  The nesting and number of values in
-      // resp.value() are different, depending on the contents
-      // of the stream in redis.  Uncomment the above commented-out
-      // code for examples while running the XADD command.
-
-      std::size_t item_index = 0;
-      while (item_index < std::size(resp.value())) {
-         auto const& val = resp.value().at(item_index).value;
-
-         if (field.compare(val) == 0) {
-            // We've hit a myfield field.
-            // The streamId is located at item_index - 2
-            // The payload is located at item_index + 1
-            stream_id = resp.value().at(item_index - 2).value;
-            std::cout << "StreamId: " << stream_id << ", "
-                      << "MyField: " << resp.value().at(item_index + 1).value << std::endl;
-            ++item_index;  // We can increase so we don't read this again
-         }
-
-         ++item_index;
-      }
-
-      req.clear();
-      resp.value().clear();
-   }
-}
-
-// Run this in another terminal:
-// redis-cli -r 100000 -i 0.0001 XADD "test-topic" "*" "myfield" "myfieldvalue1"
-auto co_main(config cfg) -> net::awaitable<void>
-{
-   auto ex = co_await net::this_coro::executor;
-   auto conn = std::make_shared<connection>(ex);
-   net::co_spawn(ex, stream_reader(conn), net::detached);
-
-   // Disable health checks.
-   cfg.health_check_interval = std::chrono::seconds::zero();
-   conn->async_run(cfg, net::consign(net::detached, conn));
-
-   signal_set sig_set(ex, SIGINT, SIGTERM);
-   co_await sig_set.async_wait();
-   conn->cancel();
-}
-#endif  // defined(BOOST_ASIO_HAS_CO_AWAIT)
--- a/example/cpp20_subscriber.cpp
+++ b/example/cpp20_subscriber.cpp
@@ -1,97 +0,0 @@
-/* Copyright (c) 2018-2025 Marcelo Zimbres Silva (mzimbres@gmail.com)
- *
- * Distributed under the Boost Software License, Version 1.0. (See
- * accompanying file LICENSE.txt)
- */
-
-#include <boost/redis/connection.hpp>
-
-#include <boost/asio/as_tuple.hpp>
-#include <boost/asio/awaitable.hpp>
-#include <boost/asio/co_spawn.hpp>
-#include <boost/asio/consign.hpp>
-#include <boost/asio/detached.hpp>
-#include <boost/asio/signal_set.hpp>
-
-#include <iostream>
-
-#if defined(BOOST_ASIO_HAS_CO_AWAIT)
-
-namespace asio = boost::asio;
-using namespace std::chrono_literals;
-using boost::redis::request;
-using boost::redis::generic_flat_response;
-using boost::redis::config;
-using boost::system::error_code;
-using boost::redis::connection;
-using asio::signal_set;
-
-/* This example will subscribe and read pushes indefinitely.
- *
- * To test send messages with redis-cli
- *
- *    $ redis-cli -3
- *    127.0.0.1:6379> PUBLISH mychannel some-message
- *    (integer) 3
- *    127.0.0.1:6379>
- *
- * To test reconnection try, for example, to close all clients currently
- * connected to the Redis instance
- *
- * $ redis-cli
- * > CLIENT kill TYPE pubsub
- */
-
-// Receives server pushes.
-auto receiver(std::shared_ptr<connection> conn) -> asio::awaitable<void>
-{
-   generic_flat_response resp;
-   conn->set_receive_response(resp);
-
-   // Subscribe to the channel 'mychannel'. You can add any number of channels here.
-   request req;
-   req.subscribe({"mychannel"});
-   co_await conn->async_exec(req);
-
-   // You're now subscribed to 'mychannel'. Pushes sent over this channel will be stored
-   // in resp. If the connection encounters a network error and reconnects to the server,
-   // it will automatically subscribe to 'mychannel' again. This is transparent to the user.
-   // You need to use specialized request::subscribe() function (instead of request::push)
-   // to enable this behavior.
-
-   // Loop to read Redis push messages.
-   while (conn->will_reconnect()) {
-      // Wait for pushes
-      auto [ec] = co_await conn->async_receive2(asio::as_tuple);
-
-      // Check for errors and cancellations
-      if (ec) {
-         std::cerr << "Error during receive: " << ec << std::endl;
-         break;
-      }
-
-      // The response must be consumed without suspending the
-      // coroutine i.e. without the use of async operations.
-      for (auto const& elem : resp.value())
-         std::cout << elem.value << "\n";
-
-      std::cout << std::endl;
-
-      resp.value().clear();
-   }
-}
-
-auto co_main(config cfg) -> asio::awaitable<void>
-{
-   auto ex = co_await asio::this_coro::executor;
-   auto conn = std::make_shared<connection>(ex);
-   asio::co_spawn(ex, receiver(conn), asio::detached);
-   conn->async_run(cfg, asio::consign(asio::detached, conn));
-
-   signal_set sig_set(ex, SIGINT, SIGTERM);
-   co_await sig_set.async_wait();
-
-   conn->cancel();
-}
-
-#endif  // defined(BOOST_ASIO_HAS_CO_AWAIT)
--- a/example/cpp20_timeouts.cpp
+++ b/example/cpp20_timeouts.cpp
@@ -1,49 +0,0 @@
-/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
- *
- * Distributed under the Boost Software License, Version 1.0. (See
- * accompanying file LICENSE.txt)
- */
-
-#include <boost/redis/connection.hpp>
-
-#include <boost/asio/cancel_after.hpp>
-#include <boost/asio/co_spawn.hpp>
-#include <boost/asio/consign.hpp>
-#include <boost/asio/detached.hpp>
-
-#include <iostream>
-
-#if defined(BOOST_ASIO_HAS_CO_AWAIT)
-
-namespace asio = boost::asio;
-using boost::redis::request;
-using boost::redis::response;
-using boost::redis::config;
-using boost::redis::connection;
-using namespace std::chrono_literals;
-
-// Called from the main function (see main.cpp)
-auto co_main(config cfg) -> asio::awaitable<void>
-{
-   auto conn = std::make_shared<connection>(co_await asio::this_coro::executor);
-   conn->async_run(cfg, asio::consign(asio::detached, conn));
-
-   // A request containing only a ping command.
-   request req;
-   req.push("PING", "Hello world");
-
-   // Response where the PONG response will be stored.
-   response<std::string> resp;
-
-   // Executes the request with a timeout. If the server is down,
-   // async_exec will wait until it's back again, so it,
-   // may suspend for a long time.
-   // For this reason, it's good practice to set a timeout to requests with cancel_after.
-   // If the request hasn't completed after 10 seconds, an exception will be thrown.
-   co_await conn->async_exec(req, resp, asio::cancel_after(10s));
-   conn->cancel();
-
-   std::cout << "PING: " << std::get<0>(resp).value() << std::endl;
-}
-
-#endif  // defined(BOOST_ASIO_HAS_CO_AWAIT)
--- a/example/cpp20_unix_sockets.cpp
+++ b/example/cpp20_unix_sockets.cpp
@@ -1,60 +0,0 @@
-//
-// Copyright (c) 2025 Marcelo Zimbres Silva (mzimbres@gmail.com),
-// Ruben Perez Hidalgo (rubenperez038 at gmail dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-#include <boost/asio/awaitable.hpp>
-
-#if defined(BOOST_ASIO_HAS_CO_AWAIT)
-
-#include <boost/redis/connection.hpp>
-
-#include <boost/asio/consign.hpp>
-#include <boost/asio/detached.hpp>
-#include <boost/asio/this_coro.hpp>
-
-#include <iostream>
-
-namespace asio = boost::asio;
-using boost::redis::request;
-using boost::redis::response;
-using boost::redis::config;
-using boost::redis::logger;
-using boost::redis::connection;
-
-#ifdef BOOST_ASIO_HAS_LOCAL_SOCKETS
-
-auto co_main(config cfg) -> asio::awaitable<void>
-{
-   // If unix_socket is set to a non-empty string, UNIX domain sockets will be used
-   // instead of TCP. Set this value to the path where your server is listening.
-   // UNIX domain socket connections work in the same way as TCP connections.
-   cfg.unix_socket = "/tmp/redis-socks/redis.sock";
-
-   auto conn = std::make_shared<connection>(co_await asio::this_coro::executor);
-   conn->async_run(cfg, asio::consign(asio::detached, conn));
-
-   request req;
-   req.push("PING");
-
-   response<std::string> resp;
-
-   co_await conn->async_exec(req, resp);
-   conn->cancel();
-
-   std::cout << "Response: " << std::get<0>(resp).value() << std::endl;
-}
-
-#else
-
-auto co_main(config) -> asio::awaitable<void>
-{
-   std::cout << "Sorry, your system does not support UNIX domain sockets\n";
-   co_return;
-}
-
-#endif
-
-#endif
--- a/examples/boost_redis.cpp
+++ b/examples/boost_redis.cpp
--- a/examples/cpp17_intro.cpp
+++ b/examples/cpp17_intro.cpp
@@ -5,18 +5,16 @@
 */

 #include <boost/redis/connection.hpp>
-
 #include <boost/asio/detached.hpp>
-
 #include <iostream>

-namespace asio = boost::asio;
+namespace net = boost::asio;
 using boost::redis::connection;
 using boost::redis::request;
 using boost::redis::response;
 using boost::redis::config;

-auto main(int argc, char* argv[]) -> int
+auto main(int argc, char * argv[]) -> int
 {
   try {
      config cfg;
@@ -31,10 +29,10 @@ auto main(int argc, char* argv[]) -> int

      response<std::string> resp;

-      asio::io_context ioc;
+      net::io_context ioc;
      connection conn{ioc};

-      conn.async_run(cfg, asio::detached);
+      conn.async_run(cfg, {}, net::detached);

      conn.async_exec(req, resp, [&](auto ec, auto) {
         if (!ec)
@@ -49,3 +47,4 @@ auto main(int argc, char* argv[]) -> int
      return 1;
   }
 }
+
--- a/examples/cpp17_intro_sync.cpp
+++ b/examples/cpp17_intro_sync.cpp
@@ -6,15 +6,16 @@

 #include "sync_connection.hpp"

-#include <iostream>
 #include <string>
+#include <iostream>

+namespace net = boost::asio;
 using boost::redis::sync_connection;
 using boost::redis::request;
 using boost::redis::response;
 using boost::redis::config;

-auto main(int argc, char* argv[]) -> int
+auto main(int argc, char * argv[]) -> int
 {
   try {
      config cfg;
--- a/examples/cpp20_chat_room.cpp
+++ b/examples/cpp20_chat_room.cpp
@@ -0,0 +1,99 @@
+/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
+ *
+ * Distributed under the Boost Software License, Version 1.0. (See
+ * accompanying file LICENSE.txt)
+ */
+
+#include <boost/redis/connection.hpp>
+#include <boost/asio/deferred.hpp>
+#include <boost/asio/signal_set.hpp>
+#include <boost/asio/co_spawn.hpp>
+#include <boost/asio/detached.hpp>
+#include <boost/asio/redirect_error.hpp>
+#include <boost/asio/posix/stream_descriptor.hpp>
+#include <unistd.h>
+#include <iostream>
+
+#if defined(BOOST_ASIO_HAS_CO_AWAIT)
+#if defined(BOOST_ASIO_HAS_POSIX_STREAM_DESCRIPTOR)
+
+namespace net = boost::asio;
+using stream_descriptor = net::deferred_t::as_default_on_t<net::posix::stream_descriptor>;
+using signal_set = net::deferred_t::as_default_on_t<net::signal_set>;
+using boost::redis::request;
+using boost::redis::generic_response;
+using boost::redis::config;
+using boost::redis::connection;
+using boost::redis::ignore;
+using net::redirect_error;
+using net::use_awaitable;
+using boost::system::error_code;
+using namespace std::chrono_literals;
+
+// Chat over Redis pubsub. To test, run this program from multiple
+// terminals and type messages to stdin.
+
+auto
+receiver(std::shared_ptr<connection> conn) -> net::awaitable<void>
+{
+   request req;
+   req.push("SUBSCRIBE", "channel");
+
+   while (conn->will_reconnect()) {
+
+      // Subscribe to channels.
+      co_await conn->async_exec(req, ignore, net::deferred);
+
+      // Loop reading Redis push messages.
+      for (generic_response resp;;) {
+         error_code ec;
+         co_await conn->async_receive(resp, redirect_error(use_awaitable, ec));
+         if (ec)
+            break; // Connection lost, break so we can reconnect to channels.
+         std::cout
+            << resp.value().at(1).value
+            << " " << resp.value().at(2).value
+            << " " << resp.value().at(3).value
+            << std::endl;
+         resp.value().clear();
+      }
+   }
+}
+
+// Publishes stdin messages to a Redis channel.
+auto publisher(std::shared_ptr<stream_descriptor> in, std::shared_ptr<connection> conn) -> net::awaitable<void>
+{
+   for (std::string msg;;) {
+      auto n = co_await net::async_read_until(*in, net::dynamic_buffer(msg, 1024), "\n");
+      request req;
+      req.push("PUBLISH", "channel", msg);
+      co_await conn->async_exec(req, ignore, net::deferred);
+      msg.erase(0, n);
+   }
+}
+
+// Called from the main function (see main.cpp)
+auto co_main(config cfg) -> net::awaitable<void>
+{
+   auto ex = co_await net::this_coro::executor;
+   auto conn = std::make_shared<connection>(ex);
+   auto stream = std::make_shared<stream_descriptor>(ex, ::dup(STDIN_FILENO));
+
+   net::co_spawn(ex, receiver(conn), net::detached);
+   net::co_spawn(ex, publisher(stream, conn), net::detached);
+   conn->async_run(cfg, {}, net::consign(net::detached, conn));
+
+   signal_set sig_set{ex, SIGINT, SIGTERM};
+   co_await sig_set.async_wait();
+   conn->cancel();
+   stream->cancel();
+}
+
+#else // defined(BOOST_ASIO_HAS_POSIX_STREAM_DESCRIPTOR)
+auto co_main(config const&) -> net::awaitable<void>
+{
+   std::cout << "Requires support for posix streams." << std::endl;
+   co_return;
+}
+#endif // defined(BOOST_ASIO_HAS_POSIX_STREAM_DESCRIPTOR)
+#endif // defined(BOOST_ASIO_HAS_CO_AWAIT)
--- a/examples/cpp20_containers.cpp
+++ b/examples/cpp20_containers.cpp
@@ -0,0 +1,102 @@
+/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
+ *
+ * Distributed under the Boost Software License, Version 1.0. (See
+ * accompanying file LICENSE.txt)
+ */
+
+#include <boost/redis/connection.hpp>
+#include <boost/asio/deferred.hpp>
+#include <boost/asio/detached.hpp>
+#include <boost/asio/co_spawn.hpp>
+#include <map>
+#include <vector>
+#include <iostream>
+
+#if defined(BOOST_ASIO_HAS_CO_AWAIT)
+
+namespace net = boost::asio;
+using boost::redis::request;
+using boost::redis::response;
+using boost::redis::ignore_t;
+using boost::redis::ignore;
+using boost::redis::config;
+using boost::redis::connection;
+
+void print(std::map<std::string, std::string> const& cont)
+{
+   for (auto const& e: cont)
+      std::cout << e.first << ": " << e.second << "\n";
+}
+
+void print(std::vector<int> const& cont)
+{
+   for (auto const& e: cont) std::cout << e << " ";
+   std::cout << "\n";
+}
+
+// Stores the content of some STL containers in Redis.
+auto store(std::shared_ptr<connection> conn) -> net::awaitable<void>
+{
+   std::vector<int> vec
+      {1, 2, 3, 4, 5, 6};
+
+   std::map<std::string, std::string> map
+      {{"key1", "value1"}, {"key2", "value2"}, {"key3", "value3"}};
+
+   request req;
+   req.push_range("RPUSH", "rpush-key", vec);
+   req.push_range("HSET", "hset-key", map);
+
+   co_await conn->async_exec(req, ignore, net::deferred);
+}
+
+auto hgetall(std::shared_ptr<connection> conn) -> net::awaitable<void>
+{
+   // A request contains multiple commands.
+   request req;
+   req.push("HGETALL", "hset-key");
+
+   // Responses as tuple elements.
+   response<std::map<std::string, std::string>> resp;
+
+   // Executes the request and reads the response.
+   co_await conn->async_exec(req, resp, net::deferred);
+
+   print(std::get<0>(resp).value());
+}
+
+// Retrieves in a transaction.
+auto transaction(std::shared_ptr<connection> conn) -> net::awaitable<void>
+{
+   request req;
+   req.push("MULTI");
+   req.push("LRANGE", "rpush-key", 0, -1); // Retrieves
+   req.push("HGETALL", "hset-key"); // Retrieves
+   req.push("EXEC");
+
+   response<
+      ignore_t, // multi
+      ignore_t, // lrange
+      ignore_t, // hgetall
+      response<std::optional<std::vector<int>>, std::optional<std::map<std::string, std::string>>> // exec
+   > resp;
+
+   co_await conn->async_exec(req, resp, net::deferred);
+
+   print(std::get<0>(std::get<3>(resp).value()).value().value());
+   print(std::get<1>(std::get<3>(resp).value()).value().value());
+}
+
+// Called from the main function (see main.cpp)
+net::awaitable<void> co_main(config cfg)
+{
+   auto conn = std::make_shared<connection>(co_await net::this_coro::executor);
+   conn->async_run(cfg, {}, net::consign(net::detached, conn));
+
+   co_await store(conn);
+   co_await transaction(conn);
+   co_await hgetall(conn);
+   conn->cancel();
+}
+
+#endif // defined(BOOST_ASIO_HAS_CO_AWAIT)
--- a/examples/cpp20_echo_server.cpp
+++ b/examples/cpp20_echo_server.cpp
@@ -5,20 +5,19 @@
 */

 #include <boost/redis/connection.hpp>
-
-#include <boost/asio/co_spawn.hpp>
-#include <boost/asio/consign.hpp>
-#include <boost/asio/detached.hpp>
-#include <boost/asio/read_until.hpp>
-#include <boost/asio/redirect_error.hpp>
+#include <boost/asio/deferred.hpp>
 #include <boost/asio/signal_set.hpp>
-
+#include <boost/asio/detached.hpp>
+#include <boost/asio/redirect_error.hpp>
+#include <boost/asio/co_spawn.hpp>
 #include <iostream>

 #if defined(BOOST_ASIO_HAS_CO_AWAIT)

-namespace asio = boost::asio;
-using boost::asio::signal_set;
+namespace net = boost::asio;
+using tcp_socket = net::deferred_t::as_default_on_t<net::ip::tcp::socket>;
+using tcp_acceptor = net::deferred_t::as_default_on_t<net::ip::tcp::acceptor>;
+using signal_set = net::deferred_t::as_default_on_t<net::signal_set>;
 using boost::redis::request;
 using boost::redis::response;
 using boost::redis::config;
@@ -26,17 +25,16 @@ using boost::system::error_code;
 using boost::redis::connection;
 using namespace std::chrono_literals;

-auto echo_server_session(asio::ip::tcp::socket socket, std::shared_ptr<connection> conn)
-   -> asio::awaitable<void>
+auto echo_server_session(tcp_socket socket, std::shared_ptr<connection> conn) -> net::awaitable<void>
 {
   request req;
   response<std::string> resp;

   for (std::string buffer;;) {
-      auto n = co_await asio::async_read_until(socket, asio::dynamic_buffer(buffer, 1024), "\n");
+      auto n = co_await net::async_read_until(socket, net::dynamic_buffer(buffer, 1024), "\n");
      req.push("PING", buffer);
-      co_await conn->async_exec(req, resp);
-      co_await asio::async_write(socket, asio::buffer(std::get<0>(resp).value()));
+      co_await conn->async_exec(req, resp, net::deferred);
+      co_await net::async_write(socket, net::buffer(std::get<0>(resp).value()));
      std::get<0>(resp).value().clear();
      req.clear();
      buffer.erase(0, n);
@@ -44,29 +42,29 @@ auto echo_server_session(asio::ip::tcp::socket socket, std::shared_ptr<connectio
 }

 // Listens for tcp connections.
-auto listener(std::shared_ptr<connection> conn) -> asio::awaitable<void>
+auto listener(std::shared_ptr<connection> conn) -> net::awaitable<void>
 {
   try {
-      auto ex = co_await asio::this_coro::executor;
-      asio::ip::tcp::acceptor acc(ex, {asio::ip::tcp::v4(), 55555});
+      auto ex = co_await net::this_coro::executor;
+      tcp_acceptor acc(ex, {net::ip::tcp::v4(), 55555});
      for (;;)
-         asio::co_spawn(ex, echo_server_session(co_await acc.async_accept(), conn), asio::detached);
+         net::co_spawn(ex, echo_server_session(co_await acc.async_accept(), conn), net::detached);
   } catch (std::exception const& e) {
      std::clog << "Listener: " << e.what() << std::endl;
   }
 }

 // Called from the main function (see main.cpp)
-auto co_main(config cfg) -> asio::awaitable<void>
+auto co_main(config cfg) -> net::awaitable<void>
 {
-   auto ex = co_await asio::this_coro::executor;
+   auto ex = co_await net::this_coro::executor;
   auto conn = std::make_shared<connection>(ex);
-   asio::co_spawn(ex, listener(conn), asio::detached);
-   conn->async_run(cfg, asio::consign(asio::detached, conn));
+   net::co_spawn(ex, listener(conn), net::detached);
+   conn->async_run(cfg, {}, net::consign(net::detached, conn));

   signal_set sig_set(ex, SIGINT, SIGTERM);
   co_await sig_set.async_wait();
   conn->cancel();
 }

-#endif  // defined(BOOST_ASIO_HAS_CO_AWAIT)
+#endif // defined(BOOST_ASIO_HAS_CO_AWAIT)
--- a/examples/cpp20_intro.cpp
+++ b/examples/cpp20_intro.cpp
@@ -5,26 +5,25 @@
 */

 #include <boost/redis/connection.hpp>
-
+#include <boost/asio/deferred.hpp>
 #include <boost/asio/co_spawn.hpp>
-#include <boost/asio/consign.hpp>
 #include <boost/asio/detached.hpp>
-
+#include <boost/asio/consign.hpp>
 #include <iostream>

 #if defined(BOOST_ASIO_HAS_CO_AWAIT)

-namespace asio = boost::asio;
+namespace net = boost::asio;
 using boost::redis::request;
 using boost::redis::response;
 using boost::redis::config;
 using boost::redis::connection;

 // Called from the main function (see main.cpp)
-auto co_main(config cfg) -> asio::awaitable<void>
+auto co_main(config cfg) -> net::awaitable<void>
 {
-   auto conn = std::make_shared<connection>(co_await asio::this_coro::executor);
-   conn->async_run(cfg, asio::consign(asio::detached, conn));
+   auto conn = std::make_shared<connection>(co_await net::this_coro::executor);
+   conn->async_run(cfg, {}, net::consign(net::detached, conn));

   // A request containing only a ping command.
   request req;
@@ -34,10 +33,10 @@ auto co_main(config cfg) -> asio::awaitable<void>
   response<std::string> resp;

   // Executes the request.
-   co_await conn->async_exec(req, resp);
+   co_await conn->async_exec(req, resp, net::deferred);
   conn->cancel();

   std::cout << "PING: " << std::get<0>(resp).value() << std::endl;
 }

-#endif  // defined(BOOST_ASIO_HAS_CO_AWAIT)
+#endif // defined(BOOST_ASIO_HAS_CO_AWAIT)
--- a/examples/cpp20_intro_tls.cpp
+++ b/examples/cpp20_intro_tls.cpp
@@ -5,30 +5,28 @@
 */

 #include <boost/redis/connection.hpp>
-
-#include <boost/asio/consign.hpp>
-#include <boost/asio/detached.hpp>
-#include <boost/asio/ssl/context.hpp>
+#include <boost/asio/deferred.hpp>
 #include <boost/asio/use_awaitable.hpp>
-
+#include <boost/asio/detached.hpp>
+#include <boost/asio/consign.hpp>
 #include <iostream>

 #if defined(BOOST_ASIO_HAS_CO_AWAIT)

-namespace asio = boost::asio;
+namespace net = boost::asio;
 using boost::redis::request;
 using boost::redis::response;
 using boost::redis::config;
 using boost::redis::logger;
 using boost::redis::connection;

-auto verify_certificate(bool, asio::ssl::verify_context&) -> bool
+auto verify_certificate(bool, net::ssl::verify_context&) -> bool
 {
   std::cout << "set_verify_callback" << std::endl;
   return true;
 }

-auto co_main(config cfg) -> asio::awaitable<void>
+auto co_main(config cfg) -> net::awaitable<void>
 {
   cfg.use_ssl = true;
   cfg.username = "aedis";
@@ -36,22 +34,21 @@ auto co_main(config cfg) -> asio::awaitable<void>
   cfg.addr.host = "db.occase.de";
   cfg.addr.port = "6380";

-   asio::ssl::context ctx{asio::ssl::context::tlsv12_client};
-   ctx.set_verify_mode(asio::ssl::verify_peer);
-   ctx.set_verify_callback(verify_certificate);
-
-   auto conn = std::make_shared<connection>(co_await asio::this_coro::executor, std::move(ctx));
-   conn->async_run(cfg, asio::consign(asio::detached, conn));
+   auto conn = std::make_shared<connection>(co_await net::this_coro::executor);
+   conn->async_run(cfg, {}, net::consign(net::detached, conn));

   request req;
   req.push("PING");

   response<std::string> resp;

-   co_await conn->async_exec(req, resp);
+   conn->next_layer().set_verify_mode(net::ssl::verify_peer);
+   conn->next_layer().set_verify_callback(verify_certificate);
+
+   co_await conn->async_exec(req, resp, net::deferred);
   conn->cancel();

   std::cout << "Response: " << std::get<0>(resp).value() << std::endl;
 }

-#endif  // defined(BOOST_ASIO_HAS_CO_AWAIT)
+#endif // defined(BOOST_ASIO_HAS_CO_AWAIT)
--- a/examples/cpp20_json.cpp
+++ b/examples/cpp20_json.cpp
@@ -5,35 +5,33 @@
 */

 #include <boost/redis/connection.hpp>
-
-#include <boost/asio/consign.hpp>
+#include <boost/asio/deferred.hpp>
 #include <boost/asio/detached.hpp>
-#include <boost/asio/use_awaitable.hpp>
 #include <boost/describe.hpp>
-
-#include <iostream>
+#include <boost/asio/consign.hpp>
+#include <boost/asio/use_awaitable.hpp>
 #include <string>
+#include <iostream>

 #if defined(BOOST_ASIO_HAS_CO_AWAIT)

-#include <boost/redis/resp3/serialization.hpp>
-
-#include <boost/json/parse.hpp>
+#define BOOST_JSON_NO_LIB
+#define BOOST_CONTAINER_NO_LIB
 #include <boost/json/serialize.hpp>
+#include <boost/json/parse.hpp>
 #include <boost/json/value_from.hpp>
-#include <boost/json/value_to.hpp>
+#include <boost/redis/resp3/serialization.hpp>
+#include <boost/json/src.hpp>

-namespace asio = boost::asio;
-namespace resp3 = boost::redis::resp3;
+namespace net = boost::asio;
 using namespace boost::describe;
 using boost::redis::request;
 using boost::redis::response;
 using boost::redis::ignore_t;
 using boost::redis::config;
 using boost::redis::connection;
-using boost::redis::resp3::node_view;

-// Struct that will be stored in Redis using json serialization.
+// Struct that will be stored in Redis using json serialization. 
 struct user {
   std::string name;
   std::string age;
@@ -43,40 +41,37 @@ struct user {
 // The type must be described for serialization to work.
 BOOST_DESCRIBE_STRUCT(user, (), (name, age, country))

-// Boost.Redis customization points (example/json.hpp)
+// Boost.Redis customization points (examples/json.hpp)
 void boost_redis_to_bulk(std::string& to, user const& u)
-{
-   resp3::boost_redis_to_bulk(to, boost::json::serialize(boost::json::value_from(u)));
-}
+   { boost::redis::resp3::boost_redis_to_bulk(to, boost::json::serialize(boost::json::value_from(u))); }

-void boost_redis_from_bulk(user& u, node_view const& node, boost::system::error_code&)
-{
-   u = boost::json::value_to<user>(boost::json::parse(node.value));
-}
+void boost_redis_from_bulk(user& u, std::string_view sv, boost::system::error_code&)
+   { u = boost::json::value_to<user>(boost::json::parse(sv)); }

-auto co_main(config cfg) -> asio::awaitable<void>
+auto co_main(config cfg) -> net::awaitable<void>
 {
-   auto ex = co_await asio::this_coro::executor;
+   auto ex = co_await net::this_coro::executor;
   auto conn = std::make_shared<connection>(ex);
-   conn->async_run(cfg, asio::consign(asio::detached, conn));
+   conn->async_run(cfg, {}, net::consign(net::detached, conn));

   // user object that will be stored in Redis in json format.
   user const u{"Joao", "58", "Brazil"};

   // Stores and retrieves in the same request.
   request req;
-   req.push("SET", "json-key", u);  // Stores in Redis.
-   req.push("GET", "json-key");     // Retrieves from Redis.
+   req.push("SET", "json-key", u); // Stores in Redis.
+   req.push("GET", "json-key"); // Retrieves from Redis.

   response<ignore_t, user> resp;

-   co_await conn->async_exec(req, resp);
+   co_await conn->async_exec(req, resp, net::deferred);
   conn->cancel();

   // Prints the first ping
-   std::cout << "Name: " << std::get<1>(resp).value().name << "\n"
-             << "Age: " << std::get<1>(resp).value().age << "\n"
-             << "Country: " << std::get<1>(resp).value().country << "\n";
+   std::cout
+      << "Name: " << std::get<1>(resp).value().name << "\n"
+      << "Age: " << std::get<1>(resp).value().age << "\n"
+      << "Country: " << std::get<1>(resp).value().country << "\n";
 }

-#endif  // defined(BOOST_ASIO_HAS_CO_AWAIT)
+#endif // defined(BOOST_ASIO_HAS_CO_AWAIT)
--- a/examples/cpp20_protobuf.cpp
+++ b/examples/cpp20_protobuf.cpp
@@ -6,12 +6,11 @@

 #include <boost/redis/connection.hpp>
 #include <boost/redis/resp3/serialization.hpp>
-
+#include <boost/asio/deferred.hpp>
 #include <boost/asio/co_spawn.hpp>
-#include <boost/asio/consign.hpp>
 #include <boost/asio/detached.hpp>
+#include <boost/asio/consign.hpp>
 #include <boost/system/errc.hpp>
-
 #include <iostream>

 // See the definition in person.proto. This header is automatically
@@ -20,21 +19,20 @@

 #if defined(BOOST_ASIO_HAS_CO_AWAIT)

-namespace asio = boost::asio;
-namespace resp3 = boost::redis::resp3;
+namespace net = boost::asio;
 using boost::redis::request;
 using boost::redis::response;
 using boost::redis::operation;
 using boost::redis::ignore_t;
 using boost::redis::config;
 using boost::redis::connection;
-using boost::redis::resp3::node_view;

-// The protobuf type described in example/person.proto
+// The protobuf type described in examples/person.proto
 using tutorial::person;

-// Boost.Redis customization points (example/protobuf.hpp)
-namespace tutorial {
+// Boost.Redis customization points (examples/protobuf.hpp)
+namespace tutorial
+{

 // Below I am using a Boost.Redis to indicate a protobuf error, this
 // is ok for an example, users however might want to define their own
@@ -45,26 +43,26 @@ void boost_redis_to_bulk(std::string& to, person const& u)
   if (!u.SerializeToString(&tmp))
      throw boost::system::system_error(boost::redis::error::invalid_data_type);

-   resp3::boost_redis_to_bulk(to, tmp);
+   boost::redis::resp3::boost_redis_to_bulk(to, tmp);
 }

-void boost_redis_from_bulk(person& u, node_view const& node, boost::system::error_code& ec)
+void boost_redis_from_bulk(person& u, std::string_view sv, boost::system::error_code& ec)
 {
-   std::string const tmp{node.value};
+   std::string const tmp {sv};
   if (!u.ParseFromString(tmp))
      ec = boost::redis::error::invalid_data_type;
 }

-}  // namespace tutorial
+} // tutorial

 using tutorial::boost_redis_to_bulk;
 using tutorial::boost_redis_from_bulk;

-asio::awaitable<void> co_main(config cfg)
+net::awaitable<void> co_main(config cfg)
 {
-   auto ex = co_await asio::this_coro::executor;
+   auto ex = co_await net::this_coro::executor;
   auto conn = std::make_shared<connection>(ex);
-   conn->async_run(cfg, asio::consign(asio::detached, conn));
+   conn->async_run(cfg, {}, net::consign(net::detached, conn));

   person p;
   p.set_name("Louis");
@@ -78,12 +76,13 @@ asio::awaitable<void> co_main(config cfg)
   response<ignore_t, person> resp;

   // Sends the request and receives the response.
-   co_await conn->async_exec(req, resp);
+   co_await conn->async_exec(req, resp, net::deferred);
   conn->cancel();

-   std::cout << "Name: " << std::get<1>(resp).value().name() << "\n"
-             << "Age: " << std::get<1>(resp).value().id() << "\n"
-             << "Email: " << std::get<1>(resp).value().email() << "\n";
+   std::cout
+      << "Name: " << std::get<1>(resp).value().name() << "\n"
+      << "Age: " << std::get<1>(resp).value().id() << "\n"
+      << "Email: " << std::get<1>(resp).value().email() << "\n";
 }

-#endif  // defined(BOOST_ASIO_HAS_CO_AWAIT)
+#endif // defined(BOOST_ASIO_HAS_CO_AWAIT)
--- a/examples/cpp20_resolve_with_sentinel.cpp
+++ b/examples/cpp20_resolve_with_sentinel.cpp
@@ -0,0 +1,75 @@
+/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
+ *
+ * Distributed under the Boost Software License, Version 1.0. (See
+ * accompanying file LICENSE.txt)
+ */
+
+#include <boost/redis/connection.hpp>
+#include <boost/asio/use_awaitable.hpp>
+#include <boost/asio/redirect_error.hpp>
+#include <boost/asio/detached.hpp>
+#include <iostream>
+
+#if defined(BOOST_ASIO_HAS_CO_AWAIT)
+
+namespace net = boost::asio;
+using endpoints = net::ip::tcp::resolver::results_type;
+using boost::redis::request;
+using boost::redis::response;
+using boost::redis::ignore_t;
+using boost::redis::config;
+using boost::redis::address;
+using boost::redis::connection;
+
+auto redir(boost::system::error_code& ec)
+   { return net::redirect_error(net::use_awaitable, ec); }
+
+// For more info see
+// - https://redis.io/docs/manual/sentinel.
+// - https://redis.io/docs/reference/sentinel-clients.
+auto resolve_master_address(std::vector<address> const& addresses) -> net::awaitable<address>
+{
+   request req;
+   req.push("SENTINEL", "get-master-addr-by-name", "mymaster");
+   req.push("QUIT");
+
+   auto conn = std::make_shared<connection>(co_await net::this_coro::executor);
+
+   response<std::optional<std::array<std::string, 2>>, ignore_t> resp;
+   for (auto addr : addresses) {
+      boost::system::error_code ec;
+      config cfg;
+      cfg.addr = addr;
+      // TODO: async_run and async_exec should be lauched in
+      // parallel here so we can wait for async_run completion
+      // before eventually calling it again.
+      conn->async_run(cfg, {}, net::consign(net::detached, conn));
+      co_await conn->async_exec(req, resp, redir(ec));
+      conn->cancel();
+      conn->reset_stream();
+      if (!ec && std::get<0>(resp))
+         co_return address{std::get<0>(resp).value().value().at(0), std::get<0>(resp).value().value().at(1)};
+   }
+
+   co_return address{};
+}
+
+auto co_main(config cfg) -> net::awaitable<void>
+{
+   // A list of sentinel addresses from which only one is responsive.
+   // This simulates sentinels that are down.
+   std::vector<address> const addresses
+   { address{"foo", "26379"}
+   , address{"bar", "26379"}
+   , cfg.addr
+   };
+
+   auto const ep = co_await resolve_master_address(addresses);
+
+   std::clog
+      << "Host: " << ep.host << "\n"
+      << "Port: " << ep.port << "\n"
+      << std::flush;
+}
+
+#endif // defined(BOOST_ASIO_HAS_CO_AWAIT)
--- a/examples/cpp20_streams.cpp
+++ b/examples/cpp20_streams.cpp
@@ -0,0 +1,98 @@
+/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
+ *
+ * Distributed under the Boost Software License, Version 1.0. (See
+ * accompanying file LICENSE.txt)
+ */
+
+#include <boost/redis/connection.hpp>
+#include <boost/asio/deferred.hpp>
+#include <boost/asio/co_spawn.hpp>
+#include <boost/asio/detached.hpp>
+#include <boost/asio/consign.hpp>
+#include <boost/asio/signal_set.hpp>
+#include <boost/asio/awaitable.hpp>
+#include <iostream>
+
+#if defined(BOOST_ASIO_HAS_CO_AWAIT)
+
+#include <memory>
+#include <string>
+#include <thread>
+#include <vector>
+
+namespace net = boost::asio;
+using boost::redis::config;
+using boost::redis::generic_response;
+using boost::redis::operation;
+using boost::redis::request;
+using boost::redis::connection;
+using signal_set = net::deferred_t::as_default_on_t<net::signal_set>;
+
+auto stream_reader(std::shared_ptr<connection> conn) -> net::awaitable<void>
+{
+    std::string redisStreamKey_;
+    request req;
+    generic_response resp;
+
+    std::string stream_id{"$"};
+    std::string const field = "myfield";
+
+    for (;;) {
+        req.push("XREAD", "BLOCK", "0", "STREAMS", "test-topic", stream_id);
+        co_await conn->async_exec(req, resp, net::deferred);
+
+        //std::cout << "Response: ";
+        //for (auto i = 0UL; i < resp->size(); ++i) {
+        //    std::cout << resp->at(i).value << ", ";
+        //}
+        //std::cout << std::endl;
+
+        // The following approach was taken in order to be able to
+        // deal with the responses, as generated by redis in the case
+        // that there are multiple stream 'records' within a single
+        // generic_response.  The nesting and number of values in
+        // resp.value() are different, depending on the contents
+        // of the stream in redis.  Uncomment the above commented-out
+        // code for examples while running the XADD command.
+
+        std::size_t item_index = 0;
+        while (item_index < std::size(resp.value())) {
+           auto const& val = resp.value().at(item_index).value;
+
+           if (field.compare(val) == 0) {
+               // We've hit a myfield field.
+               // The streamId is located at item_index - 2
+               // The payload is located at item_index + 1
+               stream_id = resp.value().at(item_index - 2).value;
+               std::cout
+                  << "StreamId: " << stream_id << ", "
+                  << "MyField: " << resp.value().at(item_index + 1).value
+                  << std::endl;
+               ++item_index; // We can increase so we don't read this again
+           }
+
+           ++item_index;
+        }
+
+        req.clear();
+        resp.value().clear();
+    }
+}
+
+// Run this in another terminal:
+// redis-cli -r 100000 -i 0.0001 XADD "test-topic" "*" "myfield" "myfieldvalue1"
+auto co_main(config cfg) -> net::awaitable<void>
+{
+   auto ex = co_await net::this_coro::executor;
+   auto conn = std::make_shared<connection>(ex);
+   net::co_spawn(ex, stream_reader(conn), net::detached);
+
+   // Disable health checks.
+   cfg.health_check_interval = std::chrono::seconds::zero();
+   conn->async_run(cfg, {}, net::consign(net::detached, conn));
+
+   signal_set sig_set(ex, SIGINT, SIGTERM);
+   co_await sig_set.async_wait();
+   conn->cancel();
+}
+#endif // defined(BOOST_ASIO_HAS_CO_AWAIT)
--- a/examples/cpp20_subscriber.cpp
+++ b/examples/cpp20_subscriber.cpp
@@ -0,0 +1,90 @@
+/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
+ *
+ * Distributed under the Boost Software License, Version 1.0. (See
+ * accompanying file LICENSE.txt)
+ */
+
+#include <boost/redis/connection.hpp>
+#include <boost/redis/logger.hpp>
+#include <boost/asio/awaitable.hpp>
+#include <boost/asio/use_awaitable.hpp>
+#include <boost/asio/deferred.hpp>
+#include <boost/asio/co_spawn.hpp>
+#include <boost/asio/detached.hpp>
+#include <boost/asio/consign.hpp>
+#include <boost/asio/redirect_error.hpp>
+#include <boost/asio/signal_set.hpp>
+#include <iostream>
+
+#if defined(BOOST_ASIO_HAS_CO_AWAIT)
+
+namespace net = boost::asio;
+using namespace std::chrono_literals;
+using boost::redis::request;
+using boost::redis::generic_response;
+using boost::redis::logger;
+using boost::redis::config;
+using boost::redis::ignore;
+using boost::system::error_code;
+using boost::redis::connection;
+using signal_set = net::deferred_t::as_default_on_t<net::signal_set>;
+
+/* This example will subscribe and read pushes indefinitely.
+ *
+ * To test send messages with redis-cli
+ *
+ *    $ redis-cli -3
+ *    127.0.0.1:6379> PUBLISH channel some-message
+ *    (integer) 3
+ *    127.0.0.1:6379>
+ *
+ * To test reconnection try, for example, to close all clients currently
+ * connected to the Redis instance
+ *
+ * $ redis-cli
+ * > CLIENT kill TYPE pubsub
+ */
+
+// Receives server pushes.
+auto
+receiver(std::shared_ptr<connection> conn) -> net::awaitable<void>
+{
+   request req;
+   req.push("SUBSCRIBE", "channel");
+
+   // Loop while reconnection is enabled
+   while (conn->will_reconnect()) {
+
+      // Reconnect to channels.
+      co_await conn->async_exec(req, ignore, net::deferred);
+
+      // Loop reading Redis pushs messages.
+      for (generic_response resp;;) {
+         error_code ec;
+         co_await conn->async_receive(resp, net::redirect_error(net::use_awaitable, ec));
+         if (ec)
+            break; // Connection lost, break so we can reconnect to channels.
+         std::cout
+            << resp.value().at(1).value
+            << " " << resp.value().at(2).value
+            << " " << resp.value().at(3).value
+            << std::endl;
+         resp.value().clear();
+      }
+   }
+}
+
+auto co_main(config cfg) -> net::awaitable<void>
+{
+   auto ex = co_await net::this_coro::executor;
+   auto conn = std::make_shared<connection>(ex);
+   net::co_spawn(ex, receiver(conn), net::detached);
+   conn->async_run(cfg, {}, net::consign(net::detached, conn));
+
+   signal_set sig_set(ex, SIGINT, SIGTERM);
+   co_await sig_set.async_wait();
+
+   conn->cancel();
+}
+
+#endif // defined(BOOST_ASIO_HAS_CO_AWAIT)
--- a/examples/main.cpp
+++ b/examples/main.cpp
@@ -4,24 +4,22 @@
 * accompanying file LICENSE.txt)
 */

-#include <boost/redis/config.hpp>
 #include <boost/redis/connection.hpp>
-
+#include <boost/redis/config.hpp>
 #include <boost/asio/co_spawn.hpp>
-#include <boost/asio/io_context.hpp>
 #include <boost/asio/use_awaitable.hpp>
-
+#include <boost/asio/io_context.hpp>
 #include <iostream>

-namespace asio = boost::asio;
+namespace net = boost::asio;
 using boost::redis::config;
 using boost::redis::logger;

 #if defined(BOOST_ASIO_HAS_CO_AWAIT)

-extern asio::awaitable<void> co_main(config);
+extern net::awaitable<void> co_main(config);

-auto main(int argc, char* argv[]) -> int
+auto main(int argc, char * argv[]) -> int
 {
   try {
      config cfg;
@@ -31,8 +29,8 @@ auto main(int argc, char* argv[]) -> int
         cfg.addr.port = argv[2];
      }

-      asio::io_context ioc;
-      asio::co_spawn(ioc, co_main(cfg), [](std::exception_ptr p) {
+      net::io_context ioc;
+      net::co_spawn(ioc, std::move(co_main(cfg)), [](std::exception_ptr p) {
         if (p)
            std::rethrow_exception(p);
      });
@@ -44,7 +42,7 @@ auto main(int argc, char* argv[]) -> int
   }
 }

-#else  // defined(BOOST_ASIO_HAS_CO_AWAIT)
+#else // defined(BOOST_ASIO_HAS_CO_AWAIT)

 auto main() -> int
 {
@@ -52,4 +50,4 @@ auto main() -> int
   return 0;
 }

-#endif  // defined(BOOST_ASIO_HAS_CO_AWAIT)
+#endif // defined(BOOST_ASIO_HAS_CO_AWAIT)
--- a/examples/person.proto
+++ b/examples/person.proto
--- a/examples/sync_connection.hpp
+++ b/examples/sync_connection.hpp
@@ -1,5 +1,5 @@

-/* Copyright (c) 2018-2024 Marcelo Zimbres Silva (mzimbres@gmail.com)
+/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
 *
 * Distributed under the Boost Software License, Version 1.0. (See
 * accompanying file LICENSE.txt)
@@ -7,17 +7,16 @@

 #include <boost/redis/connection.hpp>
 #include <boost/redis/request.hpp>
-
 #include <boost/asio/deferred.hpp>
 #include <boost/asio/detached.hpp>
 #include <boost/asio/use_future.hpp>
-
-#include <chrono>
 #include <thread>
+#include <chrono>

 using namespace std::chrono_literals;

-namespace boost::redis {
+namespace boost::redis
+{

 class sync_connection {
 public:
@@ -26,32 +25,33 @@ public:
   , conn_{std::make_shared<connection>(ioc_)}
   { }

-   ~sync_connection() { thread_.join(); }
+   ~sync_connection()
+   {
+      thread_.join();
+   }

   void run(config cfg)
   {
      // Starts a thread that will can io_context::run on which the
      // connection will run.
      thread_ = std::thread{[this, cfg]() {
-         conn_->async_run(cfg, asio::detached);
+         conn_->async_run(cfg, {}, asio::detached);
         ioc_.run();
      }};
   }

   void stop()
   {
-      asio::dispatch(ioc_, [this]() {
-         conn_->cancel();
-      });
+      asio::dispatch(ioc_, [this]() { conn_->cancel(); });
   }

   template <class Response>
   auto exec(request const& req, Response& resp)
   {
-      asio::dispatch(conn_->get_executor(), asio::deferred([this, &req, &resp]() {
-                        return conn_->async_exec(req, resp, asio::deferred);
-                     }))(asio::use_future)
-         .get();
+      asio::dispatch(
+         conn_->get_executor(),
+         asio::deferred([this, &req, &resp]() { return conn_->async_exec(req, resp, asio::deferred); }))
+         (asio::use_future).get();
   }

 private:
@@ -60,4 +60,4 @@ private:
   std::thread thread_;
 };

-}  // namespace boost::redis
+}
--- a/include/boost/redis.hpp
+++ b/include/boost/redis.hpp
@@ -1,4 +1,4 @@
-/* Copyright (c) 2018-2024 Marcelo Zimbres Silva (mzimbres@gmail.com)
+/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
 *
 * Distributed under the Boost Software License, Version 1.0. (See
 * accompanying file LICENSE.txt)
@@ -8,12 +8,12 @@
 #define BOOST_REDIS_HPP

 #include <boost/redis/config.hpp>
-#include <boost/redis/connection.hpp>
 #include <boost/redis/error.hpp>
-#include <boost/redis/ignore.hpp>
-#include <boost/redis/logger.hpp>
+#include <boost/redis/connection.hpp>
 #include <boost/redis/request.hpp>
 #include <boost/redis/response.hpp>
+#include <boost/redis/ignore.hpp>
+#include <boost/redis/logger.hpp>

 /** @defgroup high-level-api Reference
 *
@@ -25,4 +25,4 @@
 *  This page contains the documentation of the Aedis low-level API.
 */

-#endif  // BOOST_REDIS_HPP
+#endif // BOOST_REDIS_HPP
--- a/include/boost/redis/adapter/adapt.hpp
+++ b/include/boost/redis/adapter/adapt.hpp
@@ -1,4 +1,4 @@
-/* Copyright (c) 2018-2024 Marcelo Zimbres Silva (mzimbres@gmail.com)
+/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
 *
 * Distributed under the Boost Software License, Version 1.0. (See
 * accompanying file LICENSE.txt)
@@ -7,40 +7,74 @@
 #ifndef BOOST_REDIS_ADAPTER_ADAPT_HPP
 #define BOOST_REDIS_ADAPTER_ADAPT_HPP

-#include <boost/redis/adapter/detail/response_traits.hpp>
+#include <boost/redis/resp3/node.hpp>
+#include <boost/redis/response.hpp>
 #include <boost/redis/adapter/detail/result_traits.hpp>
-#include <boost/redis/ignore.hpp>
+#include <boost/redis/adapter/detail/response_traits.hpp>
+#include <boost/mp11.hpp>
+#include <boost/system.hpp>

-namespace boost::redis::adapter {
+#include <tuple>
+#include <limits>
+#include <string_view>
+#include <variant>
+
+namespace boost::redis::adapter
+{

 /** @brief Adapts a type to be used as a response.
 *
 *  The type T must be either
 *
- *  @li a `response<T1, T2, T3, ...>`
- *  @li `std::vector<node<String>>`
+ *  1. a response<T1, T2, T3, ...> or
+ *  2. std::vector<node<String>>
 *
 *  The types T1, T2, etc can be any STL container, any integer type
 *  and `std::string`.
 *
- *  @tparam T The response type.
+ *  @param t Tuple containing the responses.
 */
-template <class T>
+template<class T>
 auto boost_redis_adapt(T& t) noexcept
 {
   return detail::response_traits<T>::adapt(t);
 }

-/** @brief Adapts a type to be used as the response to an individual command.
+/** @brief Adapts user data to read operations.
+ *  @ingroup low-level-api
 *
- * It can be used with low-level APIs, like @ref boost::redis::resp3::parser.
+ *  STL containers, \c resp3::response and built-in types are supported and
+ *  can be used in conjunction with \c std::optional<T>.
+ *
+ *  Example usage:
+ *
+ *  @code
+ *  std::unordered_map<std::string, std::string> cont;
+ *  co_await async_read(socket, buffer, adapt(cont));
+ *  @endcode
+ * 
+ *  For a transaction
+ *
+ *  @code
+ *  sr.push(command::multi);
+ *  sr.push(command::ping, ...);
+ *  sr.push(command::incr, ...);
+ *  sr.push_range(command::rpush, ...);
+ *  sr.push(command::lrange, ...);
+ *  sr.push(command::incr, ...);
+ *  sr.push(command::exec);
+ *
+ *  co_await async_write(socket, buffer(request));
+ *
+ *  // Reads the response to a transaction
+ *  resp3::response<std::string, int, int, std::vector<std::string>, int> execs;
+ *  co_await resp3::async_read(socket, dynamic_buffer(buffer), adapt(execs));
+ *  @endcode
 */
-template <class T>
+template<class T>
 auto adapt2(T& t = redis::ignore) noexcept
-{
-   return detail::result_traits<T>::adapt(t);
-}
+   { return detail::result_traits<T>::adapt(t); }

-}  // namespace boost::redis::adapter
+} // boost::redis::adapter

-#endif  // BOOST_REDIS_ADAPTER_ADAPT_HPP
+#endif // BOOST_REDIS_ADAPTER_ADAPT_HPP
--- a/include/boost/redis/adapter/any_adapter.hpp
+++ b/include/boost/redis/adapter/any_adapter.hpp
@@ -1,125 +0,0 @@
-/* Copyright (c) 2018-2025 Marcelo Zimbres Silva (mzimbres@gmail.com)
- *
- * Distributed under the Boost Software License, Version 1.0. (See
- * accompanying file LICENSE.txt)
- */
-
-#ifndef BOOST_REDIS_ANY_ADAPTER_HPP
-#define BOOST_REDIS_ANY_ADAPTER_HPP
-
-#include <boost/redis/adapter/adapt.hpp>
-#include <boost/redis/resp3/node.hpp>
-
-#include <boost/system/error_code.hpp>
-
-#include <functional>
-#include <type_traits>
-
-namespace boost::redis {
-
-/** @brief A type-erased reference to a response.
- *
- *  A type-erased response adapter. It can be executed using @ref connection::async_exec.
- *  Using this type instead of raw response references enables separate compilation.
- *
- *  Given a response object `resp` that can be passed to `async_exec`, the following two
- *  statements have the same effect:
- *
- *  @code
- *      co_await conn.async_exec(req, resp);
- *      co_await conn.async_exec(req, any_response(resp));
- *  @endcode
- */
-class any_adapter {
-public:
-   /** @brief Parse events that an adapter must support.
-    */
-   enum class parse_event
-   {
-      /// Called before the parser starts processing data
-      init,
-      /// Called for each and every node of RESP3 data
-      node,
-      /// Called when done processing a complete RESP3 message
-      done
-   };
-
-   /// The type erased implementation type.
-   using impl_t = std::function<void(parse_event, resp3::node_view const&, system::error_code&)>;
-
-   template <class T>
-   static auto create_impl(T& resp) -> impl_t;
-
-   /// Contructs from a type erased adaper
-   any_adapter(impl_t fn = [](parse_event, resp3::node_view const&, system::error_code&) { })
-   : impl_{std::move(fn)}
-   { }
-
-   /**
-     * @brief Constructor.
-     * 
-     * Creates a type-erased response adapter from `resp` by calling
-     * `boost_redis_adapt`. `T` must be a valid Redis response type.
-     * Any type passed to @ref connection::async_exec qualifies.
-     *
-     * This object stores a reference to `resp`, which must be kept alive
-     * while `*this` is being used.
-     */
-   template <class T, class = std::enable_if_t<!std::is_same_v<T, any_adapter>>>
-   explicit any_adapter(T& resp)
-   : impl_(create_impl(resp))
-   { }
-
-   /// Calls the implementation with the arguments `impl_(parse_event::init, ...);`
-   void on_init()
-   {
-      system::error_code ec;
-      impl_(parse_event::init, {}, ec);
-   };
-
-   /// Calls the implementation with the arguments `impl_(parse_event::done, ...);`
-   void on_done()
-   {
-      system::error_code ec;
-      impl_(parse_event::done, {}, ec);
-   };
-
-   /// Calls the implementation with the arguments `impl_(parse_event::node, ...);`
-   void on_node(resp3::node_view const& nd, system::error_code& ec)
-   {
-      impl_(parse_event::node, nd, ec);
-   };
-
-private:
-   impl_t impl_;
-};
-
-namespace detail {
-
-template <class Adapter>
-any_adapter::impl_t make_any_adapter_impl(Adapter&& value)
-{
-   return [adapter = std::move(value)](
-             any_adapter::parse_event ev,
-             resp3::node_view const& nd,
-             system::error_code& ec) mutable {
-      switch (ev) {
-         case any_adapter::parse_event::init: adapter.on_init(); break;
-         case any_adapter::parse_event::node: adapter.on_node(nd, ec); break;
-         case any_adapter::parse_event::done: adapter.on_done(); break;
-      }
-   };
-}
-
-}  // namespace detail
-
-}  // namespace boost::redis
-
-template <class T>
-auto boost::redis::any_adapter::create_impl(T& resp) -> impl_t
-{
-   using adapter::boost_redis_adapt;
-   return detail::make_any_adapter_impl(boost_redis_adapt(resp));
-}
-
-#endif
--- a/include/boost/redis/adapter/detail/adapters.hpp
+++ b/include/boost/redis/adapter/detail/adapters.hpp
@@ -1,4 +1,4 @@
-/* Copyright (c) 2018-2025 Marcelo Zimbres Silva (mzimbres@gmail.com)
+/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
 *
 * Distributed under the Boost Software License, Version 1.0. (See
 * accompanying file LICENSE.txt)
@@ -7,135 +7,80 @@
 #ifndef BOOST_REDIS_ADAPTER_ADAPTERS_HPP
 #define BOOST_REDIS_ADAPTER_ADAPTERS_HPP

-#include <boost/redis/adapter/result.hpp>
 #include <boost/redis/error.hpp>
-#include <boost/redis/resp3/flat_tree.hpp>
-#include <boost/redis/resp3/node.hpp>
-#include <boost/redis/resp3/serialization.hpp>
 #include <boost/redis/resp3/type.hpp>
-#include <boost/redis/response.hpp>
-
+#include <boost/redis/resp3/serialization.hpp>
+#include <boost/redis/resp3/node.hpp>
+#include <boost/redis/adapter/result.hpp>
 #include <boost/assert.hpp>

-#include <array>
-#include <charconv>
-#include <deque>
-#include <forward_list>
-#include <list>
-#include <map>
-#include <optional>
 #include <set>
-#include <string_view>
-#include <system_error>
-#include <type_traits>
-#include <unordered_map>
+#include <optional>
 #include <unordered_set>
+#include <forward_list>
+#include <system_error>
+#include <map>
+#include <unordered_map>
+#include <list>
+#include <deque>
 #include <vector>
+#include <array>
+#include <string_view>
+#include <charconv>

 // See https://stackoverflow.com/a/31658120/1077832
+#include<ciso646>
 #ifdef _LIBCPP_VERSION
 #else
 #include <cstdlib>
 #endif

-namespace boost::redis::adapter::detail {
+namespace boost::redis::adapter::detail
+{

-// Exclude bools, char and charXY_t types
-template <class T> struct is_integral_number : std::is_integral<T> { };
-template <> struct is_integral_number<bool> : std::false_type { };
-template <> struct is_integral_number<char> : std::false_type { };
-template <> struct is_integral_number<char16_t> : std::false_type { };
-template <> struct is_integral_number<char32_t> : std::false_type { };
-template <> struct is_integral_number<wchar_t> : std::false_type { };
-#ifdef __cpp_char8_t
-template <> struct is_integral_number<char8_t> : std::false_type { };
-#endif
-
-template <class T, bool = is_integral_number<T>::value>
-struct converter;
+// Serialization.

 template <class T>
-struct converter<T, true> {
-   template <class String>
-   static void apply(T& i, resp3::basic_node<String> const& node, system::error_code& ec)
-   {
-      auto const res = std::from_chars(node.value.data(), node.value.data() + node.value.size(), i);
-      if (res.ec != std::errc())
-         ec = redis::error::not_a_number;
-   }
-};
+auto boost_redis_from_bulk(T& i, std::string_view sv, system::error_code& ec) -> typename std::enable_if<std::is_integral<T>::value, void>::type
+{
+   auto const res = std::from_chars(sv.data(), sv.data() + std::size(sv), i);
+   if (res.ec != std::errc())
+      ec = redis::error::not_a_number;
+}

-template <>
-struct converter<bool, false> {
-   template <class String>
-   static void apply(bool& t, resp3::basic_node<String> const& node, system::error_code&)
-   {
-      t = *node.value.data() == 't';
-   }
-};
+inline
+void boost_redis_from_bulk(bool& t, std::string_view sv, system::error_code&)
+{
+   t = *sv.data() == 't';
+}

-template <>
-struct converter<double, false> {
-   template <class String>
-   static void apply(double& d, resp3::basic_node<String> const& node, system::error_code& ec)
-   {
+inline
+void boost_redis_from_bulk(double& d, std::string_view sv, system::error_code& ec)
+{
 #ifdef _LIBCPP_VERSION
-      // The string in node.value is not null terminated and we also
-      // don't know if there is enough space at the end for a null
-      // char. The easiest thing to do is to create a temporary.
-      std::string const tmp{node.value.data(), node.value.data() + node.value.size()};
-      char* end{};
-      d = std::strtod(tmp.data(), &end);
-      if (d == HUGE_VAL || d == 0)
-         ec = redis::error::not_a_double;
+   // The string in sv is not null terminated and we also don't know
+   // if there is enough space at the end for a null char. The easiest
+   // thing to do is to create a temporary.
+   std::string const tmp{sv.data(), sv.data() + std::size(sv)};
+   char* end{};
+   d = std::strtod(tmp.data(), &end);
+   if (d == HUGE_VAL || d == 0)
+      ec = redis::error::not_a_double;
 #else
-      auto const res = std::from_chars(node.value.data(), node.value.data() + node.value.size(), d);
-      if (res.ec != std::errc())
-         ec = redis::error::not_a_double;
-#endif  // _LIBCPP_VERSION
-   }
-};
+   auto const res = std::from_chars(sv.data(), sv.data() + std::size(sv), d);
+   if (res.ec != std::errc())
+      ec = redis::error::not_a_double;
+#endif // _LIBCPP_VERSION
+}

 template <class CharT, class Traits, class Allocator>
-struct converter<std::basic_string<CharT, Traits, Allocator>, false> {
-   template <class String>
-   static void apply(
-      std::basic_string<CharT, Traits, Allocator>& s,
-      resp3::basic_node<String> const& node,
-      system::error_code&)
-   {
-      s.append(node.value.data(), node.value.size());
-   }
-};
-
-template <class T>
-struct from_bulk_impl {
-   template <class String>
-   static void apply(T& t, resp3::basic_node<String> const& node, system::error_code& ec)
-   {
-      converter<T>::apply(t, node, ec);
-   }
-};
-
-template <class T>
-struct from_bulk_impl<std::optional<T>> {
-   template <class String>
-   static void apply(
-      std::optional<T>& op,
-      resp3::basic_node<String> const& node,
-      system::error_code& ec)
-   {
-      if (node.data_type != resp3::type::null) {
-         op.emplace(T{});
-         converter<T>::apply(op.value(), node, ec);
-      }
-   }
-};
-
-template <class T, class String>
-void boost_redis_from_bulk(T& t, resp3::basic_node<String> const& node, system::error_code& ec)
+void
+boost_redis_from_bulk(
+   std::basic_string<CharT, Traits, Allocator>& s,
+   std::string_view sv,
+   system::error_code&)
 {
-   from_bulk_impl<T>::apply(t, node, ec);
+  s.append(sv.data(), sv.size());
 }

 //================================================
@@ -146,155 +91,36 @@ private:
   Result* result_;

 public:
-   explicit general_aggregate(Result* c = nullptr)
-   : result_(c)
-   { }
-
-   void on_init() { }
-   void on_done() { }
-
-   template <class String>
-   void on_node(resp3::basic_node<String> const& nd, system::error_code&)
+   explicit general_aggregate(Result* c = nullptr): result_(c) {}
+   void operator()(resp3::basic_node<std::string_view> const& nd, system::error_code&)
   {
      BOOST_ASSERT_MSG(!!result_, "Unexpected null pointer");
      switch (nd.data_type) {
         case resp3::type::blob_error:
         case resp3::type::simple_error:
-            *result_ = error{
-               nd.data_type,
-               std::string{std::cbegin(nd.value), std::cend(nd.value)}
-            };
+            *result_ = error{nd.data_type, std::string{std::cbegin(nd.value), std::cend(nd.value)}};
            break;
         default:
-            if (result_->has_value()) {
-               (**result_).push_back({
-                  nd.data_type,
-                  nd.aggregate_size,
-                  nd.depth,
-                  std::string{std::cbegin(nd.value), std::cend(nd.value)}
-               });
-            }
+            result_->value().push_back({nd.data_type, nd.aggregate_size, nd.depth, std::string{std::cbegin(nd.value), std::cend(nd.value)}});
      }
   }
 };

-template <>
-class general_aggregate<resp3::tree> {
-private:
-   resp3::tree* tree_ = nullptr;
-
-public:
-   explicit general_aggregate(resp3::tree* c = nullptr)
-   : tree_(c)
-   { }
-
-   void on_init() { }
-   void on_done() { }
-
-   template <class String>
-   void on_node(resp3::basic_node<String> const& nd, system::error_code&)
-   {
-      BOOST_ASSERT_MSG(!!tree_, "Unexpected null pointer");
-
-      resp3::node tmp;
-      tmp.data_type = nd.data_type;
-      tmp.aggregate_size = nd.aggregate_size;
-      tmp.depth = nd.depth;
-      tmp.value = std::string{std::cbegin(nd.value), std::cend(nd.value)};
-
-      tree_->push_back(std::move(tmp));
-   }
-};
-
-template <>
-class general_aggregate<generic_flat_response> {
-private:
-   generic_flat_response* tree_ = nullptr;
-
-public:
-   explicit general_aggregate(generic_flat_response* c = nullptr)
-   : tree_(c)
-   { }
-
-   void on_init()
-   {
-      if (tree_->has_value()) {
-         tree_->value().notify_init();
-      }
-   }
-   void on_done()
-   {
-      BOOST_ASSERT_MSG(!!tree_, "Unexpected null pointer");
-      if (tree_->has_value()) {
-         tree_->value().notify_done();
-      }
-   }
-
-   template <class String>
-   void on_node(resp3::basic_node<String> const& nd, system::error_code&)
-   {
-      BOOST_ASSERT_MSG(!!tree_, "Unexpected null pointer");
-      switch (nd.data_type) {
-         case resp3::type::blob_error:
-         case resp3::type::simple_error:
-            *tree_ = error{
-               nd.data_type,
-               std::string{std::cbegin(nd.value), std::cend(nd.value)}
-            };
-            break;
-         default:
-            if (tree_->has_value()) {
-               (**tree_).push(nd);
-            }
-      }
-   }
-};
-
-template <>
-class general_aggregate<resp3::flat_tree> {
-private:
-   resp3::flat_tree* tree_ = nullptr;
-
-public:
-   explicit general_aggregate(resp3::flat_tree* c = nullptr)
-   : tree_(c)
-   { }
-
-   void on_init() { tree_->notify_init(); }
-   void on_done() { tree_->notify_done(); }
-
-   template <class String>
-   void on_node(resp3::basic_node<String> const& nd, system::error_code&)
-   {
-      BOOST_ASSERT_MSG(!!tree_, "Unexpected null pointer");
-      tree_->push(nd);
-   }
-};
-
 template <class Node>
 class general_simple {
 private:
   Node* result_;

 public:
-   explicit general_simple(Node* t = nullptr)
-   : result_(t)
-   { }
+   explicit general_simple(Node* t = nullptr) : result_(t) {}

-   void on_init() { }
-   void on_done() { }
-
-   template <class String>
-   void on_node(resp3::basic_node<String> const& nd, system::error_code&)
+   void operator()(resp3::basic_node<std::string_view> const& nd, system::error_code&)
   {
      BOOST_ASSERT_MSG(!!result_, "Unexpected null pointer");
      switch (nd.data_type) {
         case resp3::type::blob_error:
         case resp3::type::simple_error:
-            *result_ = error{
-               nd.data_type,
-               std::string{std::cbegin(nd.value), std::cend(nd.value)}
-            };
+            *result_ = error{nd.data_type, std::string{std::cbegin(nd.value), std::cend(nd.value)}};
            break;
         default:
            result_->value().data_type = nd.data_type;
@@ -308,20 +134,20 @@ public:
 template <class Result>
 class simple_impl {
 public:
-   void on_value_available(Result&) { }
+   void on_value_available(Result&) {}

-   void on_init() { }
-   void on_done() { }
-
-   template <class String>
-   void on_node(Result& result, resp3::basic_node<String> const& node, system::error_code& ec)
+   void
+   operator()(
+      Result& result,
+      resp3::basic_node<std::string_view> const& n,
+      system::error_code& ec)
   {
-      if (is_aggregate(node.data_type)) {
+      if (is_aggregate(n.data_type)) {
         ec = redis::error::expects_resp3_simple_type;
         return;
      }

-      boost_redis_from_bulk(result, node, ec);
+      boost_redis_from_bulk(result, n.value, ec);
   }
 };

@@ -331,13 +157,14 @@ private:
   typename Result::iterator hint_;

 public:
-   void on_value_available(Result& result) { hint_ = std::end(result); }
+   void on_value_available(Result& result)
+      { hint_ = std::end(result); }

-   void on_init() { }
-   void on_done() { }
-
-   template <class String>
-   void on_node(Result& result, resp3::basic_node<String> const& nd, system::error_code& ec)
+   void
+   operator()(
+      Result& result,
+      resp3::basic_node<std::string_view> const& nd,
+      system::error_code& ec)
   {
      if (is_aggregate(nd.data_type)) {
         if (nd.data_type != resp3::type::set)
@@ -348,12 +175,12 @@ public:
      BOOST_ASSERT(nd.aggregate_size == 1);

      if (nd.depth < 1) {
-         ec = redis::error::expects_resp3_set;
-         return;
+	 ec = redis::error::expects_resp3_set;
+	 return;
      }

      typename Result::key_type obj;
-      boost_redis_from_bulk(obj, nd, ec);
+      boost_redis_from_bulk(obj, nd.value, ec);
      hint_ = result.insert(hint_, std::move(obj));
   }
 };
@@ -365,34 +192,35 @@ private:
   bool on_key_ = true;

 public:
-   void on_value_available(Result& result) { current_ = std::end(result); }
+   void on_value_available(Result& result)
+      { current_ = std::end(result); }

-   void on_init() { }
-   void on_done() { }
-
-   template <class String>
-   void on_node(Result& result, resp3::basic_node<String> const& nd, system::error_code& ec)
+   void
+   operator()(
+      Result& result,
+      resp3::basic_node<std::string_view> const& nd,
+      system::error_code& ec)
   {
      if (is_aggregate(nd.data_type)) {
         if (element_multiplicity(nd.data_type) != 2)
-            ec = redis::error::expects_resp3_map;
+           ec = redis::error::expects_resp3_map;
         return;
      }

      BOOST_ASSERT(nd.aggregate_size == 1);

      if (nd.depth < 1) {
-         ec = redis::error::expects_resp3_map;
-         return;
+	 ec = redis::error::expects_resp3_map;
+	 return;
      }

      if (on_key_) {
         typename Result::key_type obj;
-         boost_redis_from_bulk(obj, nd, ec);
+         boost_redis_from_bulk(obj, nd.value, ec);
         current_ = result.insert(current_, {std::move(obj), {}});
      } else {
         typename Result::mapped_type obj;
-         boost_redis_from_bulk(obj, nd, ec);
+         boost_redis_from_bulk(obj, nd.value, ec);
         current_->second = std::move(obj);
      }

@@ -403,20 +231,20 @@ public:
 template <class Result>
 class vector_impl {
 public:
-   void on_value_available(Result&) { }
+   void on_value_available(Result& ) { }

-   void on_init() { }
-   void on_done() { }
-
-   template <class String>
-   void on_node(Result& result, resp3::basic_node<String> const& nd, system::error_code& ec)
+   void
+   operator()(
+      Result& result,
+      resp3::basic_node<std::string_view> const& nd,
+      system::error_code& ec)
   {
      if (is_aggregate(nd.data_type)) {
         auto const m = element_multiplicity(nd.data_type);
         result.reserve(result.size() + m * nd.aggregate_size);
      } else {
         result.push_back({});
-         boost_redis_from_bulk(result.back(), nd, ec);
+         boost_redis_from_bulk(result.back(), nd.value, ec);
      }
   }
 };
@@ -427,16 +255,16 @@ private:
   int i_ = -1;

 public:
-   void on_value_available(Result&) { }
+   void on_value_available(Result& ) { }

-   void on_init() { }
-   void on_done() { }
-
-   template <class String>
-   void on_node(Result& result, resp3::basic_node<String> const& nd, system::error_code& ec)
+   void
+   operator()(
+      Result& result,
+      resp3::basic_node<std::string_view> const& nd,
+      system::error_code& ec)
   {
      if (is_aggregate(nd.data_type)) {
-         if (i_ != -1) {
+	 if (i_ != -1) {
            ec = redis::error::nested_aggregate_not_supported;
            return;
         }
@@ -452,7 +280,7 @@ public:
         }

         BOOST_ASSERT(nd.aggregate_size == 1);
-         boost_redis_from_bulk(result.at(i_), nd, ec);
+         boost_redis_from_bulk(result.at(i_), nd.value, ec);
      }

      ++i_;
@@ -461,23 +289,24 @@ public:

 template <class Result>
 struct list_impl {
-   void on_value_available(Result&) { }

-   void on_init() { }
-   void on_done() { }
+   void on_value_available(Result& ) { }

-   template <class String>
-   void on_node(Result& result, resp3::basic_node<String> const& nd, system::error_code& ec)
+   void
+   operator()(
+      Result& result,
+      resp3::basic_node<std::string_view> const& nd,
+      system::error_code& ec)
   {
      if (!is_aggregate(nd.data_type)) {
-         BOOST_ASSERT(nd.aggregate_size == 1);
-         if (nd.depth < 1) {
-            ec = redis::error::expects_resp3_aggregate;
-            return;
-         }
+        BOOST_ASSERT(nd.aggregate_size == 1);
+        if (nd.depth < 1) {
+           ec = redis::error::expects_resp3_aggregate;
+           return;
+        }

-         result.push_back({});
-         boost_redis_from_bulk(result.back(), nd, ec);
+        result.push_back({});
+        boost_redis_from_bulk(result.back(), nd.value, ec);
      }
   }
 };
@@ -485,127 +314,94 @@ struct list_impl {
 //---------------------------------------------------

 template <class T>
-struct impl_map {
-   using type = simple_impl<T>;
-};
+struct impl_map { using type = simple_impl<T>; };

 template <class Key, class Compare, class Allocator>
-struct impl_map<std::set<Key, Compare, Allocator>> {
-   using type = set_impl<std::set<Key, Compare, Allocator>>;
-};
+struct impl_map<std::set<Key, Compare, Allocator>> { using type = set_impl<std::set<Key, Compare, Allocator>>; };

 template <class Key, class Compare, class Allocator>
-struct impl_map<std::multiset<Key, Compare, Allocator>> {
-   using type = set_impl<std::multiset<Key, Compare, Allocator>>;
-};
+struct impl_map<std::multiset<Key, Compare, Allocator>> { using type = set_impl<std::multiset<Key, Compare, Allocator>>; };

 template <class Key, class Hash, class KeyEqual, class Allocator>
-struct impl_map<std::unordered_set<Key, Hash, KeyEqual, Allocator>> {
-   using type = set_impl<std::unordered_set<Key, Hash, KeyEqual, Allocator>>;
-};
+struct impl_map<std::unordered_set<Key, Hash, KeyEqual, Allocator>> { using type = set_impl<std::unordered_set<Key, Hash, KeyEqual, Allocator>>; };

 template <class Key, class Hash, class KeyEqual, class Allocator>
-struct impl_map<std::unordered_multiset<Key, Hash, KeyEqual, Allocator>> {
-   using type = set_impl<std::unordered_multiset<Key, Hash, KeyEqual, Allocator>>;
-};
+struct impl_map<std::unordered_multiset<Key, Hash, KeyEqual, Allocator>> { using type = set_impl<std::unordered_multiset<Key, Hash, KeyEqual, Allocator>>; };

 template <class Key, class T, class Compare, class Allocator>
-struct impl_map<std::map<Key, T, Compare, Allocator>> {
-   using type = map_impl<std::map<Key, T, Compare, Allocator>>;
-};
+struct impl_map<std::map<Key, T, Compare, Allocator>> { using type = map_impl<std::map<Key, T, Compare, Allocator>>; };

 template <class Key, class T, class Compare, class Allocator>
-struct impl_map<std::multimap<Key, T, Compare, Allocator>> {
-   using type = map_impl<std::multimap<Key, T, Compare, Allocator>>;
-};
+struct impl_map<std::multimap<Key, T, Compare, Allocator>> { using type = map_impl<std::multimap<Key, T, Compare, Allocator>>; };

 template <class Key, class Hash, class KeyEqual, class Allocator>
-struct impl_map<std::unordered_map<Key, Hash, KeyEqual, Allocator>> {
-   using type = map_impl<std::unordered_map<Key, Hash, KeyEqual, Allocator>>;
-};
+struct impl_map<std::unordered_map<Key, Hash, KeyEqual, Allocator>> { using type = map_impl<std::unordered_map<Key, Hash, KeyEqual, Allocator>>; };

 template <class Key, class Hash, class KeyEqual, class Allocator>
-struct impl_map<std::unordered_multimap<Key, Hash, KeyEqual, Allocator>> {
-   using type = map_impl<std::unordered_multimap<Key, Hash, KeyEqual, Allocator>>;
-};
+struct impl_map<std::unordered_multimap<Key, Hash, KeyEqual, Allocator>> { using type = map_impl<std::unordered_multimap<Key, Hash, KeyEqual, Allocator>>; };

 template <class T, class Allocator>
-struct impl_map<std::vector<T, Allocator>> {
-   using type = vector_impl<std::vector<T, Allocator>>;
-};
+struct impl_map<std::vector<T, Allocator>> { using type = vector_impl<std::vector<T, Allocator>>; };

 template <class T, std::size_t N>
-struct impl_map<std::array<T, N>> {
-   using type = array_impl<std::array<T, N>>;
-};
+struct impl_map<std::array<T, N>> { using type = array_impl<std::array<T, N>>; };

 template <class T, class Allocator>
-struct impl_map<std::list<T, Allocator>> {
-   using type = list_impl<std::list<T, Allocator>>;
-};
+struct impl_map<std::list<T, Allocator>> { using type = list_impl<std::list<T, Allocator>>; };

 template <class T, class Allocator>
-struct impl_map<std::deque<T, Allocator>> {
-   using type = list_impl<std::deque<T, Allocator>>;
-};
+struct impl_map<std::deque<T, Allocator>> { using type = list_impl<std::deque<T, Allocator>>; };

 //---------------------------------------------------

 template <class>
 class wrapper;

-template <class T>
-class wrapper<result<T>> {
+template <class Result>
+class wrapper<result<Result>> {
 public:
-   using response_type = result<T>;
-
+   using response_type = result<Result>;
 private:
   response_type* result_;
-   typename impl_map<T>::type impl_;
-   bool called_once_ = false;
+   typename impl_map<Result>::type impl_;

-   template <class String>
-   bool set_if_resp3_error(resp3::basic_node<String> const& nd) noexcept
+   bool set_if_resp3_error(resp3::basic_node<std::string_view> const& nd) noexcept
   {
      switch (nd.data_type) {
         case resp3::type::null:
         case resp3::type::simple_error:
         case resp3::type::blob_error:
-            *result_ = error{
-               nd.data_type,
-               {std::cbegin(nd.value), std::cend(nd.value)}
-            };
+            *result_ = error{nd.data_type, {std::cbegin(nd.value), std::cend(nd.value)}};
            return true;
-         default: return false;
+         default:
+            return false;
      }
   }

 public:
-   explicit wrapper(response_type* t = nullptr)
-   : result_(t)
+   explicit wrapper(response_type* t = nullptr) : result_(t)
   {
      if (result_) {
-         result_->value() = T{};
+         result_->value() = Result{};
         impl_.on_value_available(result_->value());
      }
   }

-   void on_init() { impl_.on_init(); }
-   void on_done() { impl_.on_done(); }
-
-   template <class String>
-   void on_node(resp3::basic_node<String> const& nd, system::error_code& ec)
+   void
+   operator()(
+      resp3::basic_node<std::string_view> const& nd,
+      system::error_code& ec)
   {
      BOOST_ASSERT_MSG(!!result_, "Unexpected null pointer");

      if (result_->has_error())
         return;

-      if (!std::exchange(called_once_, true) && set_if_resp3_error(nd))
+      if (set_if_resp3_error(nd))
         return;

      BOOST_ASSERT(result_);
-      impl_.on_node(result_->value(), nd, ec);
+      impl_(result_->value(), nd, ec);
   }
 };

@@ -617,33 +413,26 @@ public:
 private:
   response_type* result_;
   typename impl_map<T>::type impl_{};
-   bool called_once_ = false;

-   template <class String>
-   bool set_if_resp3_error(resp3::basic_node<String> const& nd) noexcept
+   bool set_if_resp3_error(resp3::basic_node<std::string_view> const& nd) noexcept
   {
      switch (nd.data_type) {
         case resp3::type::blob_error:
         case resp3::type::simple_error:
-            *result_ = error{
-               nd.data_type,
-               {std::cbegin(nd.value), std::cend(nd.value)}
-            };
+            *result_ = error{nd.data_type, {std::cbegin(nd.value), std::cend(nd.value)}};
            return true;
-         default: return false;
+         default:
+            return false;
      }
   }

 public:
-   explicit wrapper(response_type* o = nullptr)
-   : result_(o)
-   { }
+   explicit wrapper(response_type* o = nullptr) : result_(o) {}

-   void on_init() { impl_.on_init(); }
-   void on_done() { impl_.on_done(); }
-
-   template <class String>
-   void on_node(resp3::basic_node<String> const& nd, system::error_code& ec)
+   void
+   operator()(
+      resp3::basic_node<std::string_view> const& nd,
+      system::error_code& ec)
   {
      BOOST_ASSERT_MSG(!!result_, "Unexpected null pointer");

@@ -653,18 +442,18 @@ public:
      if (set_if_resp3_error(nd))
         return;

-      if (!std::exchange(called_once_, true) && nd.data_type == resp3::type::null)
+      if (nd.data_type == resp3::type::null)
         return;

      if (!result_->value().has_value()) {
-         result_->value() = T{};
-         impl_.on_value_available(result_->value().value());
+        result_->value() = T{};
+        impl_.on_value_available(result_->value().value());
      }

-      impl_.on_node(result_->value().value(), nd, ec);
+      impl_(result_->value().value(), nd, ec);
   }
 };

-}  // namespace boost::redis::adapter::detail
+} // boost::redis::adapter::detail

-#endif  // BOOST_REDIS_ADAPTER_ADAPTERS_HPP
+#endif // BOOST_REDIS_ADAPTER_ADAPTERS_HPP
--- a/include/boost/redis/adapter/detail/response_traits.hpp
+++ b/include/boost/redis/adapter/detail/response_traits.hpp
@@ -1,4 +1,4 @@
-/* Copyright (c) 2018-2025 Marcelo Zimbres Silva (mzimbres@gmail.com)
+/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
 *
 * Distributed under the Boost Software License, Version 1.0. (See
 * accompanying file LICENSE.txt)
@@ -7,20 +7,37 @@
 #ifndef BOOST_REDIS_ADAPTER_DETAIL_RESPONSE_TRAITS_HPP
 #define BOOST_REDIS_ADAPTER_DETAIL_RESPONSE_TRAITS_HPP

-#include <boost/redis/adapter/detail/result_traits.hpp>
-#include <boost/redis/ignore.hpp>
 #include <boost/redis/resp3/node.hpp>
 #include <boost/redis/response.hpp>
-
+#include <boost/redis/adapter/detail/result_traits.hpp>
 #include <boost/mp11.hpp>
 #include <boost/system.hpp>

+#include <tuple>
 #include <limits>
 #include <string_view>
-#include <tuple>
 #include <variant>

-namespace boost::redis::adapter::detail {
+namespace boost::redis::adapter::detail
+{
+
+class ignore_adapter {
+public:
+   void
+   operator()(std::size_t, resp3::basic_node<std::string_view> const& nd, system::error_code& ec)
+   {
+      switch (nd.data_type) {
+         case resp3::type::simple_error: ec = redis::error::resp3_simple_error; break;
+         case resp3::type::blob_error: ec = redis::error::resp3_blob_error; break;
+         case resp3::type::null: ec = redis::error::resp3_null; break;
+         default:;
+      }
+   }
+
+   [[nodiscard]]
+   auto get_supported_response_size() const noexcept
+      { return static_cast<std::size_t>(-1);}
+};

 template <class Response>
 class static_adapter {
@@ -31,44 +48,53 @@ private:
   using adapters_array_type = std::array<variant_type, size>;

   adapters_array_type adapters_;
-   std::size_t i_ = 0;

 public:
-   explicit static_adapter(Response& r) { assigner<size - 1>::assign(adapters_, r); }
-
-   void on_init()
+   explicit static_adapter(Response& r)
   {
-      using std::visit;
-      visit(
-         [&](auto& arg) {
-            arg.on_init();
-         },
-         adapters_.at(i_));
+      assigner<size - 1>::assign(adapters_, r);
   }

-   void on_done()
+   [[nodiscard]]
+   auto get_supported_response_size() const noexcept
+      { return size;}
+
+   void
+   operator()(
+      std::size_t i,
+      resp3::basic_node<std::string_view> const& nd,
+      system::error_code& ec)
   {
      using std::visit;
-      visit(
-         [&](auto& arg) {
-            arg.on_done();
-         },
-         adapters_.at(i_));
-      i_ += 1;
-   }
-
-   template <class String>
-   void on_node(resp3::basic_node<String> const& nd, system::error_code& ec)
-   {
-      using std::visit;
-
      // I am usure whether this should be an error or an assertion.
-      BOOST_ASSERT(i_ < adapters_.size());
-      visit(
-         [&](auto& arg) {
-            arg.on_node(nd, ec);
-         },
-         adapters_.at(i_));
+      BOOST_ASSERT(i < adapters_.size());
+      visit([&](auto& arg){arg(nd, ec);}, adapters_.at(i));
+   }
+};
+
+template <class Vector>
+class vector_adapter {
+private:
+   using adapter_type = typename result_traits<Vector>::adapter_type;
+   adapter_type adapter_;
+
+public:
+   explicit vector_adapter(Vector& v)
+   : adapter_{internal_adapt(v)}
+   { }
+
+   [[nodiscard]]
+   auto
+   get_supported_response_size() const noexcept
+      { return static_cast<std::size_t>(-1);}
+
+   void
+   operator()(
+      std::size_t,
+      resp3::basic_node<std::string_view> const& nd,
+      system::error_code& ec)
+   {
+      adapter_(nd, ec);
   }
 };

@@ -78,59 +104,61 @@ struct response_traits;
 template <>
 struct response_traits<ignore_t> {
   using response_type = ignore_t;
-   using adapter_type = ignore;
+   using adapter_type = detail::ignore_adapter;

-   static auto adapt(response_type&) noexcept { return ignore{}; }
+   static auto adapt(response_type&) noexcept
+      { return detail::ignore_adapter{}; }
 };

 template <>
 struct response_traits<result<ignore_t>> {
   using response_type = result<ignore_t>;
-   using adapter_type = ignore;
+   using adapter_type = detail::ignore_adapter;

-   static auto adapt(response_type&) noexcept { return ignore{}; }
+   static auto adapt(response_type&) noexcept
+      { return detail::ignore_adapter{}; }
 };

 template <class String, class Allocator>
-struct response_traits<result<resp3::basic_tree<String, Allocator>>> {
-   using response_type = result<resp3::basic_tree<String, Allocator>>;
-   using adapter_type = general_aggregate<response_type>;
+struct response_traits<result<std::vector<resp3::basic_node<String>, Allocator>>> {
+   using response_type = result<std::vector<resp3::basic_node<String>, Allocator>>;
+   using adapter_type = vector_adapter<response_type>;

-   static auto adapt(response_type& v) noexcept { return adapter_type{&v}; }
+   static auto adapt(response_type& v) noexcept
+      { return adapter_type{v}; }
 };

-template <class String>
-struct response_traits<resp3::basic_tree<String>> {
-   using response_type = resp3::basic_tree<String>;
-   using adapter_type = general_aggregate<response_type>;
-
-   static auto adapt(response_type& v) noexcept { return adapter_type{&v}; }
-};
-
-template <>
-struct response_traits<resp3::flat_tree> {
-   using response_type = resp3::flat_tree;
-   using adapter_type = general_aggregate<response_type>;
-
-   static auto adapt(response_type& v) noexcept { return adapter_type{&v}; }
-};
-
-template <>
-struct response_traits<generic_flat_response> {
-   using response_type = generic_flat_response;
-   using adapter_type = general_aggregate<response_type>;
-
-   static auto adapt(response_type& v) noexcept { return adapter_type{&v}; }
-};
-
-template <class... Ts>
+template <class ...Ts>
 struct response_traits<response<Ts...>> {
   using response_type = response<Ts...>;
   using adapter_type = static_adapter<response_type>;

-   static auto adapt(response_type& r) noexcept { return adapter_type{r}; }
+   static auto adapt(response_type& r) noexcept
+      { return adapter_type{r}; }
 };

-}  // namespace boost::redis::adapter::detail
+template <class Adapter>
+class wrapper {
+public:
+   explicit wrapper(Adapter adapter) : adapter_{adapter} {}

-#endif  // BOOST_REDIS_ADAPTER_DETAIL_RESPONSE_TRAITS_HPP
+   void operator()(resp3::basic_node<std::string_view> const& nd, system::error_code& ec)
+      { return adapter_(0, nd, ec); }
+
+   [[nodiscard]]
+   auto get_supported_response_size() const noexcept
+      { return adapter_.get_supported_response_size();}
+
+private:
+   Adapter adapter_;
+};
+
+template <class Adapter>
+auto make_adapter_wrapper(Adapter adapter)
+{
+   return wrapper{adapter};
+}
+
+} // boost::redis::adapter::detail
+
+#endif // BOOST_REDIS_ADAPTER_DETAIL_RESPONSE_TRAITS_HPP
--- a/include/boost/redis/adapter/detail/result_traits.hpp
+++ b/include/boost/redis/adapter/detail/result_traits.hpp
@@ -1,4 +1,4 @@
-/* Copyright (c) 2018-2024 Marcelo Zimbres Silva (mzimbres@gmail.com)
+/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
 *
 * Distributed under the Boost Software License, Version 1.0. (See
 * accompanying file LICENSE.txt)
@@ -7,23 +7,21 @@
 #ifndef BOOST_REDIS_ADAPTER_RESPONSE_TRAITS_HPP
 #define BOOST_REDIS_ADAPTER_RESPONSE_TRAITS_HPP

-#include <boost/redis/adapter/detail/adapters.hpp>
-#include <boost/redis/adapter/ignore.hpp>
-#include <boost/redis/adapter/result.hpp>
 #include <boost/redis/error.hpp>
-#include <boost/redis/ignore.hpp>
 #include <boost/redis/resp3/type.hpp>
-#include <boost/redis/resp3/tree.hpp>
-#include <boost/redis/resp3/flat_tree.hpp>
-
+#include <boost/redis/ignore.hpp>
+#include <boost/redis/adapter/detail/adapters.hpp>
+#include <boost/redis/adapter/result.hpp>
+#include <boost/redis/adapter/ignore.hpp>
 #include <boost/mp11.hpp>

-#include <string_view>
-#include <tuple>
-#include <variant>
 #include <vector>
+#include <tuple>
+#include <string_view>
+#include <variant>

-namespace boost::redis::adapter::detail {
+namespace boost::redis::adapter::detail
+{

 /* Traits class for response objects.
 *
@@ -32,7 +30,7 @@ namespace boost::redis::adapter::detail {
 */
 template <class Result>
 struct result_traits {
-   using adapter_type = wrapper<typename std::decay<Result>::type>;
+   using adapter_type = adapter::detail::wrapper<typename std::decay<Result>::type>;
   static auto adapt(Result& r) noexcept { return adapter_type{&r}; }
 };

@@ -58,59 +56,36 @@ struct result_traits<result<resp3::basic_node<T>>> {
 };

 template <class String, class Allocator>
-struct result_traits<result<resp3::basic_tree<String, Allocator>>> {
+struct result_traits<result<std::vector<resp3::basic_node<String>, Allocator>>> {
   using response_type = result<std::vector<resp3::basic_node<String>, Allocator>>;
   using adapter_type = adapter::detail::general_aggregate<response_type>;
   static auto adapt(response_type& v) noexcept { return adapter_type{&v}; }
 };

-template <class String>
-struct result_traits<resp3::basic_tree<String>> {
-   using response_type = resp3::basic_tree<String>;
-   using adapter_type = adapter::detail::general_aggregate<response_type>;
-   static auto adapt(response_type& v) noexcept { return adapter_type{&v}; }
-};
-
-template <>
-struct result_traits<generic_flat_response> {
-   using response_type = generic_flat_response;
-   using adapter_type = general_aggregate<response_type>;
-   static auto adapt(response_type& v) noexcept { return adapter_type{&v}; }
-};
-
-template <>
-struct result_traits<resp3::flat_tree> {
-   using response_type = resp3::flat_tree;
-   using adapter_type = general_aggregate<response_type>;
-   static auto adapt(response_type& v) noexcept { return adapter_type{&v}; }
-};
-
 template <class T>
 using adapter_t = typename result_traits<std::decay_t<T>>::adapter_type;

-template <class T>
+template<class T>
 auto internal_adapt(T& t) noexcept
-{
-   return result_traits<std::decay_t<T>>::adapt(t);
-}
+   { return result_traits<std::decay_t<T>>::adapt(t); }

 template <std::size_t N>
 struct assigner {
-   template <class T1, class T2>
-   static void assign(T1& dest, T2& from)
-   {
-      dest[N].template emplace<N>(internal_adapt(std::get<N>(from)));
-      assigner<N - 1>::assign(dest, from);
-   }
+  template <class T1, class T2>
+  static void assign(T1& dest, T2& from)
+  {
+     dest[N].template emplace<N>(internal_adapt(std::get<N>(from)));
+     assigner<N - 1>::assign(dest, from);
+  }
 };

 template <>
 struct assigner<0> {
-   template <class T1, class T2>
-   static void assign(T1& dest, T2& from)
-   {
-      dest[0].template emplace<0>(internal_adapt(std::get<0>(from)));
-   }
+  template <class T1, class T2>
+  static void assign(T1& dest, T2& from)
+  {
+     dest[0].template emplace<0>(internal_adapt(std::get<0>(from)));
+  }
 };

 template <class Tuple>
@@ -119,16 +94,16 @@ class static_aggregate_adapter;
 template <class Tuple>
 class static_aggregate_adapter<result<Tuple>> {
 private:
-   using adapters_array_type = std::array<
-      mp11::mp_rename<mp11::mp_transform<adapter_t, Tuple>, std::variant>,
-      std::tuple_size<Tuple>::value>;
+   using adapters_array_type = 
+      std::array<
+         mp11::mp_rename<
+            mp11::mp_transform<
+               adapter_t, Tuple>,
+               std::variant>,
+         std::tuple_size<Tuple>::value>;

-   // Tuple element we are currently on.
   std::size_t i_ = 0;
-
-   // Nested aggregate element counter.
   std::size_t aggregate_size_ = 0;
-
   adapters_array_type adapters_;
   result<Tuple>* res_ = nullptr;

@@ -141,74 +116,46 @@ public:
      }
   }

-   template <class String>
-   void count(resp3::basic_node<String> const& elem)
+   void count(resp3::basic_node<std::string_view> const& nd)
   {
-      if (elem.depth == 1 && is_aggregate(elem.data_type)) {
-         aggregate_size_ = element_multiplicity(elem.data_type) * elem.aggregate_size;
+      if (nd.depth == 1) {
+         if (is_aggregate(nd.data_type))
+            aggregate_size_ = element_multiplicity(nd.data_type) * nd.aggregate_size;
+         else
+            ++i_;
+
+         return;
      }

-      if (aggregate_size_ == 0) {
-         i_ += 1;
-      } else {
-         aggregate_size_ -= 1;
-      }
+      if (--aggregate_size_ == 0)
+         ++i_;
   }

-   void on_init()
-   {
-      using std::visit;
-      for (auto& adapter : adapters_) {
-         visit(
-            [&](auto& arg) {
-               arg.on_init();
-            },
-            adapter);
-      }
-   }
-
-   void on_done()
-   {
-      using std::visit;
-      for (auto& adapter : adapters_) {
-         visit(
-            [&](auto& arg) {
-               arg.on_done();
-            },
-            adapter);
-      }
-   }
-
-   template <class String>
-   void on_node(resp3::basic_node<String> const& elem, system::error_code& ec)
+   void operator()(resp3::basic_node<std::string_view> const& nd, system::error_code& ec)
   {
      using std::visit;

-      if (elem.depth == 0) {
-         auto const multiplicity = element_multiplicity(elem.data_type);
-         auto const real_aggr_size = elem.aggregate_size * multiplicity;
+      if (nd.depth == 0) {
+         auto const real_aggr_size = nd.aggregate_size * element_multiplicity(nd.data_type);
         if (real_aggr_size != std::tuple_size<Tuple>::value)
            ec = redis::error::incompatible_size;

         return;
      }

-      visit(
-         [&](auto& arg) {
-            arg.on_node(elem, ec);
-         },
-         adapters_.at(i_));
-      count(elem);
+      visit([&](auto& arg){arg(nd, ec);}, adapters_[i_]);
+      count(nd);
   }
 };

 template <class... Ts>
-struct result_traits<result<std::tuple<Ts...>>> {
+struct result_traits<result<std::tuple<Ts...>>>
+{
   using response_type = result<std::tuple<Ts...>>;
   using adapter_type = static_aggregate_adapter<response_type>;
   static auto adapt(response_type& r) noexcept { return adapter_type{&r}; }
 };

-}  // namespace boost::redis::adapter::detail
+} // boost::redis::adapter::detail

-#endif  // BOOST_REDIS_ADAPTER_RESPONSE_TRAITS_HPP
+#endif // BOOST_REDIS_ADAPTER_RESPONSE_TRAITS_HPP
--- a/include/boost/redis/adapter/ignore.hpp
+++ b/include/boost/redis/adapter/ignore.hpp
@@ -1,4 +1,4 @@
-/* Copyright (c) 2018-2025 Marcelo Zimbres Silva (mzimbres@gmail.com)
+/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
 *
 * Distributed under the Boost Software License, Version 1.0. (See
 * accompanying file LICENSE.txt)
@@ -7,32 +7,31 @@
 #ifndef BOOST_REDIS_ADAPTER_IGNORE_HPP
 #define BOOST_REDIS_ADAPTER_IGNORE_HPP

-#include <boost/redis/error.hpp>
 #include <boost/redis/resp3/node.hpp>
-
+#include <boost/redis/error.hpp>
 #include <boost/system/error_code.hpp>
+#include <string>

-namespace boost::redis::adapter {
+namespace boost::redis::adapter
+{

-/** @brief An adapter that ignores responses.
+/** @brief An adapter that ignores responses
+ *  @ingroup high-level-api
 *
 *  RESP3 errors won't be ignored.
 */
 struct ignore {
-   void on_init() { }
-   void on_done() { }
-
-   void on_node(resp3::basic_node<std::string_view> const& nd, system::error_code& ec)
+   void operator()(resp3::basic_node<std::string_view> const& nd, system::error_code& ec)
   {
      switch (nd.data_type) {
         case resp3::type::simple_error: ec = redis::error::resp3_simple_error; break;
-         case resp3::type::blob_error:   ec = redis::error::resp3_blob_error; break;
-         case resp3::type::null:         ec = redis::error::resp3_null; break;
-         default:                        ;
+         case resp3::type::blob_error: ec = redis::error::resp3_blob_error; break;
+         case resp3::type::null: ec = redis::error::resp3_null; break;
+         default:;
      }
   }
 };

-}  // namespace boost::redis::adapter
+} // boost::redis::adapter

-#endif  // BOOST_REDIS_ADAPTER_IGNORE_HPP
+#endif // BOOST_REDIS_ADAPTER_IGNORE_HPP
--- a/include/boost/redis/adapter/result.hpp
+++ b/include/boost/redis/adapter/result.hpp
@@ -1,5 +1,5 @@

-/* Copyright (c) 2018-2024 Marcelo Zimbres Silva (mzimbres@gmail.com)
+/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
 *
 * Distributed under the Boost Software License, Version 1.0. (See
 * accompanying file LICENSE.txt)
@@ -8,17 +8,17 @@
 #ifndef BOOST_REDIS_ADAPTER_RESULT_HPP
 #define BOOST_REDIS_ADAPTER_RESULT_HPP

-#include <boost/redis/detail/resp3_type_to_error.hpp>
-#include <boost/redis/error.hpp>
 #include <boost/redis/resp3/type.hpp>
-
+#include <boost/redis/error.hpp>
 #include <boost/system/result.hpp>
-
 #include <string>

-namespace boost::redis::adapter {
+namespace boost::redis::adapter
+{

-/// Stores any resp3 error.
+/** @brief Stores any resp3 error
+ *  @ingroup high-level-api
+ */
 struct error {
   /// RESP3 error data type.
   resp3::type data_type = resp3::type::invalid;
@@ -44,24 +44,38 @@ inline bool operator==(error const& a, error const& b)
 *  @param a Left hand side error object.
 *  @param b Right hand side error object.
 */
-inline bool operator!=(error const& a, error const& b) { return !(a == b); }
+inline bool operator!=(error const& a, error const& b)
+{
+   return !(a == b);
+}

-/// Stores response to individual Redis commands.
+/** @brief Stores response to individual Redis commands
+ *  @ingroup high-level-api
+ */
 template <class Value>
 using result = system::result<Value, error>;

-/**
- * @brief Allows using @ref error with `boost::system::result`.
- * @param e The error to throw.
- * @relates error
- */
-BOOST_NORETURN inline void throw_exception_from_error(error const& e, boost::source_location const&)
+BOOST_NORETURN inline void
+throw_exception_from_error(error const & e, boost::source_location const &)
 {
-   throw system::system_error(
-      system::error_code(detail::resp3_type_to_error(e.data_type)),
-      e.diagnostic);
+   system::error_code ec;
+   switch (e.data_type) {
+      case resp3::type::simple_error:
+         ec = redis::error::resp3_simple_error;
+         break;
+      case resp3::type::blob_error:
+         ec = redis::error::resp3_blob_error;
+         break;
+      case resp3::type::null:
+         ec = redis::error::resp3_null;
+         break;
+      default:
+         BOOST_ASSERT_MSG(false, "Unexpected data type.");
+   }
+
+   throw system::system_error(ec, e.diagnostic);
 }

-}  // namespace boost::redis::adapter
+} // boost::redis::adapter

-#endif  // BOOST_REDIS_ADAPTER_RESULT_HPP
+#endif // BOOST_REDIS_ADAPTER_RESULT_HPP
--- a/include/boost/redis/config.hpp
+++ b/include/boost/redis/config.hpp
@@ -1,4 +1,4 @@
-/* Copyright (c) 2018-2024 Marcelo Zimbres Silva (mzimbres@gmail.com)
+/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
 *
 * Distributed under the Boost Software License, Version 1.0. (See
 * accompanying file LICENSE.txt)
@@ -7,17 +7,16 @@
 #ifndef BOOST_REDIS_CONFIG_HPP
 #define BOOST_REDIS_CONFIG_HPP

-#include <boost/redis/request.hpp>
-
-#include <chrono>
-#include <limits>
-#include <optional>
 #include <string>
-#include <vector>
+#include <chrono>
+#include <optional>

-namespace boost::redis {
+namespace boost::redis
+{

-/// Address of a Redis server.
+/** @brief Address of a Redis server
+ *  @ingroup high-level-api
+ */
 struct address {
   /// Redis host.
   std::string host = "127.0.0.1";
@@ -25,328 +24,62 @@ struct address {
   std::string port = "6379";
 };

-/** @brief Compares two addresses for equality.
- *  @relates address
- *
- *  @param a Left hand side address.
- *  @param b Right hand side address.
+/** @brief Configure parameters used by the connection classes
+ *  @ingroup high-level-api
 */
-inline bool operator==(address const& a, address const& b)
-{
-   return a.host == b.host && a.port == b.port;
-}
-
-/** @brief Compares two addresses for inequality.
- *  @relates address
- *
- *  @param a Left hand side address.
- *  @param b Right hand side address.
- */
-inline bool operator!=(address const& a, address const& b) { return !(a == b); }
-
-/// Identifies the possible roles of a Redis server.
-enum class role
-{
-   /// The server is a master.
-   master,
-
-   /// The server is a replica.
-   replica,
-};
-
-/// Configuration values to use when using Sentinel.
-struct sentinel_config {
-   /**
-    * @brief A list of (hostname, port) pairs where the Sentinels are listening.
-    *
-    * Sentinels in this list will be contacted in order, until a successful
-    * connection is made. At this point, the `SENTINEL SENTINELS` command
-    * will be used to retrieve any additional Sentinels monitoring the configured master.
-    * Thus, it is not required to keep this list comprehensive - if Sentinels are added
-    * later, they will be detected at runtime.
-    *
-    * Sentinel will only be used if this value is not empty.
-    *
-    * Numeric IP addresses are also allowed as hostnames.
-    */
-   std::vector<address> addresses{};
-
-   /**
-    * @brief The name of the master to connect to, as configured in the
-    *        `sentinel monitor` statement in `sentinel.conf`.
-    *
-    * This field is required even when connecting to replicas.
-    */
-   std::string master_name{};
-
-   /**
-    * @brief Whether connections to Sentinels should use TLS or not.
-    *        Does not affect connections to masters.
-    *
-    * When set to `true`, physical connections to Sentinels will be established
-    * using TLS. This setting does *not* influence how masters and replicas are contacted.
-    * To use TLS when connecting to these, set @ref config::use_ssl to `true`.
-    */
-   bool use_ssl = false;
-
-   /**
-    * @brief A request to be sent to Sentinels upon connection establishment.
-    *
-    * This request is executed every time a Sentinel is contacted, and before
-    * commands like `SENTINEL GET-MASTER-NAME-BY-ADDR` are run.
-    * By default, this field contains a `HELLO 3` command.
-    * You can use this request to set up any authorization required by Sentinels.
-    *
-    * This request should ensure that the connection is upgraded to RESP3
-    * by executing `HELLO 3` or similar. RESP2 is not supported yet.
-    */
-   request setup = detail::make_hello_request();
-
-   /**
-    * @brief Time span that the Sentinel resolve operation is allowed to elapse.
-    *        Does not affect connections to masters and replicas, controlled by @ref config::resolve_timeout.
-    */
-   std::chrono::steady_clock::duration resolve_timeout = std::chrono::milliseconds{500};
-
-   /**
-    * @brief Time span that the Sentinel connect operation is allowed to elapse.
-    *        Does not affect connections to masters and replicas, controlled by @ref config::connect_timeout.
-    */
-   std::chrono::steady_clock::duration connect_timeout = std::chrono::milliseconds{500};
-
-   /**
-    * @brief Time span that the Sentinel TLS handshake operation is allowed to elapse.
-    *        Does not affect connections to masters and replicas, controlled by @ref config::ssl_handshake_timeout.
-    */
-   std::chrono::steady_clock::duration ssl_handshake_timeout = std::chrono::seconds{5};
-
-   /**
-    * @brief Time span that the Sentinel request/response exchange is allowed to elapse.
-    *        Includes executing the commands in @ref setup and the commands required to
-    *        resolve the server's address.
-    */
-   std::chrono::steady_clock::duration request_timeout = std::chrono::seconds{5};
-
-   /**
-    * @brief Whether to connect to a Redis master or to a replica.
-    *
-    * The library resolves and connects to the Redis master, by default.
-    * Set this value to @ref role::replica to connect to one of the replicas
-    * of the master identified by @ref master_name.
-    * The particular replica will be chosen randomly.
-    */
-   role server_role = role::master;
-};
-
-/// Configure parameters used by the connection classes.
 struct config {
-   /**
-    * @brief Whether to use TLS instead of plaintext connections.
-    *
-    * When using Sentinel, configures whether to use TLS when connecting to masters and replicas.
-    * Use @ref sentinel_config::use_ssl to control TLS for Sentinels.
-    */
+   /// Uses SSL instead of a plain connection.
   bool use_ssl = false;

-   /// For TCP connections, hostname and port of the Redis server. Ignored when using Sentinel.
+   /// Address of the Redis server.
   address addr = address{"127.0.0.1", "6379"};

-   /**
-    * @brief The UNIX domain socket path where the server is listening.
-    *
-    * If non-empty, communication with the server will happen using
-    * UNIX domain sockets, and @ref addr will be ignored.
-    * 
-    * UNIX domain sockets can't be used with SSL: if `unix_socket` is non-empty,
-    * @ref use_ssl must be `false`. UNIX domain sockets can't be used with Sentinel, either.
-    *
-    * UNIX domain sockets can't be used with Sentinel.
+   /** @brief Username passed to the
+    * [HELLO](https://redis.io/commands/hello/) command.  If left
+    * empty `HELLO` will be sent without authentication parameters.
    */
-   std::string unix_socket;
+   std::string username;

-   /** @brief Username used for authentication during connection establishment.
-    * 
-    * If @ref use_setup is false (the default), during connection establishment,
-    * authentication is performed by sending a `HELLO` command.
-    * This field contains the username to employ.
-    *
-    * If the username equals the literal `"default"` (the default)
-    * and no password is specified, the `HELLO` command is sent
-    * without authentication parameters.
-    *
-    * When using Sentinel, this setting applies to masters and replicas.
-    * Use @ref sentinel_config::setup to configure authorization for Sentinels.
-    */
-   std::string username = "default";
-
-   /** @brief Password used for authentication during connection establishment.
-    * 
-    * If @ref use_setup is false (the default), during connection establishment,
-    * authentication is performed by sending a `HELLO` command.
-    * This field contains the password to employ.
-    *
-    * If the username equals the literal `"default"` (the default)
-    * and no password is specified, the `HELLO` command is sent
-    * without authentication parameters.
-    *
-    * When using Sentinel, this setting applies to masters and replicas.
-    * Use @ref sentinel_config::setup to configure authorization for Sentinels.
+   /** @brief Password passed to the
+    * [HELLO](https://redis.io/commands/hello/) command.  If left
+    * empty `HELLO` will be sent without authentication parameters.
    */
   std::string password;

-   /** @brief Client name parameter to use during connection establishment.
-    * 
-    * If @ref use_setup is false (the default), during connection establishment,
-    * a `HELLO` command is sent. If this field is not empty, the `HELLO` command
-    * will contain a `SETNAME` subcommand containing this value.
-    *
-    * When using Sentinel, this setting applies to masters and replicas.
-    * Use @ref sentinel_config::setup to configure this value for Sentinels.
-    */
+   /// Client name parameter of the [HELLO](https://redis.io/commands/hello/) command.
   std::string clientname = "Boost.Redis";

-   /** @brief Database index to pass to the `SELECT` command during connection establishment.
-    * 
-    * If @ref use_setup is false (the default), and this field is set to a
-    * non-empty optional, and its value is different than zero,
-    * a `SELECT` command will be issued during connection establishment to set the logical
-    * database index. By default, no `SELECT` command is sent.
-    *
-    * When using Sentinel, this setting applies to masters and replicas.
-    */
+   /// Database that will be passed to the [SELECT](https://redis.io/commands/hello/) command.
   std::optional<int> database_index = 0;

-   /// Message used by `PING` commands sent by the health checker.
+   /// Message used by the health-checker in `boost::redis::connection::async_run`.
   std::string health_check_id = "Boost.Redis";

-   /**
-    * @brief (Deprecated) Sets the logger prefix, a string printed before log messages.
-    * 
-    * Setting a prefix in this struct is deprecated. If you need to change how log messages
-    * look like, please construct a logger object passing a formatting function, and use that
-    * logger in connection's constructor. This member will be removed in subsequent releases.
-    */
+   /// Logger prefix, see `boost::redis::logger`.
   std::string log_prefix = "(Boost.Redis) ";

-   /**
-    * @brief Time span that the resolve operation is allowed to elapse.
-    *        When using Sentinel, this setting applies to masters and replicas.
-    */
+   /// Time the resolve operation is allowed to last.
   std::chrono::steady_clock::duration resolve_timeout = std::chrono::seconds{10};

-   /**
-    * @brief Time span that the connect operation is allowed to elapse.
-    *        When using Sentinel, this setting applies to masters and replicas.
-    */
+   /// Time the connect operation is allowed to last.
   std::chrono::steady_clock::duration connect_timeout = std::chrono::seconds{10};

-   /**
-    * @brief Time span that the SSL handshake operation is allowed to elapse.
-    *        When using Sentinel, this setting applies to masters and replicas.
-    */
+   /// Time the SSL handshake operation is allowed to last.
   std::chrono::steady_clock::duration ssl_handshake_timeout = std::chrono::seconds{10};

-   /** @brief Time span between successive health checks.
-    *  Set to zero to disable health-checks.
-    *
-    * When this value is set to a non-zero duration, @ref basic_connection::async_run
-    * will issue `PING` commands whenever no command is sent to the server for more
-    * than `health_check_interval`. You can configure the message passed to the `PING`
-    * command using @ref health_check_id.
-    *
-    * Enabling health checks also sets timeouts to individual network
-    * operations. The connection is considered dead if:
-    *
-    * @li No byte can be written to the server after `health_check_interval`.
-    * @li No byte is read from the server after `2 * health_check_interval`.
-    *
-    * If the health checker finds that the connection is unresponsive, it will be closed,
-    * and a reconnection will be triggered, as if a network error had occurred.
-    *
-    * The exact timeout values are *not* part of the interface, and might change
-    * in future versions.
-    *
-    * When using Sentinel, this setting applies to masters and replicas.
-    * Sentinels are not health-checked.
+   /** Health checks interval.  
+    *  
+    *  To disable health-checks pass zero as duration.
    */
   std::chrono::steady_clock::duration health_check_interval = std::chrono::seconds{2};

-   /** @brief Time span to wait between successive connection retries.
-    *         Set to zero to disable reconnection.
-    *
-    * When using Sentinel, this setting applies to masters, replicas and Sentinels.
-    * If none of the configured Sentinels can be contacted, this time span will
-    * be waited before trying again. After a connection error with a master or replica
-    * is encountered, this time span will be waited before contacting Sentinels again.
+   /** @brief Time waited before trying a reconnection.
+    *  
+    *  To disable reconnection pass zero as duration.
    */
   std::chrono::steady_clock::duration reconnect_wait_interval = std::chrono::seconds{1};
-
-   /** @brief Maximum size of the socket read-buffer in bytes.
-    *  
-    * Sets a limit on how much data is allowed to be read into the
-    * read buffer. It can be used to prevent DDOS.
-    *
-    * When using Sentinel, this setting applies to masters, replicas and Sentinels.
-    */
-   std::size_t max_read_size = (std::numeric_limits<std::size_t>::max)();
-
-   /** @brief Grow size of the read buffer.
-    *
-    * The size by which the read buffer grows when more space is
-    * needed. This can help avoiding some memory allocations. Once the
-    * maximum size is reached no more memory allocations are made
-    * since the buffer is reused.
-    *
-    * When using Sentinel, this setting applies to masters, replicas and Sentinels.
-    */
-   std::size_t read_buffer_append_size = 4096;
-
-   /** @brief Enables using a custom requests during connection establishment.
-    * 
-    * If set to true, the @ref setup member will be sent to the server immediately after
-    * connection establishment. Every time a reconnection happens, the setup
-    * request will be executed before any other request.
-    * It can be used to perform authentication,
-    * subscribe to channels or select a database index.
-    *
-    * When set to true, *the custom setup request replaces the built-in HELLO
-    * request generated by the library*. The @ref username, @ref password,
-    * @ref clientname and @ref database_index fields *will be ignored*.
-    *
-    * By default, @ref setup contains a `"HELLO 3"` command, which upgrades the
-    * protocol to RESP3. You might modify this request as you like,
-    * but you should ensure that the resulting connection uses RESP3.
-    *
-    * To prevent sending any setup request at all, set this field to true
-    * and @ref setup to an empty request. This can be used to interface with
-    * systems that don't support `HELLO`.
-    *
-    * By default, this field is false, and @ref setup will not be used.
-    *
-    * When using Sentinel, this setting applies to masters and replicas.
-    * Use @ref sentinel_config::setup for Sentinels.
-    */
-   bool use_setup = false;
-
-   /** @brief Request to be executed after connection establishment.
-    *
-    * This member is only used if @ref use_setup is `true`. Please consult
-    * @ref use_setup docs for more info.
-    *
-    * By default, `setup` contains a `"HELLO 3"` command.
-    *
-    * When using Sentinel, this setting applies to masters and replicas.
-    * Use @ref sentinel_config::setup for Sentinels.
-    */
-   request setup = detail::make_hello_request();
-
-   /**
-    * @brief Configuration values for Sentinel. Sentinel is enabled only if
-    *        @ref sentinel_config::addresses is not empty.
-    */
-   sentinel_config sentinel{};
 };

-}  // namespace boost::redis
+} // boost::redis

-#endif  // BOOST_REDIS_CONFIG_HPP
+#endif // BOOST_REDIS_CONFIG_HPP
--- a/include/boost/redis/connection.hpp
+++ b/include/boost/redis/connection.hpp
--- a/include/boost/redis/detail/buffer.hpp
+++ b/include/boost/redis/detail/buffer.hpp
@@ -0,0 +1,99 @@
+#ifndef BOOST_REDIS_BUFFER_HPP
+#define BOOST_REDIS_BUFFER_HPP
+
+#include <limits>
+#include <string>
+#include <algorithm>
+
+#include <boost/asio/buffer.hpp>
+#include <boost/throw_exception.hpp>
+
+namespace boost::redis::detail
+{
+
+template <class Elem, class Traits, class Allocator>
+class dynamic_string_buffer {
+public:
+   using const_buffers_type = asio::const_buffer;
+   using mutable_buffers_type = asio::mutable_buffer;
+
+   explicit
+   dynamic_string_buffer(
+      std::basic_string<Elem, Traits, Allocator>& s,
+      std::size_t maximum_size) noexcept
+   : string_(s)
+   , max_size_(maximum_size)
+   {
+   }
+
+   void clear()
+   {
+      consumed_ = 0;
+   }
+
+   std::size_t size() const noexcept
+   {
+      return (std::min)(string_.size() - consumed_, max_size_);
+   }
+
+   bool empty() const noexcept
+   {
+      return size() == 0;
+   }
+
+   std::size_t max_size() const noexcept
+   {
+      return max_size_;
+   }
+
+   char const& front() const noexcept
+   {
+      return string_.at(consumed_);
+   }
+
+   std::size_t capacity() const noexcept
+   {
+      return (std::min)(string_.capacity(), max_size());
+   }
+
+   mutable_buffers_type data(std::size_t pos, std::size_t n) noexcept
+   {
+      return mutable_buffers_type(asio::buffer(asio::buffer(string_, max_size_) + pos + consumed_, n));
+   }
+
+   const_buffers_type data(std::size_t pos, std::size_t n) const noexcept
+   {
+      return const_buffers_type(asio::buffer(asio::buffer(string_, max_size_) + pos + consumed_, n));
+   }
+
+   void grow(std::size_t n)
+   {
+      if (string_.size() > max_size_ || (string_.size() + n) > max_size_)
+         BOOST_THROW_EXCEPTION(std::length_error{"dynamic_string_buffer too long"});
+
+      string_.resize(string_.size() + n);
+   }
+
+   void shrink(std::size_t n)
+   {
+      string_.resize(n > (string_.size() - consumed_) ? consumed_ : string_.size() - n);
+   }
+
+   void consume(std::size_t n, std::size_t tolerance = 100'000)
+   {
+      consumed_ += n;
+      if (consumed_ > tolerance) {
+         string_.erase(0, consumed_);
+         consumed_ = 0;
+      }
+   }
+
+private:
+   std::basic_string<Elem, Traits, Allocator>& string_;
+   std::size_t consumed_ = 0;
+   std::size_t const max_size_;
+};
+
+}
+
+#endif // BOOST_REDIS_BUFFER_HPP
--- a/include/boost/redis/detail/connect_fsm.hpp
+++ b/include/boost/redis/detail/connect_fsm.hpp
@@ -1,91 +0,0 @@
-//
-// Copyright (c) 2025 Marcelo Zimbres Silva (mzimbres@gmail.com),
-// Ruben Perez Hidalgo (rubenperez038 at gmail dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef BOOST_REDIS_CONNECT_FSM_HPP
-#define BOOST_REDIS_CONNECT_FSM_HPP
-
-#include <boost/asio/cancellation_type.hpp>
-#include <boost/asio/ip/tcp.hpp>
-#include <boost/system/error_code.hpp>
-
-// Sans-io algorithm for redis_stream::async_connect, as a finite state machine
-
-namespace boost::redis::detail {
-
-struct buffered_logger;
-
-// What transport is redis_stream using?
-enum class transport_type
-{
-   tcp,          // plaintext TCP
-   tcp_tls,      // TLS over TCP
-   unix_socket,  // UNIX domain sockets
-};
-
-struct redis_stream_state {
-   transport_type type{transport_type::tcp};
-   bool ssl_stream_used{false};
-};
-
-// What should we do next?
-enum class connect_action_type
-{
-   unix_socket_close,    // Close the UNIX socket, to discard state
-   unix_socket_connect,  // Connect to the UNIX socket
-   tcp_resolve,          // Name resolution
-   tcp_connect,          // TCP connect
-   ssl_stream_reset,     // Re-create the SSL stream, to discard state
-   ssl_handshake,        // SSL handshake
-   done,                 // Complete the async op
-};
-
-struct connect_action {
-   connect_action_type type;
-   system::error_code ec;
-
-   connect_action(connect_action_type type) noexcept
-   : type{type}
-   { }
-
-   connect_action(system::error_code ec) noexcept
-   : type{connect_action_type::done}
-   , ec{ec}
-   { }
-};
-
-class connect_fsm {
-   int resume_point_{0};
-   buffered_logger* lgr_{nullptr};
-
-public:
-   connect_fsm(buffered_logger& lgr) noexcept
-   : lgr_(&lgr)
-   { }
-
-   connect_action resume(
-      system::error_code ec,
-      const asio::ip::tcp::resolver::results_type& resolver_results,
-      redis_stream_state& st,
-      asio::cancellation_type_t cancel_state);
-
-   connect_action resume(
-      system::error_code ec,
-      const asio::ip::tcp::endpoint& selected_endpoint,
-      redis_stream_state& st,
-      asio::cancellation_type_t cancel_state);
-
-   connect_action resume(
-      system::error_code ec,
-      redis_stream_state& st,
-      asio::cancellation_type_t cancel_state);
-
-};  // namespace boost::redis::detail
-
-}  // namespace boost::redis::detail
-
-#endif
--- a/include/boost/redis/detail/connect_params.hpp
+++ b/include/boost/redis/detail/connect_params.hpp
@@ -1,65 +0,0 @@
-//
-// Copyright (c) 2025 Marcelo Zimbres Silva (mzimbres@gmail.com),
-// Ruben Perez Hidalgo (rubenperez038 at gmail dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef BOOST_REDIS_CONNECT_PARAMS_HPP
-#define BOOST_REDIS_CONNECT_PARAMS_HPP
-
-// Parameters used by redis_stream::async_connect
-
-#include <boost/redis/config.hpp>
-#include <boost/redis/detail/connect_fsm.hpp>
-
-#include <chrono>
-#include <string_view>
-
-namespace boost::redis::detail {
-
-// Fully identifies where a server is listening. Reference type.
-class any_address_view {
-   transport_type type_;
-   union {
-      const address* tcp_;
-      std::string_view unix_;
-   };
-
-public:
-   any_address_view(const address& addr, bool use_ssl) noexcept
-   : type_(use_ssl ? transport_type::tcp_tls : transport_type::tcp)
-   , tcp_(&addr)
-   { }
-
-   explicit any_address_view(std::string_view unix_socket) noexcept
-   : type_(transport_type::unix_socket)
-   , unix_(unix_socket)
-   { }
-
-   transport_type type() const { return type_; }
-
-   const address& tcp_address() const
-   {
-      BOOST_ASSERT(type_ == transport_type::tcp || type_ == transport_type::tcp_tls);
-      return *tcp_;
-   }
-
-   std::string_view unix_socket() const
-   {
-      BOOST_ASSERT(type_ == transport_type::unix_socket);
-      return unix_;
-   }
-};
-
-struct connect_params {
-   any_address_view addr;
-   std::chrono::steady_clock::duration resolve_timeout;
-   std::chrono::steady_clock::duration connect_timeout;
-   std::chrono::steady_clock::duration ssl_handshake_timeout;
-};
-
-}  // namespace boost::redis::detail
-
-#endif  // BOOST_REDIS_CONNECTOR_HPP
--- a/include/boost/redis/detail/connection_base.hpp
+++ b/include/boost/redis/detail/connection_base.hpp
@@ -0,0 +1,928 @@
+/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
+ *
+ * Distributed under the Boost Software License, Version 1.0. (See
+ * accompanying file LICENSE.txt)
+ */
+
+#ifndef BOOST_REDIS_CONNECTION_BASE_HPP
+#define BOOST_REDIS_CONNECTION_BASE_HPP
+
+#include <boost/redis/adapter/adapt.hpp>
+#include <boost/redis/detail/helper.hpp>
+#include <boost/redis/detail/read.hpp>
+#include <boost/redis/error.hpp>
+#include <boost/redis/operation.hpp>
+#include <boost/redis/request.hpp>
+#include <boost/redis/resp3/type.hpp>
+#include <boost/redis/config.hpp>
+#include <boost/redis/detail/runner.hpp>
+#include <boost/redis/detail/buffer.hpp>
+
+#include <boost/system.hpp>
+#include <boost/asio/basic_stream_socket.hpp>
+#include <boost/asio/bind_executor.hpp>
+#include <boost/asio/experimental/parallel_group.hpp>
+#include <boost/asio/ip/tcp.hpp>
+#include <boost/asio/steady_timer.hpp>
+#include <boost/asio/write.hpp>
+#include <boost/assert.hpp>
+#include <boost/core/ignore_unused.hpp>
+#include <boost/asio/ssl/stream.hpp>
+#include <boost/asio/read_until.hpp>
+#include <boost/asio/buffer.hpp>
+
+#include <algorithm>
+#include <array>
+#include <chrono>
+#include <deque>
+#include <memory>
+#include <string_view>
+#include <type_traits>
+
+namespace boost::redis::detail {
+
+template <class Conn>
+struct wait_receive_op {
+   Conn* conn_;
+   asio::coroutine coro{};
+
+   template <class Self>
+   void
+   operator()(Self& self , system::error_code ec = {})
+   {
+      BOOST_ASIO_CORO_REENTER (coro)
+      {
+         conn_->read_op_timer_.cancel();
+
+         BOOST_ASIO_CORO_YIELD
+         conn_->read_op_timer_.async_wait(std::move(self));
+         if (!conn_->is_open() || is_cancelled(self)) {
+            self.complete(!!ec ? ec : asio::error::operation_aborted);
+            return;
+         }
+         self.complete({});
+      }
+   }
+};
+
+template <class Conn, class Adapter>
+class read_next_op {
+public:
+   using req_info_type = typename Conn::req_info;
+   using req_info_ptr = typename std::shared_ptr<req_info_type>;
+
+private:
+   Conn* conn_;
+   req_info_ptr info_;
+   Adapter adapter_;
+   std::size_t cmds_ = 0;
+   std::size_t read_size_ = 0;
+   std::size_t index_ = 0;
+   asio::coroutine coro_{};
+
+public:
+   read_next_op(Conn& conn, Adapter adapter, req_info_ptr info)
+   : conn_{&conn}
+   , info_{info}
+   , adapter_{adapter}
+   , cmds_{info->get_number_of_commands()}
+   {}
+
+   auto make_adapter() noexcept
+   {
+      return [i = index_, adpt = adapter_] (resp3::basic_node<std::string_view> const& nd, system::error_code& ec) mutable { adpt(i, nd, ec); };
+   }
+
+   template <class Self>
+   void
+   operator()( Self& self
+             , system::error_code ec = {}
+             , std::size_t n = 0)
+   {
+      BOOST_ASIO_CORO_REENTER (coro_)
+      {
+         // Loop reading the responses to this request.
+         while (cmds_ != 0) {
+            if (info_->stop_requested()) {
+               self.complete(asio::error::operation_aborted, 0);
+               return;
+            }
+
+            //-----------------------------------
+            // If we detect a push in the middle of a request we have
+            // to hand it to the push consumer. To do that we need
+            // some data in the read bufer.
+            if (std::empty(conn_->dbuf_)) {
+
+               if (conn_->use_ssl()) {
+                  BOOST_ASIO_CORO_YIELD
+                  asio::async_read_until(conn_->next_layer(), conn_->dbuf_, resp3::parser::sep, std::move(self));
+               } else {
+                  BOOST_ASIO_CORO_YIELD
+                  asio::async_read_until(conn_->next_layer().next_layer(), conn_->dbuf_, resp3::parser::sep, std::move(self));
+               }
+
+               BOOST_REDIS_CHECK_OP1(conn_->cancel(operation::run););
+               if (info_->stop_requested()) {
+                  self.complete(asio::error::operation_aborted, 0);
+                  return;
+               }
+            }
+
+            // If the next request is a push we have to handle it to
+            // the receive_op wait for it to be done and continue.
+            if (resp3::to_type(conn_->dbuf_.front()) == resp3::type::push) {
+               BOOST_ASIO_CORO_YIELD
+               conn_->async_wait_receive(std::move(self));
+               BOOST_REDIS_CHECK_OP1(conn_->cancel(operation::run););
+               continue;
+            }
+            //-----------------------------------
+
+            if (conn_->use_ssl()) {
+               BOOST_ASIO_CORO_YIELD
+               redis::detail::async_read(conn_->next_layer(), conn_->dbuf_, make_adapter(), std::move(self));
+            } else {
+               BOOST_ASIO_CORO_YIELD
+               redis::detail::async_read(conn_->next_layer().next_layer(), conn_->dbuf_, make_adapter(), std::move(self));
+            }
+
+            ++index_;
+
+            if (ec || redis::detail::is_cancelled(self)) {
+               conn_->cancel(operation::run);
+               self.complete(!!ec ? ec : asio::error::operation_aborted, {});
+               return;
+            }
+
+            conn_->consume(n);
+            read_size_ += n;
+
+            BOOST_ASSERT(cmds_ != 0);
+            --cmds_;
+         }
+
+         self.complete({}, read_size_);
+      }
+   }
+};
+
+template <class Conn, class Adapter>
+struct receive_op {
+   Conn* conn_;
+   Adapter adapter;
+   asio::coroutine coro{};
+
+   template <class Self>
+   void
+   operator()( Self& self
+             , system::error_code ec = {}
+             , std::size_t n = 0)
+   {
+      BOOST_ASIO_CORO_REENTER (coro)
+      {
+         if (!conn_->is_next_push()) {
+            BOOST_ASIO_CORO_YIELD
+            conn_->read_op_timer_.async_wait(std::move(self));
+            if (!conn_->is_open() || is_cancelled(self)) {
+               self.complete(!!ec ? ec : asio::error::operation_aborted, 0);
+               return;
+            }
+         }
+
+         if (conn_->use_ssl()) {
+            BOOST_ASIO_CORO_YIELD
+            redis::detail::async_read(conn_->next_layer(), conn_->dbuf_, adapter, std::move(self));
+         } else {
+            BOOST_ASIO_CORO_YIELD
+            redis::detail::async_read(conn_->next_layer().next_layer(), conn_->dbuf_, adapter, std::move(self));
+         }
+
+         if (ec || is_cancelled(self)) {
+            conn_->cancel(operation::run);
+            conn_->cancel(operation::receive);
+            self.complete(!!ec ? ec : asio::error::operation_aborted, {});
+            return;
+         }
+
+         conn_->consume(n);
+
+         if (!conn_->is_next_push()) {
+            conn_->read_op_timer_.cancel();
+         }
+
+         self.complete({}, n);
+         return;
+      }
+   }
+};
+
+template <class Conn, class Adapter>
+struct exec_op {
+   using req_info_type = typename Conn::req_info;
+
+   Conn* conn = nullptr;
+   request const* req = nullptr;
+   Adapter adapter{};
+   std::shared_ptr<req_info_type> info = nullptr;
+   asio::coroutine coro{};
+
+   template <class Self>
+   void
+   operator()( Self& self
+             , system::error_code ec = {}
+             , std::size_t n = 0)
+   {
+      BOOST_ASIO_CORO_REENTER (coro)
+      {
+         // Check whether the user wants to wait for the connection to
+         // be stablished.
+         if (req->get_config().cancel_if_not_connected && !conn->is_open()) {
+            BOOST_ASIO_CORO_YIELD
+            asio::post(std::move(self));
+            return self.complete(error::not_connected, 0);
+         }
+
+         info = std::allocate_shared<req_info_type>(asio::get_associated_allocator(self), *req, conn->get_executor());
+
+         conn->add_request_info(info);
+EXEC_OP_WAIT:
+         BOOST_ASIO_CORO_YIELD
+         info->async_wait(std::move(self));
+         BOOST_ASSERT(ec == asio::error::operation_aborted);
+
+         if (info->stop_requested()) {
+            // Don't have to call remove_request as it has already
+            // been by cancel(exec).
+            return self.complete(ec, 0);
+         }
+
+         if (is_cancelled(self)) {
+            if (info->is_written()) {
+               using c_t = asio::cancellation_type;
+               auto const c = self.get_cancellation_state().cancelled();
+               if ((c & c_t::terminal) != c_t::none) {
+                  // Cancellation requires closing the connection
+                  // otherwise it stays in inconsistent state.
+                  conn->cancel(operation::run);
+                  return self.complete(ec, 0);
+               } else {
+                  // Can't implement other cancelation types, ignoring.
+                  self.get_cancellation_state().clear();
+                  goto EXEC_OP_WAIT;
+               }
+            } else {
+               // Cancelation can be honored.
+               conn->remove_request(info);
+               self.complete(ec, 0);
+               return;
+            }
+         }
+
+         BOOST_ASSERT(conn->is_open());
+          
+         if (req->size() == 0) {
+            // Don't have to call remove_request as it has already
+            // been removed.
+            return self.complete({}, 0);
+         }
+
+         BOOST_ASSERT(!conn->reqs_.empty());
+         BOOST_ASSERT(conn->reqs_.front() != nullptr);
+         BOOST_ASIO_CORO_YIELD
+         conn->async_read_next(adapter, std::move(self));
+         BOOST_REDIS_CHECK_OP1(;);
+
+         if (info->stop_requested()) {
+            // Don't have to call remove_request as it has already
+            // been by cancel(exec).
+            return self.complete(ec, 0);
+         }
+
+         BOOST_ASSERT(!conn->reqs_.empty());
+         conn->reqs_.pop_front();
+
+         if (conn->is_waiting_response()) {
+            BOOST_ASSERT(!conn->reqs_.empty());
+            conn->reqs_.front()->proceed();
+         } else {
+            conn->read_timer_.cancel_one();
+         }
+
+         self.complete({}, n);
+      }
+   }
+};
+
+template <class Conn, class Logger>
+struct run_op {
+   Conn* conn = nullptr;
+   Logger logger_;
+   asio::coroutine coro{};
+
+   template <class Self>
+   void operator()( Self& self
+                  , std::array<std::size_t, 2> order = {}
+                  , system::error_code ec0 = {}
+                  , system::error_code ec1 = {})
+   {
+      BOOST_ASIO_CORO_REENTER (coro)
+      {
+         conn->write_buffer_.clear();
+         conn->read_buffer_.clear();
+         conn->dbuf_.clear();
+
+         BOOST_ASIO_CORO_YIELD
+         asio::experimental::make_parallel_group(
+            [this](auto token) { return conn->reader(token);},
+            [this](auto token) { return conn->writer(logger_, token);}
+         ).async_wait(
+            asio::experimental::wait_for_one(),
+            std::move(self));
+
+         if (is_cancelled(self)) {
+            self.complete(asio::error::operation_aborted);
+            return;
+         }
+
+         switch (order[0]) {
+           case 0: self.complete(ec0); break;
+           case 1: self.complete(ec1); break;
+           default: BOOST_ASSERT(false);
+         }
+      }
+   }
+};
+
+template <class Conn, class Logger>
+struct writer_op {
+   Conn* conn_;
+   Logger logger_;
+   asio::coroutine coro{};
+
+   template <class Self>
+   void operator()( Self& self
+                  , system::error_code ec = {}
+                  , std::size_t n = 0)
+   {
+      ignore_unused(n);
+
+      BOOST_ASIO_CORO_REENTER (coro) for (;;)
+      {
+         while (conn_->coalesce_requests()) {
+            if (conn_->use_ssl())
+               BOOST_ASIO_CORO_YIELD asio::async_write(conn_->next_layer(), asio::buffer(conn_->write_buffer_), std::move(self));
+            else
+               BOOST_ASIO_CORO_YIELD asio::async_write(conn_->next_layer().next_layer(), asio::buffer(conn_->write_buffer_), std::move(self));
+
+            logger_.on_write(ec, conn_->write_buffer_);
+            BOOST_REDIS_CHECK_OP0(conn_->cancel(operation::run););
+
+            conn_->on_write();
+
+            // A socket.close() may have been called while a
+            // successful write might had already been queued, so we
+            // have to check here before proceeding.
+            if (!conn_->is_open()) {
+               self.complete({});
+               return;
+            }
+         }
+
+         BOOST_ASIO_CORO_YIELD
+         conn_->writer_timer_.async_wait(std::move(self));
+         if (!conn_->is_open() || is_cancelled(self)) {
+            // Notice this is not an error of the op, stoping was
+            // requested from the outside, so we complete with
+            // success.
+            self.complete({});
+            return;
+         }
+      }
+   }
+};
+
+template <class Conn>
+struct reader_op {
+   Conn* conn;
+   asio::coroutine coro{};
+
+   bool as_push() const
+   {
+      return
+         (resp3::to_type(conn->dbuf_.front()) == resp3::type::push)
+          || conn->reqs_.empty()
+          || (!conn->reqs_.empty() && conn->reqs_.front()->get_number_of_commands() == 0)
+          || !conn->is_waiting_response(); // Added to deal with MONITOR.
+   }
+
+   template <class Self>
+   void operator()( Self& self
+                  , system::error_code ec = {}
+                  , std::size_t n = 0)
+   {
+      ignore_unused(n);
+
+      BOOST_ASIO_CORO_REENTER (coro) for (;;)
+      {
+         if (conn->use_ssl())
+            BOOST_ASIO_CORO_YIELD asio::async_read_until(conn->next_layer(), conn->dbuf_, "\r\n", std::move(self));
+         else
+            BOOST_ASIO_CORO_YIELD asio::async_read_until(conn->next_layer().next_layer(), conn->dbuf_, "\r\n", std::move(self));
+
+         if (ec == asio::error::eof) {
+            conn->cancel(operation::run);
+            return self.complete({}); // EOFINAE: EOF is not an error.
+         }
+
+         BOOST_REDIS_CHECK_OP0(conn->cancel(operation::run););
+
+         // We handle unsolicited events in the following way
+         //
+         // 1. Its resp3 type is a push.
+         //
+         // 2. A non-push type is received with an empty requests
+         //    queue. I have noticed this is possible (e.g. -MISCONF).
+         //    I expect them to have type push so we can distinguish
+         //    them from responses to commands, but it is a
+         //    simple-error. If we are lucky enough to receive them
+         //    when the command queue is empty we can treat them as
+         //    server pushes, otherwise it is impossible to handle
+         //    them properly
+         //
+         // 3. The request does not expect any response but we got
+         //    one. This may happen if for example, subscribe with
+         //    wrong syntax.
+         //
+         // Useful links:
+         //
+         // - https://github.com/redis/redis/issues/11784
+         // - https://github.com/redis/redis/issues/6426
+         //
+         BOOST_ASSERT(!conn->dbuf_.empty());
+         if (as_push()) {
+            BOOST_ASIO_CORO_YIELD
+            conn->async_wait_receive(std::move(self));
+         } else {
+            BOOST_ASSERT_MSG(conn->is_waiting_response(), "Not waiting for a response (using MONITOR command perhaps?)");
+            BOOST_ASSERT(!conn->reqs_.empty());
+            BOOST_ASSERT(conn->reqs_.front()->get_number_of_commands() != 0);
+            conn->reqs_.front()->proceed();
+            BOOST_ASIO_CORO_YIELD
+            conn->read_timer_.async_wait(std::move(self));
+            ec = {};
+         }
+
+         if (!conn->is_open() || ec || is_cancelled(self)) {
+            conn->cancel(operation::run);
+            self.complete(asio::error::basic_errors::operation_aborted);
+            return;
+         }
+      }
+   }
+};
+
+/** @brief Base class for high level Redis asynchronous connections.
+ *  @ingroup high-level-api
+ *
+ *  @tparam Executor The executor type.
+ *
+ */
+template <class Executor>
+class connection_base {
+public:
+   /// Executor type
+   using executor_type = Executor;
+
+   /// Type of the next layer
+   using next_layer_type = asio::ssl::stream<asio::basic_stream_socket<asio::ip::tcp, Executor>>;
+
+   using this_type = connection_base<Executor>;
+
+   /// Constructs from an executor.
+   connection_base(
+      executor_type ex,
+      asio::ssl::context::method method,
+      std::size_t max_read_size)
+   : ctx_{method}
+   , stream_{std::make_unique<next_layer_type>(ex, ctx_)}
+   , writer_timer_{ex}
+   , read_timer_{ex}
+   , read_op_timer_{ex}
+   , runner_{ex, {}}
+   , dbuf_{read_buffer_, max_read_size}
+   {
+      writer_timer_.expires_at(std::chrono::steady_clock::time_point::max());
+      read_timer_.expires_at(std::chrono::steady_clock::time_point::max());
+      read_op_timer_.expires_at(std::chrono::steady_clock::time_point::max());
+   }
+
+   /// Returns the ssl context.
+   auto const& get_ssl_context() const noexcept
+      { return ctx_;}
+
+   /// Returns the ssl context.
+   auto& get_ssl_context() noexcept
+      { return ctx_;}
+
+   /// Resets the underlying stream.
+   void reset_stream()
+   {
+      stream_ = std::make_unique<next_layer_type>(writer_timer_.get_executor(), ctx_);
+   }
+
+   /// Returns a reference to the next layer.
+   auto& next_layer() noexcept { return *stream_; }
+
+   /// Returns a const reference to the next layer.
+   auto const& next_layer() const noexcept { return *stream_; }
+
+   /// Returns the associated executor.
+   auto get_executor() {return writer_timer_.get_executor();}
+
+   /// Cancels specific operations.
+   virtual void cancel(operation op)
+   {
+      runner_.cancel(op);
+      if (op == operation::all) {
+         cancel_impl(operation::run);
+         cancel_impl(operation::receive);
+         cancel_impl(operation::exec);
+         return;
+      } 
+
+      cancel_impl(op);
+   }
+
+   template <class Response, class CompletionToken>
+   auto async_exec(request const& req, Response& resp, CompletionToken token)
+   {
+      using namespace boost::redis::adapter;
+      auto f = boost_redis_adapt(resp);
+      BOOST_ASSERT_MSG(req.size() <= f.get_supported_response_size(), "Request and response have incompatible sizes.");
+
+      return asio::async_compose
+         < CompletionToken
+         , void(system::error_code, std::size_t)
+         >(redis::detail::exec_op<this_type, decltype(f)>{this, &req, f}, token, writer_timer_);
+   }
+
+   template <class Response, class CompletionToken>
+   auto async_receive(Response& response, CompletionToken token)
+   {
+      using namespace boost::redis::adapter;
+      auto g = boost_redis_adapt(response);
+      auto f = adapter::detail::make_adapter_wrapper(g);
+
+      return asio::async_compose
+         < CompletionToken
+         , void(system::error_code, std::size_t)
+         >(redis::detail::receive_op<this_type, decltype(f)>{this, f}, token, read_op_timer_);
+   }
+
+   template <class Logger, class CompletionToken>
+   auto async_run(config const& cfg, Logger l, CompletionToken token)
+   {
+      runner_.set_config(cfg);
+      l.set_prefix(runner_.get_config().log_prefix);
+      return runner_.async_run(*this, l, std::move(token));
+   }
+
+private:
+   using clock_type = std::chrono::steady_clock;
+   using clock_traits_type = asio::wait_traits<clock_type>;
+   using timer_type = asio::basic_waitable_timer<clock_type, clock_traits_type, executor_type>;
+   using runner_type = redis::detail::runner<executor_type>;
+
+   auto use_ssl() const noexcept
+      { return runner_.get_config().use_ssl;}
+
+   auto cancel_on_conn_lost() -> std::size_t
+   {
+      // Must return false if the request should be removed.
+      auto cond = [](auto const& ptr)
+      {
+         BOOST_ASSERT(ptr != nullptr);
+
+         if (ptr->is_written()) {
+            return !ptr->get_request().get_config().cancel_if_unresponded;
+         } else {
+            return !ptr->get_request().get_config().cancel_on_connection_lost;
+         }
+      };
+
+      auto point = std::stable_partition(std::begin(reqs_), std::end(reqs_), cond);
+
+      auto const ret = std::distance(point, std::end(reqs_));
+
+      std::for_each(point, std::end(reqs_), [](auto const& ptr) {
+         ptr->stop();
+      });
+
+      reqs_.erase(point, std::end(reqs_));
+      std::for_each(std::begin(reqs_), std::end(reqs_), [](auto const& ptr) {
+         return ptr->reset_status();
+      });
+
+      return ret;
+   }
+
+   auto cancel_unwritten_requests() -> std::size_t
+   {
+      auto f = [](auto const& ptr)
+      {
+         BOOST_ASSERT(ptr != nullptr);
+         return ptr->is_written();
+      };
+
+      auto point = std::stable_partition(std::begin(reqs_), std::end(reqs_), f);
+
+      auto const ret = std::distance(point, std::end(reqs_));
+
+      std::for_each(point, std::end(reqs_), [](auto const& ptr) {
+         ptr->stop();
+      });
+
+      reqs_.erase(point, std::end(reqs_));
+      return ret;
+   }
+
+   void cancel_impl(operation op)
+   {
+      switch (op) {
+         case operation::exec:
+         {
+            cancel_unwritten_requests();
+         } break;
+         case operation::run:
+         {
+            close();
+            read_timer_.cancel();
+            writer_timer_.cancel();
+            cancel_on_conn_lost();
+         } break;
+         case operation::receive:
+         {
+            read_op_timer_.cancel();
+         } break;
+         default: /* ignore */;
+      }
+   }
+
+   void on_write()
+   {
+      // We have to clear the payload right after writing it to use it
+      // as a flag that informs there is no ongoing write.
+      write_buffer_.clear();
+
+      // Notice this must come before the for-each below.
+      cancel_push_requests();
+
+      // There is small optimization possible here: traverse only the
+      // partition of unwritten requests instead of them all.
+      std::for_each(std::begin(reqs_), std::end(reqs_), [](auto const& ptr) {
+         BOOST_ASSERT_MSG(ptr != nullptr, "Expects non-null pointer.");
+         if (ptr->is_staged())
+            ptr->mark_written();
+      });
+   }
+
+   struct req_info {
+   public:
+      enum class action
+      {
+         stop,
+         proceed,
+         none,
+      };
+
+      explicit req_info(request const& req, executor_type ex)
+      : timer_{ex}
+      , action_{action::none}
+      , req_{&req}
+      , cmds_{std::size(req)}
+      , status_{status::none}
+      {
+         timer_.expires_at(std::chrono::steady_clock::time_point::max());
+      }
+
+      auto proceed()
+      {
+         timer_.cancel();
+         action_ = action::proceed;
+      }
+
+      void stop()
+      {
+         timer_.cancel();
+         action_ = action::stop;
+      }
+
+      [[nodiscard]] auto is_waiting_write() const noexcept
+         { return !is_written() && !is_staged(); }
+
+      [[nodiscard]] auto is_written() const noexcept
+         { return status_ == status::written; }
+
+      [[nodiscard]] auto is_staged() const noexcept
+         { return status_ == status::staged; }
+
+      void mark_written() noexcept
+         { status_ = status::written; }
+
+      void mark_staged() noexcept
+         { status_ = status::staged; }
+
+      void reset_status() noexcept
+         { status_ = status::none; }
+
+      [[nodiscard]] auto get_number_of_commands() const noexcept
+         { return cmds_; }
+
+      [[nodiscard]] auto get_request() const noexcept -> auto const&
+         { return *req_; }
+
+      [[nodiscard]] auto stop_requested() const noexcept
+         { return action_ == action::stop;}
+
+      template <class CompletionToken>
+      auto async_wait(CompletionToken token)
+      {
+         return timer_.async_wait(std::move(token));
+      }
+
+   private:
+      enum class status
+      { none
+      , staged
+      , written
+      };
+
+      timer_type timer_;
+      action action_;
+      request const* req_;
+      std::size_t cmds_;
+      status status_;
+   };
+
+   void remove_request(std::shared_ptr<req_info> const& info)
+   {
+      reqs_.erase(std::remove(std::begin(reqs_), std::end(reqs_), info));
+   }
+
+   using reqs_type = std::deque<std::shared_ptr<req_info>>;
+
+   template <class> friend struct redis::detail::reader_op;
+   template <class, class> friend struct redis::detail::writer_op;
+   template <class, class> friend struct redis::detail::run_op;
+   template <class, class> friend struct redis::detail::exec_op;
+   template <class, class> friend class redis::detail::read_next_op;
+   template <class, class> friend struct redis::detail::receive_op;
+   template <class> friend struct redis::detail::wait_receive_op;
+   template <class, class, class> friend struct redis::detail::run_all_op;
+
+   template <class CompletionToken>
+   auto async_wait_receive(CompletionToken token)
+   {
+      return asio::async_compose
+         < CompletionToken
+         , void(system::error_code)
+         >(redis::detail::wait_receive_op<this_type>{this}, token, read_op_timer_);
+   }
+
+   void cancel_push_requests()
+   {
+      auto point = std::stable_partition(std::begin(reqs_), std::end(reqs_), [](auto const& ptr) {
+         return !(ptr->is_staged() && ptr->get_request().size() == 0);
+      });
+
+      std::for_each(point, std::end(reqs_), [](auto const& ptr) {
+         ptr->proceed();
+      });
+
+      reqs_.erase(point, std::end(reqs_));
+   }
+
+   [[nodiscard]] bool is_writing() const noexcept
+   {
+      return !write_buffer_.empty();
+   }
+
+   void add_request_info(std::shared_ptr<req_info> const& info)
+   {
+      reqs_.push_back(info);
+
+      if (info->get_request().has_hello_priority()) {
+         auto rend = std::partition_point(std::rbegin(reqs_), std::rend(reqs_), [](auto const& e) {
+               return e->is_waiting_write();
+         });
+
+         std::rotate(std::rbegin(reqs_), std::rbegin(reqs_) + 1, rend);
+      }
+
+      if (is_open() && !is_writing())
+         writer_timer_.cancel();
+   }
+
+   template <class CompletionToken>
+   auto reader(CompletionToken&& token)
+   {
+      return asio::async_compose
+         < CompletionToken
+         , void(system::error_code)
+         >(redis::detail::reader_op<this_type>{this}, token, writer_timer_);
+   }
+
+   template <class CompletionToken, class Logger>
+   auto writer(Logger l, CompletionToken&& token)
+   {
+      return asio::async_compose
+         < CompletionToken
+         , void(system::error_code)
+         >(redis::detail::writer_op<this_type, Logger>{this, l}, token, writer_timer_);
+   }
+
+   template <class Adapter, class CompletionToken>
+   auto async_read_next(Adapter adapter, CompletionToken token)
+   {
+      return asio::async_compose
+         < CompletionToken
+         , void(system::error_code, std::size_t)
+         >(redis::detail::read_next_op<this_type, Adapter>{*this, adapter, reqs_.front()}, token, writer_timer_);
+   }
+
+   template <class Logger, class CompletionToken>
+   auto async_run_lean(config const& cfg, Logger l, CompletionToken token)
+   {
+      runner_.set_config(cfg);
+      l.set_prefix(runner_.get_config().log_prefix);
+      return asio::async_compose
+         < CompletionToken
+         , void(system::error_code)
+         >(redis::detail::run_op<this_type, Logger>{this, l}, token, writer_timer_);
+   }
+
+   [[nodiscard]] bool coalesce_requests()
+   {
+      // Coalesces the requests and marks them staged. After a
+      // successful write staged requests will be marked as written.
+      auto const point = std::partition_point(std::cbegin(reqs_), std::cend(reqs_), [](auto const& ri) {
+            return !ri->is_waiting_write();
+      });
+
+      std::for_each(point, std::cend(reqs_), [this](auto const& ri) {
+         // Stage the request.
+         write_buffer_ += ri->get_request().payload();
+         ri->mark_staged();
+      });
+
+      return point != std::cend(reqs_);
+   }
+
+   bool is_waiting_response() const noexcept
+   {
+      return !std::empty(reqs_) && reqs_.front()->is_written();
+   }
+
+   void close()
+   {
+      if (stream_->next_layer().is_open())
+         stream_->next_layer().close();
+   }
+
+   bool is_next_push() const noexcept
+   {
+      return !dbuf_.empty() && (resp3::to_type(dbuf_.front()) == resp3::type::push);
+   }
+
+   auto is_open() const noexcept { return stream_->next_layer().is_open(); }
+   auto& lowest_layer() noexcept { return stream_->lowest_layer(); }
+
+   void consume(std::size_t n)
+   {
+      dbuf_.consume(n, 1'000'000);
+   }
+
+   asio::ssl::context ctx_;
+   std::unique_ptr<next_layer_type> stream_;
+
+   // Notice we use a timer to simulate a condition-variable. It is
+   // also more suitable than a channel and the notify operation does
+   // not suspend.
+   timer_type writer_timer_;
+   timer_type read_timer_;
+   timer_type read_op_timer_;
+   runner_type runner_;
+
+   using dyn_buffer_type = redis::detail::dynamic_string_buffer<char, std::char_traits<char>, std::allocator<char>>;
+
+   std::size_t const read_buffer_consume_tolerance_ = 1'000'000; // 1Mb
+   std::string read_buffer_;
+   dyn_buffer_type dbuf_;
+   std::string write_buffer_;
+   reqs_type reqs_;
+};
+
+} // boost::redis::detail
+
+#endif // BOOST_REDIS_CONNECTION_BASE_HPP
--- a/include/boost/redis/detail/connection_state.hpp
+++ b/include/boost/redis/detail/connection_state.hpp
@@ -1,64 +0,0 @@
-//
-// Copyright (c) 2025 Marcelo Zimbres Silva (mzimbres@gmail.com),
-// Ruben Perez Hidalgo (rubenperez038 at gmail dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef BOOST_REDIS_CONNECTION_STATE_HPP
-#define BOOST_REDIS_CONNECTION_STATE_HPP
-
-#include <boost/redis/config.hpp>
-#include <boost/redis/detail/multiplexer.hpp>
-#include <boost/redis/detail/subscription_tracker.hpp>
-#include <boost/redis/logger.hpp>
-#include <boost/redis/request.hpp>
-#include <boost/redis/resp3/node.hpp>
-#include <boost/redis/response.hpp>
-
-#include <random>
-#include <string>
-#include <vector>
-
-namespace boost::redis::detail {
-
-// A random engine that gets seeded lazily.
-// Seeding with std::random_device is not trivial and might fail.
-class lazy_random_engine {
-   bool seeded_{};
-   std::minstd_rand eng_;
-
-public:
-   lazy_random_engine() = default;
-   std::minstd_rand& get()
-   {
-      if (!seeded_) {
-         eng_.seed(static_cast<std::minstd_rand::result_type>(std::random_device{}()));
-         seeded_ = true;
-      }
-      return eng_;
-   }
-};
-
-// Contains all the members in connection that don't depend on the Executor.
-// Makes implementing sans-io algorithms easier
-struct connection_state {
-   buffered_logger logger;
-   config cfg{};
-   multiplexer mpx{};
-   std::string diagnostic{};  // Used by the setup request and Sentinel
-   request setup_req{};
-   request ping_req{};
-   subscription_tracker tracker{};
-   bool receive2_running{false}, receive2_cancelled{false};
-
-   // Sentinel stuff
-   lazy_random_engine eng{};
-   std::vector<address> sentinels{};
-   std::vector<resp3::node> sentinel_resp_nodes{};  // for parsing
-};
-
-}  // namespace boost::redis::detail
-
-#endif  // BOOST_REDIS_CONNECTOR_HPP
--- a/include/boost/redis/detail/connector.hpp
+++ b/include/boost/redis/detail/connector.hpp
@@ -0,0 +1,133 @@
+/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
+ *
+ * Distributed under the Boost Software License, Version 1.0. (See
+ * accompanying file LICENSE.txt)
+ */
+
+#ifndef BOOST_REDIS_CONNECTOR_HPP
+#define BOOST_REDIS_CONNECTOR_HPP
+
+#include <boost/redis/detail/helper.hpp>
+#include <boost/redis/error.hpp>
+#include <boost/asio/compose.hpp>
+#include <boost/asio/connect.hpp>
+#include <boost/asio/coroutine.hpp>
+#include <boost/asio/experimental/parallel_group.hpp>
+#include <boost/asio/ip/tcp.hpp>
+#include <boost/asio/steady_timer.hpp>
+#include <string>
+#include <chrono>
+
+namespace boost::redis::detail
+{
+
+template <class Connector, class Stream>
+struct connect_op {
+   Connector* ctor_ = nullptr;
+   Stream* stream = nullptr;
+   asio::ip::tcp::resolver::results_type const* res_ = nullptr;
+   asio::coroutine coro{};
+
+   template <class Self>
+   void operator()( Self& self
+                  , std::array<std::size_t, 2> const& order = {}
+                  , system::error_code const& ec1 = {}
+                  , asio::ip::tcp::endpoint const& ep= {}
+                  , system::error_code const& ec2 = {})
+   {
+      BOOST_ASIO_CORO_REENTER (coro)
+      {
+         ctor_->timer_.expires_after(ctor_->timeout_);
+
+         BOOST_ASIO_CORO_YIELD
+         asio::experimental::make_parallel_group(
+            [this](auto token)
+            {
+               auto f = [](system::error_code const&, auto const&) { return true; };
+               return asio::async_connect(*stream, *res_, f, token);
+            },
+            [this](auto token) { return ctor_->timer_.async_wait(token);}
+         ).async_wait(
+            asio::experimental::wait_for_one(),
+            std::move(self));
+
+         if (is_cancelled(self)) {
+            self.complete(asio::error::operation_aborted);
+            return;
+         }
+
+         switch (order[0]) {
+            case 0: {
+               ctor_->endpoint_ = ep;
+               self.complete(ec1);
+            } break;
+            case 1:
+            {
+               if (ec2) {
+                  self.complete(ec2);
+               } else {
+                  self.complete(error::connect_timeout);
+               }
+            } break;
+
+            default: BOOST_ASSERT(false);
+         }
+      }
+   }
+};
+
+template <class Executor>
+class connector {
+public:
+   using timer_type =
+      asio::basic_waitable_timer<
+         std::chrono::steady_clock,
+         asio::wait_traits<std::chrono::steady_clock>,
+         Executor>;
+
+   connector(Executor ex)
+   : timer_{ex}
+   {}
+
+   void set_config(config const& cfg)
+      { timeout_ = cfg.connect_timeout; }
+
+   template <class Stream, class CompletionToken>
+   auto
+   async_connect(
+         Stream& stream,
+         asio::ip::tcp::resolver::results_type const& res,
+         CompletionToken&& token)
+   {
+      return asio::async_compose
+         < CompletionToken
+         , void(system::error_code)
+         >(connect_op<connector, Stream>{this, &stream, &res}, token, timer_);
+   }
+
+   std::size_t cancel(operation op)
+   {
+      switch (op) {
+         case operation::connect:
+         case operation::all:
+            timer_.cancel();
+            break;
+         default: /* ignore */;
+      }
+
+      return 0;
+   }
+
+   auto const& endpoint() const noexcept { return endpoint_;}
+
+private:
+   template <class, class> friend struct connect_op;
+
+   timer_type timer_;
+   std::chrono::steady_clock::duration timeout_ = std::chrono::seconds{2};
+   asio::ip::tcp::endpoint endpoint_;
+};
+
+} // boost::redis::detail
+
+#endif // BOOST_REDIS_CONNECTOR_HPP
--- a/include/boost/redis/detail/coroutine.hpp
+++ b/include/boost/redis/detail/coroutine.hpp
@@ -1,36 +0,0 @@
-//
-// Copyright (c) 2025 Marcelo Zimbres Silva (mzimbres@gmail.com),
-// Ruben Perez Hidalgo (rubenperez038 at gmail dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef BOOST_REDIS_DETAIL_COROUTINE_HPP
-#define BOOST_REDIS_DETAIL_COROUTINE_HPP
-
-// asio::coroutine uses __COUNTER__ internally, which can trigger
-// ODR violations if we use them in header-only code. These manifest as
-// extremely hard-to-debug bugs only present in release builds.
-// Use this instead when doing coroutines in non-template code.
-// Adapted from Boost.MySQL.
-
-// Coroutine state is represented as an integer (resume_point_var).
-// Every yield gets assigned a unique value (resume_point_id).
-// Yielding sets the next resume point, returns, and sets a case label for re-entering.
-// Coroutines need to switch on resume_point_var to re-enter.
-
-// Enclosing this in a scope allows placing the macro inside a brace-less for/while loop
-// The empty scope after the case label is required because labels can't be at the end of a compound statement
-#define BOOST_REDIS_YIELD(resume_point_var, resume_point_id, ...) \
-   {                                                              \
-      resume_point_var = resume_point_id;                         \
-      return {__VA_ARGS__};                                       \
-      case resume_point_id:                                       \
-      {                                                           \
-      }                                                           \
-   }
-
-#define BOOST_REDIS_CORO_INITIAL case 0:
-
-#endif
--- a/include/boost/redis/detail/exec_fsm.hpp
+++ b/include/boost/redis/detail/exec_fsm.hpp
@@ -1,74 +0,0 @@
-//
-// Copyright (c) 2025 Marcelo Zimbres Silva (mzimbres@gmail.com),
-// Ruben Perez Hidalgo (rubenperez038 at gmail dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef BOOST_REDIS_EXEC_FSM_HPP
-#define BOOST_REDIS_EXEC_FSM_HPP
-
-#include <boost/redis/detail/multiplexer.hpp>
-
-#include <boost/asio/cancellation_type.hpp>
-#include <boost/system/error_code.hpp>
-
-#include <cstddef>
-#include <memory>
-
-// Sans-io algorithm for async_exec, as a finite state machine
-
-namespace boost::redis::detail {
-
-struct connection_state;
-
-// What should we do next?
-enum class exec_action_type
-{
-   setup_cancellation,  // Set up the cancellation types supported by the composed operation
-   immediate,           // Invoke asio::async_immediate to avoid re-entrancy problems
-   done,                // Call the final handler
-   notify_writer,       // Notify the writer task
-   wait_for_response,   // Wait to be notified
-};
-
-class exec_action {
-   exec_action_type type_;
-   system::error_code ec_;
-   std::size_t bytes_read_;
-
-public:
-   exec_action(exec_action_type type) noexcept
-   : type_{type}
-   { }
-
-   exec_action(system::error_code ec, std::size_t bytes_read = 0u) noexcept
-   : type_{exec_action_type::done}
-   , ec_{ec}
-   , bytes_read_{bytes_read}
-   { }
-
-   exec_action_type type() const { return type_; }
-   system::error_code error() const { return ec_; }
-   std::size_t bytes_read() const { return bytes_read_; }
-};
-
-class exec_fsm {
-   int resume_point_{0};
-   std::shared_ptr<multiplexer::elem> elem_;
-
-public:
-   exec_fsm(std::shared_ptr<multiplexer::elem> elem) noexcept
-   : elem_(std::move(elem))
-   { }
-
-   exec_action resume(
-      bool connection_is_open,
-      connection_state& st,
-      asio::cancellation_type_t cancel_state);
-};
-
-}  // namespace boost::redis::detail
-
-#endif  // BOOST_REDIS_CONNECTOR_HPP
--- a/include/boost/redis/detail/exec_one_fsm.hpp
+++ b/include/boost/redis/detail/exec_one_fsm.hpp
@@ -1,69 +0,0 @@
-//
-// Copyright (c) 2025 Marcelo Zimbres Silva (mzimbres@gmail.com),
-// Ruben Perez Hidalgo (rubenperez038 at gmail dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef BOOST_REDIS_EXEC_ONE_FSM_HPP
-#define BOOST_REDIS_EXEC_ONE_FSM_HPP
-
-#include <boost/redis/adapter/any_adapter.hpp>
-#include <boost/redis/resp3/parser.hpp>
-
-#include <boost/asio/cancellation_type.hpp>
-#include <boost/system/error_code.hpp>
-
-#include <cstddef>
-
-// Sans-io algorithm for async_exec_one, as a finite state machine
-
-namespace boost::redis::detail {
-
-class read_buffer;
-
-// What should we do next?
-enum class exec_one_action_type
-{
-   done,       // Call the final handler
-   write,      // Write the request
-   read_some,  // Read into the read buffer
-};
-
-struct exec_one_action {
-   exec_one_action_type type;
-   system::error_code ec;
-
-   exec_one_action(exec_one_action_type type) noexcept
-   : type{type}
-   { }
-
-   exec_one_action(system::error_code ec) noexcept
-   : type{exec_one_action_type::done}
-   , ec{ec}
-   { }
-};
-
-class exec_one_fsm {
-   int resume_point_{0};
-   any_adapter adapter_;
-   std::size_t remaining_responses_;
-   resp3::parser parser_;
-
-public:
-   exec_one_fsm(any_adapter resp, std::size_t expected_responses)
-   : adapter_(std::move(resp))
-   , remaining_responses_(expected_responses)
-   { }
-
-   exec_one_action resume(
-      read_buffer& buffer,
-      system::error_code ec,
-      std::size_t bytes_transferred,
-      asio::cancellation_type_t cancel_state);
-};
-
-}  // namespace boost::redis::detail
-
-#endif  // BOOST_REDIS_CONNECTOR_HPP
--- a/include/boost/redis/detail/handshaker.hpp
+++ b/include/boost/redis/detail/handshaker.hpp
@@ -0,0 +1,124 @@
+/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
+ *
+ * Distributed under the Boost Software License, Version 1.0. (See
+ * accompanying file LICENSE.txt)
+ */
+
+#ifndef BOOST_REDIS_SSL_CONNECTOR_HPP
+#define BOOST_REDIS_SSL_CONNECTOR_HPP
+
+#include <boost/redis/detail/helper.hpp>
+#include <boost/redis/error.hpp>
+#include <boost/asio/compose.hpp>
+#include <boost/asio/connect.hpp>
+#include <boost/asio/coroutine.hpp>
+#include <boost/asio/experimental/parallel_group.hpp>
+#include <boost/asio/ip/tcp.hpp>
+#include <boost/asio/steady_timer.hpp>
+#include <boost/asio/ssl.hpp>
+#include <string>
+#include <chrono>
+
+namespace boost::redis::detail
+{
+
+template <class Handshaker, class Stream>
+struct handshake_op {
+   Handshaker* hsher_ = nullptr;
+   Stream* stream_ = nullptr;
+   asio::coroutine coro{};
+
+   template <class Self>
+   void operator()( Self& self
+                  , std::array<std::size_t, 2> const& order = {}
+                  , system::error_code const& ec1 = {}
+                  , system::error_code const& ec2 = {})
+   {
+      BOOST_ASIO_CORO_REENTER (coro)
+      {
+         hsher_->timer_.expires_after(hsher_->timeout_);
+
+         BOOST_ASIO_CORO_YIELD
+         asio::experimental::make_parallel_group(
+            [this](auto token) { return stream_->async_handshake(asio::ssl::stream_base::client, token); },
+            [this](auto token) { return hsher_->timer_.async_wait(token);}
+         ).async_wait(
+            asio::experimental::wait_for_one(),
+            std::move(self));
+
+         if (is_cancelled(self)) {
+            self.complete(asio::error::operation_aborted);
+            return;
+         }
+
+         switch (order[0]) {
+            case 0: {
+               self.complete(ec1);
+            } break;
+            case 1:
+            {
+               if (ec2) {
+                  self.complete(ec2);
+               } else {
+                  self.complete(error::ssl_handshake_timeout);
+               }
+            } break;
+
+            default: BOOST_ASSERT(false);
+         }
+      }
+   }
+};
+
+template <class Executor>
+class handshaker {
+public:
+   using timer_type =
+      asio::basic_waitable_timer<
+         std::chrono::steady_clock,
+         asio::wait_traits<std::chrono::steady_clock>,
+         Executor>;
+
+   handshaker(Executor ex)
+   : timer_{ex}
+   {}
+
+   template <class Stream, class CompletionToken>
+   auto
+   async_handshake(Stream& stream, CompletionToken&& token)
+   {
+      return asio::async_compose
+         < CompletionToken
+         , void(system::error_code)
+         >(handshake_op<handshaker, Stream>{this, &stream}, token, timer_);
+   }
+
+   std::size_t cancel(operation op)
+   {
+      switch (op) {
+         case operation::ssl_handshake:
+         case operation::all:
+            timer_.cancel();
+            break;
+         default: /* ignore */;
+      }
+
+      return 0;
+   }
+
+   constexpr bool is_dummy() const noexcept
+      {return false;}
+
+   void set_config(config const& cfg)
+      { timeout_ = cfg.ssl_handshake_timeout; }
+
+private:
+   template <class, class> friend struct handshake_op;
+
+   timer_type timer_;
+   std::chrono::steady_clock::duration timeout_;
+};
+
+} // boost::redis::detail
+
+#endif // BOOST_REDIS_SSL_CONNECTOR_HPP
--- a/include/boost/redis/detail/health_checker.hpp
+++ b/include/boost/redis/detail/health_checker.hpp
@@ -0,0 +1,224 @@
+/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
+ *
+ * Distributed under the Boost Software License, Version 1.0. (See
+ * accompanying file LICENSE.txt)
+ */
+
+#ifndef BOOST_REDIS_HEALTH_CHECKER_HPP
+#define BOOST_REDIS_HEALTH_CHECKER_HPP
+
+// Has to included before promise.hpp to build on msvc.
+#include <boost/redis/request.hpp>
+#include <boost/redis/response.hpp>
+#include <boost/redis/operation.hpp>
+#include <boost/redis/detail/helper.hpp>
+#include <boost/redis/config.hpp>
+#include <boost/asio/steady_timer.hpp>
+#include <boost/asio/compose.hpp>
+#include <boost/asio/consign.hpp>
+#include <boost/asio/coroutine.hpp>
+#include <boost/asio/post.hpp>
+#include <boost/asio/experimental/parallel_group.hpp>
+#include <memory>
+#include <chrono>
+
+namespace boost::redis::detail {
+
+template <class HealthChecker, class Connection>
+class ping_op {
+public:
+   HealthChecker* checker_ = nullptr;
+   Connection* conn_ = nullptr;
+   asio::coroutine coro_{};
+
+   template <class Self>
+   void operator()(Self& self, system::error_code ec = {}, std::size_t = 0)
+   {
+      BOOST_ASIO_CORO_REENTER (coro_) for (;;)
+      {
+         if (checker_->checker_has_exited_) {
+            self.complete({});
+            return;
+         }
+
+         BOOST_ASIO_CORO_YIELD
+         conn_->async_exec(checker_->req_, checker_->resp_, std::move(self));
+         BOOST_REDIS_CHECK_OP0(checker_->wait_timer_.cancel();)
+
+         // Wait before pinging again.
+         checker_->ping_timer_.expires_after(checker_->ping_interval_);
+         BOOST_ASIO_CORO_YIELD
+         checker_->ping_timer_.async_wait(std::move(self));
+         BOOST_REDIS_CHECK_OP0(;)
+      }
+   }
+};
+
+template <class HealthChecker, class Connection>
+class check_timeout_op {
+public:
+   HealthChecker* checker_ = nullptr;
+   Connection* conn_ = nullptr;
+   asio::coroutine coro_{};
+
+   template <class Self>
+   void operator()(Self& self, system::error_code ec = {})
+   {
+      BOOST_ASIO_CORO_REENTER (coro_) for (;;)
+      {
+         checker_->wait_timer_.expires_after(2 * checker_->ping_interval_);
+         BOOST_ASIO_CORO_YIELD
+         checker_->wait_timer_.async_wait(std::move(self));
+         BOOST_REDIS_CHECK_OP0(;)
+
+         if (checker_->resp_.has_error()) {
+            self.complete({});
+            return;
+         }
+
+         if (checker_->resp_.value().empty()) {
+            checker_->ping_timer_.cancel();
+            conn_->cancel(operation::run);
+            checker_->checker_has_exited_ = true;
+            self.complete(error::pong_timeout);
+            return;
+         }
+
+         if (checker_->resp_.has_value()) {
+            checker_->resp_.value().clear();
+         }
+      }
+   }
+};
+
+template <class HealthChecker, class Connection>
+class check_health_op {
+public:
+   HealthChecker* checker_ = nullptr;
+   Connection* conn_ = nullptr;
+   asio::coroutine coro_{};
+
+   template <class Self>
+   void
+   operator()(
+         Self& self,
+         std::array<std::size_t, 2> order = {},
+         system::error_code ec1 = {},
+         system::error_code ec2 = {})
+   {
+      BOOST_ASIO_CORO_REENTER (coro_)
+      {
+         if (checker_->ping_interval_ == std::chrono::seconds::zero()) {
+            BOOST_ASIO_CORO_YIELD
+            asio::post(std::move(self));
+            self.complete({});
+            return;
+         }
+
+         BOOST_ASIO_CORO_YIELD
+         asio::experimental::make_parallel_group(
+            [this](auto token) { return checker_->async_ping(*conn_, token); },
+            [this](auto token) { return checker_->async_check_timeout(*conn_, token);}
+         ).async_wait(
+            asio::experimental::wait_for_one(),
+            std::move(self));
+
+         if (is_cancelled(self)) {
+            self.complete(asio::error::operation_aborted);
+            return;
+         }
+
+         switch (order[0]) {
+            case 0: self.complete(ec1); return;
+            case 1: self.complete(ec2); return;
+            default: BOOST_ASSERT(false);
+         }
+      }
+   }
+};
+
+template <class Executor>
+class health_checker {
+private:
+   using timer_type =
+      asio::basic_waitable_timer<
+         std::chrono::steady_clock,
+         asio::wait_traits<std::chrono::steady_clock>,
+         Executor>;
+
+public:
+   health_checker(Executor ex)
+   : ping_timer_{ex}
+   , wait_timer_{ex}
+   {
+      req_.push("PING", "Boost.Redis");
+   }
+
+   void set_config(config const& cfg)
+   {
+      req_.clear();
+      req_.push("PING", cfg.health_check_id);
+      ping_interval_ = cfg.health_check_interval;
+   }
+
+   template <
+      class Connection,
+      class CompletionToken = asio::default_completion_token_t<Executor>
+   >
+   auto async_check_health(Connection& conn, CompletionToken token = CompletionToken{})
+   {
+      checker_has_exited_ = false;
+      return asio::async_compose
+         < CompletionToken
+         , void(system::error_code)
+         >(check_health_op<health_checker, Connection>{this, &conn}, token, conn);
+   }
+
+   std::size_t cancel(operation op)
+   {
+      switch (op) {
+         case operation::health_check:
+         case operation::all:
+            ping_timer_.cancel();
+            wait_timer_.cancel();
+            break;
+         default: /* ignore */;
+      }
+
+      return 0;
+   }
+
+private:
+   template <class Connection, class CompletionToken>
+   auto async_ping(Connection& conn, CompletionToken token)
+   {
+      return asio::async_compose
+         < CompletionToken
+         , void(system::error_code)
+         >(ping_op<health_checker, Connection>{this, &conn}, token, conn, ping_timer_);
+   }
+
+   template <class Connection, class CompletionToken>
+   auto async_check_timeout(Connection& conn, CompletionToken token)
+   {
+      return asio::async_compose
+         < CompletionToken
+         , void(system::error_code)
+         >(check_timeout_op<health_checker, Connection>{this, &conn}, token, conn, wait_timer_);
+   }
+
+   template <class, class> friend class ping_op;
+   template <class, class> friend class check_timeout_op;
+   template <class, class> friend class check_health_op;
+
+   timer_type ping_timer_;
+   timer_type wait_timer_;
+   redis::request req_;
+   redis::generic_response resp_;
+   std::chrono::steady_clock::duration ping_interval_ = std::chrono::seconds{5};
+   bool checker_has_exited_ = false;
+};
+
+} // boost::redis::detail
+
+#endif // BOOST_REDIS_HEALTH_CHECKER_HPP
--- a/include/boost/redis/detail/helper.hpp
+++ b/include/boost/redis/detail/helper.hpp
@@ -0,0 +1,37 @@
+/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
+ *
+ * Distributed under the Boost Software License, Version 1.0. (See
+ * accompanying file LICENSE.txt)
+ */
+
+#ifndef BOOST_REDIS_HELPER_HPP
+#define BOOST_REDIS_HELPER_HPP
+
+#include <boost/asio/cancellation_type.hpp>
+
+namespace boost::redis::detail
+{
+
+template <class T>
+auto is_cancelled(T const& self)
+{
+   return self.get_cancellation_state().cancelled() != asio::cancellation_type_t::none;
+}
+
+#define BOOST_REDIS_CHECK_OP0(X)\
+   if (ec || redis::detail::is_cancelled(self)) {\
+      X\
+      self.complete(!!ec ? ec : asio::error::operation_aborted);\
+      return;\
+   }
+
+#define BOOST_REDIS_CHECK_OP1(X)\
+   if (ec || redis::detail::is_cancelled(self)) {\
+      X\
+      self.complete(!!ec ? ec : asio::error::operation_aborted, {});\
+      return;\
+   }
+
+} // boost::redis::detail
+
+#endif // BOOST_REDIS_HELPER_HPP
--- a/include/boost/redis/detail/multiplexer.hpp
+++ b/include/boost/redis/detail/multiplexer.hpp
@@ -1,239 +0,0 @@
-/* Copyright (c) 2018-2025 Marcelo Zimbres Silva (mzimbres@gmail.com)
- *
- * Distributed under the Boost Software License, Version 1.0. (See
- * accompanying file LICENSE.txt)
- */
-
-#ifndef BOOST_REDIS_MULTIPLEXER_HPP
-#define BOOST_REDIS_MULTIPLEXER_HPP
-
-#include <boost/redis/adapter/adapt.hpp>
-#include <boost/redis/adapter/any_adapter.hpp>
-#include <boost/redis/config.hpp>
-#include <boost/redis/detail/read_buffer.hpp>
-#include <boost/redis/resp3/node.hpp>
-#include <boost/redis/resp3/parser.hpp>
-#include <boost/redis/resp3/type.hpp>
-#include <boost/redis/usage.hpp>
-
-#include <boost/system/error_code.hpp>
-
-#include <cstddef>
-#include <deque>
-#include <functional>
-#include <memory>
-#include <string_view>
-#include <utility>
-
-namespace boost::redis {
-
-class request;
-
-namespace detail {
-
-// Return type of the multiplexer::consume_next function
-enum class consume_result
-{
-   needs_more,    // consume_next didn't have enough data
-   got_response,  // got a response to a regular command, vs. a push
-   got_push,      // got a response to a push
-};
-
-class multiplexer {
-public:
-   struct elem {
-   public:
-      explicit elem(request const& req, any_adapter adapter);
-
-      void set_done_callback(std::function<void()> f) noexcept { done_ = std::move(f); };
-
-      auto notify_done() noexcept -> void
-      {
-         status_ = status::done;
-         done_();
-      }
-
-      auto notify_error(system::error_code ec) noexcept -> void;
-
-      [[nodiscard]]
-      auto is_waiting() const noexcept
-      {
-         return status_ == status::waiting;
-      }
-
-      [[nodiscard]]
-      auto is_written() const noexcept
-      {
-         return status_ == status::written;
-      }
-
-      [[nodiscard]]
-      auto is_staged() const noexcept
-      {
-         return status_ == status::staged;
-      }
-
-      [[nodiscard]]
-      bool is_done() const noexcept
-      {
-         return status_ == status::done;
-      }
-
-      void mark_written() noexcept { status_ = status::written; }
-
-      void mark_staged() noexcept { status_ = status::staged; }
-
-      void mark_waiting() noexcept { status_ = status::waiting; }
-
-      auto get_error() const -> system::error_code const& { return ec_; }
-
-      auto get_request() const -> request const& { return *req_; }
-
-      auto get_read_size() const -> std::size_t { return read_size_; }
-
-      auto get_remaining_responses() const -> std::size_t { return remaining_responses_; }
-
-      auto commit_response(std::size_t read_size) -> void;
-
-      auto get_adapter() -> any_adapter& { return adapter_; }
-
-      // Marks the element as an abandoned request. An abandoned request
-      // won't cause problems when its response arrives, but that response will be ignored.
-      void mark_abandoned();
-
-      [[nodiscard]]
-      bool is_abandoned() const
-      {
-         return !req_;
-      }
-
-   private:
-      enum class status
-      {
-         waiting,  // the request hasn't been written yet
-         staged,   // we've issued the write for this request, but it hasn't finished yet
-         written,  // the request has been written successfully
-         done,     // the request has completed and the done callback has been invoked
-      };
-
-      request const* req_;
-      any_adapter adapter_;
-      std::function<void()> done_;
-
-      // Contains the number of commands that haven't been read yet.
-      std::size_t remaining_responses_;
-      status status_;
-
-      system::error_code ec_;
-      std::size_t read_size_;
-   };
-
-   multiplexer();
-
-   // To be called before a write operation. Coalesces all available requests
-   // into a single buffer. Returns the number of coalesced requests.
-   // Must be called before cancel_on_conn_lost() because it might change
-   // request status.
-   [[nodiscard]]
-   auto prepare_write() -> std::size_t;
-
-   // To be called after a write operation.
-   // Returns true once all the bytes in the buffer generated by prepare_write
-   // have been written.
-   // Must be called before cancel_on_conn_lost() because it might change
-   // request status.
-   auto commit_write(std::size_t bytes_written) -> bool;
-
-   // To be called after a successful read operation.
-   // Must be called before cancel_on_conn_lost() because it might change
-   // request status.
-   [[nodiscard]]
-   auto consume(system::error_code& ec) -> std::pair<consume_result, std::size_t>;
-
-   auto add(std::shared_ptr<elem> const& ptr) -> void;
-   void cancel(std::shared_ptr<elem> const& ptr);
-   auto reset() -> void;
-
-   [[nodiscard]]
-   auto const& get_parser() const noexcept
-   {
-      return parser_;
-   }
-
-   auto cancel_waiting() -> std::size_t;
-
-   // To be called exactly once to clean up state after a connection becomes unhealthy.
-   // Requests are canceled or returned to the waiting state to be re-sent to the server,
-   // depending on their configuration. After this function is called, prepare_write,
-   // commit_write and consume_next must not be called until a reset() happens.
-   // Otherwise, race conditions like the following might happen
-   // (see https://github.com/boostorg/redis/pull/309 and https://github.com/boostorg/redis/issues/181):
-   //
-   //   - This function runs and cancels a request, then consume_next runs. It tries to access
-   //     a request and adapter that might have been destroyed.
-   //   - This function runs and returns a request to waiting, then prepare_write runs.
-   //     It incorrectly sets the request state to staged, causing de synchronization between requests and responses.
-   void cancel_on_conn_lost();
-
-   [[nodiscard]]
-   auto get_write_buffer() const noexcept -> std::string_view
-   {
-      return std::string_view{write_buffer_}.substr(write_offset_);
-   }
-
-   [[nodiscard]]
-   auto get_read_buffer() noexcept -> read_buffer&
-   {
-      return read_buffer_;
-   }
-
-   [[nodiscard]]
-   auto get_prepared_read_buffer() noexcept -> read_buffer::span_type;
-
-   [[nodiscard]]
-   auto prepare_read() noexcept -> system::error_code;
-
-   void commit_read(std::size_t read_size);
-
-   [[nodiscard]]
-   auto get_read_buffer_size() const noexcept -> std::size_t;
-
-   void set_receive_adapter(any_adapter adapter);
-
-   [[nodiscard]]
-   auto get_usage() const noexcept -> usage
-   {
-      return usage_;
-   }
-
-   void set_config(config const& cfg);
-
-private:
-   void commit_usage(bool is_push, read_buffer::consume_result res);
-
-   [[nodiscard]]
-   auto is_next_push(std::string_view data) const noexcept -> bool;
-
-   // Completes requests that don't expect a response
-   void release_push_requests();
-
-   [[nodiscard]]
-   consume_result consume_impl(system::error_code& ec);
-
-   read_buffer read_buffer_;
-   std::string write_buffer_;
-   std::size_t write_offset_{};  // how many bytes of the write buffer have been written?
-   std::deque<std::shared_ptr<elem>> reqs_;
-   resp3::parser parser_{};
-   bool on_push_ = false;
-   bool cancel_run_called_ = false;
-   usage usage_;
-   any_adapter receive_adapter_;
-};
-
-auto make_elem(request const& req, any_adapter adapter) -> std::shared_ptr<multiplexer::elem>;
-
-}  // namespace detail
-}  // namespace boost::redis
-
-#endif  // BOOST_REDIS_MULTIPLEXER_HPP
--- a/include/boost/redis/detail/read.hpp
+++ b/include/boost/redis/detail/read.hpp
@@ -0,0 +1,291 @@
+/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
+ *
+ * Distributed under the Boost Software License, Version 1.0. (See
+ * accompanying file LICENSE.txt)
+ */
+
+#ifndef BOOST_REDIS_READ_HPP
+#define BOOST_REDIS_READ_HPP
+
+#include <boost/redis/resp3/type.hpp>
+#include <boost/redis/resp3/parser.hpp>
+#include <boost/redis/adapter/ignore.hpp>
+#include <boost/redis/detail/helper.hpp>
+#include <boost/asio/read.hpp>
+#include <boost/asio/compose.hpp>
+#include <boost/asio/coroutine.hpp>
+#include <boost/asio/post.hpp>
+
+#include <string_view>
+#include <limits>
+
+namespace boost::redis::detail {
+
+template <class DynamicBuffer>
+std::string_view buffer_view(DynamicBuffer buf) noexcept
+{
+   char const* start = static_cast<char const*>(buf.data(0, buf.size()).data());
+   return std::string_view{start, std::size(buf)};
+}
+
+template <class AsyncReadStream, class DynamicBuffer>
+class append_some_op {
+private:
+   AsyncReadStream& stream_;
+   DynamicBuffer buf_;
+   std::size_t size_ = 0;
+   std::size_t tmp_ = 0;
+   asio::coroutine coro_{};
+
+public:
+   append_some_op(AsyncReadStream& stream, DynamicBuffer buf, std::size_t size)
+   : stream_ {stream}
+   , buf_ {std::move(buf)}
+   , size_{size}
+   { }
+
+   template <class Self>
+   void operator()( Self& self
+                  , system::error_code ec = {}
+                  , std::size_t n = 0)
+   {
+      BOOST_ASIO_CORO_REENTER (coro_)
+      {
+         tmp_ = buf_.size();
+         buf_.grow(size_);
+
+         BOOST_ASIO_CORO_YIELD
+         stream_.async_read_some(buf_.data(tmp_, size_), std::move(self));
+         if (ec) {
+            self.complete(ec, 0);
+            return;
+         }
+
+         buf_.shrink(buf_.size() - tmp_ - n);
+         self.complete({}, n);
+      }
+   }
+};
+
+template <class AsyncReadStream, class DynamicBuffer, class CompletionToken>
+auto
+async_append_some(
+   AsyncReadStream& stream,
+   DynamicBuffer buffer,
+   std::size_t size,
+   CompletionToken&& token)
+{
+   return asio::async_compose
+      < CompletionToken
+      , void(system::error_code, std::size_t)
+      >(append_some_op<AsyncReadStream, DynamicBuffer> {stream, buffer, size}, token, stream);
+}
+
+template <
+   class AsyncReadStream,
+   class DynamicBuffer,
+   class ResponseAdapter>
+class parse_op {
+private:
+   AsyncReadStream& stream_;
+   DynamicBuffer buf_;
+   resp3::parser parser_;
+   ResponseAdapter adapter_;
+   bool needs_rescheduling_ = true;
+   system::error_code ec_;
+   asio::coroutine coro_{};
+
+   static std::size_t const growth = 1024;
+
+public:
+   parse_op(AsyncReadStream& stream, DynamicBuffer buf, ResponseAdapter adapter)
+   : stream_ {stream}
+   , buf_ {std::move(buf)}
+   , adapter_ {std::move(adapter)}
+   { }
+
+   template <class Self>
+   void operator()( Self& self
+                  , system::error_code ec = {}
+                  , std::size_t = 0)
+   {
+      BOOST_ASIO_CORO_REENTER (coro_)
+      {
+         while (!resp3::parse(parser_, buffer_view(buf_), adapter_, ec)) {
+            needs_rescheduling_ = false;
+            BOOST_ASIO_CORO_YIELD
+            async_append_some(
+               stream_, buf_, parser_.get_suggested_buffer_growth(growth),
+               std::move(self));
+            if (ec) {
+               self.complete(ec, 0);
+               return;
+            }
+         }
+
+         ec_ = ec;
+         if (needs_rescheduling_) {
+            BOOST_ASIO_CORO_YIELD
+            asio::post(std::move(self));
+         }
+
+         self.complete(ec_, parser_.get_consumed());
+      }
+   }
+};
+
+/** \brief Reads a complete response to a command sychronously.
+ *
+ *  This function reads a complete response to a command or a
+ *  server push synchronously. For example
+ *
+ *  @code
+ *  int resp;
+ *  std::string buffer;
+ *  resp3::read(socket, dynamic_buffer(buffer), adapt(resp));
+ *  @endcode
+ *
+ *  For a complete example see examples/intro_sync.cpp. This function
+ *  is implemented in terms of one or more calls to @c
+ *  asio::read_until and @c asio::read functions, and is known as a @a
+ *  composed @a operation. Furthermore, the implementation may read
+ *  additional bytes from the stream that lie past the end of the
+ *  message being read. These additional bytes are stored in the
+ *  dynamic buffer, which must be preserved for subsequent reads.
+ *
+ *  \param stream The stream from which to read e.g. a tcp socket.
+ *  \param buf Dynamic buffer (version 2).
+ *  \param adapter The response adapter.
+ *  \param ec If an error occurs, it will be assigned to this paramter.
+ *  \returns The number of bytes that have been consumed from the dynamic buffer.
+ *
+ *  \remark This function calls buf.consume() in each chunk of data
+ *  after it has been passed to the adapter. Users must not consume
+ *  the bytes after it returns.
+ */
+template <
+     class SyncReadStream,
+     class DynamicBuffer,
+     class ResponseAdapter
+  >
+auto
+read(
+   SyncReadStream& stream,
+   DynamicBuffer buf,
+   ResponseAdapter adapter,
+   system::error_code& ec) -> std::size_t
+{
+   static std::size_t const growth = 1024;
+
+   resp3::parser parser;
+   while (!parser.done()) {
+      auto const res = parser.consume(detail::buffer_view(buf), ec);
+      if (ec)
+         return 0UL;
+
+      if (!res.has_value()) {
+         auto const size_before = buf.size();
+         buf.grow(parser.get_suggested_buffer_growth(growth));
+         auto const n =
+            stream.read_some(
+               buf.data(size_before, parser.get_suggested_buffer_growth(growth)),
+               ec);
+         if (ec)
+            return 0UL;
+
+         buf.shrink(buf.size() - size_before - n);
+         continue;
+      }
+
+      adapter(res.value(), ec);
+      if (ec)
+         return 0UL;
+   }
+
+   return parser.get_consumed();
+}
+
+/** \brief Reads a complete response to a command sychronously.
+ *  
+ *  Same as the error_code overload but throws on error.
+ */
+template<
+   class SyncReadStream,
+   class DynamicBuffer,
+   class ResponseAdapter = adapter::ignore>
+auto
+read(
+   SyncReadStream& stream,
+   DynamicBuffer buf,
+   ResponseAdapter adapter = ResponseAdapter{})
+{
+   system::error_code ec;
+   auto const n = redis::detail::read(stream, buf, adapter, ec);
+
+   if (ec)
+       BOOST_THROW_EXCEPTION(system::system_error{ec});
+
+   return n;
+}
+
+/** \brief Reads a complete response to a Redis command asynchronously.
+ *
+ *  This function reads a complete response to a command or a
+ *  server push asynchronously. For example
+ *
+ *  @code
+ *  std::string buffer;
+ *  std::set<std::string> resp;
+ *  co_await resp3::async_read(socket, dynamic_buffer(buffer), adapt(resp));
+ *  @endcode
+ *
+ *  For a complete example see examples/transaction.cpp. This function
+ *  is implemented in terms of one or more calls to @c
+ *  asio::async_read_until and @c asio::async_read functions, and is
+ *  known as a @a composed @a operation.  Furthermore, the
+ *  implementation may read additional bytes from the stream that lie
+ *  past the end of the message being read. These additional bytes are
+ *  stored in the dynamic buffer, which must be preserved for
+ *  subsequent reads.
+ *
+ *  \param stream The stream from which to read e.g. a tcp socket.
+ *  \param buffer Dynamic buffer (version 2).
+ *  \param adapter The response adapter.
+ *  \param token The completion token.
+ *
+ *  The completion handler will receive as a parameter the total
+ *  number of bytes transferred from the stream and must have the
+ *  following signature
+ *
+ *  @code
+ *  void(system::error_code, std::size_t);
+ *  @endcode
+ *
+ *  \remark This function calls buf.consume() in each chunk of data
+ *  after it has been passed to the adapter. Users must not consume
+ *  the bytes after it returns.
+ */
+template <
+   class AsyncReadStream,
+   class DynamicBuffer,
+   class ResponseAdapter = adapter::ignore,
+   class CompletionToken = asio::default_completion_token_t<typename AsyncReadStream::executor_type>
+   >
+auto async_read(
+   AsyncReadStream& stream,
+   DynamicBuffer buffer,
+   ResponseAdapter adapter = ResponseAdapter{},
+   CompletionToken&& token =
+      asio::default_completion_token_t<typename AsyncReadStream::executor_type>{})
+{
+   return asio::async_compose
+      < CompletionToken
+      , void(system::error_code, std::size_t)
+      >(parse_op<AsyncReadStream, DynamicBuffer, ResponseAdapter> {stream, buffer, adapter},
+        token,
+        stream);
+}
+
+} // boost::redis::detail
+
+#endif // BOOST_REDIS_READ_HPP
--- a/include/boost/redis/detail/read_buffer.hpp
+++ b/include/boost/redis/detail/read_buffer.hpp
@@ -1,69 +0,0 @@
-/* Copyright (c) 2018-2025 Marcelo Zimbres Silva (mzimbres@gmail.com)
- *
- * Distributed under the Boost Software License, Version 1.0. (See
- * accompanying file LICENSE.txt)
- */
-
-#ifndef BOOST_REDIS_READ_BUFFER_HPP
-#define BOOST_REDIS_READ_BUFFER_HPP
-
-#include <boost/core/span.hpp>
-#include <boost/system/error_code.hpp>
-
-#include <cstddef>
-#include <string_view>
-#include <utility>
-#include <vector>
-
-namespace boost::redis::detail {
-
-class read_buffer {
-public:
-   using span_type = span<char>;
-
-   struct consume_result {
-      std::size_t consumed;
-      std::size_t rotated;
-   };
-
-   // See config.hpp for the meaning of these parameters.
-   struct config {
-      std::size_t read_buffer_append_size = 4096u;
-      std::size_t max_read_size = static_cast<std::size_t>(-1);
-   };
-
-   // Prepare the buffer to receive more data.
-   [[nodiscard]]
-   auto prepare() -> system::error_code;
-
-   [[nodiscard]]
-   auto get_prepared() noexcept -> span_type;
-
-   void commit(std::size_t read_size);
-
-   [[nodiscard]]
-   auto get_commited() const noexcept -> std::string_view;
-
-   void clear();
-
-   // Consumes committed data by rotating the remaining data to the
-   // front of the buffer.
-   auto consume(std::size_t size) -> consume_result;
-
-   void reserve(std::size_t n);
-
-   friend bool operator==(read_buffer const& lhs, read_buffer const& rhs);
-
-   friend bool operator!=(read_buffer const& lhs, read_buffer const& rhs);
-
-   void set_config(config const& cfg) noexcept { cfg_ = cfg; };
-
-private:
-   config cfg_ = config{};
-   std::vector<char> buffer_;
-   std::size_t append_buf_begin_ = 0;
-};
-
-}  // namespace boost::redis::detail
-
-#endif  // BOOST_REDIS_READ_BUFFER_HPP
--- a/include/boost/redis/detail/reader_fsm.hpp
+++ b/include/boost/redis/detail/reader_fsm.hpp
@@ -1,97 +0,0 @@
-/* Copyright (c) 2018-2025 Marcelo Zimbres Silva (mzimbres@gmail.com)
- *
- * Distributed under the Boost Software License, Version 1.0. (See
- * accompanying file LICENSE.txt)
- */
-
-#ifndef BOOST_REDIS_READER_FSM_HPP
-#define BOOST_REDIS_READER_FSM_HPP
-
-#include <boost/redis/detail/connection_state.hpp>
-#include <boost/redis/detail/multiplexer.hpp>
-
-#include <boost/asio/cancellation_type.hpp>
-#include <boost/system/error_code.hpp>
-
-#include <chrono>
-#include <cstddef>
-
-namespace boost::redis::detail {
-
-class read_buffer;
-
-class reader_fsm {
-public:
-   class action {
-   public:
-      enum class type
-      {
-         read_some,
-         notify_push_receiver,
-         done,
-      };
-
-      action(system::error_code ec) noexcept
-      : type_(type::done)
-      , ec_(ec)
-      { }
-
-      static action read_some(std::chrono::steady_clock::duration timeout) { return {timeout}; }
-
-      static action notify_push_receiver(std::size_t bytes) { return {bytes}; }
-
-      type get_type() const { return type_; }
-
-      system::error_code error() const
-      {
-         BOOST_ASSERT(type_ == type::done);
-         return ec_;
-      }
-
-      std::chrono::steady_clock::duration timeout() const
-      {
-         BOOST_ASSERT(type_ == type::read_some);
-         return timeout_;
-      }
-
-      std::size_t push_size() const
-      {
-         BOOST_ASSERT(type_ == type::notify_push_receiver);
-         return push_size_;
-      }
-
-   private:
-      action(std::size_t push_size) noexcept
-      : type_(type::notify_push_receiver)
-      , push_size_(push_size)
-      { }
-
-      action(std::chrono::steady_clock::duration t) noexcept
-      : type_(type::read_some)
-      , timeout_(t)
-      { }
-
-      type type_;
-      union {
-         system::error_code ec_;
-         std::chrono::steady_clock::duration timeout_;
-         std::size_t push_size_{};
-      };
-   };
-
-   action resume(
-      connection_state& st,
-      std::size_t bytes_read,
-      system::error_code ec,
-      asio::cancellation_type_t cancel_state);
-
-   reader_fsm() = default;
-
-private:
-   int resume_point_{0};
-   std::pair<consume_result, std::size_t> res_{consume_result::needs_more, 0u};
-};
-
-}  // namespace boost::redis::detail
-
-#endif  // BOOST_REDIS_READER_FSM_HPP
--- a/include/boost/redis/detail/receive_fsm.hpp
+++ b/include/boost/redis/detail/receive_fsm.hpp
@@ -1,58 +0,0 @@
-//
-// Copyright (c) 2018-2026 Marcelo Zimbres Silva (mzimbres@gmail.com),
-// Ruben Perez Hidalgo (rubenperez038 at gmail dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef BOOST_REDIS_RECEIVE_FSM_HPP
-#define BOOST_REDIS_RECEIVE_FSM_HPP
-
-#include <boost/asio/cancellation_type.hpp>
-#include <boost/system/error_code.hpp>
-
-// Sans-io algorithm for async_receive2, as a finite state machine
-
-namespace boost::redis::detail {
-
-struct connection_state;
-
-struct receive_action {
-   enum class action_type
-   {
-      setup_cancellation,  // Set up the cancellation types supported by the composed operation
-      wait,                // Wait for a message to appear in the receive channel
-      drain_channel,       // Empty the receive channel
-      immediate,           // Call async_immediate
-      done,                // Complete
-   };
-
-   action_type type;
-   system::error_code ec;
-
-   receive_action(action_type type) noexcept
-   : type{type}
-   { }
-
-   receive_action(system::error_code ec) noexcept
-   : type{action_type::done}
-   , ec{ec}
-   { }
-};
-
-class receive_fsm {
-   int resume_point_{0};
-
-public:
-   receive_fsm() = default;
-
-   receive_action resume(
-      connection_state& st,
-      system::error_code ec,
-      asio::cancellation_type_t cancel_state);
-};
-
-}  // namespace boost::redis::detail
-
-#endif
--- a/include/boost/redis/detail/redis_stream.hpp
+++ b/include/boost/redis/detail/redis_stream.hpp
@@ -1,251 +0,0 @@
-/* Copyright (c) 2018-2025 Marcelo Zimbres Silva (mzimbres@gmail.com),
- * Ruben Perez Hidalgo (rubenperez038 at gmail dot com)
- *
- * Distributed under the Boost Software License, Version 1.0. (See
- * accompanying file LICENSE.txt)
- */
-#ifndef BOOST_REDIS_REDIS_STREAM_HPP
-#define BOOST_REDIS_REDIS_STREAM_HPP
-
-#include <boost/redis/config.hpp>
-#include <boost/redis/detail/connect_fsm.hpp>
-#include <boost/redis/detail/connect_params.hpp>
-#include <boost/redis/error.hpp>
-#include <boost/redis/logger.hpp>
-
-#include <boost/asio/basic_waitable_timer.hpp>
-#include <boost/asio/cancel_after.hpp>
-#include <boost/asio/compose.hpp>
-#include <boost/asio/connect.hpp>
-#include <boost/asio/coroutine.hpp>
-#include <boost/asio/ip/basic_resolver.hpp>
-#include <boost/asio/ip/tcp.hpp>
-#include <boost/asio/local/stream_protocol.hpp>
-#include <boost/asio/ssl/context.hpp>
-#include <boost/asio/ssl/stream.hpp>
-#include <boost/asio/ssl/stream_base.hpp>
-#include <boost/asio/steady_timer.hpp>
-#include <boost/assert.hpp>
-#include <boost/system/error_code.hpp>
-
-#include <utility>
-
-namespace boost {
-namespace redis {
-namespace detail {
-
-template <class Executor>
-class redis_stream {
-   asio::ssl::context ssl_ctx_;
-   asio::ip::basic_resolver<asio::ip::tcp, Executor> resolv_;
-   asio::ssl::stream<asio::basic_stream_socket<asio::ip::tcp, Executor>> stream_;
-#ifdef BOOST_ASIO_HAS_LOCAL_SOCKETS
-   asio::basic_stream_socket<asio::local::stream_protocol, Executor> unix_socket_;
-#endif
-   typename asio::steady_timer::template rebind_executor<Executor>::other timer_;
-   redis_stream_state st_;
-
-   void reset_stream() { stream_ = {resolv_.get_executor(), ssl_ctx_}; }
-
-   struct connect_op {
-      redis_stream& obj_;
-      connect_fsm fsm_;
-      connect_params params_;
-
-      template <class Self>
-      void execute_action(Self& self, connect_action act)
-      {
-         // Prevent use-after-move errors
-         auto& obj = this->obj_;
-         auto params = this->params_;
-
-         switch (act.type) {
-            case connect_action_type::unix_socket_close:
-#ifdef BOOST_ASIO_HAS_LOCAL_SOCKETS
-            {
-               system::error_code ec;
-               obj.unix_socket_.close(ec);
-               (*this)(self, ec);  // This is a sync action
-            }
-#else
-               BOOST_ASSERT(false);
-#endif
-               return;
-            case connect_action_type::unix_socket_connect:
-#ifdef BOOST_ASIO_HAS_LOCAL_SOCKETS
-               obj.unix_socket_.async_connect(
-                  params.addr.unix_socket(),
-                  asio::cancel_after(obj.timer_, params.connect_timeout, std::move(self)));
-#else
-               BOOST_ASSERT(false);
-#endif
-               return;
-
-            case connect_action_type::tcp_resolve:
-               obj.resolv_.async_resolve(
-                  params.addr.tcp_address().host,
-                  params.addr.tcp_address().port,
-                  asio::cancel_after(obj.timer_, params.resolve_timeout, std::move(self)));
-               return;
-            case connect_action_type::ssl_stream_reset:
-               obj.reset_stream();
-               // this action does not require yielding. Execute the next action immediately
-               (*this)(self);
-               return;
-            case connect_action_type::ssl_handshake:
-               obj.stream_.async_handshake(
-                  asio::ssl::stream_base::client,
-                  asio::cancel_after(obj.timer_, params.ssl_handshake_timeout, std::move(self)));
-               return;
-            case connect_action_type::done:        self.complete(act.ec); break;
-            // Connect should use the specialized handler, where resolver results are available
-            case connect_action_type::tcp_connect:
-            default:                               BOOST_ASSERT(false);
-         }
-      }
-
-      // This overload will be used for connects
-      template <class Self>
-      void operator()(
-         Self& self,
-         system::error_code ec,
-         const asio::ip::tcp::endpoint& selected_endpoint)
-      {
-         auto act = fsm_.resume(
-            ec,
-            selected_endpoint,
-            obj_.st_,
-            self.get_cancellation_state().cancelled());
-         execute_action(self, act);
-      }
-
-      // This overload will be used for resolves
-      template <class Self>
-      void operator()(
-         Self& self,
-         system::error_code ec,
-         asio::ip::tcp::resolver::results_type endpoints)
-      {
-         auto act = fsm_.resume(ec, endpoints, obj_.st_, self.get_cancellation_state().cancelled());
-         if (act.type == connect_action_type::tcp_connect) {
-            auto& obj = this->obj_;  // prevent use-after-move errors
-            asio::async_connect(
-               obj.stream_.next_layer(),
-               std::move(endpoints),
-               asio::cancel_after(obj.timer_, params_.connect_timeout, std::move(self)));
-         } else {
-            execute_action(self, act);
-         }
-      }
-
-      template <class Self>
-      void operator()(Self& self, system::error_code ec = {})
-      {
-         auto act = fsm_.resume(ec, obj_.st_, self.get_cancellation_state().cancelled());
-         execute_action(self, act);
-      }
-   };
-
-public:
-   explicit redis_stream(Executor ex, asio::ssl::context&& ssl_ctx)
-   : ssl_ctx_{std::move(ssl_ctx)}
-   , resolv_{ex}
-   , stream_{ex, ssl_ctx_}
-#ifdef BOOST_ASIO_HAS_LOCAL_SOCKETS
-   , unix_socket_{ex}
-#endif
-   , timer_{std::move(ex)}
-   { }
-
-   // Executor. Required to satisfy the AsyncStream concept
-   using executor_type = Executor;
-   executor_type get_executor() noexcept { return resolv_.get_executor(); }
-
-   // Accessors
-   const auto& get_ssl_context() const noexcept { return ssl_ctx_; }
-   bool is_open() const
-   {
-#ifdef BOOST_ASIO_HAS_LOCAL_SOCKETS
-      if (st_.type == transport_type::unix_socket)
-         return unix_socket_.is_open();
-#endif
-      return stream_.next_layer().is_open();
-   }
-   auto& next_layer() { return stream_; }
-   const auto& next_layer() const { return stream_; }
-
-   // I/O
-   template <class CompletionToken>
-   auto async_connect(const connect_params& params, buffered_logger& l, CompletionToken&& token)
-   {
-      this->st_.type = params.addr.type();
-      return asio::async_compose<CompletionToken, void(system::error_code)>(
-         connect_op{*this, connect_fsm{l}, params},
-         token);
-   }
-
-   // These functions should only be used with callbacks (e.g. within async_compose function bodies)
-   template <class ConstBufferSequence, class CompletionToken>
-   void async_write_some(const ConstBufferSequence& buffers, CompletionToken&& token)
-   {
-      switch (st_.type) {
-         case transport_type::tcp:
-         {
-            stream_.next_layer().async_write_some(buffers, std::forward<CompletionToken>(token));
-            break;
-         }
-         case transport_type::tcp_tls:
-         {
-            stream_.async_write_some(buffers, std::forward<CompletionToken>(token));
-            break;
-         }
-#ifdef BOOST_ASIO_HAS_LOCAL_SOCKETS
-         case transport_type::unix_socket:
-         {
-            unix_socket_.async_write_some(buffers, std::forward<CompletionToken>(token));
-            break;
-         }
-#endif
-         default: BOOST_ASSERT(false);
-      }
-   }
-
-   template <class MutableBufferSequence, class CompletionToken>
-   void async_read_some(const MutableBufferSequence& buffers, CompletionToken&& token)
-   {
-      switch (st_.type) {
-         case transport_type::tcp:
-         {
-            return stream_.next_layer().async_read_some(
-               buffers,
-               std::forward<CompletionToken>(token));
-            break;
-         }
-         case transport_type::tcp_tls:
-         {
-            return stream_.async_read_some(buffers, std::forward<CompletionToken>(token));
-            break;
-         }
-#ifdef BOOST_ASIO_HAS_LOCAL_SOCKETS
-         case transport_type::unix_socket:
-         {
-            unix_socket_.async_read_some(buffers, std::forward<CompletionToken>(token));
-            break;
-         }
-#endif
-         default: BOOST_ASSERT(false);
-      }
-   }
-
-   // Cancels resolve operations. Resolve operations don't support per-operation
-   // cancellation, but resolvers have a cancel() function. Resolve operations are
-   // in general blocking and run in a separate thread. cancel() has effect only
-   // if the operation hasn't started yet. Still, trying is better than nothing
-   void cancel_resolve() { resolv_.cancel(); }
-};
-
-}  // namespace detail
-}  // namespace redis
-}  // namespace boost
-
-#endif
--- a/include/boost/redis/detail/resolver.hpp
+++ b/include/boost/redis/detail/resolver.hpp
@@ -0,0 +1,137 @@
+/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
+ *
+ * Distributed under the Boost Software License, Version 1.0. (See
+ * accompanying file LICENSE.txt)
+ */
+
+#ifndef BOOST_REDIS_RESOLVER_HPP
+#define BOOST_REDIS_RESOLVER_HPP
+
+#include <boost/redis/config.hpp>
+#include <boost/redis/detail/helper.hpp>
+#include <boost/redis/error.hpp>
+#include <boost/asio/compose.hpp>
+#include <boost/asio/coroutine.hpp>
+#include <boost/asio/experimental/parallel_group.hpp>
+#include <boost/asio/ip/tcp.hpp>
+#include <boost/asio/steady_timer.hpp>
+#include <string>
+#include <chrono>
+
+namespace boost::redis::detail
+{
+
+template <class Resolver>
+struct resolve_op {
+   Resolver* resv_ = nullptr;
+   asio::coroutine coro{};
+
+   template <class Self>
+   void operator()( Self& self
+                  , std::array<std::size_t, 2> order = {}
+                  , system::error_code ec1 = {}
+                  , asio::ip::tcp::resolver::results_type res = {}
+                  , system::error_code ec2 = {})
+   {
+      BOOST_ASIO_CORO_REENTER (coro)
+      {
+         resv_->timer_.expires_after(resv_->timeout_);
+
+         BOOST_ASIO_CORO_YIELD
+         asio::experimental::make_parallel_group(
+            [this](auto token)
+            {
+               return resv_->resv_.async_resolve(resv_->addr_.host, resv_->addr_.port, token);
+            },
+            [this](auto token) { return resv_->timer_.async_wait(token);}
+         ).async_wait(
+            asio::experimental::wait_for_one(),
+            std::move(self));
+
+         if (is_cancelled(self)) {
+            self.complete(asio::error::operation_aborted);
+            return;
+         }
+
+         switch (order[0]) {
+            case 0: {
+               // Resolver completed first.
+               resv_->results_ = res;
+               self.complete(ec1);
+            } break;
+
+            case 1: {
+               if (ec2) {
+                  // Timer completed first with error, perhaps a
+                  // cancellation going on.
+                  self.complete(ec2);
+               } else {
+                  // Timer completed first without an error, this is a
+                  // resolve timeout.
+                  self.complete(error::resolve_timeout);
+               }
+            } break;
+
+            default: BOOST_ASSERT(false);
+         }
+      }
+   }
+};
+
+template <class Executor>
+class resolver {
+public:
+   using timer_type =
+      asio::basic_waitable_timer<
+         std::chrono::steady_clock,
+         asio::wait_traits<std::chrono::steady_clock>,
+         Executor>;
+
+   resolver(Executor ex) : resv_{ex} , timer_{ex} {}
+
+   template <class CompletionToken>
+   auto async_resolve(CompletionToken&& token)
+   {
+      return asio::async_compose
+         < CompletionToken
+         , void(system::error_code)
+         >(resolve_op<resolver>{this}, token, resv_);
+   }
+
+   std::size_t cancel(operation op)
+   {
+      switch (op) {
+         case operation::resolve:
+         case operation::all:
+            resv_.cancel();
+            timer_.cancel();
+            break;
+         default: /* ignore */;
+      }
+
+      return 0;
+   }
+
+   auto const& results() const noexcept
+      { return results_;}
+
+   void set_config(config const& cfg)
+   {
+      addr_ = cfg.addr;
+      timeout_ = cfg.resolve_timeout;
+   }
+
+private:
+   using resolver_type = asio::ip::basic_resolver<asio::ip::tcp, Executor>;
+   template <class> friend struct resolve_op;
+
+   resolver_type resv_;
+   timer_type timer_;
+   address addr_;
+   std::chrono::steady_clock::duration timeout_;
+   asio::ip::tcp::resolver::results_type results_;
+};
+
+} // boost::redis::detail
+
+#endif // BOOST_REDIS_RESOLVER_HPP
--- a/include/boost/redis/detail/resp3_type_to_error.hpp
+++ b/include/boost/redis/detail/resp3_type_to_error.hpp
@@ -1,29 +0,0 @@
-/* Copyright (c) 2018-2024 Marcelo Zimbres Silva (mzimbres@gmail.com)
- *
- * Distributed under the Boost Software License, Version 1.0. (See
- * accompanying file LICENSE.txt)
- */
-
-#ifndef BOOST_RESP3_TYPE_TO_ERROR_HPP
-#define BOOST_RESP3_TYPE_TO_ERROR_HPP
-
-#include <boost/redis/error.hpp>
-#include <boost/redis/resp3/type.hpp>
-
-#include <boost/assert.hpp>
-
-namespace boost::redis::detail {
-
-inline error resp3_type_to_error(resp3::type t)
-{
-   switch (t) {
-      case resp3::type::simple_error: return error::resp3_simple_error;
-      case resp3::type::blob_error:   return error::resp3_blob_error;
-      case resp3::type::null:         return error::resp3_null;
-      default:                        BOOST_ASSERT_MSG(false, "Unexpected data type."); return error::resp3_simple_error;
-   }
-}
-
-}  // namespace boost::redis::detail
-
-#endif  // BOOST_REDIS_ADAPTER_RESULT_HPP
--- a/include/boost/redis/detail/run_fsm.hpp
+++ b/include/boost/redis/detail/run_fsm.hpp
@@ -1,67 +0,0 @@
-//
-// Copyright (c) 2025 Marcelo Zimbres Silva (mzimbres@gmail.com),
-// Ruben Perez Hidalgo (rubenperez038 at gmail dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef BOOST_REDIS_RUN_FSM_HPP
-#define BOOST_REDIS_RUN_FSM_HPP
-
-#include <boost/redis/detail/connect_params.hpp>
-
-#include <boost/asio/cancellation_type.hpp>
-#include <boost/system/error_code.hpp>
-
-// Sans-io algorithm for async_run, as a finite state machine
-
-namespace boost::redis::detail {
-
-// Forward decls
-struct connection_state;
-
-// What should we do next?
-enum class run_action_type
-{
-   done,                   // Call the final handler
-   immediate,              // Call asio::async_immediate
-   connect,                // Transport connection establishment
-   sentinel_resolve,       // Contact Sentinels to resolve the master's address
-   parallel_group,         // Run the reader, writer and friends
-   cancel_receive,         // Cancel the receiver channel
-   wait_for_reconnection,  // Sleep for the reconnection period
-};
-
-struct run_action {
-   run_action_type type;
-   system::error_code ec;
-
-   run_action(run_action_type type) noexcept
-   : type{type}
-   { }
-
-   run_action(system::error_code ec) noexcept
-   : type{run_action_type::done}
-   , ec{ec}
-   { }
-};
-
-class run_fsm {
-   int resume_point_{0};
-   system::error_code stored_ec_;
-
-public:
-   run_fsm() = default;
-
-   run_action resume(
-      connection_state& st,
-      system::error_code ec,
-      asio::cancellation_type_t cancel_state);
-};
-
-connect_params make_run_connect_params(const connection_state& st);
-
-}  // namespace boost::redis::detail
-
-#endif  // BOOST_REDIS_CONNECTOR_HPP
--- a/include/boost/redis/detail/runner.hpp
+++ b/include/boost/redis/detail/runner.hpp
@@ -0,0 +1,250 @@
+/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
+ *
+ * Distributed under the Boost Software License, Version 1.0. (See
+ * accompanying file LICENSE.txt)
+ */
+
+#ifndef BOOST_REDIS_RUNNER_HPP
+#define BOOST_REDIS_RUNNER_HPP
+
+#include <boost/redis/detail/health_checker.hpp>
+#include <boost/redis/config.hpp>
+#include <boost/redis/response.hpp>
+#include <boost/redis/detail/helper.hpp>
+#include <boost/redis/error.hpp>
+#include <boost/redis/logger.hpp>
+#include <boost/redis/operation.hpp>
+#include <boost/redis/detail/connector.hpp>
+#include <boost/redis/detail/resolver.hpp>
+#include <boost/redis/detail/handshaker.hpp>
+#include <boost/asio/compose.hpp>
+#include <boost/asio/connect.hpp>
+#include <boost/asio/coroutine.hpp>
+#include <boost/asio/experimental/parallel_group.hpp>
+#include <boost/asio/ip/tcp.hpp>
+#include <boost/asio/steady_timer.hpp>
+#include <string>
+#include <memory>
+#include <chrono>
+
+namespace boost::redis::detail
+{
+
+template <class Runner, class Connection, class Logger>
+struct hello_op {
+   Runner* runner_ = nullptr;
+   Connection* conn_ = nullptr;
+   Logger logger_;
+   asio::coroutine coro_{};
+
+   template <class Self>
+   void operator()(Self& self, system::error_code ec = {}, std::size_t = 0)
+   {
+      BOOST_ASIO_CORO_REENTER (coro_)
+      {
+         runner_->hello_req_.clear();
+         if (runner_->hello_resp_.has_value())
+            runner_->hello_resp_.value().clear();
+         runner_->add_hello();
+
+         BOOST_ASIO_CORO_YIELD
+         conn_->async_exec(runner_->hello_req_, runner_->hello_resp_, std::move(self));
+         logger_.on_hello(ec, runner_->hello_resp_);
+         BOOST_REDIS_CHECK_OP0(conn_->cancel(operation::run);)
+         self.complete(ec);
+      }
+   }
+};
+
+template <class Runner, class Connection, class Logger>
+class runner_op {
+private:
+   Runner* runner_ = nullptr;
+   Connection* conn_ = nullptr;
+   Logger logger_;
+   asio::coroutine coro_{};
+
+public:
+   runner_op(Runner* runner, Connection* conn, Logger l)
+   : runner_{runner}
+   , conn_{conn}
+   , logger_{l}
+   {}
+
+   template <class Self>
+   void operator()( Self& self
+                  , std::array<std::size_t, 3> order = {}
+                  , system::error_code ec0 = {}
+                  , system::error_code ec1 = {}
+                  , system::error_code ec2 = {}
+                  , std::size_t = 0)
+   {
+      BOOST_ASIO_CORO_REENTER (coro_)
+      {
+         BOOST_ASIO_CORO_YIELD
+         asio::experimental::make_parallel_group(
+            [this](auto token) { return runner_->async_run_all(*conn_, logger_, token); },
+            [this](auto token) { return runner_->health_checker_.async_check_health(*conn_, token); },
+            [this](auto token) { return runner_->async_hello(*conn_, logger_, token); }
+         ).async_wait(
+            asio::experimental::wait_for_all(),
+            std::move(self));
+
+         if (is_cancelled(self)) {
+            self.complete(asio::error::operation_aborted);
+            return;
+         }
+
+         if (ec0 == error::connect_timeout || ec0 == error::resolve_timeout) {
+            self.complete(ec0);
+            return;
+         }
+
+         if (order[0] == 2 && !!ec2) {
+            self.complete(ec2);
+            return;
+         }
+
+         if (order[0] == 1 && ec1 == error::pong_timeout) {
+            self.complete(ec1);
+            return;
+         }
+
+         self.complete(ec0);
+      }
+   }
+};
+
+template <class Runner, class Connection, class Logger>
+struct run_all_op {
+   Runner* runner_ = nullptr;
+   Connection* conn_ = nullptr;
+   Logger logger_;
+   asio::coroutine coro_{};
+
+   template <class Self>
+   void operator()(Self& self, system::error_code ec = {}, std::size_t = 0)
+   {
+      BOOST_ASIO_CORO_REENTER (coro_)
+      {
+         BOOST_ASIO_CORO_YIELD
+         runner_->resv_.async_resolve(std::move(self));
+         logger_.on_resolve(ec, runner_->resv_.results());
+         BOOST_REDIS_CHECK_OP0(conn_->cancel(operation::run);)
+
+         BOOST_ASIO_CORO_YIELD
+         runner_->ctor_.async_connect(conn_->next_layer().next_layer(), runner_->resv_.results(), std::move(self));
+         logger_.on_connect(ec, runner_->ctor_.endpoint());
+         BOOST_REDIS_CHECK_OP0(conn_->cancel(operation::run);)
+
+         if (conn_->use_ssl()) {
+            BOOST_ASIO_CORO_YIELD
+            runner_->hsher_.async_handshake(conn_->next_layer(), std::move(self));
+            logger_.on_ssl_handshake(ec);
+            BOOST_REDIS_CHECK_OP0(conn_->cancel(operation::run);)
+         }
+
+         BOOST_ASIO_CORO_YIELD
+         conn_->async_run_lean(runner_->cfg_, logger_, std::move(self));
+         BOOST_REDIS_CHECK_OP0(;)
+         self.complete(ec);
+      }
+   }
+};
+
+template <class Executor>
+class runner {
+public:
+   runner(Executor ex, config cfg)
+   : resv_{ex}
+   , ctor_{ex}
+   , hsher_{ex}
+   , health_checker_{ex}
+   , cfg_{cfg}
+   { }
+
+   std::size_t cancel(operation op)
+   {
+      resv_.cancel(op);
+      ctor_.cancel(op);
+      hsher_.cancel(op);
+      health_checker_.cancel(op);
+      return 0U;
+   }
+
+   void set_config(config const& cfg)
+   {
+      cfg_ = cfg;
+      resv_.set_config(cfg);
+      ctor_.set_config(cfg);
+      hsher_.set_config(cfg);
+      health_checker_.set_config(cfg);
+   }
+
+   template <class Connection, class Logger, class CompletionToken>
+   auto async_run(Connection& conn, Logger l, CompletionToken token)
+   {
+      return asio::async_compose
+         < CompletionToken
+         , void(system::error_code)
+         >(runner_op<runner, Connection, Logger>{this, &conn, l}, token, conn);
+   }
+
+   config const& get_config() const noexcept {return cfg_;}
+
+private:
+   using resolver_type = resolver<Executor>;
+   using connector_type = connector<Executor>;
+   using handshaker_type = detail::handshaker<Executor>;
+   using health_checker_type = health_checker<Executor>;
+   using timer_type = typename connector_type::timer_type;
+
+   template <class, class, class> friend struct run_all_op;
+   template <class, class, class> friend class runner_op;
+   template <class, class, class> friend struct hello_op;
+
+   template <class Connection, class Logger, class CompletionToken>
+   auto async_run_all(Connection& conn, Logger l, CompletionToken token)
+   {
+      return asio::async_compose
+         < CompletionToken
+         , void(system::error_code)
+         >(run_all_op<runner, Connection, Logger>{this, &conn, l}, token, conn);
+   }
+
+   template <class Connection, class Logger, class CompletionToken>
+   auto async_hello(Connection& conn, Logger l, CompletionToken token)
+   {
+      return asio::async_compose
+         < CompletionToken
+         , void(system::error_code)
+         >(hello_op<runner, Connection, Logger>{this, &conn, l}, token, conn);
+   }
+
+   void add_hello()
+   {
+      if (!cfg_.username.empty() && !cfg_.password.empty() && !cfg_.clientname.empty())
+         hello_req_.push("HELLO", "3", "AUTH", cfg_.username, cfg_.password, "SETNAME", cfg_.clientname);
+      else if (cfg_.username.empty() && cfg_.password.empty() && cfg_.clientname.empty())
+         hello_req_.push("HELLO", "3");
+      else if (cfg_.clientname.empty())
+         hello_req_.push("HELLO", "3", "AUTH", cfg_.username, cfg_.password);
+      else
+         hello_req_.push("HELLO", "3", "SETNAME", cfg_.clientname);
+
+      if (cfg_.database_index)
+         hello_req_.push("SELECT", cfg_.database_index.value());
+   }
+
+   resolver_type resv_;
+   connector_type ctor_;
+   handshaker_type hsher_;
+   health_checker_type health_checker_;
+   request hello_req_;
+   generic_response hello_resp_;
+   config cfg_;
+};
+
+} // boost::redis::detail
+
+#endif // BOOST_REDIS_RUNNER_HPP
--- a/include/boost/redis/detail/sentinel_resolve_fsm.hpp
+++ b/include/boost/redis/detail/sentinel_resolve_fsm.hpp
@@ -1,93 +0,0 @@
-//
-// Copyright (c) 2025 Marcelo Zimbres Silva (mzimbres@gmail.com),
-// Ruben Perez Hidalgo (rubenperez038 at gmail dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef BOOST_REDIS_SENTINEL_RESOLVE_FSM_HPP
-#define BOOST_REDIS_SENTINEL_RESOLVE_FSM_HPP
-
-#include <boost/redis/adapter/any_adapter.hpp>
-#include <boost/redis/config.hpp>
-#include <boost/redis/detail/connect_params.hpp>
-
-#include <boost/asio/cancellation_type.hpp>
-#include <boost/assert.hpp>
-#include <boost/system/error_code.hpp>
-
-// Sans-io algorithm for async_sentinel_resolve, as a finite state machine
-
-namespace boost::redis::detail {
-
-// Forward decls
-struct connection_state;
-
-class sentinel_action {
-public:
-   enum class type
-   {
-      done,     // Call the final handler
-      connect,  // Transport connection establishment
-      request,  // Send the Sentinel request
-   };
-
-   sentinel_action(system::error_code ec) noexcept
-   : type_(type::done)
-   , ec_(ec)
-   { }
-
-   sentinel_action(const address& addr) noexcept
-   : type_(type::connect)
-   , connect_(&addr)
-   { }
-
-   static sentinel_action request() { return {type::request}; }
-
-   type get_type() const { return type_; }
-
-   [[nodiscard]]
-   system::error_code error() const
-   {
-      BOOST_ASSERT(type_ == type::done);
-      return ec_;
-   }
-
-   const address& connect_addr() const
-   {
-      BOOST_ASSERT(type_ == type::connect);
-      return *connect_;
-   }
-
-private:
-   type type_;
-   union {
-      system::error_code ec_;
-      const address* connect_;
-   };
-
-   sentinel_action(type type) noexcept
-   : type_(type)
-   { }
-};
-
-class sentinel_resolve_fsm {
-   int resume_point_{0};
-   std::size_t idx_{0u};
-
-public:
-   sentinel_resolve_fsm() = default;
-
-   sentinel_action resume(
-      connection_state& st,
-      system::error_code ec,
-      asio::cancellation_type_t cancel_state);
-};
-
-connect_params make_sentinel_connect_params(const config& cfg, const address& sentinel_addr);
-any_adapter make_sentinel_adapter(connection_state& st);
-
-}  // namespace boost::redis::detail
-
-#endif  // BOOST_REDIS_CONNECTOR_HPP
--- a/include/boost/redis/detail/subscription_tracker.hpp
+++ b/include/boost/redis/detail/subscription_tracker.hpp
@@ -1,35 +0,0 @@
-//
-// Copyright (c) 2025 Marcelo Zimbres Silva (mzimbres@gmail.com),
-// Ruben Perez Hidalgo (rubenperez038 at gmail dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef BOOST_REDIS_SUBSCRIPTION_TRACKER_HPP
-#define BOOST_REDIS_SUBSCRIPTION_TRACKER_HPP
-
-#include <set>
-#include <string>
-
-namespace boost::redis {
-
-class request;
-
-namespace detail {
-
-class subscription_tracker {
-   std::set<std::string> channels_;
-   std::set<std::string> pchannels_;
-
-public:
-   subscription_tracker() = default;
-   void clear();
-   void commit_changes(const request& req);
-   void compose_subscribe_request(request& to) const;
-};
-
-}  // namespace detail
-}  // namespace boost::redis
-
-#endif
--- a/include/boost/redis/detail/write.hpp
+++ b/include/boost/redis/detail/write.hpp
@@ -1,4 +1,4 @@
-/* Copyright (c) 2018-2024 Marcelo Zimbres Silva (mzimbres@gmail.com)
+/* Copyright (c) 2018-2022 Marcelo Zimbres Silva (mzimbres@gmail.com)
 *
 * Distributed under the Boost Software License, Version 1.0. (See
 * accompanying file LICENSE.txt)
@@ -7,39 +7,40 @@
 #ifndef BOOST_REDIS_WRITE_HPP
 #define BOOST_REDIS_WRITE_HPP

-#include <boost/redis/request.hpp>
-
 #include <boost/asio/write.hpp>
+#include <boost/redis/request.hpp>

 namespace boost::redis::detail {

-/** @brief Writes a request synchronously.
+/** \brief Writes a request synchronously.
+ *  \ingroup low-level-api
 *
- *  @param stream Stream to write the request to.
- *  @param req Request to write.
+ *  \param stream Stream to write the request to.
+ *  \param req Request to write.
 */
-template <class SyncWriteStream>
+template<class SyncWriteStream>
 auto write(SyncWriteStream& stream, request const& req)
 {
   return asio::write(stream, asio::buffer(req.payload()));
 }

-template <class SyncWriteStream>
+template<class SyncWriteStream>
 auto write(SyncWriteStream& stream, request const& req, system::error_code& ec)
 {
   return asio::write(stream, asio::buffer(req.payload()), ec);
 }

-/** @brief Writes a request asynchronously.
+/** \brief Writes a request asynchronously.
+ *  \ingroup low-level-api
 *
- *  @param stream Stream to write the request to.
- *  @param req Request to write.
- *  @param token Asio completion token.
+ *  \param stream Stream to write the request to.
+ *  \param req Request to write.
+ *  \param token Asio completion token.
 */
-template <
+template<
   class AsyncWriteStream,
-   class CompletionToken =
-      asio::default_completion_token_t<typename AsyncWriteStream::executor_type> >
+   class CompletionToken = asio::default_completion_token_t<typename AsyncWriteStream::executor_type>
+   >
 auto async_write(
   AsyncWriteStream& stream,
   request const& req,
@@ -49,6 +50,6 @@ auto async_write(
   return asio::async_write(stream, asio::buffer(req.payload()), token);
 }

-}  // namespace boost::redis::detail
+} // boost::redis::detail

-#endif  // BOOST_REDIS_WRITE_HPP
+#endif // BOOST_REDIS_WRITE_HPP
--- a/include/boost/redis/detail/writer_fsm.hpp
+++ b/include/boost/redis/detail/writer_fsm.hpp
@@ -1,92 +0,0 @@
-//
-// Copyright (c) 2025 Marcelo Zimbres Silva (mzimbres@gmail.com),
-// Ruben Perez Hidalgo (rubenperez038 at gmail dot com)
-//
-// Distributed under the Boost Software License, Version 1.0. (See accompanying
-// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#ifndef BOOST_REDIS_WRITER_FSM_HPP
-#define BOOST_REDIS_WRITER_FSM_HPP
-
-#include <boost/asio/cancellation_type.hpp>
-#include <boost/assert.hpp>
-#include <boost/system/error_code.hpp>
-
-#include <chrono>
-#include <cstddef>
-
-// Sans-io algorithm for the writer task, as a finite state machine
-
-namespace boost::redis::detail {
-
-// Forward decls
-struct connection_state;
-
-// What should we do next?
-enum class writer_action_type
-{
-   done,        // Call the final handler
-   write_some,  // Issue a write on the stream
-   wait,        // Wait until there is data to be written
-};
-
-class writer_action {
-   writer_action_type type_;
-   union {
-      system::error_code ec_;
-      std::chrono::steady_clock::duration timeout_;
-   };
-
-   writer_action(writer_action_type type, std::chrono::steady_clock::duration t) noexcept
-   : type_{type}
-   , timeout_{t}
-   { }
-
-public:
-   writer_action_type type() const { return type_; }
-
-   writer_action(system::error_code ec) noexcept
-   : type_{writer_action_type::done}
-   , ec_{ec}
-   { }
-
-   static writer_action write_some(std::chrono::steady_clock::duration timeout)
-   {
-      return {writer_action_type::write_some, timeout};
-   }
-
-   static writer_action wait(std::chrono::steady_clock::duration timeout)
-   {
-      return {writer_action_type::wait, timeout};
-   }
-
-   system::error_code error() const
-   {
-      BOOST_ASSERT(type_ == writer_action_type::done);
-      return ec_;
-   }
-
-   std::chrono::steady_clock::duration timeout() const
-   {
-      BOOST_ASSERT(type_ == writer_action_type::write_some || type_ == writer_action_type::wait);
-      return timeout_;
-   }
-};
-
-class writer_fsm {
-   int resume_point_{0};
-
-public:
-   writer_fsm() = default;
-
-   writer_action resume(
-      connection_state& st,
-      system::error_code ec,
-      std::size_t bytes_written,
-      asio::cancellation_type_t cancel_state);
-};
-
-}  // namespace boost::redis::detail
-
-#endif  // BOOST_REDIS_CONNECTOR_HPP
--- a/Show More
+++ b/Show More