diff --git a/.devcontainer/Dockerfile b/.devcontainer/Dockerfile
index a30aaa6147b..f3609230636 100644
--- a/.devcontainer/Dockerfile
+++ b/.devcontainer/Dockerfile
@@ -44,17 +44,18 @@ RUN wget -O abseil-cpp-${ABSEIL_CPP_VERSION}.tar.gz https://github.com/abseil/ab
     cmake --install . --config Release --prefix ${ABSEIL_CPP_INSTALL_DIR}
 
 # Install protobuf
-ENV PROTOBUF_VERSION=3.21.12
+ENV PROTOBUF_VERSION=25.0
 ENV PROTOBUF_INSTALL_DIR=~/ydb_deps/protobuf
 RUN wget -O protobuf-${PROTOBUF_VERSION}.tar.gz https://github.com/protocolbuffers/protobuf/archive/refs/tags/v${PROTOBUF_VERSION}.tar.gz && \
     tar -xvzf protobuf-${PROTOBUF_VERSION}.tar.gz && cd protobuf-${PROTOBUF_VERSION} && \
     mkdir build && cd build && \
-    cmake -G Ninja -DCMAKE_BUILD_TYPE=Release -Dprotobuf_BUILD_TESTS=OFF -Dprotobuf_INSTALL=ON -Dprotobuf_ABSL_PROVIDER=package .. && \
+    cmake -G Ninja -DCMAKE_PREFIX_PATH="${ABSEIL_CPP_INSTALL_DIR}" \
+    -DCMAKE_BUILD_TYPE=Release -Dprotobuf_BUILD_TESTS=OFF -Dprotobuf_INSTALL=ON -Dprotobuf_ABSL_PROVIDER=package .. && \
     cmake --build . --config Release && \
     cmake --install . --config Release --prefix ${PROTOBUF_INSTALL_DIR}
 
 # Install grpc
-ENV GRPC_VERSION=1.54.3
+ENV GRPC_VERSION=1.60.2
 ENV GRPC_INSTALL_DIR=~/ydb_deps/grpc
 RUN wget -O grpc-${GRPC_VERSION}.tar.gz https://github.com/grpc/grpc/archive/refs/tags/v${GRPC_VERSION}.tar.gz && \
     tar -xvzf grpc-${GRPC_VERSION}.tar.gz && cd grpc-${GRPC_VERSION} && \
diff --git a/.github/actions/prepare_vm/action.yaml b/.github/actions/prepare_vm/action.yaml
index 35819ab6309..2e6f36d43ea 100644
--- a/.github/actions/prepare_vm/action.yaml
+++ b/.github/actions/prepare_vm/action.yaml
@@ -39,9 +39,9 @@ runs:
 
         wget https://apt.llvm.org/llvm.sh
         chmod u+x llvm.sh
-        sudo ./llvm.sh 16
-        sudo update-alternatives --install /usr/bin/clang clang /usr/bin/clang-16 10000
-        sudo update-alternatives --install /usr/bin/clang++ clang++ /usr/bin/clang++-16 10000
+        sudo ./llvm.sh 18
+        sudo update-alternatives --install /usr/bin/clang clang /usr/bin/clang-18 10000
+        sudo update-alternatives --install /usr/bin/clang++ clang++ /usr/bin/clang++-18 10000
 
         # Install abseil-cpp
         wget -O abseil-cpp-20230802.0.tar.gz https://github.com/abseil/abseil-cpp/archive/refs/tags/20230802.0.tar.gz
@@ -54,20 +54,21 @@ runs:
         cd ../../
 
         # Install protobuf
-        wget -O protobuf-3.21.12.tar.gz https://github.com/protocolbuffers/protobuf/archive/refs/tags/v3.21.12.tar.gz
-        tar -xvzf protobuf-3.21.12.tar.gz
-        cd protobuf-3.21.12
+        wget -O protobuf-25.0.tar.gz https://github.com/protocolbuffers/protobuf/archive/refs/tags/v25.0.tar.gz
+        tar -xvzf protobuf-25.0.tar.gz
+        cd protobuf-25.0
         mkdir build && cd build
-        cmake -G Ninja ${ENABLE_CCACHE} -DCMAKE_BUILD_TYPE=Release -Dprotobuf_BUILD_TESTS=OFF -Dprotobuf_INSTALL=ON ..
+        cmake -G Ninja ${ENABLE_CCACHE} -DCMAKE_PREFIX_PATH="${HOME}/ydb_deps/absl" -DCMAKE_BUILD_TYPE=Release \
+          -Dprotobuf_BUILD_TESTS=OFF -Dprotobuf_INSTALL=ON -Dprotobuf_ABSL_PROVIDER=package ..
         cmake --build . --config Release
         cmake --install . --config Release --prefix ~/ydb_deps/protobuf
         cd ../../
 
         # Install gRPC
-        wget -O grpc-1.54.3.tar.gz https://github.com/grpc/grpc/archive/refs/tags/v1.54.3.tar.gz
-        tar -xvzf grpc-1.54.3.tar.gz && cd grpc-1.54.3
+        wget -O grpc-1.60.2.tar.gz https://github.com/grpc/grpc/archive/refs/tags/v1.60.2.tar.gz
+        tar -xvzf grpc-1.60.2.tar.gz && cd grpc-1.60.2
         mkdir build && cd build
-        cmake -G Ninja ${ENABLE_CCACHE} -DCMAKE_PREFIX_PATH="~/ydb_deps/absl;~/ydb_deps/protobuf" -DCMAKE_BUILD_TYPE=Release -DCMAKE_CXX_STANDARD=17 \
+        cmake -G Ninja ${ENABLE_CCACHE} -DCMAKE_PREFIX_PATH="${HOME}/ydb_deps/absl;${HOME}/ydb_deps/protobuf" -DCMAKE_BUILD_TYPE=Release -DCMAKE_CXX_STANDARD=17 \
           -DgRPC_INSTALL=ON -DgRPC_BUILD_TESTS=OFF -DgRPC_BUILD_CSHARP_EXT=OFF \
           -DgRPC_ZLIB_PROVIDER=package -DgRPC_CARES_PROVIDER=package -DgRPC_RE2_PROVIDER=package \
           -DgRPC_SSL_PROVIDER=package -DgRPC_PROTOBUF_PROVIDER=package -DgRPC_ABSL_PROVIDER=package \
@@ -88,6 +89,6 @@ runs:
 
         # Clean up
         ccache -s
-        sudo rm -rf llvm.sh abseil-cpp-20230802.0.tar.gz protobuf-3.21.12.tar.gz grpc-1.54.3.tar.gz \
+        sudo rm -rf llvm.sh abseil-cpp-20230802.0.tar.gz protobuf-25.0.tar.gz grpc-1.60.2.tar.gz \
           brotli-1.1.0.tar.gz abseil-cpp-20230802.0 \
-          protobuf-3.21.12 grpc-1.54.3 brotli-1.1.0
+          protobuf-25.0 grpc-1.60.2 brotli-1.1.0
diff --git a/.github/import_generation.txt b/.github/import_generation.txt
index c739b42c4d2..ea90ee31980 100644
--- a/.github/import_generation.txt
+++ b/.github/import_generation.txt
@@ -1 +1 @@
-44
+45
diff --git a/.github/last_commit.txt b/.github/last_commit.txt
index 3a09c931bbf..747fec7e66d 100644
--- a/.github/last_commit.txt
+++ b/.github/last_commit.txt
@@ -1 +1 @@
-fb25fb6453264260a02c6ec49492382fcaf801ce
+1e3f62319678deefbb65acd4a3894eb0badcbb0d
diff --git a/.github/scripts/copy_sources.sh b/.github/scripts/copy_sources.sh
index 9813b2434d2..28f5ca8c8ab 100755
--- a/.github/scripts/copy_sources.sh
+++ b/.github/scripts/copy_sources.sh
@@ -1,10 +1,158 @@
 #!/bin/bash
+set -euo pipefail
 
 tmp_dir=$(mktemp -d)
 
+sync_upstream_tree() {
+    local upstream_repo=$1
+    local oss_repo=$2
+    local destination_root=$3
+    local tree=$4
+    local mode=${5:-full}
+    local previous_commit
+    local current_commit
+    local merge_dir
+    local status
+    local path
+    local new_path
+    local local_file
+    local local_target
+    local base_file
+    local upstream_file
+    local merged_file
+    local conflicts=0
+
+    previous_commit=$(cat "$oss_repo/.github/last_commit.txt")
+    current_commit=$(git -C "$upstream_repo" rev-parse HEAD)
+    merge_dir=$(mktemp -d "$tmp_dir/upstream-merge.XXXXXX")
+
+    if ! git -C "$upstream_repo" merge-base --is-ancestor "$previous_commit" "$current_commit"; then
+        echo "Cannot sync $tree: $previous_commit is not an ancestor of $current_commit" >&2
+        return 1
+    fi
+
+    while IFS=$'\t' read -r status path new_path; do
+        [ -n "$path" ] || continue
+
+        # Standalone builds use CMake and deliberately do not import Arcadia build files.
+        if [ "$(basename "$path")" = "ya.make" ] ||
+            { [ -n "${new_path:-}" ] && [ "$(basename "$new_path")" = "ya.make" ]; }; then
+            continue
+        fi
+
+        local_file="$destination_root/$path"
+        base_file="$merge_dir/base"
+        upstream_file="$merge_dir/upstream"
+        merged_file="$merge_dir/merged"
+
+        case "$status" in
+            R*)
+                local_target="$destination_root/$new_path"
+                if [ ! -f "$local_file" ]; then
+                    if [ "$mode" = "managed" ]; then
+                        continue
+                    fi
+                    echo "Cannot rename upstream file missing locally: $path" >&2
+                    conflicts=$((conflicts + 1))
+                    continue
+                fi
+                if [ -e "$local_target" ] && [ "$local_target" != "$local_file" ]; then
+                    echo "Cannot rename upstream file onto existing local file: $new_path" >&2
+                    conflicts=$((conflicts + 1))
+                    continue
+                fi
+
+                git -C "$upstream_repo" show "$previous_commit:$path" > "$base_file"
+                git -C "$upstream_repo" show "$current_commit:$new_path" > "$upstream_file"
+                mkdir -p "$(dirname "$local_target")"
+
+                if cmp -s "$local_file" "$base_file"; then
+                    cp "$upstream_file" "$local_target"
+                elif git merge-file -p "$local_file" "$base_file" "$upstream_file" > "$merged_file"; then
+                    cp "$merged_file" "$local_target"
+                else
+                    echo "Cannot merge renamed upstream and standalone changes: $path -> $new_path" >&2
+                    conflicts=$((conflicts + 1))
+                    continue
+                fi
+
+                if [ "$local_target" != "$local_file" ]; then
+                    rm "$local_file"
+                fi
+                ;;
+            A)
+                if [ "$mode" = "managed" ] && [ ! -d "$(dirname "$local_file")" ]; then
+                    continue
+                fi
+                if [ ! -e "$local_file" ]; then
+                    mkdir -p "$(dirname "$local_file")"
+                    git -C "$upstream_repo" show "$current_commit:$path" > "$local_file"
+                else
+                    git -C "$upstream_repo" show "$current_commit:$path" > "$upstream_file"
+                    if ! cmp -s "$local_file" "$upstream_file"; then
+                        echo "Cannot import added upstream file modified locally: $path" >&2
+                        conflicts=$((conflicts + 1))
+                    fi
+                fi
+                ;;
+            D)
+                if [ -e "$local_file" ]; then
+                    git -C "$upstream_repo" show "$previous_commit:$path" > "$base_file"
+                    if cmp -s "$local_file" "$base_file"; then
+                        rm "$local_file"
+                    else
+                        echo "Cannot delete upstream file modified locally: $path" >&2
+                        conflicts=$((conflicts + 1))
+                    fi
+                fi
+                ;;
+            M)
+                if [ ! -f "$local_file" ]; then
+                    if [ "$mode" = "managed" ]; then
+                        continue
+                    fi
+                    echo "Cannot update upstream file missing locally: $path" >&2
+                    conflicts=$((conflicts + 1))
+                    continue
+                fi
+
+                git -C "$upstream_repo" show "$previous_commit:$path" > "$base_file"
+                git -C "$upstream_repo" show "$current_commit:$path" > "$upstream_file"
+
+                if cmp -s "$local_file" "$upstream_file"; then
+                    continue
+                fi
+
+                if cmp -s "$local_file" "$base_file"; then
+                    cp "$upstream_file" "$local_file"
+                    continue
+                fi
+
+                if git merge-file -p "$local_file" "$base_file" "$upstream_file" > "$merged_file"; then
+                    cp "$merged_file" "$local_file"
+                else
+                    echo "Cannot merge upstream and standalone changes: $path" >&2
+                    conflicts=$((conflicts + 1))
+                fi
+                ;;
+            *)
+                echo "Unsupported upstream change '$status' for $path" >&2
+                conflicts=$((conflicts + 1))
+                ;;
+        esac
+    done < <(git -C "$upstream_repo" diff --name-status --find-renames "$previous_commit..$current_commit" -- "$tree")
+
+    rm -rf "$merge_dir"
+
+    if [ "$conflicts" -ne 0 ]; then
+        echo "Failed to import $tree: $conflicts conflicting change(s)" >&2
+        return 1
+    fi
+}
+
 echo "Copying sources..."
 
-cp -r $1/ydb/public/sdk/cpp/* $tmp_dir
+cp -r "$1"/ydb/public/sdk/cpp/* "$tmp_dir"
 echo "tmp_dir: $tmp_dir"
 
 rm -r $tmp_dir/src/client/arrow
@@ -48,6 +196,13 @@ cp -r $2/scripts $tmp_dir
 cp -r $2/third_party $tmp_dir
 cp -r $2/tools $tmp_dir
 
+sync_upstream_tree "$1" "$2" "$tmp_dir" util
+sync_upstream_tree "$1" "$2" "$tmp_dir" library/cpp managed
+sync_upstream_tree "$1" "$2" "$tmp_dir" contrib/libs/libc_compat managed
+sync_upstream_tree "$1" "$2" "$tmp_dir" contrib/libs/lzmasdk managed
+sync_upstream_tree "$1" "$2" "$tmp_dir" tools/enum_parser managed
+sync_upstream_tree "$1" "$2" "$tmp_dir" tools/rescompiler managed
+
 cp $2/.gitignore $tmp_dir
 cp $2/.gitmodules $tmp_dir
 cp $2/CMakePresets.json $tmp_dir
@@ -63,6 +218,7 @@ for oss_test_dir in slo_workloads deb_package; do
 done
 
 cp $2/include/ydb-cpp-sdk/type_switcher.h $tmp_dir/include/ydb-cpp-sdk/type_switcher.h
+cp $2/include/ydb-cpp-sdk/stlfwd.h $tmp_dir/include/ydb-cpp-sdk/stlfwd.h
 cp $2/src/version.h $tmp_dir/src/version.h
 
 cd $2
diff --git a/.github/workflows/coverage.yml b/.github/workflows/coverage.yml
index 6fb34b974e5..c6d978e0df8 100644
--- a/.github/workflows/coverage.yml
+++ b/.github/workflows/coverage.yml
@@ -61,7 +61,6 @@ jobs:
           key: ${{ steps.coverage-cache-key.outputs.prefix }}-${{ github.run_id }}-${{ github.run_attempt }}
           restore-keys: |
             ${{ steps.coverage-cache-key.outputs.prefix }}-
-            ubuntu-22.04-coverage-gcc-
 
       - name: Install dependencies
         uses: ./.github/actions/prepare_vm
@@ -84,6 +83,8 @@ jobs:
 
           find build -type f \( -name '*.gcda' -o -name '*.gcov' \) -delete
           rm -rf build/coverage
+          cmake -E remove_directory build/util/system/testing_out_stuff
+          cmake -E make_directory build/util/system/testing_out_stuff
 
           ctest -j1 --preset coverage-all -E "${EXCLUDE_REGEX}" --output-on-failure
 
@@ -121,6 +122,7 @@ jobs:
         run: |
           find build -type f \( -name '*.gcda' -o -name '*.gcov' \) -delete
           rm -rf build/coverage
+          cmake -E remove_directory build/util/system/testing_out_stuff
 
       - name: Save coverage build cache
         if: github.event_name != 'pull_request' && success() && steps.coverage-build-cache.outputs.cache-hit != 'true'
diff --git a/.github/workflows/import.yaml b/.github/workflows/import.yaml
index d1fe9f00746..ba9e7dc7177 100644
--- a/.github/workflows/import.yaml
+++ b/.github/workflows/import.yaml
@@ -32,7 +32,15 @@ jobs:
 
           LAST_COMMIT=$(cat ydb-cpp-sdk/.github/last_commit.txt)
 
-          COMMITS=$(git -C ydb log --format="%H" --reverse $LAST_COMMIT..main -- ydb/public/sdk/cpp ydb/public/api)
+          COMMITS=$(git -C ydb log --format="%H" --reverse $LAST_COMMIT..main -- \
+            ydb/public/sdk/cpp \
+            ydb/public/api \
+            util \
+            library/cpp \
+            contrib/libs/libc_compat \
+            contrib/libs/lzmasdk \
+            tools/enum_parser \
+            tools/rescompiler)
           if [ -z "$COMMITS" ]; then
             echo "No new commits to import"
             exit 0
diff --git a/.github/workflows/warmup_cache.yaml b/.github/workflows/warmup_cache.yaml
index be353eeea69..e5864270b4d 100644
--- a/.github/workflows/warmup_cache.yaml
+++ b/.github/workflows/warmup_cache.yaml
@@ -64,7 +64,6 @@ jobs:
         key: ${{ steps.coverage-cache-key.outputs.prefix }}-${{ github.run_id }}-${{ github.run_attempt }}
         restore-keys: |
           ${{ steps.coverage-cache-key.outputs.prefix }}-
-          ubuntu-22.04-coverage-gcc-
     - name: Install dependencies
       uses: ./.github/actions/prepare_vm
     - name: Configure and build with coverage
@@ -75,6 +74,7 @@ jobs:
         cmake --build build -j"$(nproc)"
         find build -type f \( -name '*.gcda' -o -name '*.gcov' \) -delete
         rm -rf build/coverage
+        cmake -E remove_directory build/util/system/testing_out_stuff
     - name: Save coverage build cache
       if: steps.coverage-build-cache.outputs.cache-hit != 'true'
       uses: actions/cache/save@v4
diff --git a/CHANGELOG.md b/CHANGELOG.md
index f9d4fe04a0c..9560323d428 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,15 @@
+## v3.21.0
+
+* Fixed Query SDK `CreateSession` metrics being recorded when reusing a session from the pool.
+
+* Added `TQueryClient::DeleteSession` to explicitly delete a query session by session id.
+
+* Driver now supports async credentials initialisation: the first request is delayed until they are ready.
+
+* Added a flag to support deferred session creation(when client timeout exceeded, the session is created in the backgroud)
+
+* Added a distributed lock primitive based on the coordination service, which implements basic_lockable concept.
+
 ## v3.20.0
 
 * Added automatic retries for unary methods of table and query clients(ExecuteQuery, ExecuteScript, BulkUpsert, ReadRows).
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 1bec181f06e..72b66aad079 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -67,6 +67,7 @@ if (YDB_CPP_SDK_SLO_USE_INSTALLED_SDK)
 
   add_subdirectory(tools)
   add_subdirectory(contrib/libs)
+  add_subdirectory(src/library/string_utils/base64)
   add_subdirectory(library/cpp)
   add_subdirectory(util)
   add_subdirectory(tests/slo_workloads)
@@ -110,6 +111,13 @@ if (YDB_SDK_INSTALL)
     get_property(PackageIncludeDirs GLOBAL PROPERTY YDB_CPP_${PackageProp}_INCLUDE_DIRS)
 
     list(REMOVE_DUPLICATES PackageSources)
+    if (NOT TargetName STREQUAL "libydb-cpp")
+      get_property(CoreSources GLOBAL PROPERTY YDB_CPP_CORE_SOURCES)
+      if (CoreSources)
+        list(REMOVE_DUPLICATES CoreSources)
+        list(REMOVE_ITEM PackageSources ${CoreSources})
+      endif()
+    endif()
     if (PackageInternalDeps)
       list(REMOVE_DUPLICATES PackageInternalDeps)
     endif()
@@ -148,6 +156,9 @@ if (YDB_SDK_INSTALL)
       set_target_properties(${TargetName} PROPERTIES OUTPUT_NAME ydb-cpp)
     endif()
     target_compile_definitions(${TargetName} PUBLIC YDB_SDK_OSS ${PackagePublicDefs})
+    if (NOT TargetName STREQUAL "libydb-cpp")
+      target_link_libraries(${TargetName} PUBLIC libydb-cpp)
+    endif()
     target_link_libraries(${TargetName} PUBLIC ${PackagePublicDeps})
     if (PackageInternalDeps)
       add_dependencies(${TargetName} ${PackageInternalDeps})
diff --git a/README.md b/README.md
index affad1c8443..41d1790d193 100644
--- a/README.md
+++ b/README.md
@@ -7,7 +7,7 @@
 ### Prerequisites
 
 - cmake 3.22+
-- clang 16+
+- clang 18+
 - git 2.20+
 - ninja 1.10+
 - ragel
@@ -44,6 +44,19 @@
 
 ### Install dependencies
 
+The standalone dependency bundle is compatible with Ubuntu 24.04 and uses
+gRPC 1.60.2 to match the imported YDB sources. Its protobuf and Abseil pins
+match the dependency set published with that gRPC release:
+
+| Dependency | Version |
+|------------|---------|
+| Abseil | 20230802.0 |
+| protobuf | 25.0 |
+| gRPC | 1.60.2 |
+
+These pins are shared by regular CI builds, SLO workload images, and the
+development container.
+
 ```bash
 sudo apt-get -y update
 sudo apt-get -y install git gdb ninja-build libidn11-dev ragel yasm libc-ares-dev libre2-dev \
@@ -52,7 +65,7 @@ sudo apt-get -y install git gdb ninja-build libidn11-dev ragel yasm libc-ares-de
 
 wget https://apt.llvm.org/llvm.sh
 chmod u+x llvm.sh
-sudo ./llvm.sh 16
+sudo ./llvm.sh 18
 
 # Install abseil-cpp
 wget -O abseil-cpp-20230802.0.tar.gz https://github.com/abseil/abseil-cpp/archive/refs/tags/20230802.0.tar.gz
@@ -65,20 +78,21 @@ cmake --install . --config Release --prefix ~/ydb_deps/absl
 cd ../../
 
 # Install protobuf
-wget -O protobuf-3.21.12.tar.gz https://github.com/protocolbuffers/protobuf/archive/refs/tags/v3.21.12.tar.gz
-tar -xvzf protobuf-3.21.12.tar.gz
-cd protobuf-3.21.12
+wget -O protobuf-25.0.tar.gz https://github.com/protocolbuffers/protobuf/archive/refs/tags/v25.0.tar.gz
+tar -xvzf protobuf-25.0.tar.gz
+cd protobuf-25.0
 mkdir build && cd build
-cmake -G Ninja -DCMAKE_BUILD_TYPE=Release -Dprotobuf_BUILD_TESTS=OFF -Dprotobuf_INSTALL=ON ..
+cmake -G Ninja -DCMAKE_PREFIX_PATH="$HOME/ydb_deps/absl" -DCMAKE_BUILD_TYPE=Release \
+  -Dprotobuf_BUILD_TESTS=OFF -Dprotobuf_INSTALL=ON -Dprotobuf_ABSL_PROVIDER=package ..
 cmake --build . --config Release
 cmake --install . --config Release --prefix ~/ydb_deps/protobuf
 cd ../../
 
 # Install gRPC
-wget -O grpc-1.54.3.tar.gz https://github.com/grpc/grpc/archive/refs/tags/v1.54.3.tar.gz
-tar -xvzf grpc-1.54.3.tar.gz && cd grpc-1.54.3
+wget -O grpc-1.60.2.tar.gz https://github.com/grpc/grpc/archive/refs/tags/v1.60.2.tar.gz
+tar -xvzf grpc-1.60.2.tar.gz && cd grpc-1.60.2
 mkdir build && cd build
-cmake -G Ninja -DCMAKE_PREFIX_PATH="~/ydb_deps/absl;~/ydb_deps/protobuf" -DCMAKE_BUILD_TYPE=Release -DCMAKE_CXX_STANDARD=17 \
+cmake -G Ninja -DCMAKE_PREFIX_PATH="$HOME/ydb_deps/absl;$HOME/ydb_deps/protobuf" -DCMAKE_BUILD_TYPE=Release -DCMAKE_CXX_STANDARD=17 \
   -DgRPC_INSTALL=ON -DgRPC_BUILD_TESTS=OFF -DgRPC_BUILD_CSHARP_EXT=OFF \
   -DgRPC_ZLIB_PROVIDER=package -DgRPC_CARES_PROVIDER=package -DgRPC_RE2_PROVIDER=package \
   -DgRPC_SSL_PROVIDER=package -DgRPC_PROTOBUF_PROVIDER=package -DgRPC_ABSL_PROVIDER=package \
@@ -101,9 +115,10 @@ cd ../../
 wget -O brotli-1.1.0.tar.gz https://github.com/google/brotli/archive/refs/tags/v1.1.0.tar.gz
 tar -xvzf brotli-1.1.0.tar.gz && cd brotli-1.1.0
 mkdir build && cd build
-cmake -G Ninja -DCMAKE_BUILD_TYPE=Release ..
+cmake -G Ninja -DCMAKE_BUILD_TYPE=Release \
+  -DCMAKE_INSTALL_PREFIX="$HOME/ydb_deps/brotli" ..
 cmake --build . --config Release
-cmake --install . --config Release --prefix ~/ydb_deps/brotli
+cmake --install . --config Release
 cd ../../
 
 # Install jwt-cpp
@@ -155,20 +170,37 @@ cmake --build --preset $sdk_configure_preset
 
 ### Build `.deb` packages
 
-The SDK can be packaged as Debian development packages with CPack. The packaging build uses static libraries and produces the following packages:
+The SDK can be packaged as Debian development packages with CPack. The complete packaging flow uses static libraries and produces the following packages:
 
+- `yandex-googleapis-api-common-protos` — generated API Common Protos headers and static library, required by `libydb-cpp-dev`;
 - `libydb-cpp-dev` — core SDK static library, public headers and CMake package files;
 - `libydb-cpp-iam-dev` — IAM credentials plugin;
 - `libydb-cpp-otel-metrics-dev` — OpenTelemetry metrics plugin (includes vendored opentelemetry-cpp);
 - `libydb-cpp-otel-tracing-dev` — OpenTelemetry tracing plugin (requires `libydb-cpp-otel-metrics-dev` for OTel headers/libs).
 
-The Debian packaging flow is intended for Ubuntu 24.04. Install the regular build dependencies first. OpenTelemetry plugins use the vendored `third_party/opentelemetry-cpp` submodule (v1.26.0, matching the YDB monorepo pin); initialize it with `git submodule update --init third_party/opentelemetry-cpp` before building.
+The Debian packaging flow is intended for Ubuntu 24.04. Initialize the required submodules before building:
+
+```bash
+git submodule update --init --recursive
+```
+
+The packaging helper first builds `yandex-googleapis-api-common-protos` from the
+vendored API Common Protos using Ubuntu 24.04's `protobuf-compiler` and
+`libprotobuf-dev`. It installs that package in the build container before
+building the SDK, so both packages use the same distro protobuf ABI.
+OpenTelemetry plugins use the vendored `third_party/opentelemetry-cpp`
+submodule (v1.26.0, matching the YDB monorepo pin).
 
-To build `.deb` packages directly with CPack:
+To build the complete `.deb` package set with the same containerized flow used
+by CI and release publishing (Docker is required):
 
 ```bash
-cmake --preset package-deb-clang
-cmake --build build-deb --target package -j$(nproc)
+mkdir -p build-deb .deb-ccache
+docker run --rm --network host \
+  -e CCACHE_DIR=/source/.deb-ccache \
+  -v "$PWD:/source" \
+  ubuntu:24.04 \
+  bash /source/scripts/build_cpack_deb_packages.sh /source/build-deb
 ```
 
 The generated `.deb` files are placed into `build-deb/`.
@@ -196,7 +228,7 @@ To smoke-test generated `.deb` packages with the sample consumer project:
 ### Install from GitHub releases
 
 Pre-built `.deb` packages for Ubuntu 24.04 (Noble) are attached to each
-GitHub release. Download the assets and install them with `dpkg`:
+GitHub release. Download the assets and install them with APT:
 
 ```bash
 # Replace <TAG> with the desired release tag (e.g. v1.2.3)
diff --git a/allowed_peerdirs.txt b/allowed_peerdirs.txt
new file mode 100644
index 00000000000..49259c99a74
--- /dev/null
+++ b/allowed_peerdirs.txt
@@ -0,0 +1,6 @@
+# Mirrors ydb-cpp-sdk/.github/scripts/copy_sources.sh.
+ydb/public/sdk/cpp/
+ydb/public/api/
+library/cpp/
+contrib/
+util/
diff --git a/cmake/PackSDK.cmake b/cmake/PackSDK.cmake
index 505d435d78b..c204e7a49e3 100644
--- a/cmake/PackSDK.cmake
+++ b/cmake/PackSDK.cmake
@@ -10,6 +10,7 @@ set(CPACK_PACKAGE_DESCRIPTION
 set(CPACK_PACKAGE_NAME "ydb-cpp-sdk")
 set(CPACK_DEBIAN_FILE_NAME DEB-DEFAULT)
 set(CPACK_GENERATOR "DEB")
+set(CPACK_PACKAGING_INSTALL_PREFIX "/usr/share/yandex")
 set(CPACK_PACKAGE_VERSION "${YDB_SDK_VERSION}")
 set(CPACK_PACKAGE_HOMEPAGE_URL "https://ydb.tech")
 set(CPACK_PACKAGE_CONTACT "YDB Team <info@ydb.tech>")
diff --git a/cmake/external_libs.cmake b/cmake/external_libs.cmake
index 64723763a86..469df6000ca 100644
--- a/cmake/external_libs.cmake
+++ b/cmake/external_libs.cmake
@@ -1,7 +1,10 @@
 find_package(IDN REQUIRED)
 find_package(Iconv REQUIRED)
 find_package(OpenSSL REQUIRED)
-find_package(Protobuf REQUIRED)
+find_package(Protobuf CONFIG QUIET)
+if (NOT Protobuf_FOUND)
+  find_package(Protobuf MODULE REQUIRED)
+endif()
 find_package(gRPC 1.41.0 REQUIRED)
 find_package(ZLIB REQUIRED)
 find_package(xxHash REQUIRED)
diff --git a/cmake/protos_public_headers.txt b/cmake/protos_public_headers.txt
index 8bf8cb074e3..468ca6d992c 100644
--- a/cmake/protos_public_headers.txt
+++ b/cmake/protos_public_headers.txt
@@ -1,7 +1,9 @@
 src/api/grpc/draft/ydb_datastreams_v1.pb.h
 src/api/grpc/ydb_topic_v1.pb.h
+src/api/protos/annotations/sensitive.pb.h
 src/api/protos/annotations/validation.pb.h
 src/api/protos/draft/datastreams.pb.h
+src/api/protos/draft/field_transformation.pb.h
 src/api/protos/ydb_common.pb.h
 src/api/protos/ydb_federation_discovery.pb.h
 src/api/protos/ydb_operation.pb.h
@@ -17,4 +19,4 @@ src/api/protos/ydb_issue_message.pb.h
 src/api/protos/ydb_export.pb.h
 src/api/protos/ydb_coordination.pb.h
 src/api/protos/ydb_status_codes.pb.h
-src/api/protos/draft/ydb_replication.pb.h
\ No newline at end of file
+src/api/protos/draft/ydb_replication.pb.h
diff --git a/cmake/public_headers.txt b/cmake/public_headers.txt
index d926140d27d..9591d3df578 100644
--- a/cmake/public_headers.txt
+++ b/cmake/public_headers.txt
@@ -100,7 +100,6 @@ util/generic/algorithm.h
 util/generic/array_size.h
 util/generic/array_ref.h
 util/generic/bitops.h
-util/generic/bt_exception.h
 util/generic/buffer.h
 util/generic/cast.h
 util/generic/deque.h
@@ -113,6 +112,7 @@ util/generic/hash_table.h
 util/generic/hash.h
 util/generic/intrlist.h
 util/generic/is_in.h
+util/generic/iterator.h
 util/generic/iterator_range.h
 util/generic/list.h
 util/generic/map.h
@@ -149,7 +149,6 @@ util/network/ip.h
 util/network/sock.h
 util/network/socket.h
 util/random/random.h
-util/stream/debug.h
 util/stream/fwd.h
 util/stream/input.h
 util/stream/labeled.h
@@ -204,4 +203,4 @@ util/thread/factory.h
 util/thread/fwd.h
 util/thread/pool.h
 util/str_stl.h
-util/ysaveload.h
\ No newline at end of file
+util/ysaveload.h
diff --git a/cmake/ydb-cpp-sdk-config.cmake.in b/cmake/ydb-cpp-sdk-config.cmake.in
index 5d53b62b283..c6817d87998 100644
--- a/cmake/ydb-cpp-sdk-config.cmake.in
+++ b/cmake/ydb-cpp-sdk-config.cmake.in
@@ -45,7 +45,10 @@ list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_LIST_DIR}/Modules")
 find_package(IDN REQUIRED)
 find_package(Iconv REQUIRED)
 find_package(OpenSSL REQUIRED)
-find_package(Protobuf REQUIRED)
+find_package(Protobuf CONFIG QUIET)
+if (NOT Protobuf_FOUND)
+  find_package(Protobuf MODULE REQUIRED)
+endif()
 find_package(gRPC REQUIRED)
 find_package(ZLIB REQUIRED)
 find_package(xxHash REQUIRED)
@@ -66,11 +69,13 @@ endif()
 if (@YDB_SDK_USE_RAPID_JSON@)
   find_package(RapidJSON REQUIRED)
 
-  add_library(RapidJSON::RapidJSON INTERFACE IMPORTED)
+  if (NOT TARGET RapidJSON::RapidJSON)
+    add_library(RapidJSON::RapidJSON INTERFACE IMPORTED)
 
-  target_include_directories(RapidJSON::RapidJSON INTERFACE
-    ${RAPIDJSON_INCLUDE_DIRS}
-  )
+    target_include_directories(RapidJSON::RapidJSON INTERFACE
+      ${RAPIDJSON_INCLUDE_DIRS}
+    )
+  endif()
 endif()
 
 if (@YDB_SDK_ENABLE_OTEL_METRICS@ OR @YDB_SDK_ENABLE_OTEL_TRACE@)
diff --git a/codecov.yml b/codecov.yml
deleted file mode 100644
index e4cddb46612..00000000000
--- a/codecov.yml
+++ /dev/null
@@ -1,25 +0,0 @@
-coverage:
-  status:
-    project:
-      default:
-        target: auto       # do not drop below the current level...
-        threshold: 1%      # ...by more than 1%
-    patch:
-      default:
-        target: 80%        # new/changed code in the PR diff must be >= 80% covered
-
-# Cross-repo uniform metric: every YDB SDK repo defines this same component_id,
-# so native-SDK coverage is queryable identically via the Codecov API
-# (?component_id=native-sdk), regardless of how each repo tags its uploads.
-#
-# The SDK proper lives in src/ (implementation) and include/ (public headers).
-# The vendored Arcadia libraries (util/, library/, contrib/, third_party/) and
-# examples/tests/tools are not part of the native SDK and are pinned out by listing
-# only the SDK paths.
-component_management:
-  individual_components:
-    - component_id: native-sdk
-      name: Native SDK
-      paths:
-        - "src/**"
-        - "include/**"
diff --git a/contrib/libs/libc_compat/CMakeLists.txt b/contrib/libs/libc_compat/CMakeLists.txt
index ddce16d2cef..e296c7c8cf1 100644
--- a/contrib/libs/libc_compat/CMakeLists.txt
+++ b/contrib/libs/libc_compat/CMakeLists.txt
@@ -5,13 +5,12 @@ target_compile_options(contrib-libs-libc_compat PRIVATE
 )
 
 target_sources(contrib-libs-libc_compat PRIVATE
-  ${YDB_SDK_SOURCE_DIR}/contrib/libs/libc_compat/string.c
+    ${YDB_SDK_SOURCE_DIR}/contrib/libs/libc_compat/string.c
 )
 
 if(NOT APPLE)
   target_sources(contrib-libs-libc_compat PRIVATE
     ${YDB_SDK_SOURCE_DIR}/contrib/libs/libc_compat/explicit_bzero.c
-    ${YDB_SDK_SOURCE_DIR}/contrib/libs/libc_compat/memfd_create.c
     ${YDB_SDK_SOURCE_DIR}/contrib/libs/libc_compat/strlcat.c
     ${YDB_SDK_SOURCE_DIR}/contrib/libs/libc_compat/strlcpy.c
     ${YDB_SDK_SOURCE_DIR}/contrib/libs/libc_compat/reallocarray/reallocarray.c
diff --git a/contrib/libs/libc_compat/README.md b/contrib/libs/libc_compat/README.md
index fe7a22fbb1e..4f6a3b85f3c 100644
--- a/contrib/libs/libc_compat/README.md
+++ b/contrib/libs/libc_compat/README.md
@@ -9,6 +9,8 @@ During development one can make use of the following mapping of `OS_SDK` into gl
 
 | Ubuntu | glibc |
 | ------ | ----- |
+| 24.04 | 2.39 |
+| 22.04 | 2.35 |
 | 20.04 | 2.30 |
 | 18.04 | 2.27 | 
 | 16.04 | 2.23 | 
diff --git a/contrib/libs/libc_compat/collate.h b/contrib/libs/libc_compat/collate.h
new file mode 100644
index 00000000000..e69de29bb2d
diff --git a/contrib/libs/libc_compat/glob.c b/contrib/libs/libc_compat/glob.c
new file mode 100644
index 00000000000..00be6371585
--- /dev/null
+++ b/contrib/libs/libc_compat/glob.c
@@ -0,0 +1,1127 @@
+/*-
+ * SPDX-License-Identifier: BSD-3-Clause
+ *
+ * Copyright (c) 1989, 1993
+ *	The Regents of the University of California.  All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * Guido van Rossum.
+ *
+ * Copyright (c) 2011 The FreeBSD Foundation
+ * All rights reserved.
+ * Portions of this software were developed by David Chisnall
+ * under sponsorship from the FreeBSD Foundation.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <sys/cdefs.h>
+__SCCSID("@(#)glob.c	8.3 (Berkeley) 10/13/93");
+__FBSDID("$FreeBSD$");
+
+/*
+ * glob(3) -- a superset of the one defined in POSIX 1003.2.
+ *
+ * The [!...] convention to negate a range is supported (SysV, Posix, ksh).
+ *
+ * Optional extra services, controlled by flags not defined by POSIX:
+ *
+ * GLOB_QUOTE:
+ *	Escaping convention: \ inhibits any special meaning the following
+ *	character might have (except \ at end of string is retained).
+ * GLOB_MAGCHAR:
+ *	Set in gl_flags if pattern contained a globbing character.
+ * GLOB_NOMAGIC:
+ *	Same as GLOB_NOCHECK, but it will only append pattern if it did
+ *	not contain any magic characters.  [Used in csh style globbing]
+ * GLOB_ALTDIRFUNC:
+ *	Use alternately specified directory access functions.
+ * GLOB_TILDE:
+ *	expand ~user/foo to the /home/dir/of/user/foo
+ * GLOB_BRACE:
+ *	expand {1,2}{a,b} to 1a 1b 2a 2b
+ * gl_matchc:
+ *	Number of matches in the current invocation of glob.
+ */
+
+/*
+ * Some notes on multibyte character support:
+ * 1. Patterns with illegal byte sequences match nothing - even if
+ *    GLOB_NOCHECK is specified.
+ * 2. Illegal byte sequences in filenames are handled by treating them as
+ *    single-byte characters with a values of such bytes of the sequence
+ *    cast to wchar_t.
+ * 3. State-dependent encodings are not currently supported.
+ */
+
+#include <sys/param.h>
+#include <sys/stat.h>
+
+#include <ctype.h>
+#include <dirent.h>
+#include <errno.h>
+#include "glob.h"
+#include <limits.h>
+#include <pwd.h>
+#include <stdint.h>
+#include <stdio.h>
+#include "stdlib.h"
+#include <string.h>
+#include "unistd.h"
+#include <wchar.h>
+
+#ifdef USE_LOCALE_COLLATE
+#include "collate.h"
+#endif
+
+/*
+ * glob(3) expansion limits. Stop the expansion if any of these limits
+ * is reached. This caps the runtime in the face of DoS attacks. See
+ * also CVE-2010-2632
+ */
+#define	GLOB_LIMIT_BRACE	128	/* number of brace calls */
+#define	GLOB_LIMIT_PATH		65536	/* number of path elements */
+#define	GLOB_LIMIT_READDIR	16384	/* number of readdirs */
+#define	GLOB_LIMIT_STAT		1024	/* number of stat system calls */
+#define	GLOB_LIMIT_STRING	ARG_MAX	/* maximum total size for paths */
+
+struct glob_limit {
+	size_t	l_brace_cnt;
+	size_t	l_path_lim;
+	size_t	l_readdir_cnt;	
+	size_t	l_stat_cnt;	
+	size_t	l_string_cnt;
+};
+
+#define	DOT		L'.'
+#define	EOS		L'\0'
+#define	LBRACKET	L'['
+#define	NOT		L'!'
+#define	QUESTION	L'?'
+#define	QUOTE		L'\\'
+#define	RANGE		L'-'
+#define	RBRACKET	L']'
+#define	SEP		L'/'
+#define	STAR		L'*'
+#define	TILDE		L'~'
+#define	LBRACE		L'{'
+#define	RBRACE		L'}'
+#define	COMMA		L','
+
+#define	M_QUOTE		0x8000000000ULL
+#define	M_PROTECT	0x4000000000ULL
+#define	M_MASK		0xffffffffffULL
+#define	M_CHAR		0x00ffffffffULL
+
+typedef uint_fast64_t Char;
+
+#define	CHAR(c)		((Char)((c)&M_CHAR))
+#define	META(c)		((Char)((c)|M_QUOTE))
+#define	UNPROT(c)	((c) & ~M_PROTECT)
+#define	M_ALL		META(L'*')
+#define	M_END		META(L']')
+#define	M_NOT		META(L'!')
+#define	M_ONE		META(L'?')
+#define	M_RNG		META(L'-')
+#define	M_SET		META(L'[')
+#define	ismeta(c)	(((c)&M_QUOTE) != 0)
+#ifdef DEBUG
+#define	isprot(c)	(((c)&M_PROTECT) != 0)
+#endif
+
+static int	 compare(const void *, const void *);
+static int	 g_Ctoc(const Char *, char *, size_t);
+static int	 g_lstat(Char *, struct stat *, glob_t *);
+static DIR	*g_opendir(Char *, glob_t *);
+static const Char *g_strchr(const Char *, wchar_t);
+#ifdef notdef
+static Char	*g_strcat(Char *, const Char *);
+#endif
+static int	 g_stat(Char *, struct stat *, glob_t *);
+static int	 glob0(const Char *, glob_t *, struct glob_limit *,
+    const char *);
+static int	 glob1(Char *, glob_t *, struct glob_limit *);
+static int	 glob2(Char *, Char *, Char *, Char *, glob_t *,
+    struct glob_limit *);
+static int	 glob3(Char *, Char *, Char *, Char *, Char *, glob_t *,
+    struct glob_limit *);
+static int	 globextend(const Char *, glob_t *, struct glob_limit *,
+    const char *);
+static const Char *
+		 globtilde(const Char *, Char *, size_t, glob_t *);
+static int	 globexp0(const Char *, glob_t *, struct glob_limit *,
+    const char *);
+static int	 globexp1(const Char *, glob_t *, struct glob_limit *);
+static int	 globexp2(const Char *, const Char *, glob_t *,
+    struct glob_limit *);
+static int	 globfinal(glob_t *, struct glob_limit *, size_t,
+    const char *);
+static int	 match(Char *, Char *, Char *);
+static int	 err_nomatch(glob_t *, struct glob_limit *, const char *);
+static int	 err_aborted(glob_t *, int, char *);
+#ifdef DEBUG
+static void	 qprintf(const char *, Char *);
+#endif
+
+int
+glob(const char * __restrict pattern, int flags,
+	 int (*errfunc)(const char *, int), glob_t * __restrict pglob)
+{
+	struct glob_limit limit = { 0, 0, 0, 0, 0 };
+	const char *patnext;
+	Char *bufnext, *bufend, patbuf[MAXPATHLEN], prot;
+	mbstate_t mbs;
+	wchar_t wc;
+	size_t clen;
+	int too_long;
+
+	patnext = pattern;
+	if (!(flags & GLOB_APPEND)) {
+		pglob->gl_pathc = 0;
+		pglob->gl_pathv = NULL;
+		if (!(flags & GLOB_DOOFFS))
+			pglob->gl_offs = 0;
+	}
+	if (flags & GLOB_LIMIT) {
+		limit.l_path_lim = pglob->gl_matchc;
+		if (limit.l_path_lim == 0)
+			limit.l_path_lim = GLOB_LIMIT_PATH;
+	}
+	pglob->gl_flags = flags & ~GLOB_MAGCHAR;
+	pglob->gl_errfunc = errfunc;
+	pglob->gl_matchc = 0;
+
+	bufnext = patbuf;
+	bufend = bufnext + MAXPATHLEN - 1;
+	too_long = 1;
+	if (flags & GLOB_NOESCAPE) {
+		memset(&mbs, 0, sizeof(mbs));
+		while (bufnext <= bufend) {
+			clen = mbrtowc(&wc, patnext, MB_LEN_MAX, &mbs);
+			if (clen == (size_t)-1 || clen == (size_t)-2)
+				return (err_nomatch(pglob, &limit, pattern));
+			else if (clen == 0) {
+				too_long = 0;
+				break;
+			}
+			*bufnext++ = wc;
+			patnext += clen;
+		}
+	} else {
+		/* Protect the quoted characters. */
+		memset(&mbs, 0, sizeof(mbs));
+		while (bufnext <= bufend) {
+			if (*patnext == '\\') {
+				if (*++patnext == '\0') {
+					*bufnext++ = QUOTE;
+					continue;
+				}
+				prot = M_PROTECT;
+			} else
+				prot = 0;
+			clen = mbrtowc(&wc, patnext, MB_LEN_MAX, &mbs);
+			if (clen == (size_t)-1 || clen == (size_t)-2)
+				return (err_nomatch(pglob, &limit, pattern));
+			else if (clen == 0) {
+				too_long = 0;
+				break;
+			}
+			*bufnext++ = wc | prot;
+			patnext += clen;
+		}
+	}
+	if (too_long)
+		return (err_nomatch(pglob, &limit, pattern));
+	*bufnext = EOS;
+
+	if (flags & GLOB_BRACE)
+	    return (globexp0(patbuf, pglob, &limit, pattern));
+	else
+	    return (glob0(patbuf, pglob, &limit, pattern));
+}
+
+static int
+globexp0(const Char *pattern, glob_t *pglob, struct glob_limit *limit,
+    const char *origpat) {
+	int rv;
+	size_t oldpathc;
+
+	/* Protect a single {}, for find(1), like csh */
+	if (pattern[0] == LBRACE && pattern[1] == RBRACE && pattern[2] == EOS) {
+		if ((pglob->gl_flags & GLOB_LIMIT) &&
+		    limit->l_brace_cnt++ >= GLOB_LIMIT_BRACE) {
+			errno = E2BIG;
+			return (GLOB_NOSPACE);
+		}
+		return (glob0(pattern, pglob, limit, origpat));
+	}
+
+	oldpathc = pglob->gl_pathc;
+
+	if ((rv = globexp1(pattern, pglob, limit)) != 0)
+		return rv;
+
+	return (globfinal(pglob, limit, oldpathc, origpat));
+}
+
+/*
+ * Expand recursively a glob {} pattern. When there is no more expansion
+ * invoke the standard globbing routine to glob the rest of the magic
+ * characters
+ */
+static int
+globexp1(const Char *pattern, glob_t *pglob, struct glob_limit *limit)
+{
+	const Char* ptr;
+
+	if ((ptr = g_strchr(pattern, LBRACE)) != NULL) {
+		if ((pglob->gl_flags & GLOB_LIMIT) &&
+		    limit->l_brace_cnt++ >= GLOB_LIMIT_BRACE) {
+			errno = E2BIG;
+			return (GLOB_NOSPACE);
+		}
+		return (globexp2(ptr, pattern, pglob, limit));
+	}
+
+	return (glob0(pattern, pglob, limit, NULL));
+}
+
+
+/*
+ * Recursive brace globbing helper. Tries to expand a single brace.
+ * If it succeeds then it invokes globexp1 with the new pattern.
+ * If it fails then it tries to glob the rest of the pattern and returns.
+ */
+static int
+globexp2(const Char *ptr, const Char *pattern, glob_t *pglob,
+    struct glob_limit *limit)
+{
+	int     i, rv;
+	Char   *lm, *ls;
+	const Char *pe, *pm, *pm1, *pl;
+	Char    patbuf[MAXPATHLEN];
+
+	/* copy part up to the brace */
+	for (lm = patbuf, pm = pattern; pm != ptr; *lm++ = *pm++)
+		continue;
+	*lm = EOS;
+	ls = lm;
+
+	/* Find the balanced brace */
+	for (i = 0, pe = ++ptr; *pe != EOS; pe++)
+		if (*pe == LBRACKET) {
+			/* Ignore everything between [] */
+			for (pm = pe++; *pe != RBRACKET && *pe != EOS; pe++)
+				continue;
+			if (*pe == EOS) {
+				/*
+				 * We could not find a matching RBRACKET.
+				 * Ignore and just look for RBRACE
+				 */
+				pe = pm;
+			}
+		}
+		else if (*pe == LBRACE)
+			i++;
+		else if (*pe == RBRACE) {
+			if (i == 0)
+				break;
+			i--;
+		}
+
+	/* Non matching braces; just glob the pattern */
+	if (i != 0 || *pe == EOS)
+		return (glob0(pattern, pglob, limit, NULL));
+
+	for (i = 0, pl = pm = ptr; pm <= pe; pm++)
+		switch (*pm) {
+		case LBRACKET:
+			/* Ignore everything between [] */
+			for (pm1 = pm++; *pm != RBRACKET && *pm != EOS; pm++)
+				continue;
+			if (*pm == EOS) {
+				/*
+				 * We could not find a matching RBRACKET.
+				 * Ignore and just look for RBRACE
+				 */
+				pm = pm1;
+			}
+			break;
+
+		case LBRACE:
+			i++;
+			break;
+
+		case RBRACE:
+			if (i) {
+			    i--;
+			    break;
+			}
+			/* FALLTHROUGH */
+		case COMMA:
+			if (i && *pm == COMMA)
+				break;
+			else {
+				/* Append the current string */
+				for (lm = ls; (pl < pm); *lm++ = *pl++)
+					continue;
+				/*
+				 * Append the rest of the pattern after the
+				 * closing brace
+				 */
+				for (pl = pe + 1; (*lm++ = *pl++) != EOS;)
+					continue;
+
+				/* Expand the current pattern */
+#ifdef DEBUG
+				qprintf("globexp2:", patbuf);
+#endif
+				rv = globexp1(patbuf, pglob, limit);
+				if (rv)
+					return (rv);
+
+				/* move after the comma, to the next string */
+				pl = pm + 1;
+			}
+			break;
+
+		default:
+			break;
+		}
+	return (0);
+}
+
+
+
+/*
+ * expand tilde from the passwd file.
+ */
+static const Char *
+globtilde(const Char *pattern, Char *patbuf, size_t patbuf_len, glob_t *pglob)
+{
+	struct passwd *pwd;
+	char *h, *sc;
+	const Char *p;
+	Char *b, *eb;
+	wchar_t wc;
+	wchar_t wbuf[MAXPATHLEN];
+	wchar_t *wbufend, *dc;
+	size_t clen;
+	mbstate_t mbs;
+	int too_long;
+
+	if (*pattern != TILDE || !(pglob->gl_flags & GLOB_TILDE))
+		return (pattern);
+
+	/* 
+	 * Copy up to the end of the string or / 
+	 */
+	eb = &patbuf[patbuf_len - 1];
+	for (p = pattern + 1, b = patbuf;
+	    b < eb && *p != EOS && UNPROT(*p) != SEP; *b++ = *p++)
+		continue;
+
+	if (*p != EOS && UNPROT(*p) != SEP)
+		return (NULL);
+
+	*b = EOS;
+	h = NULL;
+
+	if (patbuf[0] == EOS) {
+		/*
+		 * handle a plain ~ or ~/ by expanding $HOME first (iff
+		 * we're not running setuid or setgid) and then trying
+		 * the password file
+		 */
+		if (issetugid() != 0 ||
+		    (h = getenv("HOME")) == NULL) {
+			if (((h = getlogin()) != NULL &&
+			     (pwd = getpwnam(h)) != NULL) ||
+			    (pwd = getpwuid(getuid())) != NULL)
+				h = pwd->pw_dir;
+			else
+				return (pattern);
+		}
+	}
+	else {
+		/*
+		 * Expand a ~user
+		 */
+		if (g_Ctoc(patbuf, (char *)wbuf, sizeof(wbuf)))
+			return (NULL);
+		if ((pwd = getpwnam((char *)wbuf)) == NULL)
+			return (pattern);
+		else
+			h = pwd->pw_dir;
+	}
+
+	/* Copy the home directory */
+	dc = wbuf;
+	sc = h;
+	wbufend = wbuf + MAXPATHLEN - 1;
+	too_long = 1;
+	memset(&mbs, 0, sizeof(mbs));
+	while (dc <= wbufend) {
+		clen = mbrtowc(&wc, sc, MB_LEN_MAX, &mbs);
+		if (clen == (size_t)-1 || clen == (size_t)-2) {
+			/* XXX See initial comment #2. */
+			wc = (unsigned char)*sc;
+			clen = 1;
+			memset(&mbs, 0, sizeof(mbs));
+		}
+		if ((*dc++ = wc) == EOS) {
+			too_long = 0;
+			break;
+		}
+		sc += clen;
+	}
+	if (too_long)
+		return (NULL);
+
+	dc = wbuf;
+	for (b = patbuf; b < eb && *dc != EOS; *b++ = *dc++ | M_PROTECT)
+		continue;
+	if (*dc != EOS)
+		return (NULL);
+
+	/* Append the rest of the pattern */
+	if (*p != EOS) {
+		too_long = 1;
+		while (b <= eb) {
+			if ((*b++ = *p++) == EOS) {
+				too_long = 0;
+				break;
+			}
+		}
+		if (too_long)
+			return (NULL);
+	} else
+		*b = EOS;
+
+	return (patbuf);
+}
+
+
+/*
+ * The main glob() routine: compiles the pattern (optionally processing
+ * quotes), calls glob1() to do the real pattern matching, and finally
+ * sorts the list (unless unsorted operation is requested).  Returns 0
+ * if things went well, nonzero if errors occurred.
+ */
+static int
+glob0(const Char *pattern, glob_t *pglob, struct glob_limit *limit,
+    const char *origpat) {
+	const Char *qpatnext;
+	int err;
+	size_t oldpathc;
+	Char *bufnext, c, patbuf[MAXPATHLEN];
+
+	qpatnext = globtilde(pattern, patbuf, MAXPATHLEN, pglob);
+	if (qpatnext == NULL) {
+		errno = E2BIG;
+		return (GLOB_NOSPACE);
+	}
+	oldpathc = pglob->gl_pathc;
+	bufnext = patbuf;
+
+	/* We don't need to check for buffer overflow any more. */
+	while ((c = *qpatnext++) != EOS) {
+		switch (c) {
+		case LBRACKET:
+			c = *qpatnext;
+			if (c == NOT)
+				++qpatnext;
+			if (*qpatnext == EOS ||
+			    g_strchr(qpatnext+1, RBRACKET) == NULL) {
+				*bufnext++ = LBRACKET;
+				if (c == NOT)
+					--qpatnext;
+				break;
+			}
+			*bufnext++ = M_SET;
+			if (c == NOT)
+				*bufnext++ = M_NOT;
+			c = *qpatnext++;
+			do {
+				*bufnext++ = CHAR(c);
+				if (*qpatnext == RANGE &&
+				    (c = qpatnext[1]) != RBRACKET) {
+					*bufnext++ = M_RNG;
+					*bufnext++ = CHAR(c);
+					qpatnext += 2;
+				}
+			} while ((c = *qpatnext++) != RBRACKET);
+			pglob->gl_flags |= GLOB_MAGCHAR;
+			*bufnext++ = M_END;
+			break;
+		case QUESTION:
+			pglob->gl_flags |= GLOB_MAGCHAR;
+			*bufnext++ = M_ONE;
+			break;
+		case STAR:
+			pglob->gl_flags |= GLOB_MAGCHAR;
+			/* collapse adjacent stars to one,
+			 * to ensure "**" at the end continues to match the
+			 * empty string
+			 */
+			if (bufnext == patbuf || bufnext[-1] != M_ALL)
+			    *bufnext++ = M_ALL;
+			break;
+		default:
+			*bufnext++ = CHAR(c);
+			break;
+		}
+	}
+	*bufnext = EOS;
+#ifdef DEBUG
+	qprintf("glob0:", patbuf);
+#endif
+
+	if ((err = glob1(patbuf, pglob, limit)) != 0)
+		return(err);
+
+	if (origpat != NULL)
+		return (globfinal(pglob, limit, oldpathc, origpat));
+
+	return (0);
+}
+
+static int
+globfinal(glob_t *pglob, struct glob_limit *limit, size_t oldpathc,
+    const char *origpat) {
+	if (pglob->gl_pathc == oldpathc)
+		return (err_nomatch(pglob, limit, origpat));
+
+	if (!(pglob->gl_flags & GLOB_NOSORT))
+		qsort(pglob->gl_pathv + pglob->gl_offs + oldpathc,
+		    pglob->gl_pathc - oldpathc, sizeof(char *), compare);
+
+	return (0);
+}
+
+static int
+compare(const void *p, const void *q)
+{
+	return (strcoll(*(char **)p, *(char **)q));
+}
+
+static int
+glob1(Char *pattern, glob_t *pglob, struct glob_limit *limit)
+{
+	Char pathbuf[MAXPATHLEN];
+
+	/* A null pathname is invalid -- POSIX 1003.1 sect. 2.4. */
+	if (*pattern == EOS)
+		return (0);
+	return (glob2(pathbuf, pathbuf, pathbuf + MAXPATHLEN - 1,
+	    pattern, pglob, limit));
+}
+
+/*
+ * The functions glob2 and glob3 are mutually recursive; there is one level
+ * of recursion for each segment in the pattern that contains one or more
+ * meta characters.
+ */
+static int
+glob2(Char *pathbuf, Char *pathend, Char *pathend_last, Char *pattern,
+      glob_t *pglob, struct glob_limit *limit)
+{
+	struct stat sb;
+	Char *p, *q;
+	int anymeta;
+
+	/*
+	 * Loop over pattern segments until end of pattern or until
+	 * segment with meta character found.
+	 */
+	for (anymeta = 0;;) {
+		if (*pattern == EOS) {		/* End of pattern? */
+			*pathend = EOS;
+			if (g_lstat(pathbuf, &sb, pglob))
+				return (0);
+
+			if ((pglob->gl_flags & GLOB_LIMIT) &&
+			    limit->l_stat_cnt++ >= GLOB_LIMIT_STAT) {
+				errno = E2BIG;
+				return (GLOB_NOSPACE);
+			}
+			if ((pglob->gl_flags & GLOB_MARK) &&
+			    UNPROT(pathend[-1]) != SEP &&
+			    (S_ISDIR(sb.st_mode) ||
+			    (S_ISLNK(sb.st_mode) &&
+			    g_stat(pathbuf, &sb, pglob) == 0 &&
+			    S_ISDIR(sb.st_mode)))) {
+				if (pathend + 1 > pathend_last) {
+					errno = E2BIG;
+					return (GLOB_NOSPACE);
+				}
+				*pathend++ = SEP;
+				*pathend = EOS;
+			}
+			++pglob->gl_matchc;
+			return (globextend(pathbuf, pglob, limit, NULL));
+		}
+
+		/* Find end of next segment, copy tentatively to pathend. */
+		q = pathend;
+		p = pattern;
+		while (*p != EOS && UNPROT(*p) != SEP) {
+			if (ismeta(*p))
+				anymeta = 1;
+			if (q + 1 > pathend_last) {
+				errno = E2BIG;
+				return (GLOB_NOSPACE);
+			}
+			*q++ = *p++;
+		}
+
+		if (!anymeta) {		/* No expansion, do next segment. */
+			pathend = q;
+			pattern = p;
+			while (UNPROT(*pattern) == SEP) {
+				if (pathend + 1 > pathend_last) {
+					errno = E2BIG;
+					return (GLOB_NOSPACE);
+				}
+				*pathend++ = *pattern++;
+			}
+		} else			/* Need expansion, recurse. */
+			return (glob3(pathbuf, pathend, pathend_last, pattern,
+			    p, pglob, limit));
+	}
+	/* NOTREACHED */
+}
+
+static int
+glob3(Char *pathbuf, Char *pathend, Char *pathend_last,
+      Char *pattern, Char *restpattern,
+      glob_t *pglob, struct glob_limit *limit)
+{
+	struct dirent *dp;
+	DIR *dirp;
+	int err, too_long, saverrno, saverrno2;
+	char buf[MAXPATHLEN + MB_LEN_MAX - 1];
+
+	struct dirent *(*readdirfunc)(DIR *);
+
+	if (pathend > pathend_last) {
+		errno = E2BIG;
+		return (GLOB_NOSPACE);
+	}
+	*pathend = EOS;
+	if (pglob->gl_errfunc != NULL &&
+	    g_Ctoc(pathbuf, buf, sizeof(buf))) {
+		errno = E2BIG;
+		return (GLOB_NOSPACE);
+	}
+
+	saverrno = errno;
+	errno = 0;
+	if ((dirp = g_opendir(pathbuf, pglob)) == NULL) {
+		if (errno == ENOENT || errno == ENOTDIR)
+			return (0);
+		err = err_aborted(pglob, errno, buf);
+		if (errno == 0)
+			errno = saverrno;
+		return (err);
+	}
+
+	err = 0;
+
+	/* pglob->gl_readdir takes a void *, fix this manually */
+	if (pglob->gl_flags & GLOB_ALTDIRFUNC)
+		readdirfunc = (struct dirent *(*)(DIR *))pglob->gl_readdir;
+	else
+		readdirfunc = readdir;
+
+	errno = 0;
+	/* Search directory for matching names. */
+	while ((dp = (*readdirfunc)(dirp)) != NULL) {
+		char *sc;
+		Char *dc;
+		wchar_t wc;
+		size_t clen;
+		mbstate_t mbs;
+
+		if ((pglob->gl_flags & GLOB_LIMIT) &&
+		    limit->l_readdir_cnt++ >= GLOB_LIMIT_READDIR) {
+			errno = E2BIG;
+			err = GLOB_NOSPACE;
+			break;
+		}
+
+		/* Initial DOT must be matched literally. */
+		if (dp->d_name[0] == '.' && UNPROT(*pattern) != DOT) {
+			errno = 0;
+			continue;
+		}
+		memset(&mbs, 0, sizeof(mbs));
+		dc = pathend;
+		sc = dp->d_name;
+		too_long = 1;
+		while (dc <= pathend_last) {
+			clen = mbrtowc(&wc, sc, MB_LEN_MAX, &mbs);
+			if (clen == (size_t)-1 || clen == (size_t)-2) {
+				/* XXX See initial comment #2. */
+				wc = (unsigned char)*sc;
+				clen = 1;
+				memset(&mbs, 0, sizeof(mbs));
+			}
+			if ((*dc++ = wc) == EOS) {
+				too_long = 0;
+				break;
+			}
+			sc += clen;
+		}
+		if (too_long && (err = err_aborted(pglob, ENAMETOOLONG,
+		    buf))) {
+			errno = ENAMETOOLONG;
+			break;
+		}
+		if (too_long || !match(pathend, pattern, restpattern)) {
+			*pathend = EOS;
+			errno = 0;
+			continue;
+		}
+		if (errno == 0)
+			errno = saverrno;
+		err = glob2(pathbuf, --dc, pathend_last, restpattern,
+		    pglob, limit);
+		if (err)
+			break;
+		errno = 0;
+	}
+
+	saverrno2 = errno;
+	if (pglob->gl_flags & GLOB_ALTDIRFUNC)
+		(*pglob->gl_closedir)(dirp);
+	else
+		closedir(dirp);
+	errno = saverrno2;
+
+	if (err)
+		return (err);
+
+	if (dp == NULL && errno != 0 &&
+	    (err = err_aborted(pglob, errno, buf)))
+		return (err);
+
+	if (errno == 0)
+		errno = saverrno;
+	return (0);
+}
+
+
+/*
+ * Extend the gl_pathv member of a glob_t structure to accommodate a new item,
+ * add the new item, and update gl_pathc.
+ *
+ * This assumes the BSD realloc, which only copies the block when its size
+ * crosses a power-of-two boundary; for v7 realloc, this would cause quadratic
+ * behavior.
+ *
+ * Return 0 if new item added, error code if memory couldn't be allocated.
+ *
+ * Invariant of the glob_t structure:
+ *	Either gl_pathc is zero and gl_pathv is NULL; or gl_pathc > 0 and
+ *	gl_pathv points to (gl_offs + gl_pathc + 1) items.
+ */
+static int
+globextend(const Char *path, glob_t *pglob, struct glob_limit *limit,
+    const char *origpat)
+{
+	char **pathv;
+	size_t i, newn, len;
+	char *copy;
+	const Char *p;
+
+	if ((pglob->gl_flags & GLOB_LIMIT) &&
+	    pglob->gl_matchc > limit->l_path_lim) {
+		errno = E2BIG;
+		return (GLOB_NOSPACE);
+	}
+
+	newn = 2 + pglob->gl_pathc + pglob->gl_offs;
+	/* reallocarray(NULL, newn, size) is equivalent to malloc(newn*size). */
+	pathv = reallocarray(pglob->gl_pathv, newn, sizeof(*pathv));
+	if (pathv == NULL)
+		return (GLOB_NOSPACE);
+
+	if (pglob->gl_pathv == NULL && pglob->gl_offs > 0) {
+		/* first time around -- clear initial gl_offs items */
+		pathv += pglob->gl_offs;
+		for (i = pglob->gl_offs + 1; --i > 0; )
+			*--pathv = NULL;
+	}
+	pglob->gl_pathv = pathv;
+
+	if (origpat != NULL)
+		copy = strdup(origpat);
+	else {
+		for (p = path; *p++ != EOS;)
+			continue;
+		len = MB_CUR_MAX * (size_t)(p - path); /* XXX overallocation */
+		if ((copy = malloc(len)) != NULL) {
+			if (g_Ctoc(path, copy, len)) {
+				free(copy);
+				errno = E2BIG;
+				return (GLOB_NOSPACE);
+			}
+		}
+	}
+	if (copy != NULL) {
+		limit->l_string_cnt += strlen(copy) + 1;
+		if ((pglob->gl_flags & GLOB_LIMIT) &&
+		    limit->l_string_cnt >= GLOB_LIMIT_STRING) {
+			free(copy);
+			errno = E2BIG;
+			return (GLOB_NOSPACE);
+		}
+		pathv[pglob->gl_offs + pglob->gl_pathc++] = copy;
+	}
+	pathv[pglob->gl_offs + pglob->gl_pathc] = NULL;
+	return (copy == NULL ? GLOB_NOSPACE : 0);
+}
+
+/*
+ * pattern matching function for filenames.
+ */
+static int
+match(Char *name, Char *pat, Char *patend)
+{
+	int ok, negate_range;
+	Char c, k, *nextp, *nextn;
+#ifdef USE_LOCALE_COLLATE
+	struct xlocale_collate *table =
+		(struct xlocale_collate*)__get_locale()->components[XLC_COLLATE];
+#endif
+
+	nextn = NULL;
+	nextp = NULL;
+
+	while (1) {
+		while (pat < patend) {
+			c = *pat++;
+			switch (c & M_MASK) {
+			case M_ALL:
+				if (pat == patend)
+					return (1);
+				if (*name == EOS)
+					return (0);
+				nextn = name + 1;
+				nextp = pat - 1;
+				break;
+			case M_ONE:
+				if (*name++ == EOS)
+					goto fail;
+				break;
+			case M_SET:
+				ok = 0;
+				if ((k = *name++) == EOS)
+					goto fail;
+				negate_range = ((*pat & M_MASK) == M_NOT);
+				if (negate_range != 0)
+					++pat;
+				while (((c = *pat++) & M_MASK) != M_END)
+					if ((*pat & M_MASK) == M_RNG) {
+#ifdef USE_LOCALE_COLLATE
+						if (table->__collate_load_error ?
+						    CHAR(c) <= CHAR(k) &&
+						    CHAR(k) <= CHAR(pat[1]) :
+						    __wcollate_range_cmp(CHAR(c),
+						    CHAR(k)) <= 0 &&
+						    __wcollate_range_cmp(CHAR(k),
+						    CHAR(pat[1])) <= 0)
+#else
+						if (c <= k && k <= pat[1])
+#endif
+							ok = 1;
+						pat += 2;
+					} else if (c == k)
+						ok = 1;
+				if (ok == negate_range)
+					goto fail;
+				break;
+			default:
+				if (*name++ != c)
+					goto fail;
+				break;
+			}
+		}
+		if (*name == EOS)
+			return (1);
+
+	fail:
+		if (nextn == NULL)
+			break;
+		pat = nextp;
+		name = nextn;
+	}
+	return (0);
+}
+
+/* Free allocated data belonging to a glob_t structure. */
+void
+globfree(glob_t *pglob)
+{
+	size_t i;
+	char **pp;
+
+	if (pglob->gl_pathv != NULL) {
+		pp = pglob->gl_pathv + pglob->gl_offs;
+		for (i = pglob->gl_pathc; i--; ++pp)
+			if (*pp)
+				free(*pp);
+		free(pglob->gl_pathv);
+		pglob->gl_pathv = NULL;
+	}
+}
+
+static DIR *
+g_opendir(Char *str, glob_t *pglob)
+{
+	char buf[MAXPATHLEN + MB_LEN_MAX - 1];
+
+	if (*str == EOS)
+		strcpy(buf, ".");
+	else {
+		if (g_Ctoc(str, buf, sizeof(buf))) {
+			errno = ENAMETOOLONG;
+			return (NULL);
+		}
+	}
+
+	if (pglob->gl_flags & GLOB_ALTDIRFUNC)
+		return ((*pglob->gl_opendir)(buf));
+
+	return (opendir(buf));
+}
+
+static int
+g_lstat(Char *fn, struct stat *sb, glob_t *pglob)
+{
+	char buf[MAXPATHLEN + MB_LEN_MAX - 1];
+
+	if (g_Ctoc(fn, buf, sizeof(buf))) {
+		errno = ENAMETOOLONG;
+		return (-1);
+	}
+	if (pglob->gl_flags & GLOB_ALTDIRFUNC)
+		return((*pglob->gl_lstat)(buf, sb));
+	return (lstat(buf, sb));
+}
+
+static int
+g_stat(Char *fn, struct stat *sb, glob_t *pglob)
+{
+	char buf[MAXPATHLEN + MB_LEN_MAX - 1];
+
+	if (g_Ctoc(fn, buf, sizeof(buf))) {
+		errno = ENAMETOOLONG;
+		return (-1);
+	}
+	if (pglob->gl_flags & GLOB_ALTDIRFUNC)
+		return ((*pglob->gl_stat)(buf, sb));
+	return (stat(buf, sb));
+}
+
+static const Char *
+g_strchr(const Char *str, wchar_t ch)
+{
+
+	do {
+		if (*str == ch)
+			return (str);
+	} while (*str++);
+	return (NULL);
+}
+
+static int
+g_Ctoc(const Char *str, char *buf, size_t len)
+{
+	mbstate_t mbs;
+	size_t clen;
+
+	memset(&mbs, 0, sizeof(mbs));
+	while (len >= MB_CUR_MAX) {
+		clen = wcrtomb(buf, CHAR(*str), &mbs);
+		if (clen == (size_t)-1) {
+			/* XXX See initial comment #2. */
+			*buf = (char)CHAR(*str);
+			clen = 1;
+			memset(&mbs, 0, sizeof(mbs));
+		}
+		if (CHAR(*str) == EOS)
+			return (0);
+		str++;
+		buf += clen;
+		len -= clen;
+	}
+	return (1);
+}
+
+static int
+err_nomatch(glob_t *pglob, struct glob_limit *limit, const char *origpat) {
+	/*
+	 * If there was no match we are going to append the origpat
+	 * if GLOB_NOCHECK was specified or if GLOB_NOMAGIC was specified
+	 * and the origpat did not contain any magic characters
+	 * GLOB_NOMAGIC is there just for compatibility with csh.
+	 */
+	if ((pglob->gl_flags & GLOB_NOCHECK) ||
+	    ((pglob->gl_flags & GLOB_NOMAGIC) &&
+	    !(pglob->gl_flags & GLOB_MAGCHAR)))
+		return (globextend(NULL, pglob, limit, origpat));
+	return (GLOB_NOMATCH);
+}
+
+static int
+err_aborted(glob_t *pglob, int err, char *buf) {
+	if ((pglob->gl_errfunc != NULL && pglob->gl_errfunc(buf, err)) ||
+	    (pglob->gl_flags & GLOB_ERR))
+		return (GLOB_ABORTED);
+	return (0);
+}
+
+#ifdef DEBUG
+static void
+qprintf(const char *str, Char *s)
+{
+	Char *p;
+
+	(void)printf("%s\n", str);
+	if (s != NULL) {
+		for (p = s; *p != EOS; p++)
+			(void)printf("%c", (char)CHAR(*p));
+		(void)printf("\n");
+		for (p = s; *p != EOS; p++)
+			(void)printf("%c", (isprot(*p) ? '\\' : ' '));
+		(void)printf("\n");
+		for (p = s; *p != EOS; p++)
+			(void)printf("%c", (ismeta(*p) ? '_' : ' '));
+		(void)printf("\n");
+	}
+}
+#endif
diff --git a/contrib/libs/libc_compat/glob.h b/contrib/libs/libc_compat/glob.h
new file mode 100644
index 00000000000..783ba51042d
--- /dev/null
+++ b/contrib/libs/libc_compat/glob.h
@@ -0,0 +1,104 @@
+/*-
+ * SPDX-License-Identifier: BSD-3-Clause
+ *
+ * Copyright (c) 1989, 1993
+ *	The Regents of the University of California.  All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * Guido van Rossum.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ *	@(#)glob.h	8.1 (Berkeley) 6/2/93
+ * $FreeBSD$
+ */
+
+#ifndef _GLOB_H_
+#define	_GLOB_H_
+
+#include <sys/cdefs.h>
+#include <sys/types.h>
+
+
+struct stat;
+typedef struct {
+	size_t gl_pathc;	/* Count of total paths so far. */
+	size_t gl_matchc;	/* Count of paths matching pattern. */
+	size_t gl_offs;		/* Reserved at beginning of gl_pathv. */
+	int gl_flags;		/* Copy of flags parameter to glob. */
+	char **gl_pathv;	/* List of paths matching pattern. */
+				/* Copy of errfunc parameter to glob. */
+	int (*gl_errfunc)(const char *, int);
+
+	/*
+	 * Alternate filesystem access methods for glob; replacement
+	 * versions of closedir(3), readdir(3), opendir(3), stat(2)
+	 * and lstat(2).
+	 */
+	void (*gl_closedir)(void *);
+	struct dirent *(*gl_readdir)(void *);
+	void *(*gl_opendir)(const char *);
+	int (*gl_lstat)(const char *, struct stat *);
+	int (*gl_stat)(const char *, struct stat *);
+} glob_t;
+
+// #if __POSIX_VISIBLE >= 199209
+/* Believed to have been introduced in 1003.2-1992 */
+#define	GLOB_APPEND	0x0001	/* Append to output from previous call. */
+#define	GLOB_DOOFFS	0x0002	/* Use gl_offs. */
+#define	GLOB_ERR	0x0004	/* Return on error. */
+#define	GLOB_MARK	0x0008	/* Append / to matching directories. */
+#define	GLOB_NOCHECK	0x0010	/* Return pattern itself if nothing matches. */
+#define	GLOB_NOSORT	0x0020	/* Don't sort. */
+#define	GLOB_NOESCAPE	0x2000	/* Disable backslash escaping. */
+
+/* Error values returned by glob(3) */
+#define	GLOB_NOSPACE	(-1)	/* Malloc call failed. */
+#define	GLOB_ABORTED	(-2)	/* Unignored error. */
+#define	GLOB_NOMATCH	(-3)	/* No match and GLOB_NOCHECK was not set. */
+#define	GLOB_NOSYS	(-4)	/* Obsolete: source comptability only. */
+// #endif /* __POSIX_VISIBLE >= 199209 */
+
+// #if __BSD_VISIBLE
+#define	GLOB_ALTDIRFUNC	0x0040	/* Use alternately specified directory funcs. */
+#define	GLOB_BRACE	0x0080	/* Expand braces ala csh. */
+#define	GLOB_MAGCHAR	0x0100	/* Pattern had globbing characters. */
+#define	GLOB_NOMAGIC	0x0200	/* GLOB_NOCHECK without magic chars (csh). */
+#define	GLOB_QUOTE	0x0400	/* Quote special chars with \. */
+#define	GLOB_TILDE	0x0800	/* Expand tilde names from the passwd file. */
+#define	GLOB_LIMIT	0x1000	/* limit number of returned paths */
+
+/* source compatibility, these are the old names */
+#define GLOB_MAXPATH	GLOB_LIMIT
+#define	GLOB_ABEND	GLOB_ABORTED
+// #endif /* __BSD_VISIBLE */
+
+__BEGIN_DECLS
+int	glob(const char * __restrict, int,
+	int (*)(const char *, int), glob_t * __restrict);
+void	globfree(glob_t *);
+__END_DECLS
+
+#endif /* !_GLOB_H_ */
diff --git a/contrib/libs/libc_compat/ifaddrs.c b/contrib/libs/libc_compat/ifaddrs.c
new file mode 100644
index 00000000000..c59d8bc7455
--- /dev/null
+++ b/contrib/libs/libc_compat/ifaddrs.c
@@ -0,0 +1,663 @@
+/*
+Copyright (c) 2013, Kenneth MacKay
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+ * Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#include "ifaddrs.h"
+
+#include <string.h>
+#include <stdlib.h>
+#include <stddef.h>
+#include <errno.h>
+#include <unistd.h>
+#include <sys/socket.h>
+#include <netpacket/packet.h>
+#include <net/if_arp.h>
+#include <netinet/in.h>
+#include <linux/netlink.h>
+#include <linux/rtnetlink.h>
+
+typedef struct NetlinkList
+{
+    struct NetlinkList *m_next;
+    struct nlmsghdr *m_data;
+    unsigned int m_size;
+} NetlinkList;
+
+static int netlink_socket(void)
+{
+    int l_socket = socket(PF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
+    if(l_socket < 0)
+    {
+        return -1;
+    }
+    
+    struct sockaddr_nl l_addr;
+    memset(&l_addr, 0, sizeof(l_addr));
+    l_addr.nl_family = AF_NETLINK;
+    if(bind(l_socket, (struct sockaddr *)&l_addr, sizeof(l_addr)) < 0)
+    {
+        close(l_socket);
+        return -1;
+    }
+    
+    return l_socket;
+}
+
+static int netlink_send(int p_socket, int p_request)
+{
+    struct
+    {
+        struct nlmsghdr m_hdr;
+        struct rtgenmsg m_msg;
+    } l_data;
+
+    memset(&l_data, 0, sizeof(l_data));
+    
+    l_data.m_hdr.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtgenmsg));
+    l_data.m_hdr.nlmsg_type = p_request;
+    l_data.m_hdr.nlmsg_flags = NLM_F_ROOT | NLM_F_MATCH | NLM_F_REQUEST;
+    l_data.m_hdr.nlmsg_pid = 0;
+    l_data.m_hdr.nlmsg_seq = p_socket;
+    l_data.m_msg.rtgen_family = AF_UNSPEC;
+    
+    struct sockaddr_nl l_addr;
+    memset(&l_addr, 0, sizeof(l_addr));
+    l_addr.nl_family = AF_NETLINK;
+    return (sendto(p_socket, &l_data.m_hdr, l_data.m_hdr.nlmsg_len, 0, (struct sockaddr *)&l_addr, sizeof(l_addr)));
+}
+
+static int netlink_recv(int p_socket, void *p_buffer, size_t p_len)
+{
+    struct msghdr l_msg;
+    struct iovec l_iov = { p_buffer, p_len };
+    struct sockaddr_nl l_addr;
+
+    for(;;)
+    {
+        l_msg.msg_name = (void *)&l_addr;
+        l_msg.msg_namelen = sizeof(l_addr);
+        l_msg.msg_iov = &l_iov;
+        l_msg.msg_iovlen = 1;
+        l_msg.msg_control = NULL;
+        l_msg.msg_controllen = 0;
+        l_msg.msg_flags = 0;
+        int l_result = recvmsg(p_socket, &l_msg, 0);
+        
+        if(l_result < 0)
+        {
+            if(errno == EINTR)
+            {
+                continue;
+            }
+            return -2;
+        }
+        
+        if(l_msg.msg_flags & MSG_TRUNC)
+        { // buffer was too small
+            return -1;
+        }
+        return l_result;
+    }
+}
+
+static struct nlmsghdr *getNetlinkResponse(int p_socket, int *p_size, int *p_done)
+{
+    size_t l_size = 4096;
+    void *l_buffer = NULL;
+    
+    for(;;)
+    {
+        free(l_buffer);
+        l_buffer = malloc(l_size);
+        if (l_buffer == NULL)
+        {
+            return NULL;
+        }
+        
+        int l_read = netlink_recv(p_socket, l_buffer, l_size);
+        *p_size = l_read;
+        if(l_read == -2)
+        {
+            free(l_buffer);
+            return NULL;
+        }
+        if(l_read >= 0)
+        {
+            pid_t l_pid = getpid();
+            struct nlmsghdr *l_hdr;
+            for(l_hdr = (struct nlmsghdr *)l_buffer; NLMSG_OK(l_hdr, (unsigned int)l_read); l_hdr = (struct nlmsghdr *)NLMSG_NEXT(l_hdr, l_read))
+            {
+                if((pid_t)l_hdr->nlmsg_pid != l_pid || (int)l_hdr->nlmsg_seq != p_socket)
+                {
+                    continue;
+                }
+                
+                if(l_hdr->nlmsg_type == NLMSG_DONE)
+                {
+                    *p_done = 1;
+                    break;
+                }
+                
+                if(l_hdr->nlmsg_type == NLMSG_ERROR)
+                {
+                    free(l_buffer);
+                    return NULL;
+                }
+            }
+            return l_buffer;
+        }
+        
+        l_size *= 2;
+    }
+}
+
+static NetlinkList *newListItem(struct nlmsghdr *p_data, unsigned int p_size)
+{
+    NetlinkList *l_item = malloc(sizeof(NetlinkList));
+    if (l_item == NULL)
+    {
+        return NULL;
+    }
+
+    l_item->m_next = NULL;
+    l_item->m_data = p_data;
+    l_item->m_size = p_size;
+    return l_item;
+}
+
+static void freeResultList(NetlinkList *p_list)
+{
+    NetlinkList *l_cur;
+    while(p_list)
+    {
+        l_cur = p_list;
+        p_list = p_list->m_next;
+        free(l_cur->m_data);
+        free(l_cur);
+    }
+}
+
+static NetlinkList *getResultList(int p_socket, int p_request)
+{
+    if(netlink_send(p_socket, p_request) < 0)
+    {
+        return NULL;
+    }
+
+    NetlinkList *l_list = NULL;
+    NetlinkList *l_end = NULL;
+    int l_size;
+    int l_done = 0;
+    while(!l_done)
+    {
+        struct nlmsghdr *l_hdr = getNetlinkResponse(p_socket, &l_size, &l_done);
+        if(!l_hdr)
+        { // error
+            freeResultList(l_list);
+            return NULL;
+        }
+        
+        NetlinkList *l_item = newListItem(l_hdr, l_size);
+        if (!l_item)
+        {
+            freeResultList(l_list);
+            return NULL;
+        }
+        if(!l_list)
+        {
+            l_list = l_item;
+        }
+        else
+        {
+            l_end->m_next = l_item;
+        }
+        l_end = l_item;
+    }
+    return l_list;
+}
+
+static size_t maxSize(size_t a, size_t b)
+{
+    return (a > b ? a : b);
+}
+
+static size_t calcAddrLen(sa_family_t p_family, int p_dataSize)
+{
+    switch(p_family)
+    {
+        case AF_INET:
+            return sizeof(struct sockaddr_in);
+        case AF_INET6:
+            return sizeof(struct sockaddr_in6);
+        case AF_PACKET:
+            return maxSize(sizeof(struct sockaddr_ll), offsetof(struct sockaddr_ll, sll_addr) + p_dataSize);
+        default:
+            return maxSize(sizeof(struct sockaddr), offsetof(struct sockaddr, sa_data) + p_dataSize);
+    }
+}
+
+static void makeSockaddr(sa_family_t p_family, struct sockaddr *p_dest, void *p_data, size_t p_size)
+{
+    switch(p_family)
+    {
+        case AF_INET:
+            memcpy(&((struct sockaddr_in*)p_dest)->sin_addr, p_data, p_size);
+            break;
+        case AF_INET6:
+            memcpy(&((struct sockaddr_in6*)p_dest)->sin6_addr, p_data, p_size);
+            break;
+        case AF_PACKET:
+            memcpy(((struct sockaddr_ll*)p_dest)->sll_addr, p_data, p_size);
+            ((struct sockaddr_ll*)p_dest)->sll_halen = p_size;
+            break;
+        default:
+            memcpy(p_dest->sa_data, p_data, p_size);
+            break;
+    }
+    p_dest->sa_family = p_family;
+}
+
+static void addToEnd(struct ifaddrs **p_resultList, struct ifaddrs *p_entry)
+{
+    if(!*p_resultList)
+    {
+        *p_resultList = p_entry;
+    }
+    else
+    {
+        struct ifaddrs *l_cur = *p_resultList;
+        while(l_cur->ifa_next)
+        {
+            l_cur = l_cur->ifa_next;
+        }
+        l_cur->ifa_next = p_entry;
+    }
+}
+
+static int interpretLink(struct nlmsghdr *p_hdr, struct ifaddrs **p_resultList)
+{
+    struct ifinfomsg *l_info = (struct ifinfomsg *)NLMSG_DATA(p_hdr);
+
+    size_t l_nameSize = 0;
+    size_t l_addrSize = 0;
+    size_t l_dataSize = 0;
+    
+    size_t l_rtaSize = NLMSG_PAYLOAD(p_hdr, sizeof(struct ifinfomsg));
+    struct rtattr *l_rta;
+    for(l_rta = IFLA_RTA(l_info); RTA_OK(l_rta, l_rtaSize); l_rta = RTA_NEXT(l_rta, l_rtaSize))
+    {
+        void *l_rtaData = RTA_DATA(l_rta);
+        size_t l_rtaDataSize = RTA_PAYLOAD(l_rta);
+        switch(l_rta->rta_type)
+        {
+            case IFLA_ADDRESS:
+            case IFLA_BROADCAST:
+                l_addrSize += NLMSG_ALIGN(calcAddrLen(AF_PACKET, l_rtaDataSize));
+                break;
+            case IFLA_IFNAME:
+                l_nameSize += NLMSG_ALIGN(l_rtaSize + 1);
+                break;
+            case IFLA_STATS:
+                l_dataSize += NLMSG_ALIGN(l_rtaSize);
+                break;
+            default:
+                break;
+        }
+    }
+    
+    struct ifaddrs *l_entry = malloc(sizeof(struct ifaddrs) + sizeof(int) + l_nameSize + l_addrSize + l_dataSize);
+    if (l_entry == NULL)
+    {
+        return -1;
+    }
+    memset(l_entry, 0, sizeof(struct ifaddrs));
+    l_entry->ifa_name = "";
+    
+    char *l_index = ((char *)l_entry) + sizeof(struct ifaddrs);
+    char *l_name = l_index + sizeof(int);
+    char *l_addr = l_name + l_nameSize;
+    char *l_data = l_addr + l_addrSize;
+    
+    // save the interface index so we can look it up when handling the addresses.
+    memcpy(l_index, &l_info->ifi_index, sizeof(int));
+    
+    l_entry->ifa_flags = l_info->ifi_flags;
+    
+    l_rtaSize = NLMSG_PAYLOAD(p_hdr, sizeof(struct ifinfomsg));
+    for(l_rta = IFLA_RTA(l_info); RTA_OK(l_rta, l_rtaSize); l_rta = RTA_NEXT(l_rta, l_rtaSize))
+    {
+        void *l_rtaData = RTA_DATA(l_rta);
+        size_t l_rtaDataSize = RTA_PAYLOAD(l_rta);
+        switch(l_rta->rta_type)
+        {
+            case IFLA_ADDRESS:
+            case IFLA_BROADCAST:
+            {
+                size_t l_addrLen = calcAddrLen(AF_PACKET, l_rtaDataSize);
+                makeSockaddr(AF_PACKET, (struct sockaddr *)l_addr, l_rtaData, l_rtaDataSize);
+                ((struct sockaddr_ll *)l_addr)->sll_ifindex = l_info->ifi_index;
+                ((struct sockaddr_ll *)l_addr)->sll_hatype = l_info->ifi_type;
+                if(l_rta->rta_type == IFLA_ADDRESS)
+                {
+                    l_entry->ifa_addr = (struct sockaddr *)l_addr;
+                }
+                else
+                {
+                    l_entry->ifa_broadaddr = (struct sockaddr *)l_addr;
+                }
+                l_addr += NLMSG_ALIGN(l_addrLen);
+                break;
+            }
+            case IFLA_IFNAME:
+                strncpy(l_name, l_rtaData, l_rtaDataSize);
+                l_name[l_rtaDataSize] = '\0';
+                l_entry->ifa_name = l_name;
+                break;
+            case IFLA_STATS:
+                memcpy(l_data, l_rtaData, l_rtaDataSize);
+                l_entry->ifa_data = l_data;
+                break;
+            default:
+                break;
+        }
+    }
+    
+    addToEnd(p_resultList, l_entry);
+    return 0;
+}
+
+static struct ifaddrs *findInterface(int p_index, struct ifaddrs **p_links, int p_numLinks)
+{
+    int l_num = 0;
+    struct ifaddrs *l_cur = *p_links;
+    while(l_cur && l_num < p_numLinks)
+    {
+        char *l_indexPtr = ((char *)l_cur) + sizeof(struct ifaddrs);
+        int l_index;
+        memcpy(&l_index, l_indexPtr, sizeof(int));
+        if(l_index == p_index)
+        {
+            return l_cur;
+        }
+        
+        l_cur = l_cur->ifa_next;
+        ++l_num;
+    }
+    return NULL;
+}
+
+static int interpretAddr(struct nlmsghdr *p_hdr, struct ifaddrs **p_resultList, int p_numLinks)
+{
+    struct ifaddrmsg *l_info = (struct ifaddrmsg *)NLMSG_DATA(p_hdr);
+    struct ifaddrs *l_interface = findInterface(l_info->ifa_index, p_resultList, p_numLinks);
+    
+    if(l_info->ifa_family == AF_PACKET)
+    {
+        return 0;
+    }
+
+    size_t l_nameSize = 0;
+    size_t l_addrSize = 0;
+    
+    int l_addedNetmask = 0;
+    
+    size_t l_rtaSize = NLMSG_PAYLOAD(p_hdr, sizeof(struct ifaddrmsg));
+    struct rtattr *l_rta;
+    for(l_rta = IFA_RTA(l_info); RTA_OK(l_rta, l_rtaSize); l_rta = RTA_NEXT(l_rta, l_rtaSize))
+    {
+        void *l_rtaData = RTA_DATA(l_rta);
+        size_t l_rtaDataSize = RTA_PAYLOAD(l_rta);
+        
+        switch(l_rta->rta_type)
+        {
+            case IFA_ADDRESS:
+            case IFA_LOCAL:
+                if((l_info->ifa_family == AF_INET || l_info->ifa_family == AF_INET6) && !l_addedNetmask)
+                { // make room for netmask
+                    l_addrSize += NLMSG_ALIGN(calcAddrLen(l_info->ifa_family, l_rtaDataSize));
+                    l_addedNetmask = 1;
+                }
+            case IFA_BROADCAST:
+                l_addrSize += NLMSG_ALIGN(calcAddrLen(l_info->ifa_family, l_rtaDataSize));
+                break;
+            case IFA_LABEL:
+                l_nameSize += NLMSG_ALIGN(l_rtaSize + 1);
+                break;
+            default:
+                break;
+        }
+    }
+    
+    struct ifaddrs *l_entry = malloc(sizeof(struct ifaddrs) + l_nameSize + l_addrSize);
+    if (l_entry == NULL)
+    {
+        return -1;
+    }
+    memset(l_entry, 0, sizeof(struct ifaddrs));
+    l_entry->ifa_name = (l_interface ? l_interface->ifa_name : "");
+    
+    char *l_name = ((char *)l_entry) + sizeof(struct ifaddrs);
+    char *l_addr = l_name + l_nameSize;
+    
+    l_entry->ifa_flags = l_info->ifa_flags;
+    if(l_interface)
+    {
+        l_entry->ifa_flags |= l_interface->ifa_flags;
+    }
+    
+    l_rtaSize = NLMSG_PAYLOAD(p_hdr, sizeof(struct ifaddrmsg));
+    for(l_rta = IFA_RTA(l_info); RTA_OK(l_rta, l_rtaSize); l_rta = RTA_NEXT(l_rta, l_rtaSize))
+    {
+        void *l_rtaData = RTA_DATA(l_rta);
+        size_t l_rtaDataSize = RTA_PAYLOAD(l_rta);
+        switch(l_rta->rta_type)
+        {
+            case IFA_ADDRESS:
+            case IFA_BROADCAST:
+            case IFA_LOCAL:
+            {
+                size_t l_addrLen = calcAddrLen(l_info->ifa_family, l_rtaDataSize);
+                makeSockaddr(l_info->ifa_family, (struct sockaddr *)l_addr, l_rtaData, l_rtaDataSize);
+                if(l_info->ifa_family == AF_INET6)
+                {
+                    if(IN6_IS_ADDR_LINKLOCAL((struct in6_addr *)l_rtaData) || IN6_IS_ADDR_MC_LINKLOCAL((struct in6_addr *)l_rtaData))
+                    {
+                        ((struct sockaddr_in6 *)l_addr)->sin6_scope_id = l_info->ifa_index;
+                    }
+                }
+                
+                if(l_rta->rta_type == IFA_ADDRESS)
+                { // apparently in a point-to-point network IFA_ADDRESS contains the dest address and IFA_LOCAL contains the local address
+                    if(l_entry->ifa_addr)
+                    {
+                        l_entry->ifa_dstaddr = (struct sockaddr *)l_addr;
+                    }
+                    else
+                    {
+                        l_entry->ifa_addr = (struct sockaddr *)l_addr;
+                    }
+                }
+                else if(l_rta->rta_type == IFA_LOCAL)
+                {
+                    if(l_entry->ifa_addr)
+                    {
+                        l_entry->ifa_dstaddr = l_entry->ifa_addr;
+                    }
+                    l_entry->ifa_addr = (struct sockaddr *)l_addr;
+                }
+                else
+                {
+                    l_entry->ifa_broadaddr = (struct sockaddr *)l_addr;
+                }
+                l_addr += NLMSG_ALIGN(l_addrLen);
+                break;
+            }
+            case IFA_LABEL:
+                strncpy(l_name, l_rtaData, l_rtaDataSize);
+                l_name[l_rtaDataSize] = '\0';
+                l_entry->ifa_name = l_name;
+                break;
+            default:
+                break;
+        }
+    }
+    
+    if(l_entry->ifa_addr && (l_entry->ifa_addr->sa_family == AF_INET || l_entry->ifa_addr->sa_family == AF_INET6))
+    {
+        unsigned l_maxPrefix = (l_entry->ifa_addr->sa_family == AF_INET ? 32 : 128);
+        unsigned l_prefix = (l_info->ifa_prefixlen > l_maxPrefix ? l_maxPrefix : l_info->ifa_prefixlen);
+        char l_mask[16] = {0};
+        unsigned i;
+        for(i=0; i<(l_prefix/8); ++i)
+        {
+            l_mask[i] = 0xff;
+        }
+        if(l_prefix % 8)
+        {
+            l_mask[i] = 0xff << (8 - (l_prefix % 8));
+        }
+        
+        makeSockaddr(l_entry->ifa_addr->sa_family, (struct sockaddr *)l_addr, l_mask, l_maxPrefix / 8);
+        l_entry->ifa_netmask = (struct sockaddr *)l_addr;
+    }
+    
+    addToEnd(p_resultList, l_entry);
+    return 0;
+}
+
+static int interpretLinks(int p_socket, NetlinkList *p_netlinkList, struct ifaddrs **p_resultList)
+{
+    int l_numLinks = 0;
+    pid_t l_pid = getpid();
+    for(; p_netlinkList; p_netlinkList = p_netlinkList->m_next)
+    {
+        unsigned int l_nlsize = p_netlinkList->m_size;
+        struct nlmsghdr *l_hdr;
+        for(l_hdr = p_netlinkList->m_data; NLMSG_OK(l_hdr, l_nlsize); l_hdr = NLMSG_NEXT(l_hdr, l_nlsize))
+        {
+            if((pid_t)l_hdr->nlmsg_pid != l_pid || (int)l_hdr->nlmsg_seq != p_socket)
+            {
+                continue;
+            }
+            
+            if(l_hdr->nlmsg_type == NLMSG_DONE)
+            {
+                break;
+            }
+            
+            if(l_hdr->nlmsg_type == RTM_NEWLINK)
+            {
+                if(interpretLink(l_hdr, p_resultList) == -1)
+                {
+                    return -1;
+                }
+                ++l_numLinks;
+            }
+        }
+    }
+    return l_numLinks;
+}
+
+static int interpretAddrs(int p_socket, NetlinkList *p_netlinkList, struct ifaddrs **p_resultList, int p_numLinks)
+{
+    pid_t l_pid = getpid();
+    for(; p_netlinkList; p_netlinkList = p_netlinkList->m_next)
+    {
+        unsigned int l_nlsize = p_netlinkList->m_size;
+        struct nlmsghdr *l_hdr;
+        for(l_hdr = p_netlinkList->m_data; NLMSG_OK(l_hdr, l_nlsize); l_hdr = NLMSG_NEXT(l_hdr, l_nlsize))
+        {
+            if((pid_t)l_hdr->nlmsg_pid != l_pid || (int)l_hdr->nlmsg_seq != p_socket)
+            {
+                continue;
+            }
+            
+            if(l_hdr->nlmsg_type == NLMSG_DONE)
+            {
+                break;
+            }
+            
+            if(l_hdr->nlmsg_type == RTM_NEWADDR)
+            {
+                if (interpretAddr(l_hdr, p_resultList, p_numLinks) == -1)
+                {
+                    return -1;
+                }
+            }
+        }
+    }
+    return 0;
+}
+
+int getifaddrs(struct ifaddrs **ifap)
+{
+    if(!ifap)
+    {
+        return -1;
+    }
+    *ifap = NULL;
+    
+    int l_socket = netlink_socket();
+    if(l_socket < 0)
+    {
+        return -1;
+    }
+    
+    NetlinkList *l_linkResults = getResultList(l_socket, RTM_GETLINK);
+    if(!l_linkResults)
+    {
+        close(l_socket);
+        return -1;
+    }
+    
+    NetlinkList *l_addrResults = getResultList(l_socket, RTM_GETADDR);
+    if(!l_addrResults)
+    {
+        close(l_socket);
+        freeResultList(l_linkResults);
+        return -1;
+    }
+    
+    int l_result = 0;
+    int l_numLinks = interpretLinks(l_socket, l_linkResults, ifap);
+    if(l_numLinks == -1 || interpretAddrs(l_socket, l_addrResults, ifap, l_numLinks) == -1)
+    {
+        l_result = -1;
+    }
+    
+    freeResultList(l_linkResults);
+    freeResultList(l_addrResults);
+    close(l_socket);
+    return l_result;
+}
+
+void freeifaddrs(struct ifaddrs *ifa)
+{
+    struct ifaddrs *l_cur;
+    while(ifa)
+    {
+        l_cur = ifa;
+        ifa = ifa->ifa_next;
+        free(l_cur);
+    }
+}
diff --git a/contrib/libs/libc_compat/memfd_create.c b/contrib/libs/libc_compat/memfd_create/memfd_create.c
similarity index 100%
rename from contrib/libs/libc_compat/memfd_create.c
rename to contrib/libs/libc_compat/memfd_create/memfd_create.c
diff --git a/contrib/libs/libc_compat/memfd_create/sys/mman.h b/contrib/libs/libc_compat/memfd_create/sys/mman.h
new file mode 100644
index 00000000000..d36e9bdbe40
--- /dev/null
+++ b/contrib/libs/libc_compat/memfd_create/sys/mman.h
@@ -0,0 +1,16 @@
+#pragma once
+
+#include_next <sys/mman.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define MFD_CLOEXEC 		0x0001U
+#define MADV_WIPEONFORK  	18
+
+int memfd_create(const char *name, unsigned flags);
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
diff --git a/contrib/libs/libc_compat/include/windows/sys/queue.h b/contrib/libs/libc_compat/queue/sys/queue.h
similarity index 100%
rename from contrib/libs/libc_compat/include/windows/sys/queue.h
rename to contrib/libs/libc_compat/queue/sys/queue.h
diff --git a/contrib/libs/libc_compat/unistd.h b/contrib/libs/libc_compat/unistd.h
new file mode 100644
index 00000000000..c62f5f29cdd
--- /dev/null
+++ b/contrib/libs/libc_compat/unistd.h
@@ -0,0 +1,3 @@
+#include <unistd.h>
+
+#define issetugid() 0
diff --git a/contrib/libs/libc_compat/update.sh b/contrib/libs/libc_compat/update.sh
new file mode 100644
index 00000000000..4cee1609048
--- /dev/null
+++ b/contrib/libs/libc_compat/update.sh
@@ -0,0 +1,60 @@
+#!/bin/sh -e
+
+unweak() {
+    sed --in-place --expression 's/DEF_WEAK(.\+);//g' "$1"
+}
+
+get_string_method() {
+   curl "https://raw.githubusercontent.com/openbsd/src/master/lib/libc/string/$1" --output "$1" && unweak "$1"
+}
+
+fix_tabs() {
+	sed --in-place --expression 's/\t/    /g' "$1"
+}
+
+fix_decls() {
+	sed --in-place --expression 's/__BEGIN_DECLS/#ifdef __cplusplus\nextern "C" {\n#endif/g' "$1"
+	sed --in-place --expression 's/__END_DECLS/#ifdef __cplusplus\n} \/\/ extern "C"\n#endif/g' "$1"
+}
+
+get_string_method "strlcpy.c"
+get_string_method "strlcat.c"
+get_string_method "strsep.c"
+# strcasestr uses strncasecmp, which is platform dependent, so include local string.h
+get_string_method "strcasestr.c" && sed --in-place 's/#include <string.h>/#include "string.h"/g' "strcasestr.c"
+get_string_method "memrchr.c"
+get_string_method "stpcpy.c"
+
+mkdir -p include/windows/sys
+curl "https://raw.githubusercontent.com/openbsd/src/master/sys/sys/queue.h" --output "include/windows/sys/queue.h"
+
+mkdir -p include/readpassphrase
+curl "https://raw.githubusercontent.com/openbsd/src/master/include/readpassphrase.h" --output "include/readpassphrase/readpassphrase.h" && fix_decls "include/readpassphrase/readpassphrase.h"
+curl "https://raw.githubusercontent.com/openbsd/src/master/lib/libc/gen/readpassphrase.c" --output "readpassphrase.c" && unweak "readpassphrase.c" && fix_tabs "readpassphrase.c"
+
+curl "https://raw.githubusercontent.com/freebsd/freebsd/master/include/glob.h" --output "glob.h"
+curl "https://raw.githubusercontent.com/freebsd/freebsd/master/lib/libc/gen/glob.c" --output "glob.c"
+curl "https://raw.githubusercontent.com/openbsd/src/master/lib/libc/stdlib/reallocarray.c" --output "reallocarray.c" && unweak "reallocarray.c"
+> "collate.h"
+> "stdlib.h"
+> "unistd.h"
+
+mkdir -p include/uchar
+curl "https://git.musl-libc.org/cgit/musl/plain/include/uchar.h" --output "include/uchar/uchar.h"
+# TODO: provide c16rtomb, mbrtoc16, c32rtomb, mbrtoc32 implementations for uchar
+# if any code actually needs them
+
+mkdir -p include/random/sys
+curl "https://git.musl-libc.org/cgit/musl/plain/include/sys/random.h" --output "include/random/sys/random.h"
+curl "https://git.musl-libc.org/cgit/musl/plain/src/linux/getrandom.c" --output "getrandom.c"
+curl "https://git.musl-libc.org/cgit/musl/plain/src/linux/memfd_create.c" --output "memfd_create.c"
+
+# WARN: do not use github.com/morristech/android-ifaddrs, it is a long-ago abandoned fork
+curl "https://raw.githubusercontent.com/oliviertilmans/android-ifaddrs/master/ifaddrs.c" --output "ifaddrs.c"
+curl "https://raw.githubusercontent.com/oliviertilmans/android-ifaddrs/master/ifaddrs.h" --output "include/ifaddrs/ifaddrs.h"
+
+# apply patches if necessary
+for patch in patches/*.patch; do
+	echo "Applying patch from $patch"
+	patch -p1 < $patch
+done
diff --git a/contrib/libs/lzmasdk/7zVersion.h b/contrib/libs/lzmasdk/7zVersion.h
new file mode 100644
index 00000000000..0074c64be96
--- /dev/null
+++ b/contrib/libs/lzmasdk/7zVersion.h
@@ -0,0 +1,27 @@
+#define MY_VER_MAJOR 19
+#define MY_VER_MINOR 00
+#define MY_VER_BUILD 0
+#define MY_VERSION_NUMBERS "19.00"
+#define MY_VERSION MY_VERSION_NUMBERS
+
+#ifdef MY_CPU_NAME
+  #define MY_VERSION_CPU MY_VERSION " (" MY_CPU_NAME ")"
+#else
+  #define MY_VERSION_CPU MY_VERSION
+#endif
+
+#define MY_DATE "2019-02-21"
+#undef MY_COPYRIGHT
+#undef MY_VERSION_COPYRIGHT_DATE
+#define MY_AUTHOR_NAME "Igor Pavlov"
+#define MY_COPYRIGHT_PD "Igor Pavlov : Public domain"
+#define MY_COPYRIGHT_CR "Copyright (c) 1999-2018 Igor Pavlov"
+
+#ifdef USE_COPYRIGHT_CR
+  #define MY_COPYRIGHT MY_COPYRIGHT_CR
+#else
+  #define MY_COPYRIGHT MY_COPYRIGHT_PD
+#endif
+
+#define MY_COPYRIGHT_DATE MY_COPYRIGHT " : " MY_DATE
+#define MY_VERSION_COPYRIGHT_DATE MY_VERSION_CPU " : " MY_COPYRIGHT " : " MY_DATE
diff --git a/include/ydb-cpp-sdk/client/coordination/coordination.h b/include/ydb-cpp-sdk/client/coordination/coordination.h
index 4b46428ca9d..45bda4be922 100644
--- a/include/ydb-cpp-sdk/client/coordination/coordination.h
+++ b/include/ydb-cpp-sdk/client/coordination/coordination.h
@@ -291,6 +291,9 @@ struct TDescribeSemaphoreSettings {
 
 ////////////////////////////////////////////////////////////////////////////////
 
+class TDistributedLock;
+struct TDistributedLockSettings;
+
 class TClient {
 public:
     TClient(const TDriver& driver, const TCommonClientSettings& settings = TCommonClientSettings());
@@ -323,6 +326,7 @@ class TSessionContext;
 
 class TSession {
     friend class TSessionContext;
+    friend class TDistributedLock;
 
 public:
     TSession() = default;
@@ -360,9 +364,13 @@ class TSession {
     TAsyncResult<void> DeleteSemaphore(const std::string& name,
         bool force = false);
 
+    TDistributedLock CreateDistributedLock(const TDistributedLockSettings& settings);
+
 private:
     explicit TSession(TSessionContext* context);
 
+    std::shared_ptr<void> SubscribeSessionLost(std::function<void()> callback);
+
 private:
     class TImpl;
     std::shared_ptr<TImpl> Impl_;
diff --git a/include/ydb-cpp-sdk/client/coordination/distributed_lock.h b/include/ydb-cpp-sdk/client/coordination/distributed_lock.h
new file mode 100644
index 00000000000..56edbdac1f3
--- /dev/null
+++ b/include/ydb-cpp-sdk/client/coordination/distributed_lock.h
@@ -0,0 +1,42 @@
+#pragma once
+#include <ydb-cpp-sdk/client/coordination/coordination.h>
+#include <stop_token>
+namespace NYdb {
+namespace NCoordination {
+    struct TYdbLockException : public TYdbException {
+        TYdbLockException(const std::string& message) : TYdbException(message) {}
+    };
+    struct TDistributedLockSettings {
+        using TSelf = TDistributedLockSettings;
+        FLUENT_SETTING(std::string, Name);
+        FLUENT_SETTING_DEFAULT(TDuration, Timeout, TDuration::Seconds(5));
+    };
+    // Distributed exclusive lock backed by a YDB coordination semaphore.
+    // Satisfies BasicLockable (lock/unlock) for std::lock_guard; not a blocking Lockable.
+    class TDistributedLock {
+    public:
+        TDistributedLock(TSession session, const TDistributedLockSettings& settings);
+        ~TDistributedLock();
+        TDistributedLock(const TDistributedLock&) = delete;
+        TDistributedLock& operator=(const TDistributedLock&) = delete;
+        TDistributedLock(TDistributedLock&&) = delete;
+        TDistributedLock& operator=(TDistributedLock&&) = delete;
+        // Throws TYdbLockException on session start failure, acquire timeout, transport
+        // error, or contention timeout (timeout bounds the acquire wait).
+        void lock();
+        // Same as lock()
+        void Acquire();
+        // noexcept. Undefined behavior if called when the lock is not held (same as std::mutex).
+        void unlock() noexcept;
+        // Same as unlock()
+        void Release() noexcept;
+        // noexcept. Returns false on any failure without throwing.
+        bool try_lock() noexcept;
+        // Signals lock loss for the current hold; refreshed on successful acquire — call again after re-lock.
+        std::stop_token getStopToken() const;
+    private:
+        struct TImpl;
+        std::unique_ptr<TImpl> impl_;
+    };
+}
+}
diff --git a/include/ydb-cpp-sdk/client/export/export.h b/include/ydb-cpp-sdk/client/export/export.h
index 35cec0b9437..02f73af6097 100644
--- a/include/ydb-cpp-sdk/client/export/export.h
+++ b/include/ydb-cpp-sdk/client/export/export.h
@@ -4,6 +4,8 @@
 #include <ydb-cpp-sdk/client/types/operation/operation.h>
 #include <ydb-cpp-sdk/client/types/s3_settings.h>
 
+#include <variant>
+
 namespace NYdb::inline V3 {
 namespace NExport {
 
@@ -32,6 +34,15 @@ struct TEncryptionAlgorithm {
     static const std::string CHACHA_20_POLY_1305;
 };
 
+struct TYdbDumpFormat {
+};
+
+struct TParquetFormat {
+    using TSelf = TParquetFormat;
+
+    FLUENT_SETTING_DEFAULT(uint32_t, RowGroupSize, 10000);
+};
+
 /// YT
 struct TExportToYtSettings : public TOperationRequestSettings<TExportToYtSettings> {
     struct TItem {
@@ -104,6 +115,9 @@ struct TExportToS3Settings : public TOperationRequestSettings<TExportToS3Setting
     FLUENT_SETTING_DEFAULT(bool, IncludeIndexData, false);
     FLUENT_SETTING_VECTOR(std::string, ExcludeRegexp);
 
+    using FormatVariant = std::variant<TYdbDumpFormat, TParquetFormat>;
+    FLUENT_SETTING(FormatVariant, Format);
+
     TSelf& SymmetricEncryption(const std::string& algorithm, const std::string& key) {
         EncryptionAlgorithm_ = algorithm;
         SymmetricKey_ = key;
diff --git a/include/ydb-cpp-sdk/client/iam/common/generic_provider.h b/include/ydb-cpp-sdk/client/iam/common/generic_provider.h
index 37d3184e4b6..e7deca3f55e 100644
--- a/include/ydb-cpp-sdk/client/iam/common/generic_provider.h
+++ b/include/ydb-cpp-sdk/client/iam/common/generic_provider.h
@@ -14,17 +14,50 @@
 
 #include <chrono>
 #include <format>
+#include <functional>
 #include <string>
 #include <condition_variable>
 #include <mutex>
+#include <utility>
 
 namespace NYdb::inline V3 {
 
+using NCredentials::NDetail::TOwningFacilityCredentialsProvider;
+
 constexpr std::chrono::milliseconds BACKOFF_START{50};
 constexpr std::chrono::milliseconds BACKOFF_MAX{10000};
 constexpr std::chrono::milliseconds PERIODIC_TICK{100};
 constexpr std::chrono::milliseconds MINIMUM_REFRESH_INTERVAL{100};
 
+// Implementation detail for the IAM factory templates below. Symbols in NDetail are not part of
+// the public YDB C++ SDK API and may change or be removed without notice.
+namespace NIam::NDetail {
+
+template <typename... TExtraValues>
+std::string MakeClientIdentity(
+    const char* factoryType,
+    const TIamEndpoint& params,
+    const TExtraValues&... extraValues)
+{
+    TStringBuilder identity;
+    const auto append = [&identity](const auto& value) {
+        const std::string serialized = TStringBuilder() << value;
+        identity << serialized.size() << ':' << serialized;
+    };
+
+    append(factoryType);
+    append(params.Endpoint);
+    append(params.RefreshPeriod);
+    append(params.RequestTimeout);
+    append(params.EnableSsl);
+    append(params.CaCerts);
+    (append(extraValues), ...);
+
+    return identity;
+}
+
+} // namespace NIam::NDetail
+
 // This file contains internal generic implementation of IAM credentials providers.
 // DO NOT USE THIS CLASS DIRECTLY. Use specialized factory methods for specific cases.
 template<typename TRequest, typename TResponse, typename TService>
@@ -46,17 +79,16 @@ class TGrpcIamCredentialsProvider : public ICredentialsProvider {
               std::weak_ptr<ICoreFacility> responseFacility,
               TCredentialsProviderPtr authTokenProvider)
             : Rpc_(rpc)
-            , Ticket_("")
             , NextTicketUpdate_(SysTimePoint{})
             , IamEndpoint_(iamEndpoint)
             , RequestFiller_(requestFiller)
             , Context_(std::nullopt)
-            , LastRequestError_("")
             , NeedStop_(false)
             , BackoffTimeout_(BACKOFF_START)
             , Lock_()
             , ResponseFacility_(std::move(responseFacility))
             , AuthTokenProvider_(authTokenProvider)
+            , AuthInfo_(NThreading::NewPromise<std::string>())
         {
             std::shared_ptr<grpc::ChannelCredentials> creds = nullptr;
             if (IamEndpoint_.EnableSsl) {
@@ -79,53 +111,53 @@ class TGrpcIamCredentialsProvider : public ICredentialsProvider {
         void StartPeriodicTask() {
             auto facility = ResponseFacility_.lock();
             if (!facility) {
+                Fail("IAM-token provider response facility is not available");
                 return;
             }
 
             std::weak_ptr<TImpl> weakSelf = TGrpcIamCredentialsProvider<TRequest, TResponse, TService>::TImpl::weak_from_this();
-            facility->AddPeriodicTask(
-                [weakSelf](NYdb::NIssue::TIssues&&, EStatus status) {
-                    auto self = weakSelf.lock();
-                    if (!self || status != EStatus::SUCCESS) {
-                        return false;
-                    }
-                    return self->OnPeriodicTick();
-                },
-                PERIODIC_TICK
-            );
-        }
-
-        std::string GetTicket() {
-            std::lock_guard guard(Lock_);
-            if (Ticket_.empty()) {
-                ythrow yexception() << "IAM-token not ready yet. " << LastRequestError_;
+            try {
+                facility->AddPeriodicTask(
+                    [weakSelf](NYdb::NIssue::TIssues&&, EStatus status) {
+                        auto self = weakSelf.lock();
+                        if (!self) {
+                            return false;
+                        }
+                        if (status != EStatus::SUCCESS) {
+                            self->Fail(TStringBuilder()
+                                << "IAM-token provider periodic task failed with status "
+                                << static_cast<int>(status));
+                            return false;
+                        }
+                        return self->OnPeriodicTick();
+                    },
+                    PERIODIC_TICK
+                );
+            } catch (...) {
+                Fail(TStringBuilder()
+                    << "Failed to start IAM-token provider periodic task: "
+                    << CurrentExceptionMessage());
             }
-            return Ticket_;
         }
 
-        void WaitForToken() {
-            std::unique_lock guard(Lock_);
-            TokenReady_.wait_for(guard,
-                std::chrono::microseconds(2 * IamEndpoint_.RequestTimeout.MicroSeconds()),
-                [this]() {
-                    return NeedStop_ || !Ticket_.empty(); 
-                }
-            );
+        NThreading::TFuture<std::string> GetAuthInfoAsync() {
+            std::lock_guard guard(Lock_);
+            return AuthInfo_.GetFuture();
         }
 
         void Stop() {
+            NThreading::TPromise<std::string> promise;
             {
                 std::unique_lock guard(Lock_);
-                if (NeedStop_) {
-                    return;
-                }
                 NeedStop_ = true;
-                TokenReady_.notify_all();
+                promise = AuthInfo_;
                 if (Context_.has_value()) {
                     Context_->TryCancel();
                 }
                 ContextReady_.wait(guard, [this]() { return !Context_.has_value(); });
             }
+            promise.TrySetException(std::make_exception_ptr(
+                yexception() << "IAM-token provider stopped before token was ready"));
             Stub_.reset();
             Channel_.reset();
         }
@@ -133,6 +165,19 @@ class TGrpcIamCredentialsProvider : public ICredentialsProvider {
     private:
         using SysDuration = SysClock::duration;
 
+        void Fail(std::string error) {
+            NThreading::TPromise<std::string> promise;
+            {
+                std::lock_guard guard(Lock_);
+                NeedStop_ = true;
+                promise = AuthInfo_;
+                if (Context_) {
+                    Context_->TryCancel();
+                }
+            }
+            promise.TrySetException(std::make_exception_ptr(yexception() << error));
+        }
+
         static SysDuration ToBoundedSysDuration(const TDuration& d) {
             return std::chrono::duration_cast<SysDuration>(TDeadline::SafeDurationCast(d));
         }
@@ -178,8 +223,11 @@ class TGrpcIamCredentialsProvider : public ICredentialsProvider {
                 }
 
                 if (auto self = weakSelf.lock()) {
-                    std::lock_guard guard(self->Lock_);
-                    self->ResetContextImpl();
+                    {
+                        std::lock_guard guard(self->Lock_);
+                        self->ResetContextImpl();
+                    }
+                    self->Fail("IAM-token provider response facility is not available");
                 }
             };
 
@@ -187,33 +235,36 @@ class TGrpcIamCredentialsProvider : public ICredentialsProvider {
 
             try {
                 RequestFiller_(req);
+                Rpc_(Stub_.get(), &*Context_, &req, response.get(), std::move(cb));
             } catch (...) {
-                const auto now = SysClock::now();
                 std::lock_guard guard(Lock_);
-                LastRequestError_ = TStringBuilder()
-                    << "Last request error was at " << FormatSysTimeUtcIsoMicros(now)
-                    << ". Failed to prepare IAM request: " << CurrentExceptionMessage();
                 ResetContextImpl();
                 RescheduleOnFailure();
-                return;
             }
-
-            Rpc_(Stub_.get(), &*Context_, &req, response.get(), std::move(cb));
         }
 
-        void FillContext(std::unique_lock<std::mutex>& guard) {
+        bool FillContext(std::unique_lock<std::mutex>& guard) {
             std::optional<std::string> authToken;
             if (AuthTokenProvider_) {
                 guard.unlock();
                 try {
-                    authToken = AuthTokenProvider_->GetAuthInfo();
+                    if (!AuthTokenInfo_.Initialized()) {
+                        AuthTokenInfo_ = AuthTokenProvider_->GetAuthInfoAsync();
+                    }
+                    if (!AuthTokenInfo_.IsReady()) {
+                        guard.lock();
+                        return false;
+                    }
+                    authToken = AuthTokenInfo_.GetValue();
+                    AuthTokenInfo_ = {};
                 } catch (...) {
+                    AuthTokenInfo_ = {};
                     guard.lock();
                     throw;
                 }
                 guard.lock();
                 if (NeedStop_) {
-                    return;
+                    return false;
                 }
             }
 
@@ -227,6 +278,7 @@ class TGrpcIamCredentialsProvider : public ICredentialsProvider {
             if (authToken) {
                 context.AddMetadata("authorization", "Bearer " + *authToken);
             }
+            return true;
         }
 
         void ResetContextImpl() {
@@ -242,6 +294,9 @@ class TGrpcIamCredentialsProvider : public ICredentialsProvider {
         }
 
         bool OnPeriodicTick() {
+            std::optional<std::string> terminalError;
+            bool updateTicket = false;
+            bool authPending = false;
             {
                 std::unique_lock guard(Lock_);
                 if (NeedStop_) {
@@ -250,12 +305,14 @@ class TGrpcIamCredentialsProvider : public ICredentialsProvider {
                 if (Context_.has_value() || SysClock::now() < NextTicketUpdate_) {
                     return true;
                 }
+                if (AuthInfo_.GetFuture().IsReady()) {
+                    AuthInfo_ = NThreading::NewPromise<std::string>();
+                }
                 try {
-                    FillContext(guard);
+                    authPending = !FillContext(guard);
                 } catch (...) {
-                    const auto now = SysClock::now();
-                    LastRequestError_ = TStringBuilder()
-                        << "Last request error was at " << FormatSysTimeUtcIsoMicros(now)
+                    terminalError = TStringBuilder()
+                        << "Last request error was at " << FormatSysTimeUtcIsoMicros(SysClock::now())
                         << ". Failed to prepare IAM request context: " << CurrentExceptionMessage();
                     ResetContextImpl();
                 }
@@ -264,36 +321,68 @@ class TGrpcIamCredentialsProvider : public ICredentialsProvider {
                     return false;
                 }
                 if (!Context_.has_value()) {
-                    RescheduleOnFailure();
-                    return true;
+                    if (!authPending && !terminalError) {
+                        RescheduleOnFailure();
+                    }
+                } else {
+                    updateTicket = true;
                 }
             }
-            UpdateTicket();
+            if (terminalError) {
+                Fail(*terminalError);
+                return false;
+            }
+            if (updateTicket) {
+                UpdateTicket();
+            }
             return true;
         }
 
         void ProcessIamResponse(grpc::Status&& status, TResponse&& result) {
-            std::lock_guard guard(Lock_);
+            std::optional<std::string> token;
+            std::optional<std::string> terminalError;
+            NThreading::TPromise<std::string> promise;
 
-            if (!status.ok()) {
-                LastRequestError_ = TStringBuilder()
-                    << "Last request error was at " << FormatSysTimeUtcIsoMicros(SysClock::now())
-                    << ". GrpcStatusCode: " << static_cast<int>(status.error_code())
-                    << " Message: \"" << status.error_message()
-                    << "\" iam-endpoint: \"" << IamEndpoint_.Endpoint << "\"";
+            {
+                std::lock_guard guard(Lock_);
 
-                RescheduleOnFailure();
-            } else {
-                LastRequestError_ = "";
-                Ticket_ = result.iam_token();
+                if (!status.ok()) {
+                    const std::string error = TStringBuilder()
+                        << "Last request error was at " << FormatSysTimeUtcIsoMicros(SysClock::now())
+                        << ". GrpcStatusCode: " << static_cast<int>(status.error_code())
+                        << " Message: \"" << status.error_message()
+                        << "\" iam-endpoint: \"" << IamEndpoint_.Endpoint << "\"";
+
+                    if (IsRetryable(status.error_code())) {
+                        RescheduleOnFailure();
+                    } else {
+                        terminalError = error;
+                    }
+                } else if (result.iam_token().empty()) {
+                    terminalError = "IAM-token service returned an empty token";
+                } else {
+                    token = result.iam_token();
+                    promise = AuthInfo_;
+
+                    const SysTimePoint expiresAt = SysClock::from_time_t(result.expires_at().seconds());
+                    RescheduleOnSuccess(expiresAt);
+                }
 
-                const SysTimePoint expiresAt = SysClock::from_time_t(result.expires_at().seconds());
-                RescheduleOnSuccess(expiresAt);
+                ResetContextImpl();
+            }
 
-                TokenReady_.notify_all();
+            if (token) {
+                promise.TrySetValue(std::move(*token));
+            } else if (terminalError) {
+                Fail(*terminalError);
             }
+        }
 
-            ResetContextImpl();
+        static bool IsRetryable(grpc::StatusCode code) {
+            return code == grpc::StatusCode::CANCELLED || code == grpc::StatusCode::UNKNOWN ||
+                code == grpc::StatusCode::DEADLINE_EXCEEDED || code == grpc::StatusCode::RESOURCE_EXHAUSTED ||
+                code == grpc::StatusCode::ABORTED || code == grpc::StatusCode::INTERNAL ||
+                code == grpc::StatusCode::UNAVAILABLE;
         }
 
         void RescheduleOnFailure() { // call with Lock_
@@ -321,19 +410,18 @@ class TGrpcIamCredentialsProvider : public ICredentialsProvider {
         std::shared_ptr<typename TService::Stub> Stub_;
         TAsyncRpc Rpc_;
 
-        std::string Ticket_;
         SysTimePoint NextTicketUpdate_;
         const TIamEndpoint IamEndpoint_;
         const TRequestFiller RequestFiller_;
         std::optional<grpc::ClientContext> Context_;
         std::condition_variable ContextReady_;
-        std::condition_variable TokenReady_;
-        std::string LastRequestError_;
         bool NeedStop_;
         std::chrono::milliseconds BackoffTimeout_;
         std::mutex Lock_;
         std::weak_ptr<ICoreFacility> ResponseFacility_;
         TCredentialsProviderPtr AuthTokenProvider_;
+        NThreading::TFuture<std::string> AuthTokenInfo_;
+        NThreading::TPromise<std::string> AuthInfo_;
     };
 
 public:
@@ -345,7 +433,6 @@ class TGrpcIamCredentialsProvider : public ICredentialsProvider {
         : Impl_(std::make_shared<TImpl>(endpoint, requestFiller, rpc, std::move(responseFacility), authTokenProvider))
     {
         Impl_->StartPeriodicTask();
-        Impl_->WaitForToken();
     }
 
     ~TGrpcIamCredentialsProvider() {
@@ -353,42 +440,19 @@ class TGrpcIamCredentialsProvider : public ICredentialsProvider {
     }
 
     std::string GetAuthInfo() const override {
-        return Impl_->GetTicket();
-    }
-
-    bool IsValid() const override {
-        return true;
+        return GetAuthInfoAsync().GetValueSync();
     }
 
-private:
-    std::shared_ptr<TImpl> Impl_;
-};
-
-// Adapter that keeps a self-owned ICoreFacility alive for the lifetime of an inner credentials
-// provider. Used by deprecated no-arg ICredentialsProviderFactory::CreateProvider() paths where
-// the caller hasn't supplied a facility.
-class TOwningFacilityCredentialsProvider : public ICredentialsProvider {
-public:
-    TOwningFacilityCredentialsProvider(std::shared_ptr<ICoreFacility> facility,
-                                       TCredentialsProviderPtr inner)
-        : Facility_(std::move(facility))
-        , Inner_(std::move(inner))
-    {}
-
-    std::string GetAuthInfo() const override {
-        return Inner_->GetAuthInfo();
+    NThreading::TFuture<std::string> GetAuthInfoAsync() const override {
+        return Impl_->GetAuthInfoAsync();
     }
 
     bool IsValid() const override {
-        return Inner_->IsValid();
+        return true;
     }
 
 private:
-    // Field declaration order matters: Inner_ is destroyed first so that its Stop() can still
-    // drive the facility's queue (cancel the in-flight gRPC context, drain the response callback),
-    // and only then is Facility_ destroyed.
-    std::shared_ptr<ICoreFacility> Facility_;
-    TCredentialsProviderPtr Inner_;
+    std::shared_ptr<TImpl> Impl_;
 };
 
 template<typename TRequest, typename TResponse, typename TService>
@@ -400,7 +464,7 @@ class TIamJwtCredentialsProvider : public TGrpcIamCredentialsProvider<TRequest,
                 req.set_jwt(MakeSignedJwt(jwtParams));
             }, [](typename TService::Stub* stub, grpc::ClientContext* context, const TRequest* request, TResponse* response, std::function<void(grpc::Status)> cb) {
                 stub->async()->Create(context, request, response, std::move(cb));
-            }, std::move(responseFacility), nullptr) {}
+            }, std::move(responseFacility)) {}
 };
 
 template<typename TRequest, typename TResponse, typename TService>
@@ -412,7 +476,7 @@ class TIamOAuthCredentialsProvider : public TGrpcIamCredentialsProvider<TRequest
                 req.set_yandex_passport_oauth_token(TStringType{token});
             }, [](typename TService::Stub* stub, grpc::ClientContext* context, const TRequest* request, TResponse* response, std::function<void(grpc::Status)> cb) {
                 stub->async()->Create(context, request, response, std::move(cb));
-            }, std::move(responseFacility), nullptr) {}
+            }, std::move(responseFacility)) {}
 };
 
 template<typename TRequest, typename TResponse, typename TService>
@@ -424,16 +488,32 @@ class TIamJwtCredentialsProviderFactory : public ICredentialsProviderFactory {
     // that don't have access to an ICoreFacility. Spins up a private TSimpleCoreFacility and ties
     // its lifetime to the returned provider via TOwningFacilityCredentialsProvider.
     TCredentialsProviderPtr CreateProvider() const final {
-        auto facility = CreateSimpleCoreFacility();
-        auto inner = std::make_shared<TIamJwtCredentialsProvider<TRequest, TResponse, TService>>(
-            Params_, std::weak_ptr<ICoreFacility>(facility));
-        return std::make_shared<TOwningFacilityCredentialsProvider>(std::move(facility), std::move(inner));
+        return NCredentials::NDetail::GetOrCreateCachedProvider(
+            GetClientIdentity(),
+            [this] {
+                auto facility = CreateSimpleCoreFacility();
+                auto inner = std::make_shared<TIamJwtCredentialsProvider<TRequest, TResponse, TService>>(
+                    Params_, std::weak_ptr<ICoreFacility>(facility));
+                return std::make_shared<TOwningFacilityCredentialsProvider>(
+                    std::move(facility), std::move(inner));
+            });
     }
 
     TCredentialsProviderPtr CreateProvider(std::weak_ptr<ICoreFacility> facility) const override {
         return std::make_shared<TIamJwtCredentialsProvider<TRequest, TResponse, TService>>(Params_, std::move(facility));
     }
 
+    std::string GetClientIdentity() const override final {
+        return NIam::NDetail::MakeClientIdentity(
+            "TIamJwtCredentialsProviderFactory",
+            Params_,
+            TService::service_full_name(),
+            Params_.JwtParams.AccountId,
+            Params_.JwtParams.KeyId,
+            Params_.JwtParams.PubKey,
+            Params_.JwtParams.PrivKey);
+    }
+
 private:
     TIamJwtParams Params_;
 };
@@ -445,16 +525,29 @@ class TIamOAuthCredentialsProviderFactory : public ICredentialsProviderFactory {
 
     // Deprecated. Kept for backward compatibility — see comment on TIamJwtCredentialsProviderFactory.
     TCredentialsProviderPtr CreateProvider() const final {
-        auto facility = CreateSimpleCoreFacility();
-        auto inner = std::make_shared<TIamOAuthCredentialsProvider<TRequest, TResponse, TService>>(
-            Params_, std::weak_ptr<ICoreFacility>(facility));
-        return std::make_shared<TOwningFacilityCredentialsProvider>(std::move(facility), std::move(inner));
+        return NCredentials::NDetail::GetOrCreateCachedProvider(
+            GetClientIdentity(),
+            [this] {
+                auto facility = CreateSimpleCoreFacility();
+                auto inner = std::make_shared<TIamOAuthCredentialsProvider<TRequest, TResponse, TService>>(
+                    Params_, std::weak_ptr<ICoreFacility>(facility));
+                return std::make_shared<TOwningFacilityCredentialsProvider>(
+                    std::move(facility), std::move(inner));
+            });
     }
 
     TCredentialsProviderPtr CreateProvider(std::weak_ptr<ICoreFacility> facility) const override {
         return std::make_shared<TIamOAuthCredentialsProvider<TRequest, TResponse, TService>>(Params_, std::move(facility));
     }
 
+    std::string GetClientIdentity() const override final {
+        return NIam::NDetail::MakeClientIdentity(
+            "TIamOAuthCredentialsProviderFactory",
+            Params_,
+            TService::service_full_name(),
+            Params_.OAuthToken);
+    }
+
 private:
     TIamOAuth Params_;
 };
diff --git a/include/ydb-cpp-sdk/client/proto/accessor.h b/include/ydb-cpp-sdk/client/proto/accessor.h
index b3b9c2cfef8..da3da5707ca 100644
--- a/include/ydb-cpp-sdk/client/proto/accessor.h
+++ b/include/ydb-cpp-sdk/client/proto/accessor.h
@@ -58,6 +58,9 @@ class TProtoAccessor {
     static NTable::TIndexDescription FromProto(const Ydb::Table::TableIndex& tableIndex);
     static NTable::TIndexDescription FromProto(const Ydb::Table::TableIndexDescription& tableIndexDesc);
 
+    static NTable::TMultiColumnStatisticsDescription FromProto(const Ydb::Table::TableMultiColumnStatistics& tableMultiColumnStatistics);
+    static NTable::TMultiColumnStatisticsDescription FromProto(const Ydb::Table::TableMultiColumnStatisticsDescription& tableMultiColumnStatisticsDesc);
+
     static NTable::TChangefeedDescription FromProto(const Ydb::Table::Changefeed& changefeed);
     static NTable::TChangefeedDescription FromProto(const Ydb::Table::ChangefeedDescription& changefeed);
 
@@ -73,6 +76,8 @@ class TProtoAccessor {
     static Ydb::Export::ExportToS3Settings::StorageClass GetProto(NExport::TExportToS3Settings::EStorageClass value);
     static NExport::TExportToS3Settings::EStorageClass FromProto(Ydb::Export::ExportToS3Settings::StorageClass value);
     static NExport::EExportProgress FromProto(Ydb::Export::ExportProgress::Progress value);
+    static NExport::TYdbDumpFormat FromProto(const Ydb::Export::YdbDumpFormat& value);
+    static NExport::TParquetFormat FromProto(const Ydb::Export::ParquetFormat& value);
     static NImport::EImportProgress FromProto(Ydb::Import::ImportProgress::Progress value);
     static Ydb::Import::ImportFromS3Settings::IndexPopulationMode GetProto(NImport::EIndexPopulationMode value);
     static NImport::EIndexPopulationMode FromProto(Ydb::Import::ImportFromS3Settings::IndexPopulationMode value);
diff --git a/include/ydb-cpp-sdk/client/query/client.h b/include/ydb-cpp-sdk/client/query/client.h
index 3b684dfb53d..b0a87eb71e3 100644
--- a/include/ydb-cpp-sdk/client/query/client.h
+++ b/include/ydb-cpp-sdk/client/query/client.h
@@ -8,6 +8,7 @@
 #include <ydb-cpp-sdk/client/driver/driver.h>
 #include <ydb-cpp-sdk/client/params/params.h>
 #include <ydb-cpp-sdk/client/retry/retry.h>
+#include <ydb-cpp-sdk/client/types/virtual_timestamp.h>
 #include <ydb-cpp-sdk/client/types/tx/tx.h>
 #include <ydb-cpp-sdk/client/types/request_settings.h>
 
@@ -51,6 +52,10 @@ struct TSessionPoolSettings {
     // Min number of session in session pool.
     // Sessions will not be closed by CloseIdleThreshold if the number of sessions less then this limit.
     FLUENT_SETTING_DEFAULT(uint32_t, MinPoolSize, 10);
+
+    // Create session in the background even after client timeout.
+    // This is useful for applications with short session timeouts.
+    FLUENT_SETTING_DEFAULT(bool, UseDeferredSessionCreation, false);
 };
 
 struct TClientSettings : public TCommonClientSettingsBase<TClientSettings> {
@@ -127,6 +132,8 @@ class TQueryClient {
 
     TAsyncCreateSessionResult GetSession(const TCreateSessionSettings& settings = TCreateSessionSettings());
 
+    TAsyncStatus DeleteSession(const std::string& sessionId, const TDeleteSessionSettings& settings = TDeleteSessionSettings());
+
     //! Returns number of active sessions given via session pool
     int64_t GetActiveSessionCount() const;
 
@@ -287,19 +294,25 @@ class TExecuteQueryPart : public TStreamPartStatus {
     
     const std::optional<TTransaction>& GetTransaction() const { return Transaction_; }
 
-    TExecuteQueryPart(TStatus&& status, std::optional<TExecStats>&& queryStats, std::optional<TTransaction>&& tx)
+    const std::optional<NScheme::TVirtualTimestamp>& GetCommitTimestamp() const { return CommitTimestamp_; }
+
+    TExecuteQueryPart(TStatus&& status, std::optional<TExecStats>&& queryStats, std::optional<TTransaction>&& tx,
+        std::optional<NScheme::TVirtualTimestamp>&& commitTimestamp = {})
         : TStreamPartStatus(std::move(status))
         , Stats_(std::move(queryStats))
         , Transaction_(std::move(tx))
+        , CommitTimestamp_(std::move(commitTimestamp))
     {}
 
     TExecuteQueryPart(TStatus&& status, TResultSet&& resultSet, int64_t resultSetIndex,
-        std::optional<TExecStats>&& queryStats, std::optional<TTransaction>&& tx)
+        std::optional<TExecStats>&& queryStats, std::optional<TTransaction>&& tx,
+        std::optional<NScheme::TVirtualTimestamp>&& commitTimestamp = {})
         : TStreamPartStatus(std::move(status))
         , ResultSet_(std::move(resultSet))
         , ResultSetIndex_(resultSetIndex)
         , Stats_(std::move(queryStats))
         , Transaction_(std::move(tx))
+        , CommitTimestamp_(std::move(commitTimestamp))
     {}
 
 private:
@@ -307,6 +320,7 @@ class TExecuteQueryPart : public TStreamPartStatus {
     int64_t ResultSetIndex_ = 0;
     std::optional<TExecStats> Stats_;
     std::optional<TTransaction> Transaction_;
+    std::optional<NScheme::TVirtualTimestamp> CommitTimestamp_;
 };
 
 class TExecuteQueryResult : public TStatus {
@@ -319,22 +333,27 @@ class TExecuteQueryResult : public TStatus {
 
     std::optional<TTransaction> GetTransaction() const {return Transaction_; }
 
+    const std::optional<NScheme::TVirtualTimestamp>& GetCommitTimestamp() const { return CommitTimestamp_; }
+
     TExecuteQueryResult(TStatus&& status)
         : TStatus(std::move(status))
     {}
 
     TExecuteQueryResult(TStatus&& status, std::vector<TResultSet>&& resultSets,
-        std::optional<TExecStats>&& stats, std::optional<TTransaction>&& tx)
+        std::optional<TExecStats>&& stats, std::optional<TTransaction>&& tx,
+        std::optional<NScheme::TVirtualTimestamp>&& commitTimestamp = {})
         : TStatus(std::move(status))
         , ResultSets_(std::move(resultSets))
         , Stats_(std::move(stats))
         , Transaction_(std::move(tx))
+        , CommitTimestamp_(std::move(commitTimestamp))
     {}
 
 private:
     std::vector<TResultSet> ResultSets_;
     std::optional<TExecStats> Stats_;
     std::optional<TTransaction> Transaction_;
+    std::optional<NScheme::TVirtualTimestamp> CommitTimestamp_;
 };
 
 } // namespace NYdb::NQuery
diff --git a/include/ydb-cpp-sdk/client/query/fwd.h b/include/ydb-cpp-sdk/client/query/fwd.h
index 9f88fdc3c00..455cca65edf 100644
--- a/include/ydb-cpp-sdk/client/query/fwd.h
+++ b/include/ydb-cpp-sdk/client/query/fwd.h
@@ -9,6 +9,7 @@ struct TExecuteQuerySettings;
 struct TBeginTxSettings;
 struct TCommitTxSettings;
 struct TRollbackTxSettings;
+struct TDeleteSessionSettings;
 struct TExecuteScriptSettings;
 struct TFetchScriptResultsSettings;
 struct TTxOnlineSettings;
diff --git a/include/ydb-cpp-sdk/client/query/query.h b/include/ydb-cpp-sdk/client/query/query.h
index 23fc18c5558..fa0c557f038 100644
--- a/include/ydb-cpp-sdk/client/query/query.h
+++ b/include/ydb-cpp-sdk/client/query/query.h
@@ -6,6 +6,7 @@
 
 #include <ydb-cpp-sdk/client/result/result.h>
 #include <ydb-cpp-sdk/client/retry/retry.h>
+#include <ydb-cpp-sdk/client/types/virtual_timestamp.h>
 #include <ydb-cpp-sdk/client/types/fluent_settings_helpers.h>
 #include <ydb-cpp-sdk/client/types/operation/operation.h>
 #include <ydb-cpp-sdk/client/types/request_settings.h>
@@ -122,12 +123,21 @@ struct TExecuteQuerySettings : public TRequestSettings<TExecuteQuerySettings> {
 struct TBeginTxSettings : public TRequestSettings<TBeginTxSettings> {};
 struct TCommitTxSettings : public TRequestSettings<TCommitTxSettings> {};
 struct TRollbackTxSettings : public TRequestSettings<TRollbackTxSettings> {};
+struct TDeleteSessionSettings : public TRequestSettings<TDeleteSessionSettings> {
+    FLUENT_SETTING_OPTIONAL(TRetryOperationSettings, RetrySettings);
+};
 
 
 
 class TCommitTransactionResult : public TStatus {
 public:
     TCommitTransactionResult(TStatus&& status);
+    TCommitTransactionResult(TStatus&& status, std::optional<NScheme::TVirtualTimestamp>&& commitTimestamp);
+
+    const std::optional<NScheme::TVirtualTimestamp>& GetCommitTimestamp() const { return CommitTimestamp_; }
+
+private:
+    std::optional<NScheme::TVirtualTimestamp> CommitTimestamp_;
 };
 
 using TAsyncBeginTransactionResult = NThreading::TFuture<TBeginTransactionResult>;
diff --git a/include/ydb-cpp-sdk/client/scheme/scheme.h b/include/ydb-cpp-sdk/client/scheme/scheme.h
index 6ef6941b895..517bf7d2a5f 100644
--- a/include/ydb-cpp-sdk/client/scheme/scheme.h
+++ b/include/ydb-cpp-sdk/client/scheme/scheme.h
@@ -1,6 +1,7 @@
 #pragma once
 
 #include <ydb-cpp-sdk/client/driver/driver.h>
+#include <ydb-cpp-sdk/client/types/virtual_timestamp.h>
 
 namespace Ydb {
     class VirtualTimestamp;
@@ -57,25 +58,6 @@ enum class ESchemeEntryType : i32 {
     Secret = 26,
 };
 
-struct TVirtualTimestamp {
-    uint64_t PlanStep = 0;
-    uint64_t TxId = 0;
-
-    TVirtualTimestamp() = default;
-    TVirtualTimestamp(uint64_t planStep, uint64_t txId);
-    TVirtualTimestamp(const ::Ydb::VirtualTimestamp& proto);
-
-    std::string ToString() const;
-    void Out(IOutputStream& out) const;
-
-    bool operator<(const TVirtualTimestamp& rhs) const;
-    bool operator<=(const TVirtualTimestamp& rhs) const;
-    bool operator>(const TVirtualTimestamp& rhs) const;
-    bool operator>=(const TVirtualTimestamp& rhs) const;
-    bool operator==(const TVirtualTimestamp& rhs) const;
-    bool operator!=(const TVirtualTimestamp& rhs) const;
-};
-
 struct TSchemeEntry {
     std::string Name;
     std::string Owner;
diff --git a/include/ydb-cpp-sdk/client/table/fwd.h b/include/ydb-cpp-sdk/client/table/fwd.h
index 8315bce41e4..11b0cbfcb96 100644
--- a/include/ydb-cpp-sdk/client/table/fwd.h
+++ b/include/ydb-cpp-sdk/client/table/fwd.h
@@ -13,6 +13,7 @@ struct TPartitionStats;
 struct TSequenceDescription;
 class TChangefeedDescription;
 class TIndexDescription;
+class TMultiColumnStatisticsDescription;
 class TColumnFamilyDescription;
 class TTableDescription;
 
diff --git a/include/ydb-cpp-sdk/client/table/table.h b/include/ydb-cpp-sdk/client/table/table.h
index fa892c3169f..979dd631a92 100644
--- a/include/ydb-cpp-sdk/client/table/table.h
+++ b/include/ydb-cpp-sdk/client/table/table.h
@@ -41,6 +41,8 @@ class TtlSettings;
 class TtlTier;
 class TableIndex;
 class TableIndexDescription;
+class TableMultiColumnStatistics;
+class TableMultiColumnStatisticsDescription;
 class ValueSinceUnixEpochModeSettings;
 class EvictionToExternalStorageSettings;
 class CompactItem;
@@ -389,6 +391,7 @@ struct TFulltextIndexSettings {
         Whitespace,
         Standard,
         Keyword,
+        Alphanumeric,
     };
 
     struct TAnalyzers {
@@ -623,6 +626,23 @@ class TAnalyzeOperation : public TOperation {
     TMetadata Metadata_;
 };
 
+class TSetNotNullOperation : public TOperation {
+public:
+    using TOperation::TOperation;
+    TSetNotNullOperation(TStatus&& status, Ydb::Operations::Operation&& operation);
+
+    struct TMetadata {
+        ESetNotNullState State = ESetNotNullState::Unspecified;
+        float Progress = 0;
+        std::string Path;
+        std::vector<std::string> Columns;
+    };
+
+    const TMetadata& Metadata() const;
+private:
+    TMetadata Metadata_;
+};
+
 ////////////////////////////////////////////////////////////////////////////////
 
 //! Represents changefeed description
@@ -1016,6 +1036,44 @@ enum class EStoreType {
     Column = 1
 };
 
+enum class EMultiColumnStatisticsType {
+    Unknown = 0,
+    CountMinSketch = 1,
+};
+
+//! Represents multi-column table statistics description
+class TMultiColumnStatisticsDescription {
+    friend class NYdb::TProtoAccessor;
+
+public:
+    TMultiColumnStatisticsDescription(
+        const std::string& name,
+        const std::vector<std::string>& columns,
+        const std::vector<EMultiColumnStatisticsType>& types
+    );
+
+    const std::string& GetName() const;
+    const std::vector<std::string>& GetColumns() const;
+    const std::vector<EMultiColumnStatisticsType>& GetTypes() const;
+
+    void SerializeTo(Ydb::Table::TableMultiColumnStatistics& proto) const;
+
+private:
+    explicit TMultiColumnStatisticsDescription(const Ydb::Table::TableMultiColumnStatistics& proto);
+    explicit TMultiColumnStatisticsDescription(const Ydb::Table::TableMultiColumnStatisticsDescription& proto);
+
+    template <typename TProto>
+    static TMultiColumnStatisticsDescription FromProto(const TProto& proto);
+
+private:
+    std::string Name_;
+    std::vector<std::string> Columns_;
+    std::vector<EMultiColumnStatisticsType> Types_;
+};
+
+bool operator==(const TMultiColumnStatisticsDescription& lhs, const TMultiColumnStatisticsDescription& rhs);
+bool operator!=(const TMultiColumnStatisticsDescription& lhs, const TMultiColumnStatisticsDescription& rhs);
+
 //! Represents table description
 class TTableDescription {
     friend class TTableBuilder;
@@ -1031,6 +1089,7 @@ class TTableDescription {
     std::vector<TColumn> GetColumns() const;
     std::vector<TTableColumn> GetTableColumns() const;
     std::vector<TIndexDescription> GetIndexDescriptions() const;
+    std::vector<TMultiColumnStatisticsDescription> GetMultiColumnStatisticsDescriptions() const;
     std::vector<TChangefeedDescription> GetChangefeedDescriptions() const;
     std::optional<TTtlSettings> GetTtlSettings() const;
     // Deprecated. Use GetTtlSettings() instead
@@ -1124,6 +1183,9 @@ class TTableDescription {
     void AddSecondaryIndex(const std::string& indexName, const std::vector<std::string>& indexColumns);
     void AddSecondaryIndex(const std::string& indexName, const std::vector<std::string>& indexColumns, const std::vector<std::string>& dataColumns);
 
+    // multi-column statistics
+    void AddMultiColumnStatistics(const TMultiColumnStatisticsDescription& statisticsDescription);
+
     void SetTtlSettings(TTtlSettings&& settings);
     void SetTtlSettings(const TTtlSettings& settings);
 
@@ -1379,6 +1441,9 @@ class TTableBuilder {
     TTableBuilder& AddSecondaryIndex(const std::string& indexName, const std::vector<std::string>& indexColumns);
     TTableBuilder& AddSecondaryIndex(const std::string& indexName, const std::string& indexColumn);
 
+    // multi-column statistics
+    TTableBuilder& AddMultiColumnStatistics(const TMultiColumnStatisticsDescription& statisticsDescription);
+
     TTableBuilder& SetTtlSettings(TTtlSettings&& settings);
     TTableBuilder& SetTtlSettings(const TTtlSettings& settings);
     TTableBuilder& SetTtlSettings(const std::string& columnName, const TDuration& expireAfter = TDuration::Zero());
diff --git a/include/ydb-cpp-sdk/client/table/table_enum.h b/include/ydb-cpp-sdk/client/table/table_enum.h
index 6ae6d50e41f..bc195a48022 100644
--- a/include/ydb-cpp-sdk/client/table/table_enum.h
+++ b/include/ydb-cpp-sdk/client/table/table_enum.h
@@ -52,6 +52,15 @@ enum class ECompactState {
     Cancelled = 3,
 };
 
+enum class ESetNotNullState {
+    Unspecified = 0,
+    Preparing = 1,
+    Validating = 2,
+    Applying = 3,
+    Done = 4,
+    Cancelled = 5,
+};
+
 enum class EAnalyzeState {
     Unspecified = 0,
     Enqueued = 1,
diff --git a/include/ydb-cpp-sdk/client/test_shard/test_shard.h b/include/ydb-cpp-sdk/client/test_shard/test_shard.h
new file mode 100644
index 00000000000..7855f1d5bb6
--- /dev/null
+++ b/include/ydb-cpp-sdk/client/test_shard/test_shard.h
@@ -0,0 +1,56 @@
+#pragma once
+
+#include <ydb-cpp-sdk/client/common_client/settings.h>
+#include <ydb-cpp-sdk/client/driver/driver.h>
+#include <ydb-cpp-sdk/client/types/status/status.h>
+#include <ydb-cpp-sdk/client/types/request_settings.h>
+
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace NYdb::NTestShardSet {
+
+struct TCreateTestShardSetSettings : public TOperationRequestSettings<TCreateTestShardSetSettings> {};
+
+struct TDeleteTestShardSetSettings : public TOperationRequestSettings<TDeleteTestShardSetSettings> {};
+
+class TCreateTestShardSetResult : public TStatus {
+public:
+    TCreateTestShardSetResult(TStatus&& status, std::vector<uint64_t> tabletIds)
+        : TStatus(std::move(status))
+        , TabletIds_(std::move(tabletIds))
+    {}
+
+    const std::vector<uint64_t>& GetTabletIds() const {
+        return TabletIds_;
+    }
+
+private:
+    std::vector<uint64_t> TabletIds_;
+};
+
+using TAsyncCreateTestShardSetResult = NThreading::TFuture<TCreateTestShardSetResult>;
+
+class TTestShardSetClient {
+public:
+    explicit TTestShardSetClient(const TDriver& driver, const TCommonClientSettings& settings = {});
+    ~TTestShardSetClient();
+
+    TAsyncCreateTestShardSetResult CreateTestShardSet(
+        const std::string& path,
+        const std::vector<std::string>& channels,
+        uint32_t count,
+        const std::string& config,
+        const TCreateTestShardSetSettings& settings = {});
+
+    TAsyncStatus DeleteTestShardSet(
+        const std::string& path,
+        const TDeleteTestShardSetSettings& settings = {});
+
+private:
+    class TImpl;
+    std::unique_ptr<TImpl> Impl_;
+};
+
+} // namespace NYdb::NTestShardSet
diff --git a/include/ydb-cpp-sdk/client/topic/codecs.h b/include/ydb-cpp-sdk/client/topic/codecs.h
index 00c4e8a77f3..2fc66a8f2b5 100644
--- a/include/ydb-cpp-sdk/client/topic/codecs.h
+++ b/include/ydb-cpp-sdk/client/topic/codecs.h
@@ -11,6 +11,7 @@
 #include <util/system/types.h>
 
 #include <optional>
+#include <string>
 #include <string_view>
 #include <vector>
 
@@ -43,6 +44,7 @@ struct TWriteBlockCompression {
     ECodec Codec = ECodec::RAW;
     std::vector<std::string_view>& Payloads;
     const std::vector<TInstant>& CreatedAt;
+    const std::vector<std::optional<std::string>>& MessageKeys;
     TBuffer& Data;
     ui32& CodecID;
     bool& Compressed;
diff --git a/include/ydb-cpp-sdk/client/topic/read_events.h b/include/ydb-cpp-sdk/client/topic/read_events.h
index d9b2369187a..4099fb010be 100644
--- a/include/ydb-cpp-sdk/client/topic/read_events.h
+++ b/include/ydb-cpp-sdk/client/topic/read_events.h
@@ -6,6 +6,7 @@
 
 #include <util/datetime/base.h>
 
+#include <span>
 
 namespace NYdb::inline V3::NTopic {
 
diff --git a/include/ydb-cpp-sdk/client/types/core_facility/core_facility.h b/include/ydb-cpp-sdk/client/types/core_facility/core_facility.h
index 6e4d48dba74..0a6b1d5eeb0 100644
--- a/include/ydb-cpp-sdk/client/types/core_facility/core_facility.h
+++ b/include/ydb-cpp-sdk/client/types/core_facility/core_facility.h
@@ -19,7 +19,7 @@ class ICoreFacility {
     // Add task to execute periodicaly
     // Task should return false to stop execution
     virtual void AddPeriodicTask(TPeriodicCb&& cb, TDeadline::Duration period) = 0;
-    // Post task on SDK response executor.
+    // Post task on SDK response executor, never inline.
     virtual void PostToResponseQueue(TPostTaskCb&& f) = 0;
 };
 
diff --git a/include/ydb-cpp-sdk/client/types/credentials/credentials.h b/include/ydb-cpp-sdk/client/types/credentials/credentials.h
index 054db38a46e..f84ca505a13 100644
--- a/include/ydb-cpp-sdk/client/types/credentials/credentials.h
+++ b/include/ydb-cpp-sdk/client/types/credentials/credentials.h
@@ -2,8 +2,13 @@
 
 #include <ydb-cpp-sdk/client/types/fwd.h>
 
+#include <functional>
+#include <library/cpp/threading/future/future.h>
+
+#include <exception>
 #include <memory>
 #include <string>
+#include <utility>
 
 namespace NYdb::inline V3 {
 
@@ -12,16 +17,67 @@ class ICredentialsProvider {
     virtual ~ICredentialsProvider() = default;
     virtual std::string GetAuthInfo() const = 0;
     virtual bool IsValid() const = 0;
+    virtual NThreading::TFuture<std::string> GetAuthInfoAsync() const {
+        try {
+            return NThreading::MakeFuture(GetAuthInfo());
+        } catch (...) {
+            return NThreading::MakeErrorFuture<std::string>(std::current_exception());
+        }
+    }
 };
 
 using TCredentialsProviderPtr = std::shared_ptr<ICredentialsProvider>;
-
 class ICoreFacility;
+
+// Implementation detail for SDK credentials factories. Symbols in NCredentials::NDetail are not
+// part of the public YDB C++ SDK API and may change or be removed without notice.
+namespace NCredentials::NDetail {
+
+using TCredentialsProviderCreator = std::function<TCredentialsProviderPtr()>;
+
+class TOwningFacilityCredentialsProvider final : public ICredentialsProvider {
+public:
+    TOwningFacilityCredentialsProvider(std::shared_ptr<ICoreFacility> facility,
+                                       TCredentialsProviderPtr inner,
+                                       bool forwardAsync = false)
+        : Facility_(std::move(facility))
+        , Inner_(std::move(inner))
+        , ForwardAsync_(forwardAsync)
+    {}
+
+    std::string GetAuthInfo() const override {
+        return Inner_->GetAuthInfo();
+    }
+
+    NThreading::TFuture<std::string> GetAuthInfoAsync() const override {
+        return ForwardAsync_ ? Inner_->GetAuthInfoAsync() : ICredentialsProvider::GetAuthInfoAsync();
+    }
+
+    bool IsValid() const override {
+        return Inner_->IsValid();
+    }
+
+private:
+    // Reverse destruction keeps Facility_ alive while Inner_ stops.
+    std::shared_ptr<ICoreFacility> Facility_;
+    TCredentialsProviderPtr Inner_;
+    const bool ForwardAsync_;
+};
+
+// Process-wide weak cache for no-argument factory paths whose providers own their facilities.
+// Facility-bound providers must not use it: their callbacks belong to the supplied facility.
+TCredentialsProviderPtr GetOrCreateCachedProvider(
+    const std::string& identity,
+    TCredentialsProviderCreator createProvider);
+
+} // namespace NCredentials::NDetail
+
 class ICredentialsProviderFactory {
 public:
     virtual ~ICredentialsProviderFactory() = default;
     // deprecated, use CreateProvider(std::weak_ptr<ICoreFacility> facility) instead
     virtual TCredentialsProviderPtr CreateProvider() const = 0;
+    // The facility must outlive the returned provider.
     virtual TCredentialsProviderPtr CreateProvider([[maybe_unused]] std::weak_ptr<ICoreFacility> facility) const {
         return CreateProvider();
     }
diff --git a/include/ydb-cpp-sdk/client/types/virtual_timestamp.h b/include/ydb-cpp-sdk/client/types/virtual_timestamp.h
new file mode 100644
index 00000000000..e68de28f7c6
--- /dev/null
+++ b/include/ydb-cpp-sdk/client/types/virtual_timestamp.h
@@ -0,0 +1,32 @@
+#pragma once
+
+#include <src/api/protos/ydb_common.pb.h>
+
+#include <util/stream/output.h>
+
+#include <tuple>
+
+namespace NYdb::inline V3 {
+namespace NScheme {
+
+struct TVirtualTimestamp {
+    uint64_t PlanStep = 0;
+    uint64_t TxId = 0;
+
+    TVirtualTimestamp() = default;
+    TVirtualTimestamp(uint64_t planStep, uint64_t txId);
+    TVirtualTimestamp(const ::Ydb::VirtualTimestamp& proto);
+
+    std::string ToString() const;
+    void Out(IOutputStream& out) const;
+
+    bool operator<(const TVirtualTimestamp& rhs) const;
+    bool operator<=(const TVirtualTimestamp& rhs) const;
+    bool operator>(const TVirtualTimestamp& rhs) const;
+    bool operator>=(const TVirtualTimestamp& rhs) const;
+    bool operator==(const TVirtualTimestamp& rhs) const;
+    bool operator!=(const TVirtualTimestamp& rhs) const;
+};
+
+} // namespace NScheme
+} // namespace NYdb
diff --git a/include/ydb-cpp-sdk/library/operation_id/operation_id.h b/include/ydb-cpp-sdk/library/operation_id/operation_id.h
index 57b69eb2672..ec307262690 100644
--- a/include/ydb-cpp-sdk/library/operation_id/operation_id.h
+++ b/include/ydb-cpp-sdk/library/operation_id/operation_id.h
@@ -31,6 +31,7 @@ class TOperationId {
         COMPACTION = 13,
         FULL_BACKUP = 14,
         ANALYZE = 15,
+        SET_NOT_NULL = 16,
     };
 
     struct TData {
diff --git a/include/ydb-cpp-sdk/stlfwd.h b/include/ydb-cpp-sdk/stlfwd.h
index 77b97233f95..7375a154e7f 100644
--- a/include/ydb-cpp-sdk/stlfwd.h
+++ b/include/ydb-cpp-sdk/stlfwd.h
@@ -5,6 +5,7 @@
 #include <cstddef>
 #include <string>
 #include <string_view>
+#include <version>
 #include <utility>
 #include <vector>
 #include <list>
@@ -13,3 +14,7 @@
 #include <set>
 #include <filesystem>
 #include <functional>
+
+#ifdef __cpp_lib_format
+#include <format>
+#endif
diff --git a/library/cpp/CMakeLists.txt b/library/cpp/CMakeLists.txt
index b3cfe65ceee..b1f5ee76025 100644
--- a/library/cpp/CMakeLists.txt
+++ b/library/cpp/CMakeLists.txt
@@ -5,6 +5,7 @@ add_subdirectory(case_insensitive_string)
 add_subdirectory(cgiparam)
 add_subdirectory(charset)
 add_subdirectory(colorizer)
+add_subdirectory(containers/cow_string)
 add_subdirectory(containers/disjoint_interval_tree)
 add_subdirectory(containers/intrusive_rb_tree)
 add_subdirectory(containers/paged_vector)
@@ -18,6 +19,7 @@ add_subdirectory(digest/lower_case)
 add_subdirectory(digest/md5)
 add_subdirectory(digest/murmur)
 add_subdirectory(getopt)
+add_subdirectory(html/escape)
 add_subdirectory(http/fetch)
 add_subdirectory(http/io)
 add_subdirectory(http/misc)
diff --git a/library/cpp/blockcodecs/codecs.h b/library/cpp/blockcodecs/codecs.h
index fd499b54b0d..43a9244465e 100644
--- a/library/cpp/blockcodecs/codecs.h
+++ b/library/cpp/blockcodecs/codecs.h
@@ -1,3 +1,3 @@
 #pragma once
 
-#include <library/cpp/blockcodecs/core/codecs.h>
+#include <library/cpp/blockcodecs/core/codecs.h>  // IWYU pragma: export
diff --git a/library/cpp/blockcodecs/codecs/zstd/README.md b/library/cpp/blockcodecs/codecs/zstd/README.md
new file mode 100644
index 00000000000..98236f837d7
--- /dev/null
+++ b/library/cpp/blockcodecs/codecs/zstd/README.md
@@ -0,0 +1,40 @@
+Zstd codecs
+=============
+
+This library registers zstd compression codecs as `zstd_1`, ..., `zstd_22`. 
+Fast levels are also registered as `zstd_fast_1`, ..., `zstd_fast_7`.
+
+Measured codec performance on every level. Values below are provided just for reference, exact numbers may vary depending on CPU model and type of data being compressed.
+
+| Codec        | Comp. Ratio | Comp. Speed  (MBps) | Decomp. Speed (MBps) |
+|--------------|-------------|---------------------|----------------------| 
+| lz4          | 0.5876      | 913                 | 4100                 |
+| zstd_fast_7  | 0.5783      | 1066                | 2887                 |
+| zstd_fast_6  | 0.5733      | 1050                | 2870                 |
+| zstd_fast_5  | 0.5528      | 942                 | 2594                 |
+| zstd_fast_4  | 0.5529      | 918                 | 2659                 |
+| zstd_fast_3  | 0.5408      | 885                 | 2519                 |
+| zstd_fast_2  | 0.5132      | 769                 | 2374                 |
+| zstd_fast_1  | 0.5119      | 707                 | 2386                 |
+| zstd_1       | 0.4691      | 690                 | 1692                 |
+| zstd_2       | 0.4083      | 467                 | 1496                 |
+| zstd_3       | 0.3505      | 358                 | 1801                 |
+| zstd_4       | 0.3356      | 310                 | 1932                 |
+| zstd_5       | 0.3175      | 218                 | 1832                 |
+| zstd_6       | 0.3168      | 173                 | 1920                 |
+| zstd_7       | 0.3081      | 149                 | 1965                 |
+| zstd_8       | 0.3077      | 125                 | 2005                 |
+| zstd_9       | 0.272       | 128                 | 2179                 |
+| zstd_10      | 0.2693      | 98.5                | 2228                 |
+| zstd_11      | 0.2684      | 78.6                | 2185                 |
+| zstd_12      | 0.2682      | 71.1                | 2231                 |
+| zstd_13      | 0.2687      | 27.8                | 2102                 |
+| zstd_14      | 0.2676      | 24                  | 2024                 |
+| zstd_15      | 0.2663      | 18.8                | 2225                 |
+| zstd_16      | 0.257       | 15.2                | 2093                 |
+| zstd_17      | 0.2521      | 12.3                | 2072                 |
+| zstd_18      | 0.241       | 9.68                | 1696                 |
+| zstd_19      | 0.2395      | 7.97                | 1709                 |
+| zstd_20      | 0.2337      | 6.26                | 1520                 |
+| zstd_21      | 0.2255      | 5.22                | 1442                 |
+| zstd_22      | 0.2037      | 3.88                | 1490                 |
diff --git a/library/cpp/blockcodecs/codecs/zstd/zstd.cpp b/library/cpp/blockcodecs/codecs/zstd/zstd.cpp
index bcbc4005840..02133c9c04d 100644
--- a/library/cpp/blockcodecs/codecs/zstd/zstd.cpp
+++ b/library/cpp/blockcodecs/codecs/zstd/zstd.cpp
@@ -5,36 +5,38 @@
 #define ZSTD_STATIC_LINKING_ONLY
 #include <zstd.h>
 
+#include <utility>
+
 using namespace NBlockCodecs;
 
 namespace {
     struct TZStd08Codec: public TAddLengthCodec<TZStd08Codec> {
-        inline TZStd08Codec(unsigned level)
+        TZStd08Codec(int level, TString name)
             : Level(level)
-            , MyName(TStringBuf("zstd08_") + ToString(Level))
+            , MyName(std::move(name))
         {
         }
 
-        static inline size_t CheckError(size_t ret, const char* what) {
-            if (ZSTD_isError(ret)) {
+        static size_t CheckError(size_t ret, const char* what) {
+            if (Y_UNLIKELY(ZSTD_isError(ret))) {
                 ythrow yexception() << what << TStringBuf(" zstd error: ") << ZSTD_getErrorName(ret);
             }
 
             return ret;
         }
 
-        static inline size_t DoMaxCompressedLength(size_t l) noexcept {
+        static size_t DoMaxCompressedLength(size_t l) noexcept {
             return ZSTD_compressBound(l);
         }
 
-        inline size_t DoCompress(const TData& in, void* out) const {
+        size_t DoCompress(const TData& in, void* out) const {
             return CheckError(ZSTD_compress(out, DoMaxCompressedLength(in.size()), in.data(), in.size(), Level), "compress");
         }
 
-        inline void DoDecompress(const TData& in, void* out, size_t dsize) const {
+        static void DoDecompress(const TData& in, void* out, size_t dsize) {
             const size_t res = CheckError(ZSTD_decompress(out, dsize, in.data(), in.size()), "decompress");
 
-            if (res != dsize) {
+            if (Y_UNLIKELY(res != dsize)) {
                 ythrow TDecompressError(dsize, res);
             }
         }
@@ -43,15 +45,20 @@ namespace {
             return MyName;
         }
 
-        const unsigned Level;
+        const int Level;
         const TString MyName;
     };
 
     struct TZStd08Registrar {
         TZStd08Registrar() {
             for (int i = 1; i <= ZSTD_maxCLevel(); ++i) {
-                RegisterCodec(MakeHolder<TZStd08Codec>(i));
-                RegisterAlias("zstd_" + ToString(i), "zstd08_" + ToString(i));
+                const TString name = "zstd08_"sv + ToString(i);
+                RegisterCodec(MakeHolder<TZStd08Codec>(i, name));
+                RegisterAlias("zstd_"sv + ToString(i), name);
+            }
+
+            for (int i = 1; i <= 7; ++i) {
+                RegisterCodec(MakeHolder<TZStd08Codec>(-i, "zstd_fast_"sv + ToString(i)));
             }
         }
     };
diff --git a/library/cpp/blockcodecs/codecs_ut.cpp b/library/cpp/blockcodecs/codecs_ut.cpp
index bfe5a236909..e167816680e 100644
--- a/library/cpp/blockcodecs/codecs_ut.cpp
+++ b/library/cpp/blockcodecs/codecs_ut.cpp
@@ -320,7 +320,8 @@ Y_UNIT_TEST_SUITE(TBlockCodecsTest) {
             "zstd08_1,zstd08_10,zstd08_11,zstd08_12,zstd08_13,zstd08_14,zstd08_15,zstd08_16,zstd08_17,zstd08_18,"
             "zstd08_19,zstd08_2,zstd08_20,zstd08_21,zstd08_22,zstd08_3,zstd08_4,zstd08_5,zstd08_6,zstd08_7,zstd08_8,"
             "zstd08_9,zstd_1,zstd_10,zstd_11,zstd_12,zstd_13,zstd_14,zstd_15,zstd_16,zstd_17,zstd_18,zstd_19,zstd_2,"
-            "zstd_20,zstd_21,zstd_22,zstd_3,zstd_4,zstd_5,zstd_6,zstd_7,zstd_8,zstd_9";
+            "zstd_20,zstd_21,zstd_22,zstd_3,zstd_4,zstd_5,zstd_6,zstd_7,zstd_8,zstd_9,"
+            "zstd_fast_1,zstd_fast_2,zstd_fast_3,zstd_fast_4,zstd_fast_5,zstd_fast_6,zstd_fast_7";
 
         UNIT_ASSERT_VALUES_EQUAL(ALL_CODECS, JoinSeq(",", ListAllCodecs()));
     }
diff --git a/library/cpp/blockcodecs/core/codecs.h b/library/cpp/blockcodecs/core/codecs.h
index 9c93c002748..61efc04744a 100644
--- a/library/cpp/blockcodecs/core/codecs.h
+++ b/library/cpp/blockcodecs/core/codecs.h
@@ -25,8 +25,15 @@ namespace NBlockCodecs {
             : TStringBuf((const char*)t.Data(), t.Size())
         {
         }
+
     };
 
+    template <>
+    inline TData::TData(const TString& t)
+        : TStringBuf((const char*)t.data(), t.size())
+    {
+    }
+
     struct TCodecError: public yexception {
     };
 
diff --git a/library/cpp/blockcodecs/fuzz/main.cpp b/library/cpp/blockcodecs/fuzz/main.cpp
index a89fee7ab73..be4d684db2d 100644
--- a/library/cpp/blockcodecs/fuzz/main.cpp
+++ b/library/cpp/blockcodecs/fuzz/main.cpp
@@ -1,5 +1,4 @@
 #include <contrib/libs/protobuf-mutator/src/libfuzzer/libfuzzer_macro.h>
-#include <google/protobuf/stubs/logging.h>
 
 #include <library/cpp/blockcodecs/codecs.h>
 #include <library/cpp/blockcodecs/fuzz/proto/case.pb.h>
diff --git a/library/cpp/cache/cache.h b/library/cpp/cache/cache.h
index 9fe98d53666..25906d1a024 100644
--- a/library/cpp/cache/cache.h
+++ b/library/cpp/cache/cache.h
@@ -465,7 +465,7 @@ class TLWList {
     size_t MaxSize;
 };
 
-template <typename TKey, typename TValue, typename TListType, typename TDeleter, typename TAllocator = std::allocator<void>>
+template <typename TKey, typename TValue, typename TListType, typename TDeleter, typename TAllocator = std::allocator<typename TListType::TItem>>
 class TCache {
     typedef typename TListType::TItem TItem;
     typedef typename TItem::THash THash;
@@ -708,7 +708,7 @@ struct TNoopDelete {
     }
 };
 
-template <typename TKey, typename TValue, typename TDeleter = TNoopDelete, class TSizeProvider = TUniformSizeProvider<TValue>, typename TAllocator = std::allocator<void>>
+template <typename TKey, typename TValue, typename TDeleter = TNoopDelete, class TSizeProvider = TUniformSizeProvider<TValue>, typename TAllocator = std::allocator<typename TLRUList<TKey, TValue, TSizeProvider>::TItem>>
 class TLRUCache: public TCache<TKey, TValue, TLRUList<TKey, TValue, TSizeProvider>, TDeleter, TAllocator> {
     using TListType = TLRUList<TKey, TValue, TSizeProvider>;
     typedef TCache<TKey, TValue, TListType, TDeleter, TAllocator> TBase;
@@ -735,7 +735,7 @@ class TLRUCache: public TCache<TKey, TValue, TLRUList<TKey, TValue, TSizeProvide
     }
 };
 
-template <typename TKey, typename TValue, typename TDeleter = TNoopDelete, typename TAllocator = std::allocator<void>, class TSizeProvider = TUniformSizeProvider<TValue>>
+template <typename TKey, typename TValue, typename TDeleter = TNoopDelete, typename TAllocator = std::allocator<TKey>, class TSizeProvider = TUniformSizeProvider<TValue>>
 class TLFUCache: public TCache<TKey, TValue, TLFUList<TKey, TValue, TSizeProvider>, TDeleter, TAllocator> {
     typedef TCache<TKey, TValue, TLFUList<TKey, TValue, TSizeProvider>, TDeleter, TAllocator> TBase;
     using TListType = TLFUList<TKey, TValue, TSizeProvider>;
@@ -760,7 +760,7 @@ class TLFUCache: public TCache<TKey, TValue, TLFUList<TKey, TValue, TSizeProvide
 // Least Weighted cache
 // discards the least weighted items first
 // doesn't support promotion
-template <typename TKey, typename TValue, typename TWeight, typename TWeighter, typename TDeleter = TNoopDelete, typename TAllocator = std::allocator<void>>
+template <typename TKey, typename TValue, typename TWeight, typename TWeighter, typename TDeleter = TNoopDelete, typename TAllocator = std::allocator<typename TLWList<TKey, TValue, TWeight, TWeighter>::TItem>>
 class TLWCache: public TCache<TKey, TValue, TLWList<TKey, TValue, TWeight, TWeighter>, TDeleter, TAllocator> {
     typedef TCache<TKey, TValue, TLWList<TKey, TValue, TWeight, TWeighter>, TDeleter, TAllocator> TBase;
     using TListType = TLWList<TKey, TValue, TWeight, TWeighter>;
diff --git a/library/cpp/cache/thread_safe_cache.h b/library/cpp/cache/thread_safe_cache.h
index e77d1a45fd8..82b68062777 100644
--- a/library/cpp/cache/thread_safe_cache.h
+++ b/library/cpp/cache/thread_safe_cache.h
@@ -3,6 +3,7 @@
 #include "cache.h"
 
 #include <util/generic/singleton.h>
+#include <util/generic/ylimits.h>
 #include <util/system/rwlock.h>
 
 namespace NPrivate {
@@ -51,12 +52,20 @@ namespace NPrivate {
 
         const TPtr GetOrNull(TArgs... args) {
             Key key = Callbacks.GetKey(args...);
-            TReadGuard r(Mutex);
-            auto iter = Cache.Find(key);
-            if (iter == Cache.End()) {
-                return nullptr;
+            switch (GettersPromotionPolicy) {
+                case EGettersPromotionPolicy::Promoted: {
+                    TWriteGuard r(Mutex);
+                    if (auto iter = Cache.Find(key); iter != Cache.End())
+                        return iter.Value();
+                }
+                break;
+                case EGettersPromotionPolicy::Unpromoted: {
+                    TReadGuard r(Mutex);
+                    if (auto iter = Cache.Find(key); iter != Cache.End())
+                        return iter.Value();
+                }
             }
-            return iter.Value();
+            return nullptr;
         }
 
         const TPtr Get(TArgs... args) const {
diff --git a/library/cpp/cache/ut/cache_ut.cpp b/library/cpp/cache/ut/cache_ut.cpp
index 16f29b29d1f..c4c829cdb7d 100644
--- a/library/cpp/cache/ut/cache_ut.cpp
+++ b/library/cpp/cache/ut/cache_ut.cpp
@@ -2,6 +2,10 @@
 #include <library/cpp/cache/thread_safe_cache.h>
 #include <library/cpp/testing/unittest/registar.h>
 
+#include <util/thread/pool.h>
+#include <util/string/cast.h>
+#include <util/random/random.h>
+
 struct TStrokaWeighter {
     static size_t Weight(const TString& s) {
         return s.size();
@@ -536,6 +540,53 @@ Y_UNIT_TEST_SUITE(TThreadSafeCacheTest) {
     }
 }
 
+Y_UNIT_TEST_SUITE(TThreadSafeLRUCacheMultiThreadTest) {
+    typedef TThreadSafeLRUCache<ui32, TString, ui32> TCache;
+
+    class TSimpleCallbacks: public TCache::ICallbacks {
+    public:
+        TKey GetKey(ui32 i) const override {
+            return i;
+        }
+        TValue* CreateObject(ui32 i) const override {
+            Y_UNUSED(i);
+            return nullptr;
+        }
+    };
+
+    Y_UNIT_TEST(GetOrNullMultiThreadTest) {
+        const size_t poolSize = 8;
+        const size_t passCnt = 128;
+        const size_t tasksCnt = 128;
+
+        TRWMutex lock;
+        TThreadPool pool;
+        TSimpleCallbacks callbacks;
+        TCache cache(callbacks, poolSize);
+
+        for (size_t i = 0; i < poolSize; ++i) {
+            cache.Insert(i, MakeAtomicShared<TString>(ToString(i)));
+        }
+
+        pool.Start(poolSize);
+        {
+            TWriteGuard wGruard(lock);
+            for (size_t i = 0; i < tasksCnt; ++i) {
+                pool.SafeAddFunc([&lock, &cache]() {
+                    TReadGuard rGuard(lock);
+                    for (size_t j = 0; j < passCnt; ++j) {
+                        UNIT_ASSERT(cache.GetOrNull(RandomNumber<size_t>(poolSize)) != nullptr);
+                    }
+                });
+            }
+        } // start race
+        pool.Stop();
+        for (size_t i = 0; i < cache.Size(); ++i) {
+            UNIT_ASSERT(cache.GetOrNull(i) != nullptr);
+        }
+    }
+}
+
 Y_UNIT_TEST_SUITE(TThreadSafeCacheUnsafeTest) {
     typedef TThreadSafeCache<ui32, TString, ui32> TCache;
 
diff --git a/library/cpp/cgiparam/cgiparam.cpp b/library/cpp/cgiparam/cgiparam.cpp
index e2c9c0dbe55..503213719e5 100644
--- a/library/cpp/cgiparam/cgiparam.cpp
+++ b/library/cpp/cgiparam/cgiparam.cpp
@@ -11,12 +11,22 @@ TCgiParameters::TCgiParameters(std::initializer_list<std::pair<TString, TString>
     }
 }
 
-const TString& TCgiParameters::Get(const TStringBuf name, size_t numOfValue) const noexcept {
+const TString& TCgiParameters::Get(const TStringBuf name, size_t numOfValue) const noexcept Y_LIFETIME_BOUND {
     const auto it = Find(name, numOfValue);
 
     return end() == it ? Default<TString>() : it->second;
 }
 
+const TString& TCgiParameters::GetLast(const TStringBuf name) const noexcept {
+    if (auto it = this->upper_bound(name); it != this->begin()) {
+        --it;
+        if (it->first == name) {
+            return it->second;
+        }
+    }
+    return Default<TString>();
+}
+
 bool TCgiParameters::Erase(const TStringBuf name, size_t pos) {
     const auto pair = equal_range(name);
 
@@ -221,7 +231,7 @@ TString TCgiParameters::QuotedPrint(const char* safe) const {
     return res;
 }
 
-TCgiParameters::const_iterator TCgiParameters::Find(const TStringBuf name, size_t pos) const noexcept {
+TCgiParameters::const_iterator TCgiParameters::Find(const TStringBuf name, size_t pos) const noexcept Y_LIFETIME_BOUND {
     const auto pair = equal_range(name);
 
     for (auto it = pair.first; it != pair.second; ++it, --pos) {
@@ -265,7 +275,7 @@ TQuickCgiParam::TQuickCgiParam(const TStringBuf cgiParamStr) {
     }
 }
 
-const TStringBuf& TQuickCgiParam::Get(const TStringBuf name, size_t pos) const noexcept {
+TStringBuf TQuickCgiParam::Get(const TStringBuf name, size_t pos) const noexcept Y_LIFETIME_BOUND {
     const auto pair = equal_range(name);
 
     for (auto it = pair.first; it != pair.second; ++it, --pos) {
@@ -274,7 +284,7 @@ const TStringBuf& TQuickCgiParam::Get(const TStringBuf name, size_t pos) const n
         }
     }
 
-    return Default<TStringBuf>();
+    return TStringBuf{};
 }
 
 bool TQuickCgiParam::Has(const TStringBuf name, const TStringBuf value) const noexcept {
diff --git a/library/cpp/cgiparam/cgiparam.h b/library/cpp/cgiparam/cgiparam.h
index cbb212f6f06..104e3f401a8 100644
--- a/library/cpp/cgiparam/cgiparam.h
+++ b/library/cpp/cgiparam/cgiparam.h
@@ -61,7 +61,7 @@ class TCgiParameters: public TMultiMap<TString, TString> {
     }
 
     Y_PURE_FUNCTION
-    const_iterator Find(const TStringBuf name, size_t numOfValue = 0) const noexcept;
+    const_iterator Find(const TStringBuf name, size_t numOfValue = 0) const noexcept Y_LIFETIME_BOUND;
 
     Y_PURE_FUNCTION
     bool Has(const TStringBuf name, const TStringBuf value) const noexcept;
@@ -76,23 +76,32 @@ class TCgiParameters: public TMultiMap<TString, TString> {
      * @note The returned value is CGI-unescaped.
      */
     Y_PURE_FUNCTION
-    const TString& Get(const TStringBuf name, size_t numOfValue = 0) const noexcept;
+    const TString& Get(const TStringBuf name, size_t numOfValue = 0) const noexcept Y_LIFETIME_BOUND;
+
+    /// Returns the last value by name
+    /**
+     * @note The returned value is CGI-unescaped.
+     */
+    Y_PURE_FUNCTION
+    const TString& GetLast(const TStringBuf name) const noexcept Y_LIFETIME_BOUND;
 
     void InsertEscaped(const TStringBuf name, const TStringBuf value);
 
 #if !defined(__GLIBCXX__)
     template <typename TName, typename TValue>
-    inline void InsertUnescaped(TName&& name, TValue&& value) {
+    inline TCgiParameters& InsertUnescaped(TName&& name, TValue&& value) {
         // TStringBuf use as TName or TValue is C++17 actually.
         // There is no pair constructor available in C++14 when required type
         // is not implicitly constructible from given type.
         // But libc++ pair allows this with C++14.
         emplace(std::forward<TName>(name), std::forward<TValue>(value));
+        return *this;
     }
 #else
     template <typename TName, typename TValue>
-    inline void InsertUnescaped(TName&& name, TValue&& value) {
+    inline TCgiParameters& InsertUnescaped(TName&& name, TValue&& value) {
         emplace(TString(name), TString(value));
+        return *this;
     }
 #endif
 
@@ -116,24 +125,24 @@ class TCgiParameters: public TMultiMap<TString, TString> {
     bool Erase(const TStringBuf name, const TStringBuf val);
     bool ErasePattern(const TStringBuf name, const TStringBuf pat);
 
-    inline const char* FormField(const TStringBuf name, size_t numOfValue = 0) const {
+    inline const char* FormField(const TStringBuf name, size_t numOfValue = 0) const Y_LIFETIME_BOUND {
         const_iterator it = Find(name, numOfValue);
 
         if (it == end()) {
             return nullptr;
         }
 
-        return it->second.data();
+        return it->second.c_str();
     }
 
-    inline TStringBuf FormFieldBuf(const TStringBuf name, size_t numOfValue = 0) const {
+    inline TStringBuf FormFieldBuf(const TStringBuf name, size_t numOfValue = 0) const Y_LIFETIME_BOUND {
         const_iterator it = Find(name, numOfValue);
 
         if (it == end()) {
-            return nullptr;
+            return TStringBuf{};
         }
 
-        return it->second.data();
+        return it->second;
     }
 };
 
@@ -181,7 +190,7 @@ class TQuickCgiParam: public TMultiMap<TStringBuf, TStringBuf> {
     }
 
     Y_PURE_FUNCTION
-    const TStringBuf& Get(const TStringBuf name, size_t numOfValue = 0) const noexcept;
+    TStringBuf Get(const TStringBuf name, size_t numOfValue = 0) const noexcept Y_LIFETIME_BOUND;
 
 private:
     TString UnescapeBuf;
diff --git a/library/cpp/cgiparam/cgiparam_ut.cpp b/library/cpp/cgiparam/cgiparam_ut.cpp
index de6d23882dc..c82f0344d2a 100644
--- a/library/cpp/cgiparam/cgiparam_ut.cpp
+++ b/library/cpp/cgiparam/cgiparam_ut.cpp
@@ -210,8 +210,10 @@ Y_UNIT_TEST_SUITE(TCgiParametersTest) {
         UNIT_ASSERT_VALUES_EQUAL(c.NumOfValues("b"), 1u);
 
         UNIT_ASSERT_VALUES_EQUAL(c.Get("b"), "b1");
+        UNIT_ASSERT_VALUES_EQUAL(c.GetLast("b"), "b1");
         UNIT_ASSERT_VALUES_EQUAL(c.Get("a", 0), "a1");
         UNIT_ASSERT_VALUES_EQUAL(c.Get("a", 1), "a2");
+        UNIT_ASSERT_VALUES_EQUAL(c.GetLast("a"), "a2");
 
         UNIT_ASSERT_VALUES_EQUAL(c.Print(), "a=a1&a=a2&b=b1");
     }
diff --git a/library/cpp/charset/wide_ut.cpp b/library/cpp/charset/wide_ut.cpp
index 93567161bab..4f5a666cb8e 100644
--- a/library/cpp/charset/wide_ut.cpp
+++ b/library/cpp/charset/wide_ut.cpp
@@ -10,6 +10,8 @@
 
 #include <algorithm>
 
+extern const int TStringUseCow;
+
 namespace {
     //! three UTF8 encoded russian letters (A, B, V)
     const char yandexCyrillicAlphabet[] =
@@ -264,10 +266,12 @@ void TConversionTest::TestRecodeIntoString() {
     TUtf16String copy = sUnicode; // increase ref-counter
     wres = NDetail::Recode<char>(UTF8Text, sUnicode, CODES_UTF8);
     UNIT_ASSERT(sUnicode == UnicodeText); // same content
+    if (TStringUseCow) {
 #ifndef TSTRING_IS_STD_STRING
-    UNIT_ASSERT(sUnicode.data() != wdata);      // re-allocated (shared buffer supplied)
-    UNIT_ASSERT(sUnicode.data() == wres.data());      // same buffer
+        UNIT_ASSERT(sUnicode.data() != wdata);      // re-allocated (shared buffer supplied)
+        UNIT_ASSERT(sUnicode.data() == wres.data());      // same buffer
 #endif
+    }
     UNIT_ASSERT(sUnicode.size() == wres.size());      // same content
 }
 
diff --git a/library/cpp/colorizer/ut/colorizer_ut.cpp b/library/cpp/colorizer/ut/colorizer_ut.cpp
index 20341440aff..2512651861e 100644
--- a/library/cpp/colorizer/ut/colorizer_ut.cpp
+++ b/library/cpp/colorizer/ut/colorizer_ut.cpp
@@ -12,7 +12,7 @@ Y_UNIT_TEST_SUITE(ColorizerTest) {
         UNIT_ASSERT_STRINGS_EQUAL(EscapeC(colors.BlueColor()), "\\x1B[22;34m");
         UNIT_ASSERT_STRINGS_EQUAL(EscapeC(colors.ForeBlue()), "\\x1B[34m");
         colors.Disable();
-        UNIT_ASSERT(colors.BlueColor().Empty());
+        UNIT_ASSERT(colors.BlueColor().empty());
     }
 
     Y_UNIT_TEST(ResettingTest) {
diff --git a/library/cpp/containers/cow_string/CMakeLists.txt b/library/cpp/containers/cow_string/CMakeLists.txt
new file mode 100644
index 00000000000..64a93714373
--- /dev/null
+++ b/library/cpp/containers/cow_string/CMakeLists.txt
@@ -0,0 +1,30 @@
+if (YDB_SDK_TESTS)
+  add_ydb_test(NAME containers-cow_string-medium-ut
+    SOURCES
+      ut_medium/cow_string_medium_ut.cpp
+    LINK_LIBRARIES
+      containers-cow_string
+      cpp-testing-unittest_main
+    LABELS
+      medium
+  )
+  target_include_directories(containers-cow_string-medium-ut PRIVATE ${CMAKE_CURRENT_SOURCE_DIR})
+endif()
+
+_ydb_sdk_add_library(containers-cow_string)
+
+target_link_libraries(containers-cow_string
+  PUBLIC
+    yutil
+)
+
+target_sources(containers-cow_string
+  PRIVATE
+    cow_string.cpp
+    output.cpp
+    reverse.cpp
+    subst.cpp
+    ysaveload.cpp
+)
+
+_ydb_sdk_install_targets(TARGETS containers-cow_string)
diff --git a/library/cpp/containers/cow_string/README.md b/library/cpp/containers/cow_string/README.md
new file mode 100644
index 00000000000..d6aea7c734c
--- /dev/null
+++ b/library/cpp/containers/cow_string/README.md
@@ -0,0 +1,9 @@
+## Copy-on-Write based string implementation
+
+Drop in replacement for TSring in the code which deeply relies on COW-semantic.
+
+ * `#include <library/cpp/containers/cow_string/cow_string.h>` main header of the library with the COW-string class itself
+ * `#include <library/cpp/containers/cow_string/reverse.h>` in-place strings reverse implementation
+ * `#include <library/cpp/containers/cow_string/str_stl.h>` comparator/hashers/... template specialization allowing to use TCowString in tree-based or hash-based sets/maps.
+ * `#include <library/cpp/containers/cow_string/subst.h>` TCowString implementation of the substitution function provided for TString in `<util/string/subst.h>`.
+ * `#include <library/cpp/containers/cow_string/ysaveload.h>` TCowString support of the `<util/ysaveload.h>` serialization/deserialization.
diff --git a/library/cpp/containers/cow_string/cow_string.cpp b/library/cpp/containers/cow_string/cow_string.cpp
new file mode 100644
index 00000000000..87dc0ad99ec
--- /dev/null
+++ b/library/cpp/containers/cow_string/cow_string.cpp
@@ -0,0 +1,280 @@
+#include "cow_string.h"
+
+#include <util/string/ascii.h>
+#include <util/system/sanitizers.h>
+#include <util/system/sys_alloc.h>
+#include <util/charset/wide.h>
+
+#include <iostream>
+
+template <bool stopOnFirstModification, typename TCharType, typename F>
+static bool ModifySequence(TCharType*& p, const TCharType* const pe, F&& f) {
+    while (p != pe) {
+        const auto symbol = ReadSymbol(p, pe);
+        const auto modified = f(symbol);
+        if (symbol != modified) {
+            if (stopOnFirstModification) {
+                return true;
+            }
+
+            WriteSymbol(modified, p); // also moves `p` forward
+        } else {
+            p = SkipSymbol(p, pe);
+        }
+    }
+
+    return false;
+}
+
+template <bool stopOnFirstModification, typename TCharType, typename F>
+static bool ModifySequence(const TCharType*& p, const TCharType* const pe, TCharType*& out, F&& f) {
+    while (p != pe) {
+        const auto symbol = stopOnFirstModification ? ReadSymbol(p, pe) : ReadSymbolAndAdvance(p, pe);
+        const auto modified = f(symbol);
+
+        if (stopOnFirstModification) {
+            if (symbol != modified) {
+                return true;
+            }
+
+            p = SkipSymbol(p, pe);
+        }
+
+        WriteSymbol(modified, out);
+    }
+
+    return false;
+}
+
+template <class TStringType>
+static void DetachAndFixPointers(TStringType& text, typename TStringType::value_type*& p, const typename TStringType::value_type*& pe) {
+    const auto pos = p - text.data();
+    const auto count = pe - p;
+    p = text.Detach() + pos;
+    pe = p + count;
+}
+
+template <class TStringType, typename F>
+static bool ModifyStringSymbolwise(TStringType& text, size_t pos, size_t count, F&& f) {
+    // TODO(yazevnul): this is done for consistency with `TUtf16String::to_lower` and friends
+    // at r2914050, maybe worth replacing them with asserts. Also see the same code in `ToTitle`.
+    pos = pos < text.size() ? pos : text.size();
+    count = count < text.size() - pos ? count : text.size() - pos;
+
+    // TUtf16String is refcounted and it's `data` method return pointer to the constant memory.
+    // To simplify the code we do a `const_cast`, though first write to the memory will be done only
+    // after we call `Detach()` and get pointer to a writable piece of memory.
+    auto* p = const_cast<typename TStringType::value_type*>(text.data() + pos);
+    const auto* pe = text.data() + pos + count;
+
+    if (ModifySequence<true>(p, pe, f)) {
+        DetachAndFixPointers(text, p, pe);
+        ModifySequence<false>(p, pe, f);
+        return true;
+    }
+
+    return false;
+}
+
+std::ostream& operator<<(std::ostream& os, const TCowString& s) {
+    return os.write(s.data(), s.size());
+}
+
+std::istream& operator>>(std::istream& is, TCowString& s) {
+    return is >> s.MutRef();
+}
+
+template <>
+bool TBasicCowString<char, std::char_traits<char>>::to_lower(size_t pos, size_t n) {
+    return Transform([](size_t, char c) { return AsciiToLower(c); }, pos, n);
+}
+
+template <>
+bool TBasicCowString<char, std::char_traits<char>>::to_upper(size_t pos, size_t n) {
+    return Transform([](size_t, char c) { return AsciiToUpper(c); }, pos, n);
+}
+
+template <>
+bool TBasicCowString<char, std::char_traits<char>>::to_title(size_t pos, size_t n) {
+    if (n == 0) {
+        return false;
+    }
+    bool changed = to_upper(pos, 1);
+    return to_lower(pos + 1, n - 1) || changed;
+}
+
+template <>
+TUtf16CowString&
+TBasicCowString<wchar16, std::char_traits<wchar16>>::AppendAscii(const ::TStringBuf& s) {
+    ReserveAndResize(size() + s.size());
+
+    auto dst = begin() + size() - s.size();
+
+    for (const char* src = s.data(); dst != end(); ++dst, ++src) {
+        *dst = static_cast<wchar16>(*src);
+    }
+
+    return *this;
+}
+
+template <>
+TUtf16CowString&
+TBasicCowString<wchar16, std::char_traits<wchar16>>::AppendUtf8(const ::TStringBuf& s) {
+    size_t oldSize = size();
+    ReserveAndResize(size() + s.size() * 4);
+    size_t written = 0;
+    size_t pos = UTF8ToWideImpl(s.data(), s.size(), begin() + oldSize, written);
+    if (pos != s.size()) {
+        ythrow yexception() << "failed to decode UTF-8 string at pos " << pos << ::NDetail::InStringMsg(s.data(), s.size());
+    }
+    resize(oldSize + written);
+
+    return *this;
+}
+
+template <>
+bool TBasicCowString<wchar16, std::char_traits<wchar16>>::to_lower(size_t pos, size_t n) {
+    const auto f = [](const wchar32 s) { return ToLower(s); };
+    return ModifyStringSymbolwise(*this, pos, n, f);
+}
+
+template <>
+bool TBasicCowString<wchar16, std::char_traits<wchar16>>::to_upper(size_t pos, size_t n) {
+    const auto f = [](const wchar32 s) { return ToUpper(s); };
+    return ModifyStringSymbolwise(*this, pos, n, f);
+}
+
+template <>
+bool TBasicCowString<wchar16, std::char_traits<wchar16>>::to_title(size_t pos, size_t nn) {
+    if (!*this) {
+        return false;
+    }
+
+    pos = pos < this->size() ? pos : this->size();
+    nn = nn < this->size() - pos ? nn : this->size() - pos;
+
+    const auto toLower = [](const wchar32 s) { return ToLower(s); };
+
+    auto* p = const_cast<wchar16*>(this->data() + pos);
+    const auto* pe = this->data() + pos + nn;
+
+    const auto firstSymbol = ReadSymbol(p, pe);
+    if (firstSymbol == ToTitle(firstSymbol)) {
+        p = SkipSymbol(p, pe);
+        if (ModifySequence<true>(p, pe, toLower)) {
+            DetachAndFixPointers(*this, p, pe);
+            ModifySequence<false>(p, pe, toLower);
+            return true;
+        }
+    } else {
+        DetachAndFixPointers(*this, p, pe);
+        WriteSymbol(ToTitle(ReadSymbol(p, pe)), p); // also moves `p` forward
+        ModifySequence<false>(p, pe, toLower);
+        return true;
+    }
+
+    return false;
+}
+
+template <>
+TUtf32CowString&
+TBasicCowString<wchar32, std::char_traits<wchar32>>::AppendAscii(const ::TStringBuf& s) {
+    ReserveAndResize(size() + s.size());
+
+    auto dst = begin() + size() - s.size();
+
+    for (const char* src = s.data(); dst != end(); ++dst, ++src) {
+        *dst = static_cast<wchar32>(*src);
+    }
+
+    return *this;
+}
+
+template <>
+TBasicCowString<char, std::char_traits<char>>&
+TBasicCowString<char, std::char_traits<char>>::AppendUtf16(const ::TWtringBuf& s) {
+    const size_t oldSize = size();
+    ReserveAndResize(size() + WideToUTF8BufferSize(s.size()));
+
+    size_t written = 0;
+    WideToUTF8(s.data(), s.size(), begin() + oldSize, written);
+
+    resize(oldSize + written);
+
+    return *this;
+}
+
+template <>
+TUtf32CowString&
+TBasicCowString<wchar32, std::char_traits<wchar32>>::AppendUtf8(const ::TStringBuf& s) {
+    size_t oldSize = size();
+    ReserveAndResize(size() + s.size() * 4);
+    size_t written = 0;
+    size_t pos = UTF8ToWideImpl(s.data(), s.size(), begin() + oldSize, written);
+    if (pos != s.size()) {
+        ythrow yexception() << "failed to decode UTF-8 string at pos " << pos << ::NDetail::InStringMsg(s.data(), s.size());
+    }
+    resize(oldSize + written);
+
+    return *this;
+}
+
+template <>
+TUtf32CowString&
+TBasicCowString<wchar32, std::char_traits<wchar32>>::AppendUtf16(const ::TWtringBuf& s) {
+    size_t oldSize = size();
+    ReserveAndResize(size() + s.size() * 2);
+
+    wchar32* oldEnd = begin() + oldSize;
+    wchar32* end = oldEnd;
+    NDetail::UTF16ToUTF32ImplScalar(s.data(), s.data() + s.size(), end);
+    size_t written = end - oldEnd;
+
+    resize(oldSize + written);
+
+    return *this;
+}
+
+template <>
+bool TBasicCowString<wchar32, std::char_traits<wchar32>>::to_lower(size_t pos, size_t n) {
+    const auto f = [](const wchar32 s) { return ToLower(s); };
+    return ModifyStringSymbolwise(*this, pos, n, f);
+}
+
+template <>
+bool TBasicCowString<wchar32, std::char_traits<wchar32>>::to_upper(size_t pos, size_t n) {
+    const auto f = [](const wchar32 s) { return ToUpper(s); };
+    return ModifyStringSymbolwise(*this, pos, n, f);
+}
+
+template <>
+bool TBasicCowString<wchar32, std::char_traits<wchar32>>::to_title(size_t pos, size_t n) {
+    if (!*this) {
+        return false;
+    }
+
+    pos = pos < this->size() ? pos : this->size();
+    n = n < this->size() - pos ? n : this->size() - pos;
+
+    const auto toLower = [](const wchar32 s) { return ToLower(s); };
+
+    auto* p = const_cast<wchar32*>(this->data() + pos);
+    const auto* pe = this->data() + pos + n;
+
+    const auto firstSymbol = *p;
+    if (firstSymbol == ToTitle(firstSymbol)) {
+        p += 1;
+        if (ModifySequence<true>(p, pe, toLower)) {
+            DetachAndFixPointers(*this, p, pe);
+            ModifySequence<false>(p, pe, toLower);
+            return true;
+        }
+    } else {
+        DetachAndFixPointers(*this, p, pe);
+        WriteSymbol(ToTitle(ReadSymbol(p, pe)), p); // also moves `p` forward
+        ModifySequence<false>(p, pe, toLower);
+        return true;
+    }
+
+    return false;
+}
diff --git a/library/cpp/containers/cow_string/cow_string.h b/library/cpp/containers/cow_string/cow_string.h
new file mode 100644
index 00000000000..34dcff81e8a
--- /dev/null
+++ b/library/cpp/containers/cow_string/cow_string.h
@@ -0,0 +1,1016 @@
+#pragma once
+
+#include <util/generic/string.h>
+
+template <typename TCharType, typename TTraits = std::char_traits<TCharType>>
+class Y_EMPTY_BASES TBasicCowString: public TStringBase<TBasicCowString<TCharType, TTraits>, TCharType, TTraits>,
+                                     public TStdStringCompatibilityBase<TBasicString<TCharType, TTraits>, TCharType, TTraits> {
+public:
+    // TODO: Move to private section
+    using TBase = TStringBase<TBasicCowString, TCharType, TTraits>;
+    using TStringType = std::basic_string<TCharType, TTraits>;
+    using TStdStr = TStdString<TStringType>;
+    using TStorage = TIntrusivePtr<TStdStr, TStringPtrOps<TStdStr>>;
+    using reference = TBasicCharRef<TBasicCowString>;
+    using char_type = TCharType; // TODO: DROP
+    using value_type = TCharType;
+    using traits_type = TTraits;
+
+    using iterator = TCharType*;
+    using reverse_iterator = std::reverse_iterator<iterator>;
+    using typename TBase::const_iterator;
+    using typename TBase::const_reference;
+    using typename TBase::const_reverse_iterator;
+
+    struct TUninitialized {
+        explicit TUninitialized(size_t size)
+            : Size(size)
+        {
+        }
+
+        size_t Size;
+    };
+
+    size_t max_size() noexcept {
+        static size_t res = TStringType().max_size();
+
+        return res;
+    }
+
+protected:
+    TStorage S_;
+
+    template <typename... A>
+    static TStorage Construct(A&&... a) {
+        return {new TStdStr(std::forward<A>(a)...), typename TStorage::TNoIncrement()};
+    }
+
+    static TStorage Construct() noexcept {
+        return TStdStr::NullStr();
+    }
+
+    TStdStr& StdStr() noexcept {
+        return *S_;
+    }
+
+    const TStdStr& StdStr() const noexcept {
+        return *S_;
+    }
+
+    /**
+     * Makes a distinct copy of this string. `IsDetached()` is always true after this call.
+     *
+     * @throw std::length_error
+     */
+    void Clone() {
+        Construct(StdStr()).Swap(S_);
+    }
+
+    size_t RefCount() const noexcept {
+        return S_.RefCount();
+    }
+
+public:
+    inline const TStringType& ConstRef() const Y_LIFETIME_BOUND {
+        return StdStr();
+    }
+
+    inline TStringType& MutRef() Y_LIFETIME_BOUND {
+        Detach();
+
+        return StdStr();
+    }
+
+    inline const_reference operator[](size_t pos) const noexcept Y_LIFETIME_BOUND {
+        Y_ASSERT(pos <= length());
+
+        return this->data()[pos];
+    }
+
+    inline reference operator[](size_t pos) noexcept Y_LIFETIME_BOUND {
+        Y_ASSERT(pos <= length());
+
+        return reference(*this, pos);
+    }
+
+    using TBase::back;
+
+    inline reference back() noexcept Y_LIFETIME_BOUND {
+        Y_ASSERT(!this->empty());
+
+        if (Y_UNLIKELY(this->empty())) {
+            return reference(*this, 0);
+        }
+
+        return reference(*this, length() - 1);
+    }
+
+    using TBase::front;
+
+    inline reference front() noexcept Y_LIFETIME_BOUND {
+        Y_ASSERT(!this->empty());
+
+        return reference(*this, 0);
+    }
+
+    inline size_t length() const noexcept {
+        return ConstRef().length();
+    }
+
+    inline const TCharType* data() const noexcept Y_LIFETIME_BOUND {
+        return ConstRef().data();
+    }
+
+    inline const TCharType* c_str() const noexcept Y_LIFETIME_BOUND {
+        return ConstRef().c_str();
+    }
+
+    // ~~~ STL compatible method to obtain data pointer ~~~
+    iterator begin() Y_LIFETIME_BOUND {
+        return &*MutRef().begin();
+    }
+
+    iterator end() Y_LIFETIME_BOUND {
+        return &*MutRef().end();
+    }
+
+    reverse_iterator rbegin() Y_LIFETIME_BOUND {
+        return reverse_iterator(end());
+    }
+
+    reverse_iterator rend() Y_LIFETIME_BOUND {
+        return reverse_iterator(begin());
+    }
+
+    const_iterator begin() const noexcept Y_LIFETIME_BOUND {
+        return TBase::begin();
+    }
+    const_iterator cbegin() const noexcept Y_LIFETIME_BOUND {
+        return TBase::cbegin();
+    }
+
+    const_iterator cend() const noexcept Y_LIFETIME_BOUND {
+        return TBase::cend();
+    }
+
+    const_reverse_iterator crbegin() const noexcept Y_LIFETIME_BOUND {
+        return TBase::crbegin();
+    }
+
+    const_reverse_iterator crend() const noexcept Y_LIFETIME_BOUND {
+        return TBase::crend();
+    }
+
+    const_iterator end() const noexcept Y_LIFETIME_BOUND {
+        return TBase::end();
+    }
+
+    const_reverse_iterator rbegin() const noexcept Y_LIFETIME_BOUND {
+        return TBase::rbegin();
+    }
+
+    const_reverse_iterator rend() const noexcept Y_LIFETIME_BOUND {
+        return TBase::rend();
+    }
+
+    inline size_t capacity() const noexcept {
+        if (S_->IsNull()) {
+            return 0;
+        }
+
+        return S_->capacity();
+    }
+
+    TCharType* Detach() Y_LIFETIME_BOUND {
+        if (Y_UNLIKELY(!IsDetached())) {
+            Clone();
+        }
+
+        return (TCharType*)S_->data();
+    }
+
+    bool IsDetached() const {
+        return 1 == RefCount();
+    }
+
+    // ~~~ Size and capacity ~~~
+    TBasicCowString& resize(size_t n, TCharType c = ' ') Y_LIFETIME_BOUND { // remove or append
+        MutRef().resize(n, c);
+
+        return *this;
+    }
+
+    // ~~~ Constructor ~~~ : FAMILY0(,TBasicCowString)
+    TBasicCowString() noexcept
+        : S_(Construct())
+    {
+    }
+
+    inline explicit TBasicCowString(::NDetail::TReserveTag rt)
+        : S_(Construct<>())
+    {
+        reserve(rt.Capacity);
+    }
+
+    inline TBasicCowString(const TBasicCowString& s)
+        : S_(s.S_)
+    {
+    }
+
+    inline TBasicCowString(TBasicCowString&& s) noexcept
+        : S_(Construct())
+    {
+        s.swap(*this);
+    }
+
+    template <typename T, typename A>
+    explicit inline TBasicCowString(const std::basic_string<TCharType, T, A>& s)
+        : TBasicCowString(s.data(), s.size())
+    {
+    }
+
+    template <typename T, typename A>
+    inline TBasicCowString(std::basic_string<TCharType, T, A>&& s)
+        : S_(s.empty() ? Construct() : Construct(std::move(s)))
+    {
+    }
+
+    TBasicCowString(const TBasicCowString& s, size_t pos, size_t n)
+        : S_(n ? Construct(s, pos, n) : Construct())
+    {
+    }
+
+    TBasicCowString(const TCharType* pc)
+        : TBasicCowString(pc, TBase::StrLen(pc))
+    {
+    }
+    TBasicCowString(std::nullptr_t) = delete;
+
+    TBasicCowString(const TCharType* pc, size_t n)
+        : S_(n ? Construct(pc, n) : Construct())
+    {
+    }
+    TBasicCowString(std::nullptr_t, size_t) = delete;
+
+    TBasicCowString(const TCharType* pc, size_t pos, size_t n)
+        : TBasicCowString(pc + pos, n)
+    {
+    }
+
+    explicit TBasicCowString(TExplicitType<TCharType> c)
+        : TBasicCowString(&c.Value(), 1)
+    {
+    }
+    explicit TBasicCowString(const reference& c)
+        : TBasicCowString(&c, 1)
+    {
+    }
+
+    TBasicCowString(size_t n, TCharType c)
+        : S_(Construct(n, c))
+    {
+    }
+
+    /**
+     * Constructs an uninitialized string of size `uninitialized.Size`. The proper
+     * way to use this ctor is via `TBasicCowString::Uninitialized` factory function.
+     *
+     * @throw std::length_error
+     */
+    TBasicCowString(TUninitialized uninitialized)
+        : S_(Construct<>())
+    {
+        ReserveAndResize(uninitialized.Size);
+    }
+
+    TBasicCowString(const TCharType* b, const TCharType* e)
+        : TBasicCowString(b, NonNegativeDistance(b, e))
+    {
+    }
+
+    explicit TBasicCowString(const TBasicStringBuf<TCharType, TTraits> s)
+        : TBasicCowString(s.data(), s.size())
+    {
+    }
+
+    template <typename Traits>
+    explicit inline TBasicCowString(const std::basic_string_view<TCharType, Traits>& s)
+        : TBasicCowString(s.data(), s.size())
+    {
+    }
+
+    /**
+     * WARN:
+     *    Certain invocations of this method will result in link-time error.
+     *    You are free to implement corresponding methods in string.cpp if you need them.
+     */
+    static TBasicCowString FromAscii(const ::TStringBuf& s) {
+        return TBasicCowString().AppendAscii(s);
+    }
+
+    static TBasicCowString FromUtf8(const ::TStringBuf& s) {
+        return TBasicCowString().AppendUtf8(s);
+    }
+
+    static TBasicCowString FromUtf16(const ::TWtringBuf& s) {
+        return TBasicCowString().AppendUtf16(s);
+    }
+
+    static TBasicCowString Uninitialized(size_t n) {
+        return TBasicCowString(TUninitialized(n));
+    }
+
+private:
+    using TJoinHelper = TStringJoinHelper<TCharType, TTraits>;
+
+    template <typename... R>
+    static inline TBasicCowString JoinImpl(const R&... r) {
+        TBasicCowString s{TUninitialized{TJoinHelper::SumLength(r...)}};
+        TJoinHelper::CopyAll((TCharType*)s.data(), r...);
+        return s;
+    }
+
+public:
+    Y_REINITIALIZES_OBJECT inline void clear() noexcept {
+        if (IsDetached()) {
+            S_->clear();
+
+            return;
+        }
+
+        Construct().Swap(S_);
+    }
+
+    template <typename... R>
+    static inline TBasicCowString Join(const R&... r) {
+        return JoinImpl(typename TJoinHelper::template TJoinParam<R>(r)...);
+    }
+
+    // ~~~ Assignment ~~~ : FAMILY0(TBasicCowString&, assign);
+    TBasicCowString& assign(size_t size, TCharType ch) Y_LIFETIME_BOUND {
+        ReserveAndResize(size);
+        std::fill(begin(), end(), ch);
+        return *this;
+    }
+
+    TBasicCowString& assign(const TBasicCowString& s) Y_LIFETIME_BOUND {
+        TBasicCowString(s).swap(*this);
+
+        return *this;
+    }
+
+    TBasicCowString& assign(const TBasicCowString& s, size_t pos, size_t n) Y_LIFETIME_BOUND {
+        return assign(TBasicCowString(s, pos, n));
+    }
+
+    TBasicCowString& assign(const TCharType* pc) Y_LIFETIME_BOUND {
+        return assign(pc, TBase::StrLen(pc));
+    }
+
+    TBasicCowString& assign(TCharType ch) Y_LIFETIME_BOUND {
+        return assign(&ch, 1);
+    }
+
+    TBasicCowString& assign(const TCharType* pc, size_t len) Y_LIFETIME_BOUND {
+#if defined(address_sanitizer_enabled) || defined(thread_sanitizer_enabled)
+        pc = (const TCharType*)HidePointerOrigin((void*)pc);
+#endif
+        if (IsDetached()) {
+            MutRef().assign(pc, len);
+        } else {
+            TBasicCowString(pc, len).swap(*this);
+        }
+
+        return *this;
+    }
+
+    TBasicCowString& assign(const TCharType* first, const TCharType* last) Y_LIFETIME_BOUND {
+        return assign(first, NonNegativeDistance(first, last));
+    }
+
+    TBasicCowString& assign(const TCharType* pc, size_t pos, size_t n) Y_LIFETIME_BOUND {
+        return assign(pc + pos, n);
+    }
+
+    TBasicCowString& assign(const TBasicStringBuf<TCharType, TTraits> s) Y_LIFETIME_BOUND {
+        return assign(s.data(), s.size());
+    }
+
+    TBasicCowString& assign(const TBasicStringBuf<TCharType, TTraits> s, size_t spos, size_t sn = TBase::npos) Y_LIFETIME_BOUND {
+        return assign(s.SubString(spos, sn));
+    }
+
+    inline TBasicCowString& AssignNoAlias(const TCharType* pc, size_t len) Y_LIFETIME_BOUND {
+        return assign(pc, len);
+    }
+
+    inline TBasicCowString& AssignNoAlias(const TCharType* b, const TCharType* e) Y_LIFETIME_BOUND {
+        return AssignNoAlias(b, e - b);
+    }
+
+    TBasicCowString& AssignNoAlias(const TBasicStringBuf<TCharType, TTraits> s) Y_LIFETIME_BOUND {
+        return AssignNoAlias(s.data(), s.size());
+    }
+
+    TBasicCowString& AssignNoAlias(const TBasicStringBuf<TCharType, TTraits> s, size_t spos, size_t sn = TBase::npos) Y_LIFETIME_BOUND {
+        return AssignNoAlias(s.SubString(spos, sn));
+    }
+
+    /**
+     * WARN:
+     *    Certain invocations of this method will result in link-time error.
+     *    You are free to implement corresponding methods in string.cpp if you need them.
+     */
+    auto AssignAscii(const ::TStringBuf& s) {
+        clear();
+        return AppendAscii(s);
+    }
+
+    auto AssignUtf8(const ::TStringBuf& s) {
+        clear();
+        return AppendUtf8(s);
+    }
+
+    auto AssignUtf16(const ::TWtringBuf& s) {
+        clear();
+        return AppendUtf16(s);
+    }
+
+    TBasicCowString& operator=(const TBasicCowString& s) Y_LIFETIME_BOUND {
+        return assign(s);
+    }
+
+    TBasicCowString& operator=(TBasicCowString&& s) noexcept Y_LIFETIME_BOUND {
+        swap(s);
+        return *this;
+    }
+
+    template <typename T, typename A>
+    TBasicCowString& operator=(std::basic_string<TCharType, T, A>&& s) noexcept Y_LIFETIME_BOUND {
+        TBasicCowString(std::move(s)).swap(*this);
+
+        return *this;
+    }
+
+    TBasicCowString& operator=(const TBasicStringBuf<TCharType, TTraits> s) Y_LIFETIME_BOUND {
+        return assign(s);
+    }
+
+    TBasicCowString& operator=(std::initializer_list<TCharType> il) Y_LIFETIME_BOUND {
+        return assign(il.begin(), il.end());
+    }
+
+    TBasicCowString& operator=(const TCharType* s) Y_LIFETIME_BOUND {
+        return assign(s);
+    }
+    TBasicCowString& operator=(std::nullptr_t) Y_LIFETIME_BOUND = delete;
+
+    TBasicCowString& operator=(TExplicitType<TCharType> ch) Y_LIFETIME_BOUND {
+        return assign(ch);
+    }
+
+    inline void reserve(size_t len) {
+        MutRef().reserve(len);
+    }
+
+    // ~~~ Appending ~~~ : FAMILY0(TBasicCowString&, append);
+    inline TBasicCowString& append(size_t count, TCharType ch) Y_LIFETIME_BOUND {
+        MutRef().append(count, ch);
+
+        return *this;
+    }
+
+    inline TBasicCowString& append(const TBasicCowString& s) Y_LIFETIME_BOUND {
+        MutRef().append(s.ConstRef());
+
+        return *this;
+    }
+
+    inline TBasicCowString& append(const TBasicCowString& s, size_t pos, size_t n) Y_LIFETIME_BOUND {
+        MutRef().append(s.ConstRef(), pos, n);
+
+        return *this;
+    }
+
+    inline TBasicCowString& append(const TCharType* pc) Y_LIFETIME_BOUND {
+        MutRef().append(pc);
+
+        return *this;
+    }
+
+    inline TBasicCowString& append(TCharType c) Y_LIFETIME_BOUND {
+        MutRef().push_back(c);
+
+        return *this;
+    }
+
+    inline TBasicCowString& append(const TCharType* first, const TCharType* last) Y_LIFETIME_BOUND {
+        MutRef().append(first, last);
+
+        return *this;
+    }
+
+    inline TBasicCowString& append(const TCharType* pc, size_t len) Y_LIFETIME_BOUND {
+        MutRef().append(pc, len);
+
+        return *this;
+    }
+
+    inline void ReserveAndResize(size_t len) {
+        ::ResizeUninitialized(MutRef(), len);
+    }
+
+    TBasicCowString& AppendNoAlias(const TCharType* pc, size_t len) Y_LIFETIME_BOUND {
+        if (len) {
+            auto s = this->size();
+
+            ReserveAndResize(s + len);
+            memcpy(&*(begin() + s), pc, len * sizeof(*pc));
+        }
+
+        return *this;
+    }
+
+    TBasicCowString& AppendNoAlias(const TBasicStringBuf<TCharType, TTraits> s) Y_LIFETIME_BOUND {
+        return AppendNoAlias(s.data(), s.size());
+    }
+
+    TBasicCowString& AppendNoAlias(const TBasicStringBuf<TCharType, TTraits> s, size_t spos, size_t sn = TBase::npos) Y_LIFETIME_BOUND {
+        return AppendNoAlias(s.SubString(spos, sn));
+    }
+
+    TBasicCowString& append(const TBasicStringBuf<TCharType, TTraits> s) Y_LIFETIME_BOUND {
+        return append(s.data(), s.size());
+    }
+
+    TBasicCowString& append(const TBasicStringBuf<TCharType, TTraits> s, size_t spos, size_t sn = TBase::npos) Y_LIFETIME_BOUND {
+        return append(s.SubString(spos, sn));
+    }
+
+    TBasicCowString& append(const TCharType* pc, size_t pos, size_t n, size_t pc_len = TBase::npos) Y_LIFETIME_BOUND {
+        return append(pc + pos, Min(n, pc_len - pos));
+    }
+
+    /**
+     * WARN:
+     *    Certain invocations of this method will result in link-time error.
+     *    You are free to implement corresponding methods in string.cpp if you need them.
+     */
+    TBasicCowString& AppendAscii(const ::TStringBuf& s) Y_LIFETIME_BOUND;
+
+    TBasicCowString& AppendUtf8(const ::TStringBuf& s) Y_LIFETIME_BOUND;
+
+    TBasicCowString& AppendUtf16(const ::TWtringBuf& s) Y_LIFETIME_BOUND;
+
+    inline void push_back(TCharType c) {
+        // TODO
+        append(c);
+    }
+
+    template <class T>
+    TBasicCowString& operator+=(const T& s) Y_LIFETIME_BOUND {
+        return append(s);
+    }
+
+    template <class T>
+    friend TBasicCowString operator*(const TBasicCowString& s, T count) {
+        static_assert(std::is_integral<T>::value, "Integral type required.");
+
+        TBasicCowString result;
+
+        if (count > 0) {
+            result.reserve(s.length() * count);
+        }
+
+        for (T i = 0; i < count; ++i) {
+            result += s;
+        }
+
+        return result;
+    }
+
+    template <class T>
+    TBasicCowString& operator*=(T count) Y_LIFETIME_BOUND {
+        static_assert(std::is_integral<T>::value, "Integral type required.");
+
+        TBasicCowString temp;
+
+        if (count > 0) {
+            temp.reserve(length() * count);
+        }
+
+        for (T i = 0; i < count; ++i) {
+            temp += *this;
+        }
+
+        swap(temp);
+
+        return *this;
+    }
+
+    operator const TStringType&() const noexcept Y_LIFETIME_BOUND {
+        return this->ConstRef();
+    }
+
+    /* We have operator casting TString to `const std::string&` but we explicitly don't support
+    * casting TString to `std::string&` since such casting requires detaching TString and therefore
+    * modifies TString object. Sometimes compiler might call `operator std::string&`
+    * implicitly and it might lead to problems. Check IGNIETFERRO-2155 for details.
+    */
+    template <typename T, typename = std::enable_if_t<std::is_same_v<T, TStringType>>>
+    operator T&() & Y_LIFETIME_BOUND requires false {
+        return this->MutRef();
+    }
+
+    /*
+     * Following overloads of "operator+" aim to choose the cheapest implementation depending on
+     * summand types: lvalues, detached rvalues, shared rvalues.
+     *
+     * General idea is to use the detached-rvalue argument (left of right) to store the result
+     * wherever possible. If a buffer in rvalue is large enough this saves a re-allocation. If
+     * both arguments are rvalues we check which one is detached. If both of them are detached then
+     * the left argument is obviously preferrable because you won't need to shift the data.
+     *
+     * If an rvalue is shared then it's basically the same as lvalue because you cannot use its
+     * buffer to store the sum. However, we rely on the fact that append() and prepend() are already
+     * optimized for the shared case and detach the string into the buffer large enough to store
+     * the sum (compared to the detach+reallocation). This way, if we have only one rvalue argument
+     * (left or right) then we simply append/prepend into it, without checking if it's detached or
+     * not. This will be checked inside ReserveAndResize anyway.
+     *
+     * If both arguments cannot be used to store the sum (e.g. two lvalues) then we fall back to the
+     * Join function that constructs a resulting string in the new buffer with the minimum overhead:
+     * malloc + memcpy + memcpy.
+     */
+
+    friend TBasicCowString operator+(TBasicCowString&& s1, const TBasicCowString& s2) Y_WARN_UNUSED_RESULT {
+        s1 += s2;
+        return std::move(s1);
+    }
+
+    friend TBasicCowString operator+(const TBasicCowString& s1, TBasicCowString&& s2) Y_WARN_UNUSED_RESULT {
+        s2.prepend(s1);
+        return std::move(s2);
+    }
+
+    friend TBasicCowString operator+(TBasicCowString&& s1, TBasicCowString&& s2) Y_WARN_UNUSED_RESULT {
+#if 0
+        if (!s1.IsDetached() && s2.IsDetached()) {
+            s2.prepend(s1);
+            return std::move(s2);
+        }
+#endif
+        s1 += s2;
+        return std::move(s1);
+    }
+
+    friend TBasicCowString operator+(TBasicCowString&& s1, const TBasicStringBuf<TCharType, TTraits> s2) Y_WARN_UNUSED_RESULT {
+        s1 += s2;
+        return std::move(s1);
+    }
+
+    friend TBasicCowString operator+(TBasicCowString&& s1, const TCharType* s2) Y_WARN_UNUSED_RESULT {
+        s1 += s2;
+        return std::move(s1);
+    }
+
+    friend TBasicCowString operator+(TBasicCowString&& s1, TCharType s2) Y_WARN_UNUSED_RESULT {
+        s1 += s2;
+        return std::move(s1);
+    }
+
+    friend TBasicCowString operator+(TExplicitType<TCharType> ch, const TBasicCowString& s) Y_WARN_UNUSED_RESULT {
+        return Join(TCharType(ch), s);
+    }
+
+    friend TBasicCowString operator+(TExplicitType<TCharType> ch, TBasicCowString&& s) Y_WARN_UNUSED_RESULT {
+        s.prepend(ch);
+        return std::move(s);
+    }
+
+    friend TBasicCowString operator+(const TBasicCowString& s1, const TBasicCowString& s2) Y_WARN_UNUSED_RESULT {
+        return Join(s1, s2);
+    }
+
+    friend TBasicCowString operator+(const TBasicCowString& s1, const TBasicStringBuf<TCharType, TTraits> s2) Y_WARN_UNUSED_RESULT {
+        return Join(s1, s2);
+    }
+
+    friend TBasicCowString operator+(const TBasicCowString& s1, const TCharType* s2) Y_WARN_UNUSED_RESULT {
+        return Join(s1, s2);
+    }
+
+    friend TBasicCowString operator+(const TBasicCowString& s1, TCharType s2) Y_WARN_UNUSED_RESULT {
+        return Join(s1, TBasicStringBuf<TCharType, TTraits>(&s2, 1));
+    }
+
+    friend TBasicCowString operator+(const TCharType* s1, TBasicCowString&& s2) Y_WARN_UNUSED_RESULT {
+        s2.prepend(s1);
+        return std::move(s2);
+    }
+
+    friend TBasicCowString operator+(const TBasicStringBuf<TCharType, TTraits> s1, TBasicCowString&& s2) Y_WARN_UNUSED_RESULT {
+        s2.prepend(s1);
+        return std::move(s2);
+    }
+
+    friend TBasicCowString operator+(const TBasicStringBuf<TCharType, TTraits> s1, const TBasicCowString& s2) Y_WARN_UNUSED_RESULT {
+        return Join(s1, s2);
+    }
+
+    friend TBasicCowString operator+(const TCharType* s1, const TBasicCowString& s2) Y_WARN_UNUSED_RESULT {
+        return Join(s1, s2);
+    }
+
+    friend TBasicCowString operator+(std::basic_string<TCharType, TTraits> l, TBasicCowString r) {
+        return std::move(l) + r.ConstRef();
+    }
+
+    friend TBasicCowString operator+(TBasicCowString l, std::basic_string<TCharType, TTraits> r) {
+        return l.ConstRef() + std::move(r);
+    }
+
+    // ~~~ Prepending ~~~ : FAMILY0(TBasicCowString&, prepend);
+    TBasicCowString& prepend(const TBasicCowString& s) Y_LIFETIME_BOUND {
+        MutRef().insert(0, s.ConstRef());
+
+        return *this;
+    }
+
+    TBasicCowString& prepend(const TBasicCowString& s, size_t pos, size_t n) Y_LIFETIME_BOUND {
+        MutRef().insert(0, s.ConstRef(), pos, n);
+
+        return *this;
+    }
+
+    TBasicCowString& prepend(const TCharType* pc) Y_LIFETIME_BOUND {
+        MutRef().insert(0, pc);
+
+        return *this;
+    }
+
+    TBasicCowString& prepend(size_t n, TCharType c) Y_LIFETIME_BOUND {
+        MutRef().insert(size_t(0), n, c);
+
+        return *this;
+    }
+
+    TBasicCowString& prepend(TCharType c) Y_LIFETIME_BOUND {
+        MutRef().insert(size_t(0), 1, c);
+
+        return *this;
+    }
+
+    TBasicCowString& prepend(const TBasicStringBuf<TCharType, TTraits> s, size_t spos = 0, size_t sn = TBase::npos) Y_LIFETIME_BOUND {
+        return insert(0, s, spos, sn);
+    }
+
+    // ~~~ Insertion ~~~ : FAMILY1(TBasicCowString&, insert, size_t pos);
+    TBasicCowString& insert(size_t pos, const TBasicCowString& s) Y_LIFETIME_BOUND {
+        MutRef().insert(pos, s.ConstRef());
+
+        return *this;
+    }
+
+    TBasicCowString& insert(size_t pos, const TBasicCowString& s, size_t pos1, size_t n1) Y_LIFETIME_BOUND {
+        MutRef().insert(pos, s.ConstRef(), pos1, n1);
+
+        return *this;
+    }
+
+    TBasicCowString& insert(size_t pos, const TCharType* pc) Y_LIFETIME_BOUND {
+        MutRef().insert(pos, pc);
+
+        return *this;
+    }
+
+    TBasicCowString& insert(size_t pos, const TCharType* pc, size_t len) Y_LIFETIME_BOUND {
+        MutRef().insert(pos, pc, len);
+
+        return *this;
+    }
+
+    TBasicCowString& insert(const_iterator pos, const_iterator b, const_iterator e) Y_LIFETIME_BOUND {
+        return insert(this->off(pos), b, e - b);
+    }
+
+    TBasicCowString& insert(size_t pos, size_t n, TCharType c) Y_LIFETIME_BOUND {
+        MutRef().insert(pos, n, c);
+
+        return *this;
+    }
+
+    TBasicCowString& insert(const_iterator pos, size_t len, TCharType ch) Y_LIFETIME_BOUND {
+        return this->insert(this->off(pos), len, ch);
+    }
+
+    TBasicCowString& insert(const_iterator pos, TCharType ch) Y_LIFETIME_BOUND {
+        return this->insert(pos, 1, ch);
+    }
+
+    TBasicCowString& insert(size_t pos, const TBasicStringBuf<TCharType, TTraits> s, size_t spos = 0, size_t sn = TBase::npos) Y_LIFETIME_BOUND {
+        MutRef().insert(pos, s, spos, sn);
+
+        return *this;
+    }
+
+    // ~~~ Removing ~~~
+    TBasicCowString& remove(size_t pos, size_t n) Y_LIFETIME_BOUND {
+        if (pos < length()) {
+            MutRef().erase(pos, n);
+        }
+
+        return *this;
+    }
+
+    TBasicCowString& remove(size_t pos = 0) Y_LIFETIME_BOUND {
+        if (pos < length()) {
+            MutRef().erase(pos);
+        }
+
+        return *this;
+    }
+
+    TBasicCowString& erase(size_t pos = 0, size_t n = TBase::npos) Y_LIFETIME_BOUND {
+        MutRef().erase(pos, n);
+
+        return *this;
+    }
+
+    TBasicCowString& erase(const_iterator b, const_iterator e) Y_LIFETIME_BOUND {
+        return erase(this->off(b), e - b);
+    }
+
+    TBasicCowString& erase(const_iterator i) Y_LIFETIME_BOUND {
+        return erase(i, i + 1);
+    }
+
+    TBasicCowString& pop_back() Y_LIFETIME_BOUND {
+        Y_ASSERT(!this->empty());
+
+        MutRef().pop_back();
+
+        return *this;
+    }
+
+    // ~~~ replacement ~~~ : FAMILY2(TBasicCowString&, replace, size_t pos, size_t n);
+    TBasicCowString& replace(size_t pos, size_t n, const TBasicCowString& s) Y_LIFETIME_BOUND {
+        MutRef().replace(pos, n, s.ConstRef());
+
+        return *this;
+    }
+
+    TBasicCowString& replace(size_t pos, size_t n, const TBasicCowString& s, size_t pos1, size_t n1) Y_LIFETIME_BOUND {
+        MutRef().replace(pos, n, s.ConstRef(), pos1, n1);
+
+        return *this;
+    }
+
+    TBasicCowString& replace(size_t pos, size_t n, const TCharType* pc) Y_LIFETIME_BOUND {
+        MutRef().replace(pos, n, pc);
+
+        return *this;
+    }
+
+    TBasicCowString& replace(size_t pos, size_t n, const TCharType* s, size_t len) Y_LIFETIME_BOUND {
+        MutRef().replace(pos, n, s, len);
+
+        return *this;
+    }
+
+    TBasicCowString& replace(size_t pos, size_t n, const TCharType* s, size_t spos, size_t sn) Y_LIFETIME_BOUND {
+        MutRef().replace(pos, n, s + spos, sn - spos);
+
+        return *this;
+    }
+
+    TBasicCowString& replace(size_t pos, size_t n1, size_t n2, TCharType c) Y_LIFETIME_BOUND {
+        MutRef().replace(pos, n1, n2, c);
+
+        return *this;
+    }
+
+    TBasicCowString& replace(size_t pos, size_t n, const TBasicStringBuf<TCharType, TTraits> s, size_t spos = 0, size_t sn = TBase::npos) Y_LIFETIME_BOUND {
+        MutRef().replace(pos, n, s, spos, sn);
+
+        return *this;
+    }
+
+    void swap(TBasicCowString& s) noexcept {
+        S_.Swap(s.S_);
+    }
+
+    /**
+     * @returns                         String suitable for debug printing (like Python's `repr()`).
+     *                                  Format of the string is unspecified and may be changed over time.
+     */
+    TBasicCowString Quote() const {
+        extern TBasicCowString EscapeC(const TBasicCowString&);
+
+        return TBasicCowString() + '"' + EscapeC(*this) + '"';
+    }
+
+    /**
+     * Modifies the case of the string, depending on the operation.
+     * @return false if no changes have been made.
+     *
+     * @warning when the value_type is char, these methods will not work with non-ASCII letters.
+     */
+    bool to_lower(size_t pos = 0, size_t n = TBase::npos);
+    bool to_upper(size_t pos = 0, size_t n = TBase::npos);
+    bool to_title(size_t pos = 0, size_t n = TBase::npos);
+
+    constexpr const TCharType* Data() const noexcept = delete;
+    constexpr size_t Size() noexcept = delete;
+    Y_PURE_FUNCTION constexpr bool Empty() const noexcept = delete;
+
+public:
+    /**
+     * Modifies the substring of length `n` starting from `pos`, applying `f` to each position and symbol.
+     *
+     * @return false if no changes have been made.
+     */
+    template <typename T>
+    bool Transform(T&& f, size_t pos = 0, size_t n = TBase::npos) {
+        size_t len = length();
+
+        if (pos > len) {
+            pos = len;
+        }
+
+        if (n > len - pos) {
+            n = len - pos;
+        }
+
+        bool changed = false;
+
+        for (size_t i = pos; i != pos + n; ++i) {
+            auto c = f(i, data()[i]);
+            if (c != data()[i]) {
+                if (!changed) {
+                    Detach();
+                    changed = true;
+                }
+
+                begin()[i] = c;
+            }
+        }
+
+        return changed;
+    }
+};
+
+using TCowString = TBasicCowString<char>;
+using TUtf16CowString = TBasicCowString<wchar16>;
+using TUtf32CowString = TBasicCowString<wchar32>;
+
+std::ostream& operator<<(std::ostream&, const TCowString&);
+std::istream& operator>>(std::istream&, TCowString&);
+
+template <typename TCharType, typename TTraits>
+TBasicCowString<TCharType> to_lower(const TBasicCowString<TCharType, TTraits>& s) {
+    TBasicCowString<TCharType> ret(s);
+    ret.to_lower();
+    return ret;
+}
+
+template <typename TCharType, typename TTraits>
+TBasicCowString<TCharType> to_upper(const TBasicCowString<TCharType, TTraits>& s) {
+    TBasicCowString<TCharType> ret(s);
+    ret.to_upper();
+    return ret;
+}
+
+template <typename TCharType, typename TTraits>
+TBasicCowString<TCharType> to_title(const TBasicCowString<TCharType, TTraits>& s) {
+    TBasicCowString<TCharType> ret(s);
+    ret.to_title();
+    return ret;
+}
+
+namespace std {
+    template <>
+    struct hash<TCowString> {
+        using argument_type = TCowString;
+        using result_type = size_t;
+        inline result_type operator()(argument_type const& s) const noexcept {
+            return NHashPrivate::ComputeStringHash(s.data(), s.size());
+        }
+    };
+} // namespace std
+
+// interop
+template <class TCharType, class TTraits>
+auto& MutRef(TBasicCowString<TCharType, TTraits>& s Y_LIFETIME_BOUND) {
+    return s.MutRef();
+}
+
+template <class TCharType, class TTraits>
+const auto& ConstRef(const TBasicCowString<TCharType, TTraits>& s Y_LIFETIME_BOUND) noexcept {
+    return s.ConstRef();
+}
+
+template <class TCharType, class TTraits>
+void ResizeUninitialized(TBasicCowString<TCharType, TTraits>& s, size_t len) {
+    s.ReserveAndResize(len);
+}
diff --git a/library/cpp/containers/cow_string/cow_string_ut.cpp b/library/cpp/containers/cow_string/cow_string_ut.cpp
new file mode 100644
index 00000000000..1be9d607ed7
--- /dev/null
+++ b/library/cpp/containers/cow_string/cow_string_ut.cpp
@@ -0,0 +1,1296 @@
+#include <cow_string.h>
+
+#include <library/cpp/containers/cow_string/str_stl.h>
+#include <library/cpp/containers/cow_string/subst.h>
+#include <library/cpp/containers/cow_string/reverse.h>
+#include <library/cpp/containers/cow_string/ysaveload.h>
+
+#include <util/charset/wide.h>
+#include "util/generic/deque.h"
+#include "util/generic/strbuf.h"
+#include "util/generic/string_ut.h"
+#include "util/generic/vector.h"
+#include "util/generic/yexception.h"
+#include <util/stream/output.h>
+#include <util/string/subst.h>
+
+#include <string>
+#include <sstream>
+#include <algorithm>
+#include <stdexcept>
+
+static_assert(sizeof(TCowString) == sizeof(const char*), "expect sizeof(TCowString) == sizeof(const char*)");
+
+class TStringTestZero: public TTestBase {
+    UNIT_TEST_SUITE(TStringTestZero);
+    UNIT_TEST(TestZero);
+    UNIT_TEST_SUITE_END();
+
+public:
+    void TestZero() {
+        const char data[] = "abc\0def\0";
+        TCowString s(data, sizeof(data));
+        UNIT_ASSERT(s.size() == sizeof(data));
+        UNIT_ASSERT(s.StartsWith(s));
+        UNIT_ASSERT(s.EndsWith(s));
+        UNIT_ASSERT(s.Contains('\0'));
+
+        const char raw_def[] = "def";
+        const char raw_zero[] = "\0";
+        TCowString def(raw_def, sizeof(raw_def) - 1);
+        TCowString zero(raw_zero, sizeof(raw_zero) - 1);
+        UNIT_ASSERT_EQUAL(4, s.find(raw_def));
+        UNIT_ASSERT_EQUAL(4, s.find(def));
+        UNIT_ASSERT_EQUAL(4, s.find_first_of(raw_def));
+        UNIT_ASSERT_EQUAL(3, s.find_first_of(zero));
+        UNIT_ASSERT_EQUAL(7, s.find_first_not_of(def, 4));
+
+        const char nonSubstring[] = "def\0ghi";
+        UNIT_ASSERT_EQUAL(TCowString::npos, s.find(TCowString(nonSubstring, sizeof(nonSubstring))));
+
+        TCowString copy = s;
+        copy.replace(copy.size() - 1, 1, "z");
+        UNIT_ASSERT(s != copy);
+        copy.replace(copy.size() - 1, 1, "\0", 0, 1);
+        UNIT_ASSERT(s == copy);
+
+        TCowString prefix(data, 5);
+        UNIT_ASSERT(s.StartsWith(prefix));
+        UNIT_ASSERT(s != prefix);
+        UNIT_ASSERT(s > prefix);
+        UNIT_ASSERT(s > s.data());
+        UNIT_ASSERT(s == TCowString(s.data(), s.size()));
+        UNIT_ASSERT(data < s);
+
+        s.remove(5);
+        UNIT_ASSERT(s == prefix);
+    }
+};
+
+UNIT_TEST_SUITE_REGISTRATION(TStringTestZero);
+
+template <typename TStringType, typename TTestData>
+class TStringStdTestImpl {
+    using TChar = typename TStringType::char_type;
+    using TTraits = typename TStringType::traits_type;
+    using TView = std::basic_string_view<TChar, TTraits>;
+
+    TTestData Data_;
+
+protected:
+    void Constructor() {
+        UNIT_ASSERT_EXCEPTION(TStringType((size_t)-1, *Data_.a()), std::length_error);
+    }
+
+    void reserve() {
+#if 0
+        TStringType s;
+        UNIT_ASSERT_EXCEPTION(s.reserve(s.max_size() + 1), std::length_error);
+
+        // Non-shared behaviour - never shrink
+
+        s.reserve(256);
+        const auto* data = s.data();
+
+        UNIT_ASSERT(s.capacity() >= 256);
+
+        s.reserve(128);
+
+        UNIT_ASSERT(s.capacity() >= 256 && s.data() == data);
+
+        s.resize(64, 'x');
+        s.reserve(10);
+
+        UNIT_ASSERT(s.capacity() >= 256 && s.data() == data);
+
+        // Shared behaviour - always reallocate, just as much as requisted
+
+        TStringType holder = s;
+
+        UNIT_ASSERT(s.capacity() >= 256);
+
+        s.reserve(128);
+
+        UNIT_ASSERT(s.capacity() >= 128 && s.capacity() < 256 && s.data() != data);
+        UNIT_ASSERT(s.IsDetached());
+
+        s.resize(64, 'x');
+        data = s.data();
+        holder = s;
+
+        s.reserve(10);
+
+        UNIT_ASSERT(s.capacity() >= 64 && s.capacity() < 128 && s.data() != data);
+        UNIT_ASSERT(s.IsDetached());
+#endif
+    }
+
+    void short_string() {
+        TStringType const ref_short_str1(Data_.str1()), ref_short_str2(Data_.str2());
+        TStringType short_str1(ref_short_str1), short_str2(ref_short_str2);
+        TStringType const ref_long_str1(Data_.str__________________________________________________1());
+        TStringType const ref_long_str2(Data_.str__________________________________________________2());
+        TStringType long_str1(ref_long_str1), long_str2(ref_long_str2);
+
+        UNIT_ASSERT(short_str1 == ref_short_str1);
+        UNIT_ASSERT(long_str1 == ref_long_str1);
+
+        {
+            TStringType str1(short_str1);
+            str1 = long_str1;
+            UNIT_ASSERT(str1 == ref_long_str1);
+        }
+
+        {
+            TStringType str1(long_str1);
+            str1 = short_str1;
+            UNIT_ASSERT(str1 == ref_short_str1);
+        }
+
+        {
+            short_str1.swap(short_str2);
+            UNIT_ASSERT((short_str1 == ref_short_str2) && (short_str2 == ref_short_str1));
+            short_str1.swap(short_str2);
+        }
+
+        {
+            long_str1.swap(long_str2);
+            UNIT_ASSERT((long_str1 == ref_long_str2) && (long_str2 == ref_long_str1));
+            long_str1.swap(long_str2);
+        }
+
+        {
+            short_str1.swap(long_str1);
+            UNIT_ASSERT((short_str1 == ref_long_str1) && (long_str1 == ref_short_str1));
+            short_str1.swap(long_str1);
+        }
+
+        {
+            long_str1.swap(short_str1);
+            UNIT_ASSERT((short_str1 == ref_long_str1) && (long_str1 == ref_short_str1));
+            long_str1.swap(short_str1);
+        }
+
+        {
+            // This is to test move constructor
+            TVector<TStringType> str_vect;
+
+            str_vect.push_back(short_str1);
+            str_vect.push_back(long_str1);
+            str_vect.push_back(short_str2);
+            str_vect.push_back(long_str2);
+
+            UNIT_ASSERT(str_vect[0] == ref_short_str1);
+            UNIT_ASSERT(str_vect[1] == ref_long_str1);
+            UNIT_ASSERT(str_vect[2] == ref_short_str2);
+            UNIT_ASSERT(str_vect[3] == ref_long_str2);
+        }
+    }
+
+    void erase() {
+        TChar const* c_str = Data_.Hello_World();
+        TStringType str(c_str);
+        UNIT_ASSERT(str == c_str);
+
+        str.erase(str.begin() + 1, str.end() - 1); // Erase all but first and last.
+
+        size_t i;
+        for (i = 0; i < str.size(); ++i) {
+            switch (i) {
+                case 0:
+                    UNIT_ASSERT(str[i] == *Data_.H());
+                    break;
+
+                case 1:
+                    UNIT_ASSERT(str[i] == *Data_.d());
+                    break;
+
+                default:
+                    UNIT_ASSERT(false);
+            }
+        }
+
+        str.insert(1, c_str);
+        str.erase(str.begin());   // Erase first element.
+        str.erase(str.end() - 1); // Erase last element.
+        UNIT_ASSERT(str == c_str);
+        str.clear(); // Erase all.
+        UNIT_ASSERT(str.empty());
+
+        str = c_str;
+        UNIT_ASSERT(str == c_str);
+
+        str.erase(1, str.size() - 1); // Erase all but first and last.
+        for (i = 0; i < str.size(); i++) {
+            switch (i) {
+                case 0:
+                    UNIT_ASSERT(str[i] == *Data_.H());
+                    break;
+
+                case 1:
+                    UNIT_ASSERT(str[i] == *Data_.d());
+                    break;
+
+                default:
+                    UNIT_ASSERT(false);
+            }
+        }
+
+        str.erase(1);
+        UNIT_ASSERT(str == Data_.H());
+    }
+
+    void data() {
+        TStringType xx;
+
+        // ISO-IEC-14882:1998(E), 21.3.6, paragraph 3
+        UNIT_ASSERT(xx.data() != nullptr);
+    }
+
+    void c_str() {
+        TStringType low(Data_._2004_01_01());
+        TStringType xx;
+        TStringType yy;
+
+        // ISO-IEC-14882:1998(E), 21.3.6, paragraph 1
+        UNIT_ASSERT(*(yy.c_str()) == 0);
+
+        // Blocks A and B should follow each other.
+        // Block A:
+        xx = Data_._123456();
+        xx += low;
+        UNIT_ASSERT(xx.c_str() == TView(Data_._1234562004_01_01()));
+        // End of block A
+
+        // Block B:
+        xx = Data_._1234();
+        xx += Data_._5();
+        UNIT_ASSERT(xx.c_str() == TView(Data_._12345()));
+        // End of block B
+    }
+
+    void null_char_of_empty() {
+        const TStringType s;
+
+        // NOTE: https://a.yandex-team.ru/arcadia/junk/grechnik/test_string?rev=r12602052
+        i64 i = s[s.size()];
+        UNIT_ASSERT_VALUES_EQUAL(i, 0);
+    }
+
+    void null_char() {
+        // ISO/IEC 14882:1998(E), ISO/IEC 14882:2003(E), 21.3.4 ('... the const version')
+        const TStringType s(Data_._123456());
+
+        UNIT_ASSERT(s[s.size()] == 0);
+    }
+
+    // Allowed since C++17, see http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#2475
+    void null_char_assignment_to_subscript_of_empty() {
+        TStringType s;
+
+        using reference = typename TStringType::reference;
+        reference trailing_zero = s[s.size()];
+        trailing_zero = 0;
+        UNIT_ASSERT(trailing_zero == 0);
+    }
+
+    // Allowed since C++17, see http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#2475
+    void null_char_assignment_to_subscript_of_nonempty() {
+        TStringType s(Data_._123456());
+
+        using reference = typename TStringType::reference;
+        reference trailing_zero = s[s.size()];
+        trailing_zero = 0;
+        UNIT_ASSERT(trailing_zero == 0);
+    }
+
+    // Dereferencing string end() is not allowed by C++ standard as of C++20, avoid using in real code.
+    void null_char_assignment_to_end_of_empty() {
+        TStringType s;
+
+        volatile auto& trailing_zero = *(s.begin() + s.size());
+        trailing_zero = 0;
+        UNIT_ASSERT(trailing_zero == 0);
+    }
+
+    // Dereferencing string end() is not allowed by C++ standard as of C++20, avoid using in real code.
+    void null_char_assignment_to_end_of_nonempty() {
+        TStringType s(Data_._123456());
+
+        volatile auto& trailing_zero = *(s.begin() + s.size());
+        trailing_zero = 0;
+        UNIT_ASSERT(trailing_zero == 0);
+    }
+
+    void insert() {
+        TStringType strorg = Data_.This_is_test_string_for_string_calls();
+        TStringType str;
+
+        // In case of reallocation there is no auto reference problem
+        // so we reserve a big enough TStringType to be sure to test this
+        // particular point.
+
+        str.reserve(100);
+        str = strorg;
+
+        // test self insertion:
+        str.insert(10, str.c_str() + 5, 15);
+        UNIT_ASSERT(str == Data_.This_is_teis_test_string_st_string_for_string_calls());
+
+        str = strorg;
+        str.insert(15, str.c_str() + 5, 25);
+        UNIT_ASSERT(str == Data_.This_is_test_stis_test_string_for_stringring_for_string_calls());
+
+        str = strorg;
+        str.insert(0, str.c_str() + str.size() - 4, 4);
+        UNIT_ASSERT(str == Data_.allsThis_is_test_string_for_string_calls());
+
+        str = strorg;
+        str.insert(0, str.c_str() + str.size() / 2 - 1, str.size() / 2 + 1);
+        UNIT_ASSERT(str == Data_.ng_for_string_callsThis_is_test_string_for_string_calls());
+
+        str = strorg;
+        typename TStringType::iterator b = str.begin();
+        typename TStringType::const_iterator s = str.begin() + str.size() / 2 - 1;
+        typename TStringType::const_iterator e = str.end();
+        str.insert(b, s, e);
+        UNIT_ASSERT(str == Data_.ng_for_string_callsThis_is_test_string_for_string_calls());
+
+#if 0
+        // AV
+        str = strorg;
+        str.insert(str.begin(), str.begin() + str.size() / 2 - 1, str.end());
+        UNIT_ASSERT(str == Data.ng_for_string_callsThis_is_test_string_for_string_calls());
+#endif
+
+        TStringType str0;
+        str0.insert(str0.begin(), 5, *Data_._0());
+        UNIT_ASSERT(str0 == Data_._00000());
+
+        TStringType str1;
+        {
+            typename TStringType::size_type pos = 0, nb = 2;
+            str1.insert(pos, nb, *Data_._1());
+        }
+        UNIT_ASSERT(str1 == Data_._11());
+
+        str0.insert(0, str1);
+        UNIT_ASSERT(str0 == Data_._1100000());
+
+        TStringType str2(Data_._2345());
+        str0.insert(str0.size(), str2, 1, 2);
+        UNIT_ASSERT(str0 == Data_._110000034());
+
+        str1.insert(str1.begin() + 1, 2, *Data_._2());
+        UNIT_ASSERT(str1 == Data_._1221());
+
+        str1.insert(2, Data_._333333(), 3);
+        UNIT_ASSERT(str1 == Data_._1233321());
+
+        str1.insert(4, Data_._4444());
+        UNIT_ASSERT(str1 == Data_._12334444321());
+
+        str1.insert(str1.begin() + 6, *Data_._5());
+        UNIT_ASSERT(str1 == Data_._123344544321());
+    }
+
+    void resize() {
+        TStringType s;
+
+        s.resize(0);
+
+        UNIT_ASSERT(*s.c_str() == 0);
+
+        s = Data_._1234567();
+
+        s.resize(0);
+        UNIT_ASSERT(*s.c_str() == 0);
+
+        s = Data_._1234567();
+        s.resize(1);
+        UNIT_ASSERT(s.size() == 1);
+        UNIT_ASSERT(*s.c_str() == *Data_._1());
+        UNIT_ASSERT(*(s.c_str() + 1) == 0);
+
+        s = Data_._1234567();
+#if 0
+        s.resize(10);
+#else
+        s.resize(10, 0);
+#endif
+        UNIT_ASSERT(s.size() == 10);
+        UNIT_ASSERT(s[6] == *Data_._7());
+        UNIT_ASSERT(s[7] == 0);
+        UNIT_ASSERT(s[8] == 0);
+        UNIT_ASSERT(s[9] == 0);
+    }
+
+    void find() {
+        TStringType s(Data_.one_two_three_one_two_three());
+
+        UNIT_ASSERT(s.find(Data_.one()) == 0);
+        UNIT_ASSERT(s.find(*Data_.t()) == 4);
+        UNIT_ASSERT(s.find(*Data_.t(), 5) == 8);
+
+        UNIT_ASSERT(s.find(Data_.four()) == TStringType::npos);
+        UNIT_ASSERT(s.find(Data_.one(), TStringType::npos) == TStringType::npos);
+        UNIT_ASSERT(s.find_first_of(Data_.abcde()) == 2);
+        UNIT_ASSERT(s.find_first_not_of(Data_.enotw_()) == 9);
+    }
+
+    void capacity() {
+        TStringType s;
+
+        UNIT_ASSERT(s.capacity() < s.max_size());
+        UNIT_ASSERT(s.capacity() >= s.size());
+
+        for (int i = 0; i < 18; ++i) {
+            s += ' ';
+
+            UNIT_ASSERT(s.capacity() > 0);
+            UNIT_ASSERT(s.capacity() < s.max_size());
+            UNIT_ASSERT(s.capacity() >= s.size());
+        }
+    }
+
+    void assign() {
+        TStringType s;
+        TChar const* cstr = Data_.test_string_for_assign();
+
+        s.assign(cstr, cstr + 22);
+        UNIT_ASSERT(s == Data_.test_string_for_assign());
+
+        TStringType s2(Data_.other_test_string());
+        s.assign(s2);
+        UNIT_ASSERT(s == s2);
+
+        static TStringType str1;
+        static TStringType str2;
+
+        // short TStringType optim:
+        str1 = Data_._123456();
+        // longer than short TStringType:
+        str2 = Data_._1234567890123456789012345678901234567890();
+
+        UNIT_ASSERT(str1[5] == *Data_._6());
+        UNIT_ASSERT(str2[29] == *Data_._0());
+    }
+
+    void copy() {
+        TStringType s(Data_.foo());
+        TChar dest[4];
+        dest[0] = dest[1] = dest[2] = dest[3] = 1;
+        s.copy(dest, 4);
+        int pos = 0;
+        UNIT_ASSERT(dest[pos++] == *Data_.f());
+        UNIT_ASSERT(dest[pos++] == *Data_.o());
+        UNIT_ASSERT(dest[pos++] == *Data_.o());
+        UNIT_ASSERT(dest[pos++] == 1);
+
+        dest[0] = dest[1] = dest[2] = dest[3] = 1;
+        s.copy(dest, 4, 2);
+        pos = 0;
+        UNIT_ASSERT(dest[pos++] == *Data_.o());
+        UNIT_ASSERT(dest[pos++] == 1);
+
+        UNIT_ASSERT_EXCEPTION(s.copy(dest, 4, 5), std::out_of_range);
+    }
+
+    void cbegin_cend() {
+        const char helloThere[] = "Hello there";
+        TCowString s = helloThere;
+        size_t index = 0;
+        for (auto it = s.cbegin(); s.cend() != it; ++it, ++index) {
+            UNIT_ASSERT_VALUES_EQUAL(helloThere[index], *it);
+        }
+    }
+
+    void compare() {
+        TStringType str1(Data_.abcdef());
+        TStringType str2;
+
+        str2 = Data_.abcdef();
+        UNIT_ASSERT(str1.compare(str2) == 0);
+        UNIT_ASSERT(str1.compare(str2.data(), str2.size()) == 0);
+        str2 = Data_.abcde();
+        UNIT_ASSERT(str1.compare(str2) > 0);
+        UNIT_ASSERT(str1.compare(str2.data(), str2.size()) > 0);
+        str2 = Data_.abcdefg();
+        UNIT_ASSERT(str1.compare(str2) < 0);
+        UNIT_ASSERT(str1.compare(str2.data(), str2.size()) < 0);
+
+        UNIT_ASSERT(str1.compare(Data_.abcdef()) == 0);
+        UNIT_ASSERT(str1.compare(Data_.abcde()) > 0);
+        UNIT_ASSERT(str1.compare(Data_.abcdefg()) < 0);
+
+        str2 = Data_.cde();
+        UNIT_ASSERT(str1.compare(2, 3, str2) == 0);
+        str2 = Data_.cd();
+        UNIT_ASSERT(str1.compare(2, 3, str2) > 0);
+        str2 = Data_.cdef();
+        UNIT_ASSERT(str1.compare(2, 3, str2) < 0);
+
+        str2 = Data_.abcdef();
+        UNIT_ASSERT(str1.compare(2, 3, str2, 2, 3) == 0);
+        UNIT_ASSERT(str1.compare(2, 3, str2, 2, 2) > 0);
+        UNIT_ASSERT(str1.compare(2, 3, str2, 2, 4) < 0);
+
+        UNIT_ASSERT(str1.compare(2, 3, Data_.cdefgh(), 3) == 0);
+        UNIT_ASSERT(str1.compare(2, 3, Data_.cdefgh(), 2) > 0);
+        UNIT_ASSERT(str1.compare(2, 3, Data_.cdefgh(), 4) < 0);
+    }
+
+    void find_last_of() {
+        // 21.3.6.4
+        TStringType s(Data_.one_two_three_one_two_three());
+
+        UNIT_ASSERT(s.find_last_of(Data_.abcde()) == 26);
+        UNIT_ASSERT(s.find_last_of(TStringType(Data_.abcde())) == 26);
+
+        TStringType test(Data_.aba());
+
+        UNIT_ASSERT(test.find_last_of(Data_.a(), 2, 1) == 2);
+        UNIT_ASSERT(test.find_last_of(Data_.a(), 1, 1) == 0);
+        UNIT_ASSERT(test.find_last_of(Data_.a(), 0, 1) == 0);
+
+        UNIT_ASSERT(test.find_last_of(*Data_.a(), 2) == 2);
+        UNIT_ASSERT(test.find_last_of(*Data_.a(), 1) == 0);
+        UNIT_ASSERT(test.find_last_of(*Data_.a(), 0) == 0);
+    }
+#if 0
+    void rfind() {
+        // 21.3.6.2
+        TStringType s(Data.one_two_three_one_two_three());
+
+        UNIT_ASSERT(s.rfind(Data.two()) == 18);
+        UNIT_ASSERT(s.rfind(Data.two(), 0) == TStringType::npos);
+        UNIT_ASSERT(s.rfind(Data.two(), 11) == 4);
+        UNIT_ASSERT(s.rfind(*Data.w()) == 19);
+
+        TStringType test(Data.aba());
+
+        UNIT_ASSERT(test.rfind(Data.a(), 2, 1) == 2);
+        UNIT_ASSERT(test.rfind(Data.a(), 1, 1) == 0);
+        UNIT_ASSERT(test.rfind(Data.a(), 0, 1) == 0);
+
+        UNIT_ASSERT(test.rfind(*Data.a(), 2) == 2);
+        UNIT_ASSERT(test.rfind(*Data.a(), 1) == 0);
+        UNIT_ASSERT(test.rfind(*Data.a(), 0) == 0);
+    }
+#endif
+    void find_last_not_of() {
+        // 21.3.6.6
+        TStringType s(Data_.one_two_three_one_two_three());
+
+        UNIT_ASSERT(s.find_last_not_of(Data_.ehortw_()) == 15);
+
+        TStringType test(Data_.aba());
+
+        UNIT_ASSERT(test.find_last_not_of(Data_.a(), 2, 1) == 1);
+        UNIT_ASSERT(test.find_last_not_of(Data_.b(), 2, 1) == 2);
+        UNIT_ASSERT(test.find_last_not_of(Data_.a(), 1, 1) == 1);
+        UNIT_ASSERT(test.find_last_not_of(Data_.b(), 1, 1) == 0);
+        UNIT_ASSERT(test.find_last_not_of(Data_.a(), 0, 1) == TStringType::npos);
+        UNIT_ASSERT(test.find_last_not_of(Data_.b(), 0, 1) == 0);
+
+        UNIT_ASSERT(test.find_last_not_of(*Data_.a(), 2) == 1);
+        UNIT_ASSERT(test.find_last_not_of(*Data_.b(), 2) == 2);
+        UNIT_ASSERT(test.find_last_not_of(*Data_.a(), 1) == 1);
+        UNIT_ASSERT(test.find_last_not_of(*Data_.b(), 1) == 0);
+        UNIT_ASSERT(test.find_last_not_of(*Data_.a(), 0) == TStringType::npos);
+        UNIT_ASSERT(test.find_last_not_of(*Data_.b(), 0) == 0);
+    }
+#if 0
+    void replace() {
+        // This test case is for the non template basic_TString::replace method,
+        // this is why we play with the const iterators and reference to guaranty
+        // that the right method is called.
+
+        const TStringType v(Data._78());
+        TStringType s(Data._123456());
+        TStringType const& cs = s;
+
+        typename TStringType::iterator i = s.begin() + 1;
+        s.replace(i, i + 3, v.begin(), v.end());
+        UNIT_ASSERT(s == Data._17856());
+
+        s = Data._123456();
+        i = s.begin() + 1;
+        s.replace(i, i + 1, v.begin(), v.end());
+        UNIT_ASSERT(s == Data._1783456());
+
+        s = Data._123456();
+        i = s.begin() + 1;
+        typename TStringType::const_iterator ci = s.begin() + 1;
+        s.replace(i, i + 3, ci + 3, cs.end());
+        UNIT_ASSERT(s == Data._15656());
+
+        s = Data._123456();
+        i = s.begin() + 1;
+        ci = s.begin() + 1;
+        s.replace(i, i + 3, ci, ci + 2);
+        UNIT_ASSERT(s == Data._12356());
+
+        s = Data._123456();
+        i = s.begin() + 1;
+        ci = s.begin() + 1;
+        s.replace(i, i + 3, ci + 1, cs.end());
+        UNIT_ASSERT(s == Data._1345656());
+
+        s = Data._123456();
+        i = s.begin();
+        ci = s.begin() + 1;
+        s.replace(i, i, ci, ci + 1);
+        UNIT_ASSERT(s == Data._2123456());
+
+        s = Data._123456();
+        s.replace(s.begin() + 4, s.end(), cs.begin(), cs.end());
+        UNIT_ASSERT(s == Data._1234123456());
+
+        // This is the test for the template replace method.
+
+        s = Data._123456();
+        typename TStringType::iterator b = s.begin() + 4;
+        typename TStringType::iterator e = s.end();
+        typename TStringType::const_iterator rb = s.begin();
+        typename TStringType::const_iterator re = s.end();
+        s.replace(b, e, rb, re);
+        UNIT_ASSERT(s == Data._1234123456());
+
+        s = Data._123456();
+        s.replace(s.begin() + 4, s.end(), s.begin(), s.end());
+        UNIT_ASSERT(s == Data._1234123456());
+
+        TStringType strorg(Data.This_is_test_StringT_for_StringT_calls());
+        TStringType str = strorg;
+        str.replace(5, 15, str.c_str(), 10);
+        UNIT_ASSERT(str == Data.This_This_is_tefor_StringT_calls());
+
+        str = strorg;
+        str.replace(5, 5, str.c_str(), 10);
+        UNIT_ASSERT(str == Data.This_This_is_test_StringT_for_StringT_calls());
+
+    #if !defined(STLPORT) || defined(_STLP_MEMBER_TEMPLATES)
+        deque<TChar> cdeque;
+        cdeque.push_back(*Data.I());
+        str.replace(str.begin(), str.begin() + 11, cdeque.begin(), cdeque.end());
+        UNIT_ASSERT(str == Data.Is_test_StringT_for_StringT_calls());
+    #endif
+    }
+#endif
+}; // TStringStdTestImpl
+
+class TStringTest: public TTestBase, private TStringTestImpl<TCowString, TTestData<char>> {
+public:
+    UNIT_TEST_SUITE(TStringTest);
+    UNIT_TEST(TestMaxSize);
+    UNIT_TEST(TestConstructors);
+    UNIT_TEST(TestReplace);
+    UNIT_TEST(TestRefCount);
+    UNIT_TEST(TestFind);
+    UNIT_TEST(TestContains);
+    UNIT_TEST(TestOperators);
+    UNIT_TEST(TestMulOperators);
+    UNIT_TEST(TestFuncs);
+    UNIT_TEST(TestUtils);
+    UNIT_TEST(TestEmpty);
+    UNIT_TEST(TestJoin);
+    UNIT_TEST(TestCopy);
+    UNIT_TEST(TestStrCpy);
+    UNIT_TEST(TestPrefixSuffix);
+    UNIT_TEST(TestCharRef);
+    UNIT_TEST(TestBack)
+    UNIT_TEST(TestFront)
+    UNIT_TEST(TestIterators);
+    UNIT_TEST(TestReverseIterators);
+    UNIT_TEST(TestAppendUtf16)
+    UNIT_TEST(TestFillingAssign)
+    UNIT_TEST(TestStdStreamApi)
+    // UNIT_TEST(TestOperatorsCI); must fail
+    UNIT_TEST_SUITE_END();
+
+    void TestAppendUtf16() {
+        TCowString appended = TCowString("А роза упала").AppendUtf16(u" на лапу Азора");
+        UNIT_ASSERT(appended == "А роза упала на лапу Азора");
+    }
+
+    void TestFillingAssign() {
+        TCowString s("abc");
+        s.assign(5, 'a');
+        UNIT_ASSERT_VALUES_EQUAL(s, "aaaaa");
+    }
+
+    void TestStdStreamApi() {
+        const TCowString data = "abracadabra";
+        std::stringstream ss;
+        ss << data;
+
+        UNIT_ASSERT_VALUES_EQUAL(data, ss.str());
+
+        ss << '\n'
+           << data << std::endl;
+
+        TCowString read = "xxx";
+        ss >> read;
+        UNIT_ASSERT_VALUES_EQUAL(read, data);
+    }
+};
+
+UNIT_TEST_SUITE_REGISTRATION(TStringTest);
+
+class TWideStringTest: public TTestBase, private TStringTestImpl<TUtf16CowString, TTestData<wchar16>> {
+public:
+    UNIT_TEST_SUITE(TWideStringTest);
+    UNIT_TEST(TestConstructors);
+    UNIT_TEST(TestReplace);
+    UNIT_TEST(TestRefCount);
+    UNIT_TEST(TestFind);
+    UNIT_TEST(TestContains);
+    UNIT_TEST(TestOperators);
+    UNIT_TEST(TestLetOperator)
+    UNIT_TEST(TestMulOperators);
+    UNIT_TEST(TestFuncs);
+    UNIT_TEST(TestUtils);
+    UNIT_TEST(TestEmpty);
+    UNIT_TEST(TestJoin);
+    UNIT_TEST(TestCopy);
+    UNIT_TEST(TestStrCpy);
+    UNIT_TEST(TestPrefixSuffix);
+    UNIT_TEST(TestCharRef);
+    UNIT_TEST(TestBack);
+    UNIT_TEST(TestFront)
+    UNIT_TEST(TestDecodingMethods);
+    UNIT_TEST(TestIterators);
+    UNIT_TEST(TestReverseIterators);
+    UNIT_TEST(TestStringLiterals);
+    UNIT_TEST_SUITE_END();
+
+private:
+    void TestDecodingMethods() {
+        UNIT_ASSERT(TUtf16CowString::FromAscii("").empty());
+        UNIT_ASSERT(TUtf16CowString::FromAscii("abc") == ASCIIToWide("abc"));
+
+#if 0 // no wide convertions support
+        const char* text = "123kx83abcd ej)#$%ddja&%J&";
+        TUtf16CowString wtext = ASCIIToWide(text);
+
+        UNIT_ASSERT(wtext == TUtf16CowString::FromAscii(text));
+
+        TCowString strtext(text);
+        UNIT_ASSERT(wtext == TUtf16CowString::FromAscii(strtext));
+
+        TStringBuf strbuftext(text);
+        UNIT_ASSERT(wtext == TUtf16CowString::FromAscii(strbuftext));
+
+        UNIT_ASSERT(wtext.substr(5) == TUtf16CowString::FromAscii(text + 5));
+
+        const wchar16 wideCyrillicAlphabet[] = {
+            0x0410, 0x0411, 0x0412, 0x0413, 0x0414, 0x0415, 0x0416, 0x0417, 0x0418, 0x0419, 0x041A, 0x041B, 0x041C, 0x041D, 0x041E, 0x041F,
+            0x0420, 0x0421, 0x0422, 0x0423, 0x0424, 0x0425, 0x0426, 0x0427, 0x0428, 0x0429, 0x042A, 0x042B, 0x042C, 0x042D, 0x042E, 0x042F,
+            0x0430, 0x0431, 0x0432, 0x0433, 0x0434, 0x0435, 0x0436, 0x0437, 0x0438, 0x0439, 0x043A, 0x043B, 0x043C, 0x043D, 0x043E, 0x043F,
+            0x0440, 0x0441, 0x0442, 0x0443, 0x0444, 0x0445, 0x0446, 0x0447, 0x0448, 0x0449, 0x044A, 0x044B, 0x044C, 0x044D, 0x044E, 0x044F,
+            0x00};
+
+        TUtf16CowString strWide(wideCyrillicAlphabet);
+        TCowString strUtf8 = WideToUTF8(strWide);
+
+        UNIT_ASSERT(strWide == TUtf16CowString::FromUtf8(strUtf8.c_str()));
+        UNIT_ASSERT(strWide == TUtf16CowString::FromUtf8(strUtf8));
+        UNIT_ASSERT(strWide == TUtf16CowString::FromUtf8(TStringBuf(strUtf8)));
+
+        // assign
+
+        TUtf16CowString s1;
+        s1.AssignAscii("1234");
+        UNIT_ASSERT(s1 == ASCIIToWide("1234"));
+
+        s1.AssignUtf8(strUtf8);
+        UNIT_ASSERT(s1 == strWide);
+
+        s1.AssignAscii(text);
+        UNIT_ASSERT(s1 == wtext);
+
+        // append
+
+        TUtf16CowString s2;
+        TUtf16CowString testAppend = strWide;
+        s2.AppendUtf8(strUtf8);
+        UNIT_ASSERT(testAppend == s2);
+
+        testAppend += ' ';
+        s2.AppendAscii(" ");
+        UNIT_ASSERT(testAppend == s2);
+
+        testAppend += '_';
+        s2.AppendUtf8("_");
+        UNIT_ASSERT(testAppend == s2);
+
+        testAppend += wtext;
+        s2.AppendAscii(text);
+        UNIT_ASSERT(testAppend == s2);
+
+        testAppend += wtext;
+        s2.AppendUtf8(text);
+        UNIT_ASSERT(testAppend == s2);
+#endif
+    }
+
+    void TestLetOperator() {
+        TUtf16CowString str;
+
+        str = wchar16('X');
+        UNIT_ASSERT(str == TUtf16CowString::FromAscii("X"));
+
+        const TUtf16CowString hello = TUtf16CowString::FromAscii("hello");
+        str = hello.data();
+        UNIT_ASSERT(str == hello);
+
+        str = hello;
+        UNIT_ASSERT(str == hello);
+    }
+
+    void TestStringLiterals() {
+        TUtf16CowString s1 = u"hello";
+        UNIT_ASSERT_VALUES_EQUAL(s1, TUtf16CowString::FromAscii("hello"));
+
+        TUtf16CowString s2 = u"привет";
+        UNIT_ASSERT_VALUES_EQUAL(s2, TUtf16CowString::FromUtf8("привет"));
+    }
+};
+
+UNIT_TEST_SUITE_REGISTRATION(TWideStringTest);
+
+class TUtf32StringTest: public TTestBase, private TStringTestImpl<TUtf32CowString, TTestData<wchar32>> {
+public:
+    UNIT_TEST_SUITE(TUtf32StringTest);
+    UNIT_TEST(TestConstructors);
+    UNIT_TEST(TestReplace);
+    UNIT_TEST(TestRefCount);
+    UNIT_TEST(TestFind);
+    UNIT_TEST(TestContains);
+    UNIT_TEST(TestOperators);
+    UNIT_TEST(TestLetOperator)
+    UNIT_TEST(TestMulOperators);
+    UNIT_TEST(TestFuncs);
+    UNIT_TEST(TestUtils);
+    UNIT_TEST(TestEmpty);
+    UNIT_TEST(TestJoin);
+    UNIT_TEST(TestCopy);
+    UNIT_TEST(TestStrCpy);
+    UNIT_TEST(TestPrefixSuffix);
+    UNIT_TEST(TestCharRef);
+    UNIT_TEST(TestBack);
+    UNIT_TEST(TestFront)
+    UNIT_TEST(TestDecodingMethods);
+    UNIT_TEST(TestDecodingMethodsMixedStr);
+    UNIT_TEST(TestIterators);
+    UNIT_TEST(TestReverseIterators);
+    UNIT_TEST(TestStringLiterals);
+    UNIT_TEST_SUITE_END();
+
+private:
+    void TestDecodingMethods() {
+        UNIT_ASSERT(TUtf32CowString::FromAscii("").empty());
+        UNIT_ASSERT(TUtf32CowString::FromAscii("abc") == ASCIIToUTF32("abc"));
+
+#if 0 // no wide convertions support
+        const char* text = "123kx83abcd ej)#$%ddja&%J&";
+        TUtf32CowString wtext = ASCIIToUTF32(text);
+
+        UNIT_ASSERT(wtext == TUtf32CowString::FromAscii(text));
+
+        TCowString strtext(text);
+        UNIT_ASSERT(wtext == TUtf32CowString::FromAscii(strtext));
+
+        TStringBuf strbuftext(text);
+        UNIT_ASSERT(wtext == TUtf32CowString::FromAscii(strbuftext));
+
+        UNIT_ASSERT(wtext.substr(5) == TUtf32CowString::FromAscii(text + 5));
+
+        const wchar32 wideCyrillicAlphabet[] = {
+            0x0410, 0x0411, 0x0412, 0x0413, 0x0414, 0x0415, 0x0416, 0x0417, 0x0418, 0x0419, 0x041A, 0x041B, 0x041C, 0x041D, 0x041E, 0x041F,
+            0x0420, 0x0421, 0x0422, 0x0423, 0x0424, 0x0425, 0x0426, 0x0427, 0x0428, 0x0429, 0x042A, 0x042B, 0x042C, 0x042D, 0x042E, 0x042F,
+            0x0430, 0x0431, 0x0432, 0x0433, 0x0434, 0x0435, 0x0436, 0x0437, 0x0438, 0x0439, 0x043A, 0x043B, 0x043C, 0x043D, 0x043E, 0x043F,
+            0x0440, 0x0441, 0x0442, 0x0443, 0x0444, 0x0445, 0x0446, 0x0447, 0x0448, 0x0449, 0x044A, 0x044B, 0x044C, 0x044D, 0x044E, 0x044F,
+            0x00};
+
+        TUtf32CowString strWide(wideCyrillicAlphabet);
+        TCowString strUtf8 = WideToUTF8(strWide);
+
+        UNIT_ASSERT(strWide == TUtf32CowString::FromUtf8(strUtf8.c_str()));
+        UNIT_ASSERT(strWide == TUtf32CowString::FromUtf8(strUtf8));
+        UNIT_ASSERT(strWide == TUtf32CowString::FromUtf8(TStringBuf(strUtf8)));
+
+        // assign
+
+        TUtf32CowString s1;
+        s1.AssignAscii("1234");
+        UNIT_ASSERT(s1 == ASCIIToUTF32("1234"));
+
+        s1.AssignUtf8(strUtf8);
+        UNIT_ASSERT(s1 == strWide);
+
+        s1.AssignAscii(text);
+        UNIT_ASSERT(s1 == wtext);
+
+        // append
+
+        TUtf32CowString s2;
+        TUtf32CowString testAppend = strWide;
+        s2.AppendUtf8(strUtf8);
+        UNIT_ASSERT(testAppend == s2);
+
+        testAppend += ' ';
+        s2.AppendAscii(" ");
+        UNIT_ASSERT(testAppend == s2);
+
+        testAppend += '_';
+        s2.AppendUtf8("_");
+        UNIT_ASSERT(testAppend == s2);
+
+        testAppend += wtext;
+        s2.AppendAscii(text);
+        UNIT_ASSERT(testAppend == s2);
+
+        testAppend += wtext;
+        s2.AppendUtf8(text);
+
+        UNIT_ASSERT(testAppend == s2);
+#endif
+    }
+
+    void TestDecodingMethodsMixedStr() {
+        UNIT_ASSERT(TUtf32CowString::FromAscii("").empty());
+        UNIT_ASSERT(TUtf32CowString::FromAscii("abc") == ASCIIToUTF32("abc"));
+
+#if 0 // no wide convertions support
+        const char* text = "123kx83abcd ej)#$%ddja&%J&";
+        TUtf32CowString wtext = ASCIIToUTF32(text);
+
+        UNIT_ASSERT(wtext == TUtf32CowString::FromAscii(text));
+
+        TCowString strtext(text);
+        UNIT_ASSERT(wtext == TUtf32CowString::FromAscii(strtext));
+
+        TStringBuf strbuftext(text);
+        UNIT_ASSERT(wtext == TUtf32CowString::FromAscii(strbuftext));
+
+        UNIT_ASSERT(wtext.substr(5) == TUtf32CowString::FromAscii(text + 5));
+
+        const wchar32 cyrilicAndLatinWide[] = {
+            0x0410, 0x0411, 0x0412, 0x0413, 0x0414, 0x0415, 0x0416, 0x0417, 0x0418, 0x0419, 0x041A, 0x041B, 0x041C, 0x041D, 0x041E, 0x041F,
+            0x0420, 0x0421, 0x0422, 0x0423, 0x0424, 0x0425, 0x0426, 0x0427, 0x0428, 0x0429, 0x042A, 0x042B, 0x042C, 0x042D, 0x042E, 0x042F,
+            0x0430, 0x0431, 0x0432, 0x0433, 0x0434, 0x0435, 0x0436, 0x0437, 0x0438, 0x0439, 0x043A, 0x043B, 0x043C, 0x043D, 0x043E, 0x043F,
+            wchar32('z'),
+            0x0440, 0x0441, 0x0442, 0x0443, 0x0444, 0x0445, 0x0446, 0x0447, 0x0448, 0x0449, 0x044A, 0x044B, 0x044C, 0x044D, 0x044E, 0x044F,
+            wchar32('z'),
+            0x00};
+
+        TUtf32CowString strWide(cyrilicAndLatinWide);
+        TCowString strUtf8 = WideToUTF8(strWide);
+
+        UNIT_ASSERT(strWide == TUtf32CowString::FromUtf8(strUtf8.c_str()));
+        UNIT_ASSERT(strWide == TUtf32CowString::FromUtf8(strUtf8));
+        UNIT_ASSERT(strWide == UTF8ToUTF32<true>(strUtf8));
+        UNIT_ASSERT(strWide == UTF8ToUTF32<false>(strUtf8));
+        UNIT_ASSERT(strWide == TUtf32CowString::FromUtf8(TStringBuf(strUtf8)));
+
+        // assign
+
+        TUtf32CowString s1;
+        s1.AssignAscii("1234");
+        UNIT_ASSERT(s1 == ASCIIToUTF32("1234"));
+
+        s1.AssignUtf8(strUtf8);
+        UNIT_ASSERT(s1 == strWide);
+
+        s1.AssignAscii(text);
+        UNIT_ASSERT(s1 == wtext);
+
+        // append
+
+        TUtf32CowString s2;
+        TUtf32CowString testAppend = strWide;
+        s2.AppendUtf16(UTF8ToWide(strUtf8));
+        UNIT_ASSERT(testAppend == s2);
+
+        testAppend += ' ';
+        s2.AppendAscii(" ");
+        UNIT_ASSERT(testAppend == s2);
+
+        testAppend += '_';
+        s2.AppendUtf8("_");
+        UNIT_ASSERT(testAppend == s2);
+
+        testAppend += wtext;
+        s2.AppendAscii(text);
+        UNIT_ASSERT(testAppend == s2);
+
+        testAppend += wtext;
+        s2.AppendUtf8(text);
+
+        UNIT_ASSERT(testAppend == s2);
+#endif
+    }
+
+    void TestLetOperator() {
+        TUtf32CowString str;
+
+        str = wchar32('X');
+        UNIT_ASSERT(str == TUtf32CowString::FromAscii("X"));
+
+        const TUtf32CowString hello = TUtf32CowString::FromAscii("hello");
+        str = hello.data();
+        UNIT_ASSERT(str == hello);
+
+        str = hello;
+        UNIT_ASSERT(str == hello);
+    }
+
+    void TestStringLiterals() {
+        TUtf32CowString s1 = U"hello";
+        UNIT_ASSERT_VALUES_EQUAL(s1, TUtf32CowString::FromAscii("hello"));
+
+        TUtf32CowString s2 = U"привет";
+        UNIT_ASSERT_VALUES_EQUAL(s2, TUtf32CowString::FromUtf8("привет"));
+    }
+};
+
+UNIT_TEST_SUITE_REGISTRATION(TUtf32StringTest);
+
+class TStringStdTest: public TTestBase, private TStringStdTestImpl<TCowString, TTestData<char>> {
+public:
+    UNIT_TEST_SUITE(TStringStdTest);
+    UNIT_TEST(Constructor);
+    UNIT_TEST(reserve);
+    UNIT_TEST(short_string);
+    UNIT_TEST(erase);
+    UNIT_TEST(data);
+    UNIT_TEST(c_str);
+    UNIT_TEST(null_char_of_empty);
+    UNIT_TEST(null_char);
+    UNIT_TEST(null_char_assignment_to_subscript_of_empty);
+    UNIT_TEST(null_char_assignment_to_subscript_of_nonempty);
+    UNIT_TEST(null_char_assignment_to_end_of_empty);
+    UNIT_TEST(null_char_assignment_to_end_of_nonempty);
+    UNIT_TEST(insert);
+    UNIT_TEST(resize);
+    UNIT_TEST(find);
+    UNIT_TEST(capacity);
+    UNIT_TEST(assign);
+    UNIT_TEST(copy);
+    UNIT_TEST(cbegin_cend);
+    UNIT_TEST(compare);
+    UNIT_TEST(find_last_of);
+#if 0
+        UNIT_TEST(rfind);
+        UNIT_TEST(replace);
+#endif
+    UNIT_TEST(find_last_not_of);
+    UNIT_TEST_SUITE_END();
+};
+
+UNIT_TEST_SUITE_REGISTRATION(TStringStdTest);
+
+class TWideStringStdTest: public TTestBase, private TStringStdTestImpl<TUtf16CowString, TTestData<wchar16>> {
+public:
+    UNIT_TEST_SUITE(TWideStringStdTest);
+    UNIT_TEST(Constructor);
+    UNIT_TEST(reserve);
+    UNIT_TEST(short_string);
+    UNIT_TEST(erase);
+    UNIT_TEST(data);
+    UNIT_TEST(c_str);
+    UNIT_TEST(null_char_of_empty);
+    UNIT_TEST(null_char);
+    UNIT_TEST(null_char_assignment_to_subscript_of_empty);
+    UNIT_TEST(null_char_assignment_to_subscript_of_nonempty);
+    UNIT_TEST(null_char_assignment_to_end_of_empty);
+    UNIT_TEST(null_char_assignment_to_end_of_nonempty);
+    UNIT_TEST(insert);
+    UNIT_TEST(resize);
+    UNIT_TEST(find);
+    UNIT_TEST(capacity);
+    UNIT_TEST(assign);
+    UNIT_TEST(copy);
+    UNIT_TEST(cbegin_cend);
+    UNIT_TEST(compare);
+    UNIT_TEST(find_last_of);
+#if 0
+        UNIT_TEST(rfind);
+        UNIT_TEST(replace);
+#endif
+    UNIT_TEST(find_last_not_of);
+    UNIT_TEST_SUITE_END();
+};
+
+UNIT_TEST_SUITE_REGISTRATION(TWideStringStdTest);
+
+Y_UNIT_TEST_SUITE(TCowStringSerializationTest) {
+    TCowString SerializeThereAndBack(const TCowString& value) {
+        std::array<char, 1024> buf;
+        TMemoryWriteBuffer out{buf.data(), buf.size()};
+        Save(&out, value);
+
+        TMemoryInput in{buf.data(), out.Len()};
+        TCowString deserialized;
+        Load<TCowString>(&in, deserialized);
+        return deserialized;
+    }
+
+    Y_UNIT_TEST(EmptyStringSerializationTest) {
+        TCowString nothing{};
+        TCowString deserialized = SerializeThereAndBack(nothing);
+
+        UNIT_ASSERT_VALUES_EQUAL(nothing, deserialized);
+    }
+
+    Y_UNIT_TEST(RegularStringSerializationTest) {
+        TCowString abra = "cadabra";
+        TCowString deserialized = SerializeThereAndBack(abra);
+
+        UNIT_ASSERT_VALUES_EQUAL(abra, deserialized);
+    }
+} // Y_UNIT_TEST_SUITE(TCowStringSerializationTest)
+
+Y_UNIT_TEST_SUITE(TStringConversionTest) {
+    Y_UNIT_TEST(ConversionToStdStringTest) {
+        TCowString abra = "cadabra";
+        std::string stdAbra = abra;
+        UNIT_ASSERT_VALUES_EQUAL(stdAbra, "cadabra");
+    }
+
+    Y_UNIT_TEST(ConversionToStdStringViewTest) {
+        TCowString abra = "cadabra";
+        std::string_view stdAbra = abra;
+        UNIT_ASSERT_VALUES_EQUAL(stdAbra, "cadabra");
+    }
+} // Y_UNIT_TEST_SUITE(TStringConversionTest)
+
+Y_UNIT_TEST_SUITE(HashFunctorTests) {
+    Y_UNIT_TEST(TestTransparency) {
+        THash<TCowString> h;
+        const char* ptr = "a";
+        const TStringBuf strbuf = ptr;
+        const TCowString str = ptr;
+        const std::string stdStr = ptr;
+        UNIT_ASSERT_VALUES_EQUAL(h(ptr), h(strbuf));
+        UNIT_ASSERT_VALUES_EQUAL(h(ptr), h(str));
+        UNIT_ASSERT_VALUES_EQUAL(h(ptr), h(stdStr));
+    }
+} // Y_UNIT_TEST_SUITE(HashFunctorTests)
+
+Y_UNIT_TEST_SUITE(StdNonConformant) {
+    Y_UNIT_TEST(TestEraseNoThrow) {
+        TCowString x;
+
+        LegacyErase(x, 10);
+    }
+
+    Y_UNIT_TEST(TestReplaceNoThrow) {
+        TCowString x;
+
+        LegacyReplace(x, 0, 0, "1");
+
+        UNIT_ASSERT_VALUES_EQUAL(x, "1");
+
+        LegacyReplace(x, 10, 0, "1");
+
+        UNIT_ASSERT_VALUES_EQUAL(x, "1");
+    }
+
+    Y_UNIT_TEST(TestNoAlias) {
+        TCowString s = "x";
+
+        s.AppendNoAlias("abc", 3);
+
+        UNIT_ASSERT_VALUES_EQUAL(s, "xabc");
+        UNIT_ASSERT_VALUES_EQUAL(TCowString(s.c_str()), "xabc");
+    }
+} // Y_UNIT_TEST_SUITE(StdNonConformant)
+
+Y_UNIT_TEST_SUITE(Interop) {
+    static void Mutate(std::string& s) {
+        s += "y";
+    }
+
+    static void Mutate(TCowString& s) {
+        Mutate(MutRef(s));
+    }
+
+    Y_UNIT_TEST(TestMutate) {
+        TCowString x = "x";
+
+        Mutate(x);
+
+        UNIT_ASSERT_VALUES_EQUAL(x, "xy");
+    }
+
+    static std::string TransformStd(const std::string& s) {
+        return s + "y";
+    }
+
+    static TCowString Transform(const TCowString& s) {
+        return TransformStd(s);
+    }
+
+    Y_UNIT_TEST(TestTransform) {
+        UNIT_ASSERT_VALUES_EQUAL(Transform(TCowString("x")), "xy");
+    }
+
+    Y_UNIT_TEST(TestTemp) {
+        UNIT_ASSERT_VALUES_EQUAL("x" + ConstRef(TCowString("y")), "xy");
+    }
+
+    static void ComparePointers(const std::string& s, const void* expected, TStringBuf descr) {
+        UNIT_ASSERT_VALUES_EQUAL_C(static_cast<const void*>(s.c_str()), expected, descr);
+    }
+
+    Y_UNIT_TEST(TestConstShared) {
+        TCowString s(600, 'a');
+        const void* stringStart = s.c_str();
+        ComparePointers(s, stringStart, "unique");
+        TCowString shared{s};
+        ComparePointers(s, stringStart, "shared"); // converting a TCowString to a `const std::string&` should not cause data cloning
+    }
+} // Y_UNIT_TEST_SUITE(Interop)
+
+Y_UNIT_TEST_SUITE(CowPitfalls) {
+    template<class T>
+    static TString CopyStringViaBeginEndIterators(T& string, bool reverse) {
+        decltype(string.begin()) b;
+        decltype(string.end()) e;
+        if (!reverse) {
+            b = string.begin();
+            e = string.end();
+        } else {
+            e = string.end();
+            b = string.begin();
+        }
+        return TString{b, e};
+    }
+
+    Y_UNIT_TEST(IteratorCallOrder) {
+        const TString ref(600, 'a');
+        for (const bool reverse : {false, true}) {
+            TCowString s = {ref.begin(), ref.end()};
+            // sanity check
+            UNIT_ASSERT_VALUES_EQUAL_C(CopyStringViaBeginEndIterators<const TCowString>(s, reverse), TStringBuf(ref), LabeledOutput(reverse));
+            UNIT_ASSERT_VALUES_EQUAL_C(CopyStringViaBeginEndIterators<TCowString>(s, reverse), TStringBuf(ref), LabeledOutput(reverse));
+            // test
+            TCowString copy = s;
+            UNIT_ASSERT_VALUES_EQUAL_C(CopyStringViaBeginEndIterators<const TCowString>(s, reverse), TStringBuf(ref), LabeledOutput(reverse));
+            UNIT_ASSERT_VALUES_EQUAL_C(CopyStringViaBeginEndIterators<TCowString>(s, reverse), TStringBuf(ref), LabeledOutput(reverse));
+        }
+    }
+
+    Y_UNIT_TEST(RangeFor) {
+        TCowString str;
+        str.resize(200);
+        TCowString copy = str;
+        for (auto& c : str) {
+            c = 'x';
+        }
+        UNIT_ASSERT_VALUES_EQUAL(str, TString(200, 'x'));
+    }
+} // Y_UNIT_TEST_SUITE(CowPitfalls)
diff --git a/library/cpp/containers/cow_string/output.cpp b/library/cpp/containers/cow_string/output.cpp
new file mode 100644
index 00000000000..e0b4924ad31
--- /dev/null
+++ b/library/cpp/containers/cow_string/output.cpp
@@ -0,0 +1,46 @@
+#include "cow_string.h"
+
+#include <util/charset/wide.h>
+#include <util/stream/input.h>
+#include <util/string/cast.h>
+
+constexpr size_t MAX_UTF8_BYTES = 4; // UTF-8-encoded code point takes between 1 and 4 bytes
+
+template <typename TCharType>
+static void WriteString(IOutputStream& o, const TCharType* w, size_t n) {
+    const size_t buflen = (n * MAX_UTF8_BYTES); // * 4 because the conversion functions can convert unicode character into maximum 4 bytes of UTF8
+    TTempBuf buffer(buflen + 1);
+    size_t written = 0;
+    WideToUTF8(w, n, buffer.Data(), written);
+    o.Write(buffer.Data(), written);
+}
+
+template <>
+void Out<TCowString>(IOutputStream& o, const TCowString& p) {
+    o.Write(p.data(), p.size());
+}
+
+template <>
+void Out<TUtf16CowString>(IOutputStream& o, const TUtf16CowString& w) {
+    WriteString(o, w.c_str(), w.size());
+}
+
+template <>
+void Out<TUtf32CowString>(IOutputStream& o, const TUtf32CowString& w) {
+    WriteString(o, w.c_str(), w.size());
+}
+
+template <>
+void Out<TBasicCharRef<TCowString>>(IOutputStream& o, const TBasicCharRef<TCowString>& c) {
+    o << static_cast<char>(c);
+}
+
+template <>
+void Out<TBasicCharRef<TUtf16CowString>>(IOutputStream& o, const TBasicCharRef<TUtf16CowString>& c) {
+    o << static_cast<wchar16>(c);
+}
+
+template <>
+void Out<TBasicCharRef<TUtf32CowString>>(IOutputStream& o, const TBasicCharRef<TUtf32CowString>& c) {
+    o << static_cast<wchar32>(c);
+}
diff --git a/library/cpp/containers/cow_string/reverse.cpp b/library/cpp/containers/cow_string/reverse.cpp
new file mode 100644
index 00000000000..b5bd10d250a
--- /dev/null
+++ b/library/cpp/containers/cow_string/reverse.cpp
@@ -0,0 +1,32 @@
+#include "reverse.h"
+
+#include <util/generic/vector.h>
+#include <util/charset/wide_specific.h>
+
+#include <algorithm>
+
+void ReverseInPlace(TCowString& string) {
+    auto* begin = string.begin();
+    std::reverse(begin, begin + string.size());
+}
+
+void ReverseInPlace(TUtf16CowString& string) {
+    auto* begin = string.begin();
+    const auto len = string.size();
+    auto* end = begin + string.size();
+
+    TVector<wchar16> buffer(len);
+    wchar16* rbegin = buffer.data() + len;
+    for (wchar16* p = begin; p < end;) {
+        const size_t symbolSize = W16SymbolSize(p, end);
+        rbegin -= symbolSize;
+        std::copy(p, p + symbolSize, rbegin);
+        p += symbolSize;
+    }
+    std::copy(buffer.begin(), buffer.end(), begin);
+}
+
+void ReverseInPlace(TUtf32CowString& string) {
+    auto* begin = string.begin();
+    std::reverse(begin, begin + string.size());
+}
diff --git a/library/cpp/containers/cow_string/reverse.h b/library/cpp/containers/cow_string/reverse.h
new file mode 100644
index 00000000000..d27b0b4fed6
--- /dev/null
+++ b/library/cpp/containers/cow_string/reverse.h
@@ -0,0 +1,16 @@
+#pragma once
+
+#include <library/cpp/containers/cow_string/cow_string.h>
+
+void ReverseInPlace(TCowString& string);
+
+/** NB. UTF-16 is variable-length encoding because of the surrogate pairs.
+ * This function takes this into account and treats a surrogate pair as a single symbol.
+ * Ex. if [C D] is a surrogate pair,
+ * A B [C D] E
+ * will become
+ * E [C D] B A
+ */
+void ReverseInPlace(TUtf16CowString& string);
+
+void ReverseInPlace(TUtf32CowString& string);
diff --git a/library/cpp/containers/cow_string/str_stl.h b/library/cpp/containers/cow_string/str_stl.h
new file mode 100644
index 00000000000..d8256a6e10b
--- /dev/null
+++ b/library/cpp/containers/cow_string/str_stl.h
@@ -0,0 +1,67 @@
+#pragma once
+
+#include <util/str_stl.h>
+
+template <>
+struct hash<TCowString>: ::NHashPrivate::TStringHash<char> {
+};
+
+template <>
+struct hash<TUtf16CowString>: ::NHashPrivate::TStringHash<wchar16> {
+};
+
+template <>
+struct hash<TUtf32CowString>: ::NHashPrivate::TStringHash<wchar32> {
+};
+
+template <>
+struct TEqualTo<TCowString>: public TEqualTo<TStringBuf> {
+    using is_transparent = void;
+};
+
+template <>
+struct TEqualTo<TUtf16CowString>: public TEqualTo<TWtringBuf> {
+    using is_transparent = void;
+};
+
+template <>
+struct TEqualTo<TUtf32CowString>: public TEqualTo<TUtf32StringBuf> {
+    using is_transparent = void;
+};
+
+template <>
+struct TCIEqualTo<TCowString> {
+    inline bool operator()(const TCowString& a, const TCowString& b) const {
+        return a.size() == b.size() && strnicmp(a.data(), b.data(), a.size()) == 0;
+    }
+};
+
+template <>
+struct TLess<TCowString>: public TLess<TStringBuf> {
+    using is_transparent = void;
+};
+
+template <>
+struct TLess<TUtf16CowString>: public TLess<TWtringBuf> {
+    using is_transparent = void;
+};
+
+template <>
+struct TLess<TUtf32CowString>: public TLess<TUtf32StringBuf> {
+    using is_transparent = void;
+};
+
+template <>
+struct TGreater<TCowString>: public TGreater<TStringBuf> {
+    using is_transparent = void;
+};
+
+template <>
+struct TGreater<TUtf16CowString>: public TGreater<TWtringBuf> {
+    using is_transparent = void;
+};
+
+template <>
+struct TGreater<TUtf32CowString>: public TGreater<TUtf32StringBuf> {
+    using is_transparent = void;
+};
diff --git a/library/cpp/containers/cow_string/subst.cpp b/library/cpp/containers/cow_string/subst.cpp
new file mode 100644
index 00000000000..d4e9ff3395d
--- /dev/null
+++ b/library/cpp/containers/cow_string/subst.cpp
@@ -0,0 +1,182 @@
+#include "subst.h"
+
+#include <util/generic/strbuf.h>
+#include <util/generic/string.h>
+#include <util/system/compiler.h>
+
+#include <string>
+#include <type_traits>
+
+// a bit of template magic (to be fast and unreadable)
+template <class TStringType, class TTo, bool Main>
+static Y_FORCE_INLINE void MoveBlock(typename TStringType::value_type* ptr, size_t& srcPos, size_t& dstPos, const size_t off, const TTo to, const size_t toSize) {
+    const size_t unchangedSize = off - srcPos;
+    if (dstPos < srcPos) {
+        for (size_t i = 0; i < unchangedSize; ++i) {
+            ptr[dstPos++] = ptr[srcPos++];
+        }
+    } else {
+        dstPos += unchangedSize;
+        srcPos += unchangedSize;
+    }
+
+    if (Main) {
+        for (size_t i = 0; i < toSize; ++i) {
+            ptr[dstPos++] = to[i];
+        }
+    }
+}
+
+template <typename T, typename U>
+static bool IsIntersect(const T& a, const U& b) noexcept {
+    if (b.data() < a.data()) {
+        return IsIntersect(b, a);
+    }
+
+    return !a.empty() && !b.empty() &&
+           ((a.data() <= b.data() && b.data() < a.data() + a.size()) ||
+            (a.data() < b.data() + b.size() && b.data() + b.size() <= a.data() + a.size()));
+}
+
+/**
+ * Replaces all occurences of substring @c from in string @c s to string @c to.
+ * Uses two separate implementations (inplace for shrink and append for grow case)
+ * See IGNIETFERRO-394
+ **/
+template <class TStringType, typename TStringViewType = TBasicStringBuf<typename TStringType::value_type>>
+static inline size_t SubstGlobalImpl(TStringType& s, const TStringViewType from, const TStringViewType to, size_t fromPos = 0) {
+    if (from.empty()) {
+        return 0;
+    }
+
+    Y_ASSERT(!IsIntersect(s, from));
+    Y_ASSERT(!IsIntersect(s, to));
+
+    const size_t fromSize = from.size();
+    const size_t toSize = to.size();
+    size_t replacementsCount = 0;
+    size_t off = fromPos;
+    size_t srcPos = 0;
+
+    if (toSize > fromSize) {
+        // string will grow: append to another string
+        TStringType result;
+        for (; (off = TStringViewType(s).find(from, off)) != TStringType::npos; off += fromSize) {
+            if (!replacementsCount) {
+                // first replacement occured, we can prepare result string
+                result.reserve(s.size() + s.size() / 3);
+            }
+            result.append(s.begin() + srcPos, s.begin() + off);
+            result.append(to.data(), to.size());
+            srcPos = off + fromSize;
+            ++replacementsCount;
+        }
+        if (replacementsCount) {
+            // append tail
+            result.append(s.begin() + srcPos, s.end());
+            s = std::move(result);
+        }
+        return replacementsCount;
+    }
+
+    // string will not grow: use inplace algo
+    size_t dstPos = 0;
+    typename TStringType::value_type* ptr = &*s.begin();
+    for (; (off = TStringViewType(s).find(from, off)) != TStringType::npos; off += fromSize) {
+        Y_ASSERT(dstPos <= srcPos);
+        MoveBlock<TStringType, TStringViewType, true>(ptr, srcPos, dstPos, off, to, toSize);
+        srcPos = off + fromSize;
+        ++replacementsCount;
+    }
+
+    if (replacementsCount) {
+        // append tail
+        MoveBlock<TStringType, TStringViewType, false>(ptr, srcPos, dstPos, s.size(), to, toSize);
+        s.resize(dstPos);
+    }
+    return replacementsCount;
+}
+
+/// Replaces all occurences of the 'from' symbol in a string to the 'to' symbol.
+template <class TStringType>
+inline size_t SubstCharGlobalImpl(TStringType& s, typename TStringType::value_type from, typename TStringType::value_type to, size_t fromPos = 0) {
+    if (fromPos >= s.size()) {
+        return 0;
+    }
+
+    size_t result = 0;
+    fromPos = s.find(from, fromPos);
+
+    // s.begin() might cause memory copying, so call it only if needed
+    if (fromPos != TStringType::npos) {
+        auto* it = &*s.begin() + fromPos;
+        *it = to;
+        ++result;
+        // at this point string is copied and it's safe to use constant s.end() to iterate
+        const auto* const sEnd = &*s.end();
+        // unrolled loop goes first because it is more likely that `it` will be properly aligned
+        for (const auto* const end = sEnd - (sEnd - it) % 4; it < end;) {
+            if (*it == from) {
+                *it = to;
+                ++result;
+            }
+            ++it;
+            if (*it == from) {
+                *it = to;
+                ++result;
+            }
+            ++it;
+            if (*it == from) {
+                *it = to;
+                ++result;
+            }
+            ++it;
+            if (*it == from) {
+                *it = to;
+                ++result;
+            }
+            ++it;
+        }
+        for (; it < sEnd; ++it) {
+            if (*it == from) {
+                *it = to;
+                ++result;
+            }
+        }
+    }
+
+    return result;
+}
+
+/* Standard says that `char16_t` is a distinct type and has same size, signedness and alignment as
+ * `std::uint_least16_t`, so we check if `char16_t` has same signedness and size as `wchar16` to be
+ * sure that we can make safe casts between values of these types and pointers.
+ */
+static_assert(sizeof(wchar16) == sizeof(char16_t), "");
+static_assert(sizeof(wchar32) == sizeof(char32_t), "");
+static_assert(std::is_unsigned<wchar16>::value == std::is_unsigned<char16_t>::value, "");
+static_assert(std::is_unsigned<wchar32>::value == std::is_unsigned<char32_t>::value, "");
+
+size_t SubstGlobal(TCowString& text, const TStringBuf what, const TStringBuf with, size_t from) {
+    return SubstGlobalImpl(text, what, with, from);
+}
+
+size_t SubstGlobal(TUtf16CowString& text, const TWtringBuf what, const TWtringBuf with, size_t from) {
+    return SubstGlobalImpl(text, what, with, from);
+}
+
+size_t SubstGlobal(TUtf32CowString& text, const TUtf32StringBuf what, const TUtf32StringBuf with, size_t from) {
+    return SubstGlobalImpl(text, what, with, from);
+}
+
+size_t SubstGlobal(TCowString& text, char what, char with, size_t from) {
+    return SubstCharGlobalImpl(text, what, with, from);
+}
+
+size_t SubstGlobal(TUtf16CowString& text, wchar16 what, wchar16 with, size_t from) {
+    return SubstCharGlobalImpl(text, (char16_t)what, (char16_t)with, from);
+}
+
+size_t SubstGlobal(TUtf32CowString& text, wchar32 what, wchar32 with, size_t from) {
+    return SubstCharGlobalImpl(text, (char32_t)what, (char32_t)with, from);
+}
diff --git a/library/cpp/containers/cow_string/subst.h b/library/cpp/containers/cow_string/subst.h
new file mode 100644
index 00000000000..6090ba54b25
--- /dev/null
+++ b/library/cpp/containers/cow_string/subst.h
@@ -0,0 +1,31 @@
+#pragma once
+
+#include <library/cpp/containers/cow_string/cow_string.h>
+
+#include <util/string/subst.h>
+
+/* Replace all occurences of substring `what` with string `with` starting from position `from`.
+ *
+ * @param text      String to modify.
+ * @param what      Substring to replace.
+ * @param with      Substring to use as replacement.
+ * @param from      Position at with to start replacement.
+ *
+ * @return          Number of replacements occured.
+ */
+size_t SubstGlobal(TCowString& text, TStringBuf what, TStringBuf with, size_t from = 0);
+size_t SubstGlobal(TUtf16CowString& text, TWtringBuf what, TWtringBuf with, size_t from = 0);
+size_t SubstGlobal(TUtf32CowString& text, TUtf32StringBuf what, TUtf32StringBuf with, size_t from = 0);
+
+/* Replace all occurences of character `what` with character `with` starting from position `from`.
+ *
+ * @param text      String to modify.
+ * @param what      Character to replace.
+ * @param with      Character to use as replacement.
+ * @param from      Position at with to start replacement.
+ *
+ * @return          Number of replacements occured.
+ */
+size_t SubstGlobal(TCowString& text, char what, char with, size_t from = 0);
+size_t SubstGlobal(TUtf16CowString& text, wchar16 what, wchar16 with, size_t from = 0);
+size_t SubstGlobal(TUtf32CowString& text, wchar32 what, wchar32 with, size_t from = 0);
diff --git a/library/cpp/containers/cow_string/ut_medium/cow_string_medium_ut.cpp b/library/cpp/containers/cow_string/ut_medium/cow_string_medium_ut.cpp
new file mode 100644
index 00000000000..a9a37db776d
--- /dev/null
+++ b/library/cpp/containers/cow_string/ut_medium/cow_string_medium_ut.cpp
@@ -0,0 +1,55 @@
+#include <library/cpp/containers/cow_string/cow_string.h>
+
+#include <library/cpp/testing/unittest/registar.h>
+
+#include <util/generic/strbuf.h>
+#include <util/generic/yexception.h>
+#include <util/stream/output.h>
+#include <util/system/thread.h>
+
+#include <string>
+#include <barrier>
+
+static_assert(sizeof(TCowString) == sizeof(const char*), "expect sizeof(TCowString) == sizeof(const char*)");
+
+Y_UNIT_TEST_SUITE(CowPitfalls) {
+    Y_UNIT_TEST(ParallelDetach) {
+        // best results with thread-sanitizer
+        std::vector<std::unique_ptr<TThread>> threads;
+        TCowString a = "the string";
+        TCowString b = a;
+        auto makeRefToA = [&a, &b]() {
+            b = a; // make second reference to the same string
+        };
+        constexpr int nThreads = 8;
+#ifdef _tsan_enabled_
+        constexpr i64 retries = 1'000;
+#else
+        constexpr i64 retries = 1'000'000;
+#endif
+        std::barrier iterationSyncPoint(nThreads, makeRefToA);
+        std::atomic<i64> totalLen = 0;
+        auto addLen = [](std::string a, std::atomic<i64>& len) {
+            len += a.length();
+        };
+        auto workload = [&a, &addLen, &totalLen, &iterationSyncPoint]() {
+            std::atomic<i64> len = 0;
+            for (i64 j = 0; j < retries; ++j) {
+                addLen(a, len); // possibility of bad implicit conversion
+                iterationSyncPoint.arrive_and_wait();
+            }
+            totalLen += len.load();
+        };
+        for (int i = 0; i < nThreads; ++i) {
+            threads.push_back(std::make_unique<TThread>(workload));
+        }
+        for (auto& t : threads) {
+            t->Start();
+        }
+        for (auto& t : threads) {
+            t->Join();
+        }
+        UNIT_ASSERT_VALUES_EQUAL(totalLen.load(), b.size() * nThreads * retries);
+    }
+
+} // Y_UNIT_TEST_SUITE(CowPitfalls)
diff --git a/library/cpp/containers/cow_string/ysaveload.cpp b/library/cpp/containers/cow_string/ysaveload.cpp
new file mode 100644
index 00000000000..57555fc1d9e
--- /dev/null
+++ b/library/cpp/containers/cow_string/ysaveload.cpp
@@ -0,0 +1 @@
+#include "ysaveload.h"
diff --git a/library/cpp/containers/cow_string/ysaveload.h b/library/cpp/containers/cow_string/ysaveload.h
new file mode 100644
index 00000000000..a4da801c404
--- /dev/null
+++ b/library/cpp/containers/cow_string/ysaveload.h
@@ -0,0 +1,9 @@
+#pragma once
+
+#include "cow_string.h"
+
+#include <util/ysaveload.h>
+
+template <>
+class TSerializer<TCowString>: public TVectorSerializer<TCowString> {
+};
diff --git a/library/cpp/containers/disjoint_interval_tree/disjoint_interval_tree.h b/library/cpp/containers/disjoint_interval_tree/disjoint_interval_tree.h
index f0c6644d4be..c5bfb659acb 100644
--- a/library/cpp/containers/disjoint_interval_tree/disjoint_interval_tree.h
+++ b/library/cpp/containers/disjoint_interval_tree/disjoint_interval_tree.h
@@ -115,7 +115,8 @@ class TDisjointIntervalTree {
             if (containingBegin->first < begin && begin < containingBegin->second) { // Contains begin.
                 if (containingBegin->second > end) { // Contains end.
                     const T prevEnd = containingBegin->second;
-                    Y_ASSERT(containingBegin->second - begin <= NumElements);
+                    Y_ASSERT(containingBegin->second >= begin);
+                    Y_ASSERT(static_cast<size_t>(containingBegin->second - begin) <= NumElements);
 
                     Y_ASSERT(containingBegin->second - containingBegin->first > end - begin);
                     containingBegin->second = begin;
diff --git a/library/cpp/containers/disjoint_interval_tree/ut/disjoint_interval_tree_ut.cpp b/library/cpp/containers/disjoint_interval_tree/ut/disjoint_interval_tree_ut.cpp
index 508a82459af..69278c31f73 100644
--- a/library/cpp/containers/disjoint_interval_tree/ut/disjoint_interval_tree_ut.cpp
+++ b/library/cpp/containers/disjoint_interval_tree/ut/disjoint_interval_tree_ut.cpp
@@ -288,4 +288,23 @@ Y_UNIT_TEST_SUITE(DisjointIntervalTreeTest) {
             UNIT_ASSERT(!tree.Intersects(15, 18));
         }
     }
+
+    Y_UNIT_TEST(TestI64) {
+        {
+            TDisjointIntervalTree<i64> tree;
+            tree.InsertInterval(-5, 10);
+            UNIT_ASSERT_VALUES_EQUAL(tree.EraseInterval(-2, 4), 6);
+            UNIT_ASSERT_VALUES_EQUAL(tree.GetNumIntervals(), 2);
+            UNIT_ASSERT_VALUES_EQUAL(tree.GetNumElements(), 9);
+
+            UNIT_ASSERT_VALUES_EQUAL(tree.EraseInterval(-5, -2), 3);
+            UNIT_ASSERT_VALUES_EQUAL(tree.GetNumIntervals(), 1);
+            UNIT_ASSERT_VALUES_EQUAL(tree.GetNumElements(), 6);
+
+            UNIT_ASSERT_VALUES_EQUAL(tree.EraseInterval(4, 10), 6);
+            UNIT_ASSERT_VALUES_EQUAL(tree.GetNumIntervals(), 0);
+            UNIT_ASSERT_VALUES_EQUAL(tree.GetNumElements(), 0);
+            UNIT_ASSERT(tree.Empty());
+        }
+    }
 }
diff --git a/library/cpp/containers/paged_vector/README.md b/library/cpp/containers/paged_vector/README.md
new file mode 100644
index 00000000000..ae49c0c6523
--- /dev/null
+++ b/library/cpp/containers/paged_vector/README.md
@@ -0,0 +1,99 @@
+# TPagedVector
+
+`NPagedVector::TPagedVector<T, PageSize>` is a dynamic sequence container implemented as a 2-level radix tree: elements are stored in fixed-size, individually heap-allocated pages, and a top-level vector holds pointers to those pages.
+
+```cpp
+#include <library/cpp/containers/paged_vector/paged_vector.h>
+
+namespace NPagedVector {
+    template <class T, ui32 PageSize = 1u << 20u>
+    class TPagedVector;
+}
+```
+
+- `T` — element type.
+- `PageSize` — number of elements per page (default: `1u << 20u` = 1,048,576 elements).
+
+## Why use it instead of TVector / std::vector?
+
+- **No reallocation of elements.** Growth allocates a new page instead of reallocating and moving the entire buffer. Elements are never moved on `push_back`/`emplace_back`, so references and pointers to existing elements remain valid when appending (iterators are offset-based and also stay usable).
+- **No large contiguous allocations.** Memory is requested in page-size chunks, which is friendlier to the allocator for very large containers.
+- **Cheaper worst-case append.** `push_back` never triggers an O(n) copy; the cost is at most one page allocation.
+
+The trade-off is that storage is not contiguous (no `data()`), and indexing does one extra pointer dereference (`idx / PageSize`, `idx % PageSize`).
+
+## API overview
+
+The interface mirrors a subset of `std::vector`:
+
+| Category | Members |
+|---|---|
+| Construction | default, copy, move, `TPagedVector(TIter b, TIter e)` |
+| Assignment | copy, move, `swap()` |
+| Element access | `operator[]`, `at()` (throws `std::out_of_range`), `front()`, `back()` |
+| Iterators | `begin()/end()`, `rbegin()/rend()` + const versions; random-access iterators |
+| Capacity | `size()`, `empty()`, `explicit operator bool()` (true when non-empty) |
+| Modifiers | `push_back()`, `emplace_back()` (returns a reference), `pop_back()`, `append(b, e)`, `erase(it)`, `erase(b, e)`, `resize()`, `clear()` |
+| Iteration helpers | `ForEach(fn)`, `ForEachReverse(fn)` |
+| Comparison | `operator==`, `operator<` (lexicographical) |
+
+Notable differences from `std::vector`:
+
+- No `reserve()`/`capacity()`/`shrink_to_fit()` and no `data()` — storage is paged, not contiguous.
+
+## Iterators
+
+Iterators are random-access and are implemented as an *(owner pointer, offset)* pair. Consequences:
+
+- Iterators are not invalidated by `push_back`/`emplace_back` (an `end()` iterator taken earlier keeps pointing to the same logical position).
+- Dereferencing goes through the vector, so an iterator is only valid while its source container is alive.
+- To get the current index of an element from an iterator, call `it.GetIndex()` — it returns the offset of the pointed-to element within the container (equivalent to `it - begin()`).
+
+## Iteration helpers
+
+```cpp
+template <class Function>
+void ForEach(Function fn) const;
+
+template <class Function>
+void ForEachReverse(Function fn) const;
+```
+
+`ForEach` applies `fn` to every element **from the first to the last**; `ForEachReverse` applies `fn` **from the last to the first**.
+
+These are faster than iterating with `begin()/end()` or `rbegin()/rend()`: they walk the pages directly through raw pointers, avoiding the two levels of indirection that the offset-based iterators go through on each dereference. This matters for containers with a large `PageSize` (the default is 1M elements per page), where the inner per-page loop is tight.
+
+```cpp
+TPagedVector<int, 1024> v;
+// ... fill v ...
+
+long long sum = 0;
+v.ForEach([&](int x) { sum += x; });
+
+// process elements back-to-front, e.g. for a stack-like traversal
+v.ForEachReverse([&](int x) {
+    // ...
+});
+```
+
+Notes:
+
+- The order is well-defined and contiguous: `ForEach` visits element `0, 1, ..., size()-1`; `ForEachReverse` visits `size()-1, ..., 1, 0`.
+- Both are O(n) and do not allocate.
+
+## Complexity
+
+| Operation | Complexity |
+|---|---|
+| `operator[]` / `at()` | O(1) |
+| `push_back` / `emplace_back` | O(1) amortized (page allocation at most every `PageSize` appends) |
+| `pop_back` | O(1) |
+| `erase` | O(n) — shifts all following elements |
+| `clear` | O(n) for non-trivially destructible `T`, O(pages) otherwise |
+| `ForEach` / `ForEachReverse` | O(n), no allocations |
+
+## Notes
+
+- Pages are allocated as raw storage; elements are constructed in place and destroyed explicitly, so non-trivially destructible types are handled correctly.
+- Destruction of trivially destructible types is skipped entirely, making `clear()` and the destructor fast for POD-like types.
+- The copy constructor is exception-safe: on a throw during copying, already-constructed elements are destroyed.
diff --git a/library/cpp/containers/paged_vector/paged_vector.h b/library/cpp/containers/paged_vector/paged_vector.h
index 3a2c58caf7b..43073852ab3 100644
--- a/library/cpp/containers/paged_vector/paged_vector.h
+++ b/library/cpp/containers/paged_vector/paged_vector.h
@@ -4,90 +4,91 @@
 #include <util/generic/vector.h>
 #include <util/generic/yexception.h>
 
+#include <algorithm>
 #include <iterator>
 
 namespace NPagedVector {
-    template <class T, ui32 PageSize = 1u << 20u, class A = std::allocator<T>>
+    template <class T, ui32 PageSize = 1u << 20u>
     class TPagedVector;
 
     namespace NPrivate {
-        template <class T, class TT, ui32 PageSize, class A>
+        template <class T, class TT, ui32 PageSize>
         struct TPagedVectorIterator {
         private:
-            friend class TPagedVector<TT, PageSize, A>;
-            typedef TPagedVector<TT, PageSize, A> TVec;
-            typedef TPagedVectorIterator<T, TT, PageSize, A> TSelf;
-            size_t Offset;
-            TVec* Vector;
+            friend class TPagedVector<TT, PageSize>;
+            using TVec = TPagedVector<TT, PageSize>;
+            using TSelf = TPagedVectorIterator<T, TT, PageSize>;
+            size_t Index_;
+            TVec* Vector_;
 
-            template <class T1, class TT1, ui32 PageSize1, class A1>
+            template <class T1, class TT1, ui32 PageSize1>
             friend struct TPagedVectorIterator;
 
         public:
             TPagedVectorIterator()
-                : Offset()
-                , Vector()
+                : Index_()
+                , Vector_()
             {
             }
 
-            TPagedVectorIterator(TVec* vector, size_t offset)
-                : Offset(offset)
-                , Vector(vector)
+            TPagedVectorIterator(TVec* vector, size_t index)
+                : Index_(index)
+                , Vector_(vector)
             {
             }
 
-            template <class T1, class TT1, ui32 PageSize1, class A1>
-            TPagedVectorIterator(const TPagedVectorIterator<T1, TT1, PageSize1, A1>& it)
-                : Offset(it.Offset)
-                , Vector(it.Vector)
+            template <class T1, class TT1, ui32 PageSize1>
+            TPagedVectorIterator(const TPagedVectorIterator<T1, TT1, PageSize1>& it)
+                : Index_(it.Index_)
+                , Vector_(it.Vector_)
             {
             }
 
             T& operator*() const {
-                return (*Vector)[Offset];
+                return (*Vector_)[Index_];
             }
 
             T* operator->() const {
                 return &(**this);
             }
 
-            template <class T1, class TT1, ui32 PageSize1, class A1>
-            bool operator==(const TPagedVectorIterator<T1, TT1, PageSize1, A1>& it) const {
-                return Offset == it.Offset;
+            template <class T1, class TT1, ui32 PageSize1>
+            bool operator==(const TPagedVectorIterator<T1, TT1, PageSize1>& it) const {
+                return Index_ == it.Index_;
             }
 
-            template <class T1, class TT1, ui32 PageSize1, class A1>
-            bool operator!=(const TPagedVectorIterator<T1, TT1, PageSize1, A1>& it) const {
+            template <class T1, class TT1, ui32 PageSize1>
+            bool operator!=(const TPagedVectorIterator<T1, TT1, PageSize1>& it) const {
                 return !(*this == it);
             }
 
-            template <class T1, class TT1, ui32 PageSize1, class A1>
-            bool operator<(const TPagedVectorIterator<T1, TT1, PageSize1, A1>& it) const {
-                return Offset < it.Offset;
+            template <class T1, class TT1, ui32 PageSize1>
+            bool operator<(const TPagedVectorIterator<T1, TT1, PageSize1>& it) const {
+                return Index_ < it.Index_;
             }
 
-            template <class T1, class TT1, ui32 PageSize1, class A1>
-            bool operator<=(const TPagedVectorIterator<T1, TT1, PageSize1, A1>& it) const {
-                return Offset <= it.Offset;
+            template <class T1, class TT1, ui32 PageSize1>
+            bool operator<=(const TPagedVectorIterator<T1, TT1, PageSize1>& it) const {
+                return Index_ <= it.Index_;
             }
 
-            template <class T1, class TT1, ui32 PageSize1, class A1>
-            bool operator>(const TPagedVectorIterator<T1, TT1, PageSize1, A1>& it) const {
+            template <class T1, class TT1, ui32 PageSize1>
+            bool operator>(const TPagedVectorIterator<T1, TT1, PageSize1>& it) const {
                 return !(*this <= it);
             }
 
-            template <class T1, class TT1, ui32 PageSize1, class A1>
-            bool operator>=(const TPagedVectorIterator<T1, TT1, PageSize1, A1>& it) const {
+            template <class T1, class TT1, ui32 PageSize1>
+            bool operator>=(const TPagedVectorIterator<T1, TT1, PageSize1>& it) const {
                 return !(*this < it);
             }
 
-            template <class T1, class TT1, ui32 PageSize1, class A1>
-            ptrdiff_t operator-(const TPagedVectorIterator<T1, TT1, PageSize1, A1>& it) const {
-                return Offset - it.Offset;
+            template <class T1, class TT1, ui32 PageSize1>
+            ptrdiff_t operator-(const TPagedVectorIterator<T1, TT1, PageSize1>& it) const {
+                return Index_ - it.Index_;
             }
 
             TSelf& operator+=(ptrdiff_t off) {
-                Offset += off;
+                Index_ += off;
                 return *this;
             }
 
@@ -125,51 +126,121 @@ namespace NPagedVector {
                 return this->operator+(-off);
             }
 
-            size_t GetOffset() const {
-                return Offset;
+            [[nodiscard]] size_t GetIndex() const {
+                return Index_;
             }
         };
-    }
-}
+    } // namespace NPrivate
+} // namespace NPagedVector
 
 namespace std {
-    template <class T, class TT, ui32 PageSize, class A>
-    struct iterator_traits<NPagedVector::NPrivate::TPagedVectorIterator<T, TT, PageSize, A>> {
-        typedef ptrdiff_t difference_type;
-        typedef T value_type;
-        typedef T* pointer;
-        typedef T& reference;
-        typedef random_access_iterator_tag iterator_category;
+    template <class T, class TT, ui32 PageSize>
+    struct iterator_traits<NPagedVector::NPrivate::TPagedVectorIterator<T, TT, PageSize>> {
+        using difference_type = ptrdiff_t;
+        using value_type = T;
+        using pointer = T*;
+        using reference = T&;
+        using iterator_category = random_access_iterator_tag;
     };
 
-}
+} // namespace std
 
 namespace NPagedVector {
-    //2-level radix tree
-    template <class T, ui32 PageSize, class A>
-    class TPagedVector: private TVector<TSimpleSharedPtr<TVector<T, A>>, A> {
+    // 2-level radix tree
+    template <class T, ui32 PageSize>
+    class TPagedVector {
         static_assert(PageSize, "expect PageSize");
 
-        typedef TVector<T, A> TPage;
-        typedef TVector<TSimpleSharedPtr<TPage>, A> TPages;
-        typedef TPagedVector<T, PageSize, A> TSelf;
+        class alignas(T) TPage {
+            alignas(T) std::array<char, PageSize * sizeof(T)> Data_;
+
+        public:
+            T* data() {
+                return reinterpret_cast<T*>(Data_.data());
+            }
+
+            const T* data() const {
+                return reinterpret_cast<const T*>(Data_.data());
+            }
+
+            T& operator[](size_t idx) {
+                return *(data() + idx);
+            }
+
+            const T& operator[](size_t idx) const {
+                return *(data() + idx);
+            }
+        };
+
+        using TPages = TVector<THolder<TPage>>;
+        using TSelf = TPagedVector<T, PageSize>;
+
+        TPages Pages_;
+        size_t CurrentPageSize_ = 0;
 
     public:
-        typedef NPrivate::TPagedVectorIterator<T, T, PageSize, A> iterator;
-        typedef NPrivate::TPagedVectorIterator<const T, T, PageSize, A> const_iterator;
-        typedef std::reverse_iterator<iterator> reverse_iterator;
-        typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
-        typedef T value_type;
-        typedef value_type& reference;
-        typedef const value_type& const_reference;
+        using iterator = NPrivate::TPagedVectorIterator<T, T, PageSize>;
+        using const_iterator = NPrivate::TPagedVectorIterator<const T, T, PageSize>;
+        using reverse_iterator = std::reverse_iterator<iterator>;
+        using const_reverse_iterator = std::reverse_iterator<const_iterator>;
+        using value_type = T;
+        using reference = value_type&;
+        using const_reference = const value_type&;
 
         TPagedVector() = default;
+        TPagedVector(TPagedVector&& other) noexcept
+            : Pages_(std::move(other.Pages_))
+            , CurrentPageSize_(other.CurrentPageSize_)
+        {
+            other.CurrentPageSize_ = 0;
+        }
+
+        TPagedVector(const TPagedVector& other) {
+            Pages_.reserve(other.Pages_.size());
+            try {
+                for (auto& ptr : other.Pages_) {
+                    auto& newPage = *Pages_.emplace_back(MakeHolder<TPage>());
+                    CurrentPageSize_ = 0;
+                    const size_t copyCount = Pages_.size() == other.Pages_.size()
+                                                 ? other.CurrentPageSize_
+                                                 : PageSize;
+
+                    std::uninitialized_copy_n(ptr->data(), copyCount, newPage.data());
+                    CurrentPageSize_ = copyCount;
+                }
+            } catch (...) {
+                clear();
+                throw;
+            }
+        }
+
+        ~TPagedVector() {
+            clear();
+        }
 
         template <typename TIter>
         TPagedVector(TIter b, TIter e) {
             append(b, e);
         }
 
+        TPagedVector& operator=(const TPagedVector& other) {
+            if (this != &other) {
+                TPagedVector tmp(other);
+                swap(tmp);
+            }
+            return *this;
+        }
+
+        TPagedVector& operator=(TPagedVector&& other) noexcept {
+            if (this != &other) {
+                clear();
+                Pages_ = std::move(other.Pages_);
+                CurrentPageSize_ = other.CurrentPageSize_;
+                other.CurrentPageSize_ = 0;
+            }
+            return *this;
+        }
+
         iterator begin() {
             return iterator(this, 0);
         }
@@ -203,7 +274,53 @@ namespace NPagedVector {
         }
 
         void swap(TSelf& v) {
-            TPages::swap((TPages&)v);
+            Pages_.swap(v.Pages_);
+            std::swap(CurrentPageSize_, v.CurrentPageSize_);
+        }
+
+        // Fast iteration over all elements.
+        template <class Function>
+        void ForEach(Function fn) const {
+            if (Pages_.empty()) {
+                return;
+            }
+
+            const auto currentPageIt = Pages_.end() - 1;
+            for (auto it = Pages_.begin(); it != currentPageIt; ++it) {
+                const TPage& page = **it;
+                for (size_t i = 0; i < PageSize; ++i) {
+                    fn(page[i]);
+                }
+            }
+
+            const TPage& currentPage = **currentPageIt;
+
+            for (size_t i = 0; i < CurrentPageSize_; ++i) {
+                fn(currentPage[i]);
+            }
+        }
+
+        // Fast iteration over all elements in reverse order.
+        template <class Function>
+        void ForEachReverse(Function fn) const {
+            if (Pages_.empty()) {
+                return;
+            }
+
+            const TPage& currentPage = *Pages_.back();
+
+            for (size_t i = CurrentPageSize_; i > 0;) {
+                --i;
+                fn(currentPage[i]);
+            }
+
+            for (auto it = Pages_.rbegin() + 1; it != Pages_.rend(); ++it) {
+                const TPage& page = **it;
+                for (size_t i = PageSize; i > 0;) {
+                    --i;
+                    fn(page[i]);
+                }
+            }
         }
 
     private:
@@ -215,110 +332,99 @@ namespace NPagedVector {
             return idx % PageSize;
         }
 
-        static size_t Index(size_t pnum, size_t poff) {
-            return pnum * PageSize + poff;
-        }
-
         TPage& PageAt(size_t pnum) const {
-            return *TPages::at(pnum);
+            return *Pages_.at(pnum);
         }
 
         TPage& CurrentPage() const {
-            return *TPages::back();
-        }
-
-        size_t CurrentPageSize() const {
-            return TPages::empty() ? 0 : CurrentPage().size();
+            return *Pages_.back();
         }
 
         size_t NPages() const {
-            return TPages::size();
+            return Pages_.size();
         }
 
         void AllocateNewPage() {
-            TPages::push_back(new TPage());
-            CurrentPage().reserve(PageSize);
-        }
-
-        void MakeNewPage() {
-            AllocateNewPage();
-            CurrentPage().resize(PageSize);
+            Pages_.emplace_back(MakeHolder<TPage>());
+            CurrentPageSize_ = 0;
         }
 
         void PrepareAppend() {
-            if (TPages::empty() || CurrentPage().size() + 1 > PageSize)
+            if (Pages_.empty() || CurrentPageSize_ >= PageSize) {
                 AllocateNewPage();
+            }
         }
 
     public:
         size_t size() const {
-            return empty() ? 0 : (NPages() - 1) * PageSize + CurrentPage().size();
+            return Pages_.empty() ? 0 : (NPages() - 1) * PageSize + CurrentPageSize_;
         }
 
         bool empty() const {
-            return TPages::empty() || (1 == NPages() && CurrentPage().empty());
+            return Pages_.empty() || (1 == NPages() && CurrentPageSize_ == 0);
         }
 
         explicit operator bool() const noexcept {
             return !empty();
         }
 
-        template<typename... Args>
+        template <typename... Args>
         reference emplace_back(Args&&... args) {
             PrepareAppend();
-            return CurrentPage().emplace_back(std::forward<Args>(args)...);
+            T* ptr = new (CurrentPage().data() + CurrentPageSize_) T(std::forward<Args>(args)...);
+            ++CurrentPageSize_;
+            return *ptr;
         }
 
         void push_back(const_reference t) {
             PrepareAppend();
-            CurrentPage().push_back(t);
+            new (CurrentPage().data() + CurrentPageSize_) T(t);
+            ++CurrentPageSize_;
         }
 
         void pop_back() {
-            if (CurrentPage().empty())
-                TPages::pop_back();
-            CurrentPage().pop_back();
+            Y_ASSERT(!empty());
+            if (CurrentPageSize_ == 0) {
+                Pages_.pop_back();
+                CurrentPageSize_ = PageSize;
+            }
+            --CurrentPageSize_;
+            if constexpr (!std::is_trivially_destructible_v<T>) {
+                CurrentPage()[CurrentPageSize_].~T();
+            }
         }
 
         template <typename TIter>
         void append(TIter b, TIter e) {
-            size_t sz = e - b;
-            size_t sz1 = Min<size_t>(sz, PageSize - CurrentPageSize());
-            size_t sz2 = (sz - sz1) / PageSize;
-            size_t sz3 = (sz - sz1) % PageSize;
-
-            if (sz1) {
-                PrepareAppend();
-                TPage& p = CurrentPage();
-                p.insert(p.end(), b, b + sz1);
-            }
-
-            for (size_t i = 0; i < sz2; ++i) {
-                AllocateNewPage();
-                TPage& p = CurrentPage();
-                p.insert(p.end(), b + sz1 + i * PageSize, b + sz1 + (i + 1) * PageSize);
-            }
-
-            if (sz3) {
-                AllocateNewPage();
-                TPage& p = CurrentPage();
-                p.insert(p.end(), b + sz1 + sz2 * PageSize, e);
+            for (TIter it = b; it != e; ++it) {
+                push_back(*it);
             }
         }
 
         iterator erase(iterator it) {
-            size_t pnum = PageNumber(it.Offset);
-            size_t pidx = InPageIndex(it.Offset);
-
-            if (CurrentPage().empty())
-                TPages::pop_back();
+            if (CurrentPageSize_ == 0) {
+                Pages_.pop_back();
+                CurrentPageSize_ = Pages_.empty() ? 0 : PageSize;
+            }
 
-            for (size_t p = NPages() - 1; p > pnum; --p) {
-                PageAt(p - 1).push_back(PageAt(p).front());
-                PageAt(p).erase(PageAt(p).begin());
+            size_t pidx = InPageIndex(it.Index_);
+            for (size_t pnum = PageNumber(it.Index_);; ++pnum) {
+                TPage& page = *Pages_[pnum];
+                if (pnum + 1 == Pages_.size()) {
+                    std::shift_left(page.data() + pidx, page.data() + CurrentPageSize_, 1);
+                    --CurrentPageSize_;
+                    if constexpr (!std::is_trivially_destructible_v<T>) {
+                        page[CurrentPageSize_].~T();
+                    }
+                    break;
+                }
+
+                std::shift_left(page.data() + pidx, page.data() + PageSize, 1);
+                TPage& nextPage = *Pages_[pnum + 1];
+                page[PageSize - 1] = std::move(nextPage[0]);
+                pidx = 0;
             }
 
-            PageAt(pnum).erase(PageAt(pnum).begin() + pidx);
             return it;
         }
 
@@ -332,86 +438,96 @@ namespace NPagedVector {
             return b;
         }
 
-        iterator insert(iterator it, const value_type& v) {
-            size_t pnum = PageNumber(it.Offset);
-            size_t pidx = InPageIndex(it.Offset);
-
-            PrepareAppend();
-
-            for (size_t p = NPages() - 1; p > pnum; --p) {
-                PageAt(p).insert(PageAt(p).begin(), PageAt(p - 1).back());
-                PageAt(p - 1).pop_back();
-            }
-
-            PageAt(pnum).insert(PageAt(pnum).begin() + pidx, v);
-            return it;
-        }
-
-        template <typename TIter>
-        void insert(iterator it, TIter b, TIter e) {
-            // todo : suboptimal!
-            for (; b != e; ++b, ++it)
-                it = insert(it, *b);
-        }
-
         reference front() {
-            return TPages::front()->front();
+            Y_ASSERT(CurrentPageSize_ > 0 || Pages_.size() > 1);
+            return (*Pages_.front())[0];
         }
 
         const_reference front() const {
-            return TPages::front()->front();
+            Y_ASSERT(CurrentPageSize_ > 0 || Pages_.size() > 1);
+            return (*Pages_.front())[0];
         }
 
         reference back() {
-            return CurrentPage().back();
+            if (CurrentPageSize_ > 0) {
+                return CurrentPage()[CurrentPageSize_ - 1];
+            } else {
+                Y_ASSERT(Pages_.size() >= 2);
+                return (**(Pages_.end() - 2))[PageSize - 1];
+            }
         }
 
         const_reference back() const {
-            return CurrentPage().back();
+            if (CurrentPageSize_ > 0) {
+                return CurrentPage()[CurrentPageSize_ - 1];
+            } else {
+                Y_ASSERT(Pages_.size() >= 2);
+                return (**(Pages_.end() - 2))[PageSize - 1];
+            }
         }
 
         void clear() {
-            TPages::clear();
+            if constexpr (std::is_trivially_destructible_v<T>) {
+                Pages_.clear();
+                CurrentPageSize_ = 0;
+            } else {
+                while (!Pages_.empty()) {
+                    TPage& page = CurrentPage();
+                    while (CurrentPageSize_ > 0) {
+                        --CurrentPageSize_;
+                        page[CurrentPageSize_].~T();
+                    }
+                    Pages_.pop_back();
+                    CurrentPageSize_ = Pages_.empty() ? 0 : PageSize;
+                }
+            }
         }
 
         void resize(size_t sz) {
-            if (sz == size())
+            size_t curSize = size();
+            if (sz == curSize) {
                 return;
+            }
 
-            const size_t npages = NPages();
-            const size_t newwholepages = sz / PageSize;
-            const size_t pagepart = sz % PageSize;
-            const size_t newpages = newwholepages + bool(pagepart);
-
-            if (npages && newwholepages >= npages)
-                CurrentPage().resize(PageSize);
-
-            if (newpages < npages)
-                TPages::resize(newpages);
-            else
-                for (size_t i = npages; i < newpages; ++i)
-                    MakeNewPage();
-
-            if (pagepart)
-                CurrentPage().resize(pagepart);
-
-            Y_ABORT_UNLESS(sz == size(), "%" PRIu64 " %" PRIu64, (ui64)sz, (ui64)size());
+            if (sz < curSize) {
+                while (sz < curSize) {
+                    pop_back();
+                    --curSize;
+                }
+            } else {
+                while (sz > curSize) {
+                    emplace_back();
+                    ++curSize;
+                }
+            }
         }
 
         reference at(size_t idx) {
-            return TPages::at(PageNumber(idx))->at(InPageIndex(idx));
+            if (idx >= size()) {
+                throw std::out_of_range("TPagedVector::at() - index out of range");
+            }
+            const size_t pnum = PageNumber(idx);
+            const size_t inPageIdx = InPageIndex(idx);
+
+            return (*Pages_[pnum])[inPageIdx];
         }
 
         const_reference at(size_t idx) const {
-            return TPages::at(PageNumber(idx))->at(InPageIndex(idx));
+            if (idx >= size()) {
+                throw std::out_of_range("TPagedVector::at() - index out of range");
+            }
+            const size_t pnum = PageNumber(idx);
+            const size_t inPageIdx = InPageIndex(idx);
+
+            return (*Pages_[pnum])[inPageIdx];
         }
 
         reference operator[](size_t idx) {
-            return TPages::operator[](PageNumber(idx))->operator[](InPageIndex(idx));
+            return Pages_.operator[](PageNumber(idx))->operator[](InPageIndex(idx));
         }
 
         const_reference operator[](size_t idx) const {
-            return TPages::operator[](PageNumber(idx))->operator[](InPageIndex(idx));
+            return Pages_.operator[](PageNumber(idx))->operator[](InPageIndex(idx));
         }
 
         friend bool operator==(const TSelf& a, const TSelf& b) {
@@ -424,10 +540,9 @@ namespace NPagedVector {
     };
 
     namespace NPrivate {
-        typedef std::is_same<std::random_access_iterator_tag, std::iterator_traits<
-                                                                  TPagedVector<ui32>::iterator>::iterator_category>
-            TIteratorCheck;
+        using TIteratorCheck = std::is_same<std::random_access_iterator_tag, std::iterator_traits<
+                                                                                 TPagedVector<ui32>::iterator>::iterator_category>;
         static_assert(TIteratorCheck::value, "expect TIteratorCheck::Result");
-    }
+    } // namespace NPrivate
 
-}
+} // namespace NPagedVector
diff --git a/library/cpp/containers/paged_vector/ut/paged_vector_ut.cpp b/library/cpp/containers/paged_vector/ut/paged_vector_ut.cpp
index d059ce34ec1..b0f39f748fe 100644
--- a/library/cpp/containers/paged_vector/ut/paged_vector_ut.cpp
+++ b/library/cpp/containers/paged_vector/ut/paged_vector_ut.cpp
@@ -12,13 +12,25 @@ class TPagedVectorTest: public TTestBase {
     UNIT_TEST(Test4)
     UNIT_TEST(Test5)
     UNIT_TEST(Test6)
-    UNIT_TEST(Test7)
     UNIT_TEST(TestAt)
     UNIT_TEST(TestAutoRef)
     UNIT_TEST(TestIterators)
     UNIT_TEST(TestEmplaceBack1)
     UNIT_TEST(TestEmplaceBack2)
-    //UNIT_TEST(TestEbo)
+    UNIT_TEST(TestCopyConstructor)
+    UNIT_TEST(TestCopyAssignment)
+    UNIT_TEST(TestMoveConstructor)
+    UNIT_TEST(TestMoveAssignment)
+    UNIT_TEST(TestCopyConstructorString)
+    UNIT_TEST(TestCopyAssignmentString)
+    UNIT_TEST(TestMoveConstructorString)
+    UNIT_TEST(TestMoveAssignmentString)
+    UNIT_TEST(TestEmplaceBackNoncopyable)
+    UNIT_TEST(TestClear)
+    UNIT_TEST(TestBack)
+    UNIT_TEST(TestIterator)
+    UNIT_TEST(TestForEach)
+    UNIT_TEST(TestForEachReverse)
     UNIT_TEST_SUITE_END();
 
 private:
@@ -122,8 +134,9 @@ class TPagedVectorTest: public TTestBase {
         TPagedVector<char, 1> v2;
         v2.resize(v1.size());
 
-        for (size_t i = 0; i < v1.size(); ++i)
+        for (size_t i = 0; i < v1.size(); ++i) {
             v2[i] = v1[i];
+        }
 
         v2[1] = 'o'; // Replace second character.
 
@@ -215,44 +228,6 @@ class TPagedVectorTest: public TTestBase {
         UNIT_ASSERT(v[1] == 25);
     }
 
-    void Test7() {
-        int array1[] = {1, 4, 25};
-        int array2[] = {9, 16};
-
-        typedef NPagedVector::TPagedVector<int, 3> TVectorType;
-
-        TVectorType v(array1, array1 + 3);
-        TVectorType::iterator vit;
-        vit = v.insert(v.begin(), 0); // Insert before first element.
-        UNIT_ASSERT_VALUES_EQUAL(*vit, 0);
-
-        vit = v.insert(v.end(), 36); // Insert after last element.
-        UNIT_ASSERT(*vit == 36);
-
-        UNIT_ASSERT(v.size() == 5);
-        UNIT_ASSERT(v[0] == 0);
-        UNIT_ASSERT(v[1] == 1);
-        UNIT_ASSERT(v[2] == 4);
-        UNIT_ASSERT(v[3] == 25);
-        UNIT_ASSERT(v[4] == 36);
-
-        // Insert contents of array2 before fourth element.
-        v.insert(v.begin() + 3, array2, array2 + 2);
-
-        UNIT_ASSERT(v.size() == 7);
-
-        UNIT_ASSERT(v[0] == 0);
-        UNIT_ASSERT(v[1] == 1);
-        UNIT_ASSERT(v[2] == 4);
-        UNIT_ASSERT(v[3] == 9);
-        UNIT_ASSERT(v[4] == 16);
-        UNIT_ASSERT(v[5] == 25);
-        UNIT_ASSERT(v[6] == 36);
-
-        v.clear();
-        UNIT_ASSERT(v.empty());
-    }
-
     void TestAt() {
         using NPagedVector::TPagedVector;
         TPagedVector<int, 3> v;
@@ -332,14 +307,14 @@ class TPagedVectorTest: public TTestBase {
 
         UNIT_ASSERT(vint.rbegin() == vint.rbegin());
         // Not Standard:
-        //UNIT_ASSERT(vint.rbegin() == crvint.rbegin());
-        //UNIT_ASSERT(crvint.rbegin() == vint.rbegin());
+        // UNIT_ASSERT(vint.rbegin() == crvint.rbegin());
+        // UNIT_ASSERT(crvint.rbegin() == vint.rbegin());
         UNIT_ASSERT(crvint.rbegin() == crvint.rbegin());
 
         UNIT_ASSERT(vint.rbegin() != vint.rend());
         // Not Standard:
-        //UNIT_ASSERT(vint.rbegin() != crvint.rend());
-        //UNIT_ASSERT(crvint.rbegin() != vint.rend());
+        // UNIT_ASSERT(vint.rbegin() != crvint.rend());
+        // UNIT_ASSERT(crvint.rbegin() != vint.rend());
         UNIT_ASSERT(crvint.rbegin() != crvint.rend());
     }
 
@@ -376,37 +351,519 @@ class TPagedVectorTest: public TTestBase {
         }
     }
 
-    /* This test check a potential issue with empty base class
-         * optimization. Some compilers (VC6) do not implement it
-         * correctly resulting ina wrong behavior. */
-    void TestEbo() {
+    void TestCopyConstructor() {
+        using NPagedVector::TPagedVector;
+        TPagedVector<int, 3> v;
+        for (int i = 0; i < 10; ++i) {
+            v.push_back(i);
+        }
+
+        TPagedVector<int, 3> copied(v);
+
+        UNIT_ASSERT_VALUES_EQUAL(copied.size(), 10u);
+        UNIT_ASSERT_VALUES_EQUAL(v.size(), 10u);
+
+        for (int i = 0; i < 10; ++i) {
+            // values are the same
+            UNIT_ASSERT_VALUES_EQUAL(v[i], i);
+            UNIT_ASSERT_VALUES_EQUAL(copied[i], i);
+
+            // but pointers are different (the elements have been copied)
+            UNIT_ASSERT_VALUES_UNEQUAL(&copied[i], &v[i]);
+        }
+
+        // Modifying the copy must not affect the original.
+        copied[0] = 999;
+        UNIT_ASSERT_VALUES_EQUAL(v[0], 0);
+    }
+
+    void TestCopyAssignment() {
+        using NPagedVector::TPagedVector;
+        TPagedVector<int, 3> v;
+        for (int i = 0; i < 10; ++i) {
+            v.push_back(i);
+        }
+
+        TPagedVector<int, 3> assigned;
+        assigned.push_back(999);
+        assigned = v;
+
+        // The source vector should remain unchanged after copy.
+        UNIT_ASSERT_VALUES_EQUAL(v.size(), 10u);
+
+        UNIT_ASSERT_VALUES_EQUAL(assigned.size(), 10u);
+        for (int i = 0; i < 10; ++i) {
+            // values are the same
+            UNIT_ASSERT_VALUES_EQUAL(v[i], i);
+            UNIT_ASSERT_VALUES_EQUAL(assigned[i], i);
+
+            // but pointers are different (the elements have been copied)
+            UNIT_ASSERT_VALUES_UNEQUAL(&assigned[i], &v[i]);
+        }
+
+        // Modifying the assigned vector must not affect the original.
+        assigned[0] = 999;
+        UNIT_ASSERT_VALUES_EQUAL(v[0], 0);
+    }
+
+    void TestMoveConstructor() {
+        using NPagedVector::TPagedVector;
+        TPagedVector<int, 3> v;
+        for (int i = 0; i < 10; ++i) {
+            v.push_back(i);
+        }
+
+        auto orig_ptr = &v[5];
+
+        TPagedVector<int, 3> moved(std::move(v));
+
+        UNIT_ASSERT_VALUES_EQUAL(moved.size(), 10u);
+
+        // the move must keep original element pointers
+        UNIT_ASSERT_VALUES_EQUAL(orig_ptr, &moved[5]);
+
+        for (int i = 0; i < 10; ++i) {
+            UNIT_ASSERT_VALUES_EQUAL(moved[i], i);
+        }
+
+        // After move, the source vector should be empty.
+        UNIT_ASSERT(v.empty());
+        UNIT_ASSERT_VALUES_EQUAL(v.size(), 0u);
+    }
+
+    void TestMoveAssignment() {
+        using NPagedVector::TPagedVector;
+        TPagedVector<int, 3> v;
+        for (int i = 0; i < 10; ++i) {
+            v.push_back(i);
+        }
+
+        auto orig_ptr = &v[7];
+
+        TPagedVector<int, 3> assigned;
+        assigned.push_back(999);
+        assigned = std::move(v);
+
+        UNIT_ASSERT_VALUES_EQUAL(assigned.size(), 10u);
+
+        // the move must keep original element pointers
+        UNIT_ASSERT_VALUES_EQUAL(orig_ptr, &assigned[7]);
+
+        for (int i = 0; i < 10; ++i) {
+            UNIT_ASSERT_VALUES_EQUAL(assigned[i], i);
+        }
+
+        // After move, the source vector should be empty.
+        UNIT_ASSERT(v.empty());
+        UNIT_ASSERT_VALUES_EQUAL(v.size(), 0u);
+    }
+
+    void TestCopyConstructorString() {
+        using NPagedVector::TPagedVector;
+        TPagedVector<TString, 3> v;
+        for (int i = 0; i < 10; ++i) {
+            v.push_back(ToString(i));
+        }
+
+        TPagedVector<TString, 3> copied(v);
+
+        UNIT_ASSERT_VALUES_EQUAL(copied.size(), 10u);
+        UNIT_ASSERT_VALUES_EQUAL(v.size(), 10u);
+
+        for (int i = 0; i < 10; ++i) {
+            // values are the same
+            UNIT_ASSERT_VALUES_EQUAL(v[i], ToString(i));
+            UNIT_ASSERT_VALUES_EQUAL(copied[i], ToString(i));
+
+            // but pointers are different (the elements have been copied, not moved)
+            UNIT_ASSERT_VALUES_UNEQUAL(&copied[i], &v[i]);
+        }
+
+        // Modifying the copy must not affect the original (deep copy semantics).
+        copied[0] = "modified";
+        UNIT_ASSERT_VALUES_EQUAL(v[0], "0");
+    }
+
+    void TestCopyAssignmentString() {
+        using NPagedVector::TPagedVector;
+        TPagedVector<TString, 3> v;
+        for (int i = 0; i < 10; ++i) {
+            v.push_back(ToString(i));
+        }
+
+        TPagedVector<TString, 3> assigned;
+        assigned.push_back("old");
+        assigned = v;
+
+        // The source vector should remain unchanged after copy.
+        UNIT_ASSERT_VALUES_EQUAL(v.size(), 10u);
+
+        UNIT_ASSERT_VALUES_EQUAL(assigned.size(), 10u);
+        for (int i = 0; i < 10; ++i) {
+            // values are the same
+            UNIT_ASSERT_VALUES_EQUAL(v[i], ToString(i));
+            UNIT_ASSERT_VALUES_EQUAL(assigned[i], ToString(i));
+
+            // but pointers are different (the elements have been copied, not moved)
+            UNIT_ASSERT_VALUES_UNEQUAL(&assigned[i], &v[i]);
+        }
+
+        // Modifying the assigned vector must not affect the original.
+        assigned[0] = "modified";
+        UNIT_ASSERT_VALUES_EQUAL(v[0], "0");
+    }
+
+    void TestMoveConstructorString() {
+        using NPagedVector::TPagedVector;
+        TPagedVector<TString, 3> v;
+        for (int i = 0; i < 10; ++i) {
+            v.push_back(ToString(i));
+        }
+
+        auto orig_ptr = &v[5];
+
+        TPagedVector<TString, 3> moved(std::move(v));
+
+        UNIT_ASSERT_VALUES_EQUAL(moved.size(), 10u);
+
+        // the move must keep original element pointers (pages are stolen, not copied)
+        UNIT_ASSERT_VALUES_EQUAL(orig_ptr, &moved[5]);
+
+        for (int i = 0; i < 10; ++i) {
+            UNIT_ASSERT_VALUES_EQUAL(moved[i], ToString(i));
+        }
+
+        // After move, the source vector should be empty.
+        UNIT_ASSERT(v.empty());
+        UNIT_ASSERT_VALUES_EQUAL(v.size(), 0u);
+    }
+
+    void TestMoveAssignmentString() {
+        using NPagedVector::TPagedVector;
+        TPagedVector<TString, 3> v;
+        for (int i = 0; i < 10; ++i) {
+            v.push_back(ToString(i));
+        }
+
+        auto orig_ptr = &v[7];
+
+        TPagedVector<TString, 3> assigned;
+        assigned.push_back("old");
+        assigned = std::move(v);
+
+        UNIT_ASSERT_VALUES_EQUAL(assigned.size(), 10u);
+
+        // the move must keep original element pointers (pages are stolen, not copied)
+        UNIT_ASSERT_VALUES_EQUAL(orig_ptr, &assigned[7]);
+
+        for (int i = 0; i < 10; ++i) {
+            UNIT_ASSERT_VALUES_EQUAL(assigned[i], ToString(i));
+        }
+
+        // After move, the source vector should be empty.
+        UNIT_ASSERT(v.empty());
+        UNIT_ASSERT_VALUES_EQUAL(v.size(), 0u);
+    }
+
+    struct TNonCopyableTestClass {
+        const TString Str;
+        TNonCopyableTestClass(const TString s)
+            : Str(s)
+        {
+        }
+    };
+
+    void TestEmplaceBackNoncopyable() {
+        using NPagedVector::TPagedVector;
+        TPagedVector<TNonCopyableTestClass, 5> v;
+
+        for (int i = 0; i < 19; ++i) {
+            v.emplace_back(ToString(i));
+        }
+
+        for (int i = 0; i < 19; ++i) {
+            UNIT_ASSERT_VALUES_EQUAL(v[i].Str, ToString(i));
+        }
+
+        v.pop_back();
+        v.pop_back();
+        v.emplace_back("Hello world");
+        UNIT_ASSERT_VALUES_EQUAL(v[17].Str, "Hello world");
+    }
+
+    void TestClear() {
+        using NPagedVector::TPagedVector;
+        TPagedVector<TString, 3> v;
+        for (int i = 0; i < 4; ++i) {
+            v.push_back(ToString(i));
+        }
+
+        v.pop_back();
+        v.clear();
+
+        UNIT_ASSERT(v.empty());
+        UNIT_ASSERT_VALUES_EQUAL(v.size(), 0u);
+    }
+
+    void TestBack() {
+        using NPagedVector::TPagedVector;
+        TPagedVector<TString, 3> v;
+        for (int i = 0; i < 4; ++i) {
+            v.push_back(ToString(i));
+        }
+
+        UNIT_ASSERT_VALUES_EQUAL(v.back(), "3");
+        v.pop_back();
+        UNIT_ASSERT_VALUES_EQUAL(v.back(), "2");
+    }
+
+    void TestIterator() {
+        using NPagedVector::TPagedVector;
+        TPagedVector<TString, 5> v;
+        for (int i = 0; i < 11; ++i) {
+            v.push_back(ToString(i));
+        }
+
+        v.emplace_back("Hello");
+        v.emplace_back("world");
+
+        auto it = v.begin();
+
+        UNIT_ASSERT_VALUES_EQUAL(it.GetIndex(), 0);
+        UNIT_ASSERT_VALUES_EQUAL(*it, "0");
+
+        ++it;
+
+        UNIT_ASSERT_VALUES_EQUAL(it.GetIndex(), 1);
+        UNIT_ASSERT_VALUES_EQUAL(*it, "1");
+
+        it += 5;
+
+        UNIT_ASSERT_VALUES_EQUAL(it.GetIndex(), 6);
+        UNIT_ASSERT_VALUES_EQUAL(*it, "6");
+
+        it = v.erase(it);
+
+        UNIT_ASSERT_VALUES_EQUAL(it.GetIndex(), 6);
+        UNIT_ASSERT_VALUES_EQUAL(*it, "7");
+    }
+
+    void TestForEach() {
         using NPagedVector::TPagedVector;
-        // We use heap memory as test failure can corrupt vector internal
-        // representation making executable crash on vector destructor invocation.
-        // We prefer a simple memory leak, internal corruption should be reveal
-        // by size or capacity checks.
-        typedef TPagedVector<int, 3> V;
-        V* pv1 = new V;
 
-        pv1->resize(1);
-        pv1->at(0) = 1;
+        // Empty vector: the callback must not be invoked at all.
+        {
+            TPagedVector<int, 3> v;
+            size_t calls = 0;
+            v.ForEach([&](int) {
+                ++calls;
+            });
+            UNIT_ASSERT_VALUES_EQUAL(calls, 0u);
+        }
 
-        V* pv2 = new V;
+        // Single element: the only element is visited once.
+        {
+            TPagedVector<int, 3> v;
+            v.push_back(42);
+            TVector<int> visited;
+            v.ForEach([&](int x) {
+                visited.push_back(x);
+            });
+            TVector<int> expected{42};
+            UNIT_ASSERT_VALUES_EQUAL(visited, expected);
+        }
 
-        pv2->resize(10);
-        for (int i = 0; i < 10; ++i)
-            pv2->at(i) = 2;
+        // Several elements within a single (partially filled) page.
+        {
+            TPagedVector<int, 3> v;
+            for (int i = 0; i < 2; ++i) {
+                v.push_back(i);
+            }
+            TVector<int> visited;
+            int expectedElement = 0;
+            v.ForEach([&](int x) {
+                UNIT_ASSERT_VALUES_EQUAL(x, expectedElement);
+                ++expectedElement;
+                visited.push_back(x);
+            });
+            TVector<int> expected{0, 1};
+            UNIT_ASSERT_VALUES_EQUAL(visited, expected);
+        }
 
-        pv1->swap(*pv2);
+        // A single exactly full page (3 elements): the visit order must be
+        // strictly forward.
+        {
+            TPagedVector<int, 3> v;
+            for (int i = 0; i < 3; ++i) {
+                v.push_back(i);
+            }
+            TVector<int> visited;
+            int expectedElement = 0;
+            v.ForEach([&](int x) {
+                UNIT_ASSERT_VALUES_EQUAL(x, expectedElement);
+                ++expectedElement;
+                visited.push_back(x);
+            });
+            TVector<int> expected{0, 1, 2};
+            UNIT_ASSERT_VALUES_EQUAL(visited, expected);
+        }
 
-        UNIT_ASSERT(pv1->size() == 10);
-        UNIT_ASSERT((*pv1)[5] == 2);
+        // Multiple pages with a partially filled last page: the visit order
+        // must be strictly forward (from the first element to the last).
+        {
+            TPagedVector<int, 3> v;
+            const int n = 10; // spans 4 pages of size 3: [0..2][3..5][6..8][9]
+            for (int i = 0; i < n; ++i) {
+                v.push_back(i);
+            }
+            TVector<int> visited;
+            visited.reserve(n);
+            int expectedElement = 0;
+            v.ForEach([&](int x) {
+                UNIT_ASSERT_VALUES_EQUAL(x, expectedElement);
+                ++expectedElement;
+                visited.push_back(x);
+            });
+            TVector<int> expected;
+            expected.reserve(n);
+            for (int i = 0; i < n; ++i) {
+                expected.push_back(i);
+            }
+            UNIT_ASSERT_VALUES_EQUAL(visited, expected);
+        }
 
-        UNIT_ASSERT(pv2->size() == 1);
-        UNIT_ASSERT((*pv2)[0] == 1);
+        // Exactly full pages (no partial tail): every element is visited,
+        // last page is completely filled.
+        {
+            TPagedVector<int, 3> v;
+            const int n = 9; // exactly 3 full pages of size 3
+            for (int i = 0; i < n; ++i) {
+                v.push_back(i);
+            }
+            TVector<int> visited;
+            visited.reserve(n);
+            int expectedElement = 0;
+            v.ForEach([&](int x) {
+                UNIT_ASSERT_VALUES_EQUAL(x, expectedElement);
+                ++expectedElement;
+                visited.push_back(x);
+            });
+            TVector<int> expected;
+            expected.reserve(n);
+            for (int i = 0; i < n; ++i) {
+                expected.push_back(i);
+            }
+            UNIT_ASSERT_VALUES_EQUAL(visited, expected);
+        }
+    }
 
-        delete pv2;
-        delete pv1;
+    void TestForEachReverse() {
+        using NPagedVector::TPagedVector;
+
+        // Empty vector: the callback must not be invoked at all.
+        {
+            TPagedVector<int, 3> v;
+            size_t calls = 0;
+            v.ForEachReverse([&](int) {
+                ++calls;
+            });
+            UNIT_ASSERT_VALUES_EQUAL(calls, 0u);
+        }
+
+        // Single element: the only element is visited once.
+        {
+            TPagedVector<int, 3> v;
+            v.push_back(42);
+            TVector<int> visited;
+            v.ForEachReverse([&](int x) {
+                visited.push_back(x);
+            });
+            TVector<int> expected{42};
+            UNIT_ASSERT_VALUES_EQUAL(visited, expected);
+        }
+
+        // Several elements within a single (partially filled) page.
+        {
+            TPagedVector<int, 3> v;
+            for (int i = 0; i < 2; ++i) {
+                v.push_back(i);
+            }
+            TVector<int> visited;
+            int expectedElement = 1;
+            v.ForEachReverse([&](int x) {
+                UNIT_ASSERT_VALUES_EQUAL(x, expectedElement);
+                --expectedElement;
+                visited.push_back(x);
+            });
+            TVector<int> expected{1, 0};
+            UNIT_ASSERT_VALUES_EQUAL(visited, expected);
+        }
+
+        // A single exactly full page (3 elements): the visit order must be
+        // strictly reverse.
+        {
+            TPagedVector<int, 3> v;
+            for (int i = 0; i < 3; ++i) {
+                v.push_back(i);
+            }
+            TVector<int> visited;
+            int expectedElement = 2;
+            v.ForEachReverse([&](int x) {
+                UNIT_ASSERT_VALUES_EQUAL(x, expectedElement);
+                --expectedElement;
+                visited.push_back(x);
+            });
+            TVector<int> expected{2, 1, 0};
+            UNIT_ASSERT_VALUES_EQUAL(visited, expected);
+        }
+
+        // Multiple pages with a partially filled last page: the visit order
+        // must be strictly reverse (from the last element to the first).
+        {
+            TPagedVector<int, 3> v;
+            const int n = 10; // spans 4 pages of size 3: [0..2][3..5][6..8][9]
+            for (int i = 0; i < n; ++i) {
+                v.push_back(i);
+            }
+            TVector<int> visited;
+            visited.reserve(n);
+            int expectedElement = n - 1;
+            v.ForEachReverse([&](int x) {
+                UNIT_ASSERT_VALUES_EQUAL(x, expectedElement);
+                --expectedElement;
+                visited.push_back(x);
+            });
+            TVector<int> expected;
+            expected.reserve(n);
+            for (int i = n - 1; i >= 0; --i) {
+                expected.push_back(i);
+            }
+            UNIT_ASSERT_VALUES_EQUAL(visited, expected);
+        }
+
+        // Exactly full pages (no partial tail): every element is visited,
+        // last page is completely filled.
+        {
+            TPagedVector<int, 3> v;
+            const int n = 9; // exactly 3 full pages of size 3
+            for (int i = 0; i < n; ++i) {
+                v.push_back(i);
+            }
+            TVector<int> visited;
+            visited.reserve(n);
+            int expectedElement = n - 1;
+            v.ForEachReverse([&](int x) {
+                UNIT_ASSERT_VALUES_EQUAL(x, expectedElement);
+                --expectedElement;
+                visited.push_back(x);
+            });
+            TVector<int> expected;
+            expected.reserve(n);
+            for (int i = n - 1; i >= 0; --i) {
+                expected.push_back(i);
+            }
+            UNIT_ASSERT_VALUES_EQUAL(visited, expected);
+        }
     }
 };
 
diff --git a/library/cpp/containers/stack_vector/stack_vec.h b/library/cpp/containers/stack_vector/stack_vec.h
index b6036059b26..f2641b5d070 100644
--- a/library/cpp/containers/stack_vector/stack_vec.h
+++ b/library/cpp/containers/stack_vector/stack_vec.h
@@ -82,7 +82,7 @@ namespace NPrivate {
         }
 
     private:
-        std::aligned_storage_t<sizeof(T), alignof(T)> StackBasedStorage[CountOnStack];
+        alignas(T) char StackBasedStorage[CountOnStack][sizeof(T)];
         bool IsStorageUsed = false;
 
     private:
diff --git a/library/cpp/coroutine/engine/coroutine_ut.cpp b/library/cpp/coroutine/engine/coroutine_ut.cpp
index de56d0ed2bb..20176fdb91f 100644
--- a/library/cpp/coroutine/engine/coroutine_ut.cpp
+++ b/library/cpp/coroutine/engine/coroutine_ut.cpp
@@ -2,7 +2,6 @@
 #include "condvar.h"
 #include "network.h"
 
-#include <library/cpp/deprecated/atomic/atomic.h>
 #include <library/cpp/testing/unittest/registar.h>
 
 #include <util/string/cast.h>
@@ -13,6 +12,8 @@
 #include <util/generic/xrange.h>
 #include <util/generic/serialized_enum.h>
 
+#include <atomic>
+
 // TODO (velavokr): BALANCER-1345 add more tests on pollers
 
 class TCoroTest: public TTestBase {
@@ -112,7 +113,7 @@ void TCoroTest::TestException() {
 
     auto f2 = [&unc, &f2run](TCont*) {
         f2run = true;
-        unc = std::uncaught_exception();
+        unc = std::uncaught_exceptions();
 
         // check segfault
         try {
@@ -162,11 +163,11 @@ void TCoroTest::TestSimpleX1() {
 void TCoroTest::TestSimpleX1MultiThread() {
     TVector<THolder<TThread>> threads;
     const size_t nThreads = 0;
-    TAtomic c = 0;
+    std::atomic<size_t> c = 0;
     for (size_t i = 0; i < nThreads; ++i) {
         threads.push_back(MakeHolder<TThread>([&]() {
             TestSimpleX1();
-            AtomicIncrement(c);
+            ++c;
         }));
     }
 
@@ -178,7 +179,7 @@ void TCoroTest::TestSimpleX1MultiThread() {
         t->Join();
     }
 
-    UNIT_ASSERT_EQUAL(c, nThreads);
+    UNIT_ASSERT_EQUAL(c.load(), nThreads);
 }
 
 struct TTestObject {
diff --git a/library/cpp/cppparser/parser.cpp b/library/cpp/cppparser/parser.cpp
index 3bd968b4594..70fb6a87356 100644
--- a/library/cpp/cppparser/parser.cpp
+++ b/library/cpp/cppparser/parser.cpp
@@ -1,4 +1,5 @@
 #include <util/generic/hash.h>
+#include <util/string/ascii.h>
 #include <util/string/cast.h>
 #include <util/generic/hash_set.h>
 #include <util/generic/yexception.h>
@@ -127,6 +128,10 @@ class TCppSaxParser::TImpl {
                             break;
 
                         case '\'':
+                            if (QuoteCharIsADigitSeparator()) {
+                                Text_.Data += ch;
+                                break;
+                            }
                             Action(ch);
                             State_ = Character;
 
@@ -356,6 +361,35 @@ class TCppSaxParser::TImpl {
         }
     }
 
+    // digit separator in integral literal (ex. 73'709'550'592)
+    bool QuoteCharIsADigitSeparator() const {
+        const TStringBuf data = Text_.Data;
+        if (data.empty()) {
+            return false;
+        }
+        if (!IsAsciiHex(data.back())) {
+            return false;
+        }
+        // check for char literal prefix (ex. `u8'$'`)
+        static constexpr TStringBuf literalPrefixes[] {
+            "u8",
+            "u",
+            "U",
+            "L",
+        };
+        for (const TStringBuf& literalPrefix : literalPrefixes) {
+            if (TStringBuf prev; data.BeforeSuffix(literalPrefix, prev)) {
+                if (!prev.empty() && (IsAsciiAlnum(prev.back()) || prev.back() == '_' || prev.back() == '$')) {
+                    // some macro name ends with an `u8` sequence
+                    continue;
+                }
+                // it is a prefixed character literal
+                return false;
+            }
+        }
+        return true;
+    }
+
     inline void Action(char ch) {
         Action();
         Text_.Data += ch;
diff --git a/library/cpp/digest/md5/md5.cpp b/library/cpp/digest/md5/md5.cpp
index de497498082..c583a08170d 100644
--- a/library/cpp/digest/md5/md5.cpp
+++ b/library/cpp/digest/md5/md5.cpp
@@ -12,7 +12,6 @@ namespace {
 
     constexpr size_t MD5_BLOCK_LENGTH = 64;
     constexpr size_t MD5_PADDING_SHIFT = 56;
-    constexpr size_t MD5_HEX_DIGEST_LENGTH = 32;
 
     struct TMd5Stream: public IOutputStream {
         inline TMd5Stream(MD5* md5)
diff --git a/library/cpp/digest/md5/md5.h b/library/cpp/digest/md5/md5.h
index 2c17aa05181..b6aecb8f460 100644
--- a/library/cpp/digest/md5/md5.h
+++ b/library/cpp/digest/md5/md5.h
@@ -6,6 +6,9 @@
 class IInputStream;
 
 class MD5 {
+public:
+    static constexpr size_t MD5_HEX_DIGEST_LENGTH = 32;
+
 public:
     MD5() {
         Init();
diff --git a/library/cpp/digest/md5/md5_ut.cpp b/library/cpp/digest/md5/md5_ut.cpp
index 1c3e4ad0a9f..7fb7f58a996 100644
--- a/library/cpp/digest/md5/md5_ut.cpp
+++ b/library/cpp/digest/md5/md5_ut.cpp
@@ -14,7 +14,7 @@ Y_UNIT_TEST_SUITE(TMD5Test) {
         r.Update((const unsigned char*)b, 15);
         r.Update((const unsigned char*)b + 15, strlen(b) - 15);
 
-        char rs[33];
+        char rs[MD5::MD5_HEX_DIGEST_LENGTH + 1];
         TString s(r.End(rs));
         s.to_lower();
 
diff --git a/library/cpp/digest/murmur/murmur.h b/library/cpp/digest/murmur/murmur.h
index cbf28864128..8ca20b378e8 100644
--- a/library/cpp/digest/murmur/murmur.h
+++ b/library/cpp/digest/murmur/murmur.h
@@ -37,7 +37,7 @@ class TMurmurHash2A {
     using TValue = typename TTraits::TValue;
 
 public:
-    inline TMurmurHash2A(TValue seed = 0)
+    inline explicit TMurmurHash2A(TValue seed = 0)
         : Hash(seed)
     {
     }
diff --git a/library/cpp/getopt/last_getopt_demo/demo.cpp b/library/cpp/getopt/last_getopt_demo/demo.cpp
index a0e82a936cd..3e98db97d4f 100644
--- a/library/cpp/getopt/last_getopt_demo/demo.cpp
+++ b/library/cpp/getopt/last_getopt_demo/demo.cpp
@@ -121,8 +121,8 @@ class TMain: public TMainClassArgs {
             })
             .Completer(NLastGetopt::NComp::File());
 
-        // These two options can't be together.
-        opts.MutuallyExclusive("post-file", "post-data");
+        // These options can not appear together.
+        opts.MutuallyExclusive("method", "post-file", "post-data");
 
         opts.AddLongOption("header")
             .RequiredArgument("header-line")
diff --git a/library/cpp/getopt/small/completion_generator.cpp b/library/cpp/getopt/small/completion_generator.cpp
index d893afb40a9..5e0e55ed38b 100644
--- a/library/cpp/getopt/small/completion_generator.cpp
+++ b/library/cpp/getopt/small/completion_generator.cpp
@@ -63,6 +63,14 @@ namespace NLastGetopt {
         L;
         manager.GenerateZsh(out);
 
+        // When the completion file is autoloaded by `compinit` from `$fpath`,
+        // zsh treats the file content as the body of function `_<command>`.
+        // On first invocation that body merely (re)defines `_<command>` and
+        // its helpers, so completion would not actually run until the second
+        // TAB. Calling the redefined function here makes it work on the very
+        // first TAB and is also harmless when the script is `source`d.
+        L << "_" << command << " \"$@\"";
+
         out.Print(stream);
     }
 
diff --git a/library/cpp/getopt/small/last_getopt_opt.h b/library/cpp/getopt/small/last_getopt_opt.h
index 8754ebb7eeb..67a937bdb13 100644
--- a/library/cpp/getopt/small/last_getopt_opt.h
+++ b/library/cpp/getopt/small/last_getopt_opt.h
@@ -13,7 +13,8 @@
 #include <util/string/join.h>
 
 #include <optional>
-#include <stdarg.h>
+#include <functional>
+#include <utility>
 
 namespace NLastGetopt {
     enum EHasArg {
@@ -23,6 +24,11 @@ namespace NLastGetopt {
         DEFAULT_HAS_ARG = REQUIRED_ARGUMENT
     };
 
+    template<class T>
+    concept ArgTagConcept =
+        std::is_enum_v<std::remove_cvref_t<T>> ||
+        std::is_same_v<std::remove_cvref_t<T>, ui32>;
+
     /**
      * NLastGetopt::TOpt is a storage of data about exactly one program option.
      * The data is: parse politics and help information.
@@ -36,12 +42,12 @@ namespace NLastGetopt {
      *   argument parse politics: no/optional/required/
      *   option existence: required or optional
      *   handlers. See detailed documentation: <TODO:link>
-     *   default value: if the option has argument, but the option is ommited,
+     *   default value: if the option has argument, but the option is omitted,
      *                     then the <default value> is used as the value of the argument
      *   optional value: if the option has optional-argument, the option is present in parsed string,
      *                      but the argument is omitted, then <optional value is used>
-     *      in case of "not given <optional value>, omited optional argument" the <default value> is used
-     *   user value: allows to store arbitary pointer for handlers
+     *      in case of "not given <optional value>, omitted optional argument" the <default value> is used
+     *   user value: allows to store arbitrary pointer for handlers
      */
     class TOpt {
     public:
@@ -94,7 +100,7 @@ namespace NLastGetopt {
         /**
          *  Checks if given string can be a long name
          *  @param name            string to check
-         *  @param c               if given, the first bad charecter will be saved in c
+         *  @param c               if given, the first bad character will be saved in c
          */
         static bool IsAllowedLongName(const TString& name, unsigned char* c = nullptr);
 
@@ -798,6 +804,9 @@ namespace NLastGetopt {
      *   argument name (title)
      */
     struct TFreeArgSpec {
+        template <ArgTagConcept E>
+        using TTagger = std::function<E(const TString&)>;
+
         TFreeArgSpec() = default;
         TFreeArgSpec(const TString& title, const TString& help = TString(), bool optional = false)
             : Title_(title)
@@ -809,6 +818,7 @@ namespace NLastGetopt {
         TString Title_;
         TString Help_;
         TString CompletionArgHelp_;
+        TTagger<ui32> Tagger_;
 
         bool Optional_ = false;
         NComp::ICompleterPtr Completer_ = nullptr;
@@ -891,5 +901,48 @@ namespace NLastGetopt {
             Completer_ = std::move(completer);
             return *this;
         }
+
+        /**
+         * Set a tagger that can compute tag dynamically for each argument value.
+         */
+        TFreeArgSpec& SetTag(TTagger<ui32>&& tagger) {
+            Tagger_ = std::forward<TTagger<ui32>>(tagger);
+            return *this;
+        }
+
+        /**
+         * Set a static tag for all arguments described by this spec.
+         */
+        template <ArgTagConcept E>
+        TFreeArgSpec& SetTag(E tag) {
+            Tagger_ = [tag](const TString&) -> ui32 {
+                return static_cast<ui32>(tag);
+            };
+            return *this;
+        }
+
+        /**
+         * Set a tagger that can compute tag dynamically for each argument value.
+         */
+        template <ArgTagConcept E>
+        TFreeArgSpec& SetTag(TTagger<E>&& tagger) {
+            Tagger_ = [tagger](const TString& value) -> ui32 {
+                return static_cast<ui32>(tagger(value));
+            };
+            return *this;
+        }
+
+        /**
+         * Compute tag for argument value at given position.
+         */
+        ui32 GetTag(const TString& value) const {
+            if (Tagger_) {
+                ui32 tag = Tagger_(value);
+                if (tag) {
+                    return tag;
+                }
+            }
+            return 0;
+        }
     };
 }
diff --git a/library/cpp/getopt/small/last_getopt_opts.cpp b/library/cpp/getopt/small/last_getopt_opts.cpp
index 984927a0387..b656e607e85 100644
--- a/library/cpp/getopt/small/last_getopt_opts.cpp
+++ b/library/cpp/getopt/small/last_getopt_opts.cpp
@@ -213,7 +213,7 @@ namespace NLastGetopt {
         if (FreeArgsMax_ < FreeArgsMin_) {
             ythrow TConfException() << "FreeArgsMax must be >= FreeArgsMin";
         }
-        if (!FreeArgSpecs_.empty() && FreeArgSpecs_.rbegin()->first >= FreeArgsMax_) {
+        if (!FreeArgSpecs_.empty() && GetTrailingArgsIndex() > FreeArgsMax_) {
             ythrow TConfException() << "Described args count is greater than FreeArgsMax. Either increase FreeArgsMax or remove unreachable descriptions";
         }
     }
@@ -335,7 +335,7 @@ namespace NLastGetopt {
         }
         os << "[OPTIONS]";
 
-        ui32 numDescribedFlags = FreeArgSpecs_.empty() ? 0 : FreeArgSpecs_.rbegin()->first + 1;
+        ui32 numDescribedFlags = GetTrailingArgsIndex();
         ui32 numArgsToShow = Max(FreeArgsMin_, FreeArgsMax_ == UNLIMITED_ARGS ? numDescribedFlags : FreeArgsMax_);
 
         for (ui32 i = 0, nonOptionalFlagsPrinted = 0; i < numArgsToShow; ++i) {
@@ -513,8 +513,8 @@ namespace NLastGetopt {
         }
         os << colors.OldColor() << Endl;
 
-        const size_t limit = FreeArgSpecs_.empty() ? 0 : FreeArgSpecs_.rbegin()->first;
-        for (size_t i = 0; i <= limit; ++i) {
+        const size_t limit = GetTrailingArgsIndex();
+        for (size_t i = 0; i < limit; ++i) {
             if (!FreeArgSpecs_.contains(i)) {
                 continue;
             }
diff --git a/library/cpp/getopt/small/last_getopt_opts.h b/library/cpp/getopt/small/last_getopt_opts.h
index 718dbfcb893..868477ec79e 100644
--- a/library/cpp/getopt/small/last_getopt_opts.h
+++ b/library/cpp/getopt/small/last_getopt_opts.h
@@ -28,7 +28,7 @@ namespace NLastGetopt {
      *            the special string " -- " will be treated as end of named
      *            options: all options after it will be parsed as free args
      *       if PERMUTE is choosen, arguments will be rearranged in correct order,
-     *       if RETURN_IN_ORDER is choosen, all free args will be ommited (TODO: looks very strange)
+     *       if RETURN_IN_ORDER is choosen, all free args will be omitted (TODO: looks very strange)
      *   - Using '+' as a prefix instead '--' for long names
      *   - Using "-" as a prefix for both short and long names
      *   - Allowing unknown options
@@ -49,7 +49,7 @@ namespace NLastGetopt {
         bool AllowSingleDashForLong_ = false;                      //
         bool AllowPlusForLong_ = false;                            // using '+' instead '--' for long options
 
-        //Allows unknwon options:
+        //Allows unknown options:
         bool AllowUnknownCharOptions_ = false;
         bool AllowUnknownLongOptions_ = false;
 
@@ -78,7 +78,7 @@ namespace NLastGetopt {
 
         /**
          * Constructs TOpts from string as in getopt(3) and
-         * additionally adds help option (for '?') and svn-verstion option (for 'V')
+         * additionally adds help option (for '?') and svn-version option (for 'V')
          */
         static TOpts Default(const TStringBuf& optstring = TStringBuf()) {
             TOpts opts(optstring);
@@ -92,7 +92,7 @@ namespace NLastGetopt {
          * Throws TConfException if validation failed.
          * Check consist of:
          *    -not intersecting of names
-         *    -compability of settings, that responsable for freeArgs parsing
+         *    -compatibility of settings, that responsible for freeArgs parsing
          */
         void Validate() const;
 
@@ -398,9 +398,22 @@ namespace NLastGetopt {
          * Note: don't use this on options with default values. If option with default value wasn't specified,
          * parser will run handlers for default value, thus triggering a false-positive exclusivity check.
          */
-        template <typename T1, typename T2>
-        void MutuallyExclusive(T1&& opt1, T2&& opt2) {
-            MutuallyExclusiveOpt(GetOption(std::forward<T1>(opt1)), GetOption(std::forward<T2>(opt2)));
+        template <typename Opt1, typename Opt2>
+        void MutuallyExclusive(Opt1&& name1, Opt2&& name2) {
+            TOpt& opt1 = GetOption(name1);
+            TOpt& opt2 = GetOption(name2);
+            MutuallyExclusiveOpt(opt1, opt2);
+        }
+
+        template <typename Opt1, typename... OtherOpts>
+        void MutuallyExclusive(Opt1&& name1, OtherOpts&& ...otherNames) {
+            TOpt& opt1 = GetOption(name1);
+            std::array<std::string_view, sizeof...(OtherOpts)> otherNamesArr{otherNames...};
+            for (const auto& otherName: otherNamesArr) {
+                TOpt& otherOpt = GetOption(otherName);
+                MutuallyExclusiveOpt(opt1, otherOpt);
+            }
+            MutuallyExclusive(std::forward<OtherOpts>(otherNames)...);
         }
 
         /**
@@ -449,6 +462,24 @@ namespace NLastGetopt {
             AddSection("Examples", std::move(examples));
         }
 
+        /**
+         * Add section with examples.
+         *
+         * @param examples text of this section
+         */
+        void SetExamples(std::string_view examples) {
+            SetExamples(TString(examples));
+        }
+
+        /**
+         * Add section with examples.
+         *
+         * @param examples text of this section
+         */
+        void SetExamples(const char* examples) {
+            SetExamples(TString(examples));
+        }
+
         /**
          * Set minimal number of free args
          *
@@ -490,6 +521,13 @@ namespace NLastGetopt {
             return FreeArgSpecs_;
         }
 
+        /**
+         * Get index from where trailing arguments start
+         */
+        ui32 GetTrailingArgsIndex() const {
+            return FreeArgSpecs_.empty() ? 0 : FreeArgSpecs_.rbegin()->first + 1;
+        }
+
         /**
          * Set exact expected number of free args
          *
@@ -529,7 +567,7 @@ namespace NLastGetopt {
 
         /**
          * Legacy, don't use. Same as `SetTrailingArgTitle`.
-         * Older versions of lastgetopt didn't have destinction between default title and title
+         * Older versions of lastgetopt didn't have distinction between default title and title
          * for the trailing argument.
          */
         void SetFreeArgDefaultTitle(const TString& title, const TString& help = TString()) {
diff --git a/library/cpp/getopt/small/last_getopt_parse_result.cpp b/library/cpp/getopt/small/last_getopt_parse_result.cpp
index 60effba41b4..016fe347141 100644
--- a/library/cpp/getopt/small/last_getopt_parse_result.cpp
+++ b/library/cpp/getopt/small/last_getopt_parse_result.cpp
@@ -9,6 +9,44 @@ namespace NLastGetopt {
         return nullptr;
     }
 
+    void TOptsParseResult::BuildTaggedFreeArgs(const TOpts* options) {
+        TaggedFreeArgs_.clear();
+
+        if (!Parser_) {
+            return;
+        }
+
+        const size_t freeArgsPos = GetFreeArgsPos();
+        for (size_t argPos = freeArgsPos; argPos < Parser_->Argc_; ++argPos) {
+            size_t index = argPos - freeArgsPos;
+
+            TString value = Parser_->Argv_[argPos];
+            ui32 tag = 0;
+
+            if (options) {
+                const TFreeArgSpec* spec = nullptr;
+                auto it = options->FreeArgSpecs_.find(index);
+                if (it != options->FreeArgSpecs_.end()) {
+                    spec = &it->second;
+                } else if (options->FreeArgsMax_ == TOpts::UNLIMITED_ARGS) {
+                    ui32 trailingArgsIndex = options->GetTrailingArgsIndex();
+                    if (index >= trailingArgsIndex) {
+                        spec = &options->TrailingArgSpec_;
+                    }
+                }
+
+                if (spec) {
+                    tag = spec->GetTag(value);
+                }
+            }
+
+            TaggedFreeArgs_.push_back(TTaggedArg {
+                .Value = value,
+                .Tag = tag
+            });
+        }
+    }
+
     const TOptParseResult* TOptsParseResult::FindOptParseResult(const TOpt* opt, bool includeDefault) const {
         const TOptParseResult* r = FindParseResult(Opts_, opt);
         if (nullptr == r && includeDefault)
@@ -99,6 +137,14 @@ namespace NLastGetopt {
         return Parser_->ProgramName_;
     }
 
+    void TOptsParseResult::SetProgramSubcommandPath(const TVector<TString>& parts) {
+        ProgramSubcommandPath_ = parts;
+    }
+
+    const TVector<TString>& TOptsParseResult::GetProgramSubcommandPath() const {
+        return ProgramSubcommandPath_;
+    }
+
     void TOptsParseResult::PrintUsage(IOutputStream& os) const {
         Parser_->Opts_->PrintUsage(Parser_->ProgramName_, os);
     }
@@ -108,15 +154,16 @@ namespace NLastGetopt {
     }
 
     TVector<TString> TOptsParseResult::GetFreeArgs() const {
-        TVector<TString> v;
-        for (size_t i = GetFreeArgsPos(); i < Parser_->Argc_; ++i) {
-            v.push_back(Parser_->Argv_[i]);
+        TVector<TString> args;
+        args.reserve(TaggedFreeArgs_.size());
+        for (const auto& arg : TaggedFreeArgs_) {
+            args.push_back(arg.Value);
         }
-        return v;
+        return args;
     }
 
     size_t TOptsParseResult::GetFreeArgCount() const {
-        return Parser_->Argc_ - GetFreeArgsPos();
+        return TaggedFreeArgs_.size();
     }
 
     void FindUserTypos(const TString& arg, const TOpts* options) {
@@ -142,6 +189,7 @@ namespace NLastGetopt {
             }
 
             Y_ENSURE(options);
+            BuildTaggedFreeArgs(options);
             const auto freeArgs = GetFreeArgs();
             for (size_t i = 0; i < freeArgs.size(); ++i) {
                 if (i >= options->ArgBindings_.size()) {
diff --git a/library/cpp/getopt/small/last_getopt_parse_result.h b/library/cpp/getopt/small/last_getopt_parse_result.h
index c6e768c4617..6574667aede 100644
--- a/library/cpp/getopt/small/last_getopt_parse_result.h
+++ b/library/cpp/getopt/small/last_getopt_parse_result.h
@@ -3,7 +3,14 @@
 #include "last_getopt_opts.h"
 #include "last_getopt_parser.h"
 
+#include <util/generic/hash.h>
+
 namespace NLastGetopt {
+    struct TTaggedArg {
+        TString Value;
+        ui32 Tag = 0;
+    };
+
     /**
      * NLastGetopt::TOptParseResult contains all arguments for exactly one TOpt,
      * that have been fetched during parsing
@@ -73,6 +80,8 @@ namespace NLastGetopt {
 
         TdVec Opts_;    //Parsing result for all options, that have been explicitly defined in argc/argv
         TdVec OptsDef_; //Parsing result for options, that have been defined by default values only
+        TVector<TString> ProgramSubcommandPath_;
+        TVector<TTaggedArg> TaggedFreeArgs_;
 
     private:
         TOptParseResult& OptParseResult();
@@ -87,6 +96,8 @@ namespace NLastGetopt {
          */
         static const TOptParseResult* FindParseResult(const TdVec& vec, const TOpt* opt);
 
+        void BuildTaggedFreeArgs(const TOpts* options);
+
     protected:
         /**
          * Performs parsing of comand line arguments.
@@ -161,6 +172,8 @@ namespace NLastGetopt {
          * @return argv[0]
          */
         TString GetProgramName() const;
+        void SetProgramSubcommandPath(const TVector<TString>& parts);
+        const TVector<TString>& GetProgramSubcommandPath() const;
 
         /**
          * Print usage string.
@@ -182,6 +195,22 @@ namespace NLastGetopt {
          */
         TVector<TString> GetFreeArgs() const;
 
+        template <ArgTagConcept E>
+        TVector<TString> GetFreeArgs(E tag) const {
+            TVector<TString> args;
+            ui32 ui32Tag = static_cast<ui32>(tag);
+            for (const auto& arg : TaggedFreeArgs_) {
+                if (arg.Tag == ui32Tag) {
+                    args.push_back(arg.Value);
+                }
+            }
+            return args;
+        }
+
+        const TVector<TTaggedArg>& GetTaggedFreeArgs() const {
+            return TaggedFreeArgs_;
+        }
+
         /**
          * @return true if given option exist in results of parsing
          *
@@ -192,7 +221,7 @@ namespace NLastGetopt {
         bool Has(const TOpt* opt, bool includeDefault = false) const;
 
         /**
-         * @return nil terminated string on the last fetched argument of givne option
+         * @return nil terminated string on the last fetched argument of given option
          *
          * @param opt                ptr on required object
          * @param includeDefault     search in results obtained from default values
@@ -200,7 +229,7 @@ namespace NLastGetopt {
         const char* Get(const TOpt* opt, bool includeDefault = true) const;
 
         /**
-         * @return nil terminated string on the last fetched argument of givne option
+         * @return nil terminated string on the last fetched argument of given option
          *    if option haven't been fetched, given defaultValue will be returned
          *
          * @param opt                ptr on required object
@@ -218,7 +247,7 @@ namespace NLastGetopt {
         bool Has(const TString& name, bool includeDefault = false) const;
 
         /**
-         * @return nil terminated string on the last fetched argument of givne option
+         * @return nil terminated string on the last fetched argument of given option
          *
          * @param name               long name of required object
          * @param includeDefault     search in results obtained from default values
@@ -226,7 +255,7 @@ namespace NLastGetopt {
         const char* Get(const TString& name, bool includeDefault = true) const;
 
         /**
-         * @return nil terminated string on the last fetched argument of givne option
+         * @return nil terminated string on the last fetched argument of given option
          *    if option haven't been fetched, given defaultValue will be returned
          *
          * @param name               long name of required object
@@ -244,7 +273,7 @@ namespace NLastGetopt {
         bool Has(char name, bool includeDefault = false) const;
 
         /**
-         * @return nil terminated string on the last fetched argument of givne option
+         * @return nil terminated string on the last fetched argument of given option
          *
          * @param c                  short name of required object
          * @param includeDefault     search in results obtained from default values
@@ -252,7 +281,7 @@ namespace NLastGetopt {
         const char* Get(char name, bool includeDefault = true) const;
 
         /**
-         * @return nil terminated string on the last fetched argument of givne option
+         * @return nil terminated string on the last fetched argument of given option
          *    if option haven't been fetched, given defaultValue will be returned
          *
          * @param c                  short name of required object
@@ -261,7 +290,7 @@ namespace NLastGetopt {
         const char* GetOrElse(char name, const char* defaultValue) const;
 
         /**
-         * for givne option return parsed value of the last fetched argument
+         * for given option return parsed value of the last fetched argument
          * if option haven't been fetched, HandleError action is called
          *
          * @param opt       required option (one of: ptr, short name, long name).
@@ -280,7 +309,7 @@ namespace NLastGetopt {
         }
 
         /**
-         * for givne option return parsed value of the last fetched argument
+         * for given option return parsed value of the last fetched argument
          * if option haven't been fetched, given defaultValue will be returned
          *
          * @param opt       required option (one of: ptr, short name, long name).
diff --git a/library/cpp/getopt/small/last_getopt_parser.cpp b/library/cpp/getopt/small/last_getopt_parser.cpp
index 911c76f3425..98c3951a1c7 100644
--- a/library/cpp/getopt/small/last_getopt_parser.cpp
+++ b/library/cpp/getopt/small/last_getopt_parser.cpp
@@ -170,9 +170,14 @@ namespace NLastGetopt {
 
     bool TOptsParser::ParseOptParam(const TOpt* opt, size_t pos) {
         Y_ASSERT(opt);
-        if (opt->GetHasArg() == NO_ARGUMENT || opt->IsEqParseOnly()) {
+        if (opt->GetHasArg() == NO_ARGUMENT ||
+            opt->GetHasArg() == OPTIONAL_ARGUMENT && opt->IsEqParseOnly()) {
             return Commit(opt, nullptr, pos, 0);
         }
+        if (opt->IsEqParseOnly()) {
+            Y_ASSERT(opt->GetHasArg() == REQUIRED_ARGUMENT);
+            throw TUsageException() << "option " << opt->ToShortString() << " requires an argument but only accepts it over =";
+        }
         if (pos == Argc_) {
             if (opt->GetHasArg() == REQUIRED_ARGUMENT)
                 throw TUsageException() << "option " << opt->ToShortString() << " must have arg";
diff --git a/library/cpp/getopt/small/last_getopt_parser.h b/library/cpp/getopt/small/last_getopt_parser.h
index 2cf8a6c308d..dca23551508 100644
--- a/library/cpp/getopt/small/last_getopt_parser.h
+++ b/library/cpp/getopt/small/last_getopt_parser.h
@@ -46,7 +46,7 @@ namespace NLastGetopt {
         bool GotMinusMinus_; //true if "--" have been seen in argv
 
     protected:
-        const TOpt* CurrentOpt_;  // ptr on the last meeted option
+        const TOpt* CurrentOpt_;  // ptr on the last met option
         TStringBuf CurrentValue_; // the value of the last met argument (corresponding to CurrentOpt_)
 
     private:
diff --git a/library/cpp/getopt/small/modchooser.cpp b/library/cpp/getopt/small/modchooser.cpp
index 3b3b0b7751e..903061dd8d9 100644
--- a/library/cpp/getopt/small/modchooser.cpp
+++ b/library/cpp/getopt/small/modchooser.cpp
@@ -58,6 +58,14 @@ class ClassWrapper: public TMainClass {
     TMainClassV* Main;
 };
 
+void TMainClass::SetSubcommandPath(TVector<TString> parts) {
+    SubcommandPath_ = std::move(parts);
+}
+
+const TVector<TString>& TMainClass::GetSubcommandPath() const {
+    return SubcommandPath_;
+}
+
 TModChooser::TMode::TMode(const TString& name, TMainClass* main, const TString& descr, bool hidden, bool noCompletion)
     : Name(name)
     , Main(main)
@@ -161,6 +169,14 @@ void TModChooser::AddCompletions(TString progName, const TString& name, bool hid
     }
 }
 
+void TModChooser::SetSubcommandPath(const TVector<TString>& subcommandPath) const {
+    SubcommandPath_ = subcommandPath;
+}
+
+const TVector<TString>& TModChooser::GetSubcommandPath() const {
+    return SubcommandPath_;
+}
+
 int TModChooser::Run(const int argc, const char** argv) const {
     Y_ENSURE(argc, "Can't run TModChooser with empty list of arguments.");
 
@@ -202,6 +218,10 @@ int TModChooser::Run(const int argc, const char** argv) const {
         return 1;
     }
 
+    TVector<TString> subcommandPath = SubcommandPath_;
+    subcommandPath.push_back(modeIter->second->Name);
+    modeIter->second->Main->SetSubcommandPath(std::move(subcommandPath));
+
     if (shiftArgs) {
         TString firstArg;
         TVector<const char*> nargv(Reserve(argc));
@@ -329,7 +349,11 @@ bool TModChooser::IsSvnRevisionOptionDisabled() const {
 }
 
 int TMainClassArgs::Run(int argc, const char** argv) {
-    return DoRun(NLastGetopt::TOptsParseResult(&GetOptions(), argc, argv));
+    NLastGetopt::TOptsParseResult res(&GetOptions(), argc, argv);
+    if (!GetSubcommandPath().empty()) {
+        res.SetProgramSubcommandPath(GetSubcommandPath());
+    }
+    return DoRun(std::move(res));
 }
 
 const NLastGetopt::TOpts& TMainClassArgs::GetOptions() {
@@ -355,10 +379,11 @@ int TMainClassModes::operator()(const int argc, const char** argv) {
 
 int TMainClassModes::Run(int argc, const char** argv) {
     auto& chooser = GetSubModes();
+    chooser.SetSubcommandPath(GetSubcommandPath());
     return chooser.Run(argc, argv);
 }
 
-const TModChooser& TMainClassModes::GetSubModes() {
+TModChooser& TMainClassModes::GetSubModes() {
     if (Modes_.Empty()) {
         Modes_.ConstructInPlace();
         RegisterModes(Modes_.GetRef());
@@ -367,6 +392,10 @@ const TModChooser& TMainClassModes::GetSubModes() {
     return Modes_.GetRef();
 }
 
+const TModChooser& TMainClassModes::GetSubModes() const {
+    return const_cast<TMainClassModes*>(this)->GetSubModes();
+}
+
 void TMainClassModes::RegisterModes(TModChooser& modes) {
     modes.SetModesHelpOption("-h");
 }
diff --git a/library/cpp/getopt/small/modchooser.h b/library/cpp/getopt/small/modchooser.h
index d41ae780052..81f0629015e 100644
--- a/library/cpp/getopt/small/modchooser.h
+++ b/library/cpp/getopt/small/modchooser.h
@@ -28,6 +28,13 @@ class TMainClass {
 public:
     virtual int operator()(int argc, const char** argv) = 0;
     virtual ~TMainClass() = default;
+
+    void SetSubcommandPath(TVector<TString> parts);
+
+    const TVector<TString>& GetSubcommandPath() const;
+
+protected:
+    TVector<TString> SubcommandPath_;
 };
 
 //! Function to handle '--version' parameter
@@ -89,6 +96,9 @@ class TModChooser {
 
     void AddCompletions(TString progName, const TString& name = "completion", bool hidden = false, bool noCompletion = false);
 
+    void SetSubcommandPath(const TVector<TString>& subcommandPath) const;
+    const TVector<TString>& GetSubcommandPath() const;
+
     /*! Run appropriate mode.
      *
      * In this method following things happen:
@@ -184,6 +194,8 @@ class TModChooser {
      * then help message will be printed to stdout
     */
     bool HelpAlwaysToStdErr{true};
+
+    mutable TVector<TString> SubcommandPath_;
 };
 
 //! Mode class that allows introspecting its console arguments.
@@ -219,7 +231,8 @@ class TMainClassModes: public TMainClass {
     int Run(int argc, const char** argv);
 
     //! Get sub-modes for this mode.
-    const TModChooser& GetSubModes();
+    TModChooser& GetSubModes();
+    const TModChooser& GetSubModes() const;
 
 protected:
     //! Fill given modchooser with sub-modes.
diff --git a/library/cpp/getopt/ut/CMakeLists.txt b/library/cpp/getopt/ut/CMakeLists.txt
index ee1a898a7ca..09465ddc741 100644
--- a/library/cpp/getopt/ut/CMakeLists.txt
+++ b/library/cpp/getopt/ut/CMakeLists.txt
@@ -1,65 +1,11 @@
-add_ydb_test(NAME getopt-last_getopt_ut
+add_ydb_test(NAME getopt-ut
   SOURCES
     last_getopt_ut.cpp
-  LINK_LIBRARIES
-    getopt
-    cpp-testing-unittest_main
-  LABELS
-    unit
-)
-
-add_ydb_test(NAME getopt-modchooser_ut
-  SOURCES
     modchooser_ut.cpp
-  LINK_LIBRARIES
-    getopt
-    cpp-testing-unittest_main
-  LABELS
-    unit
-)
-
-add_ydb_test(NAME getopt-opt2_ut
-  SOURCES
     opt2_ut.cpp
-  LINK_LIBRARIES
-    getopt
-    cpp-testing-unittest_main
-  LABELS
-    unit
-)
-
-add_ydb_test(NAME getopt-opt_ut
-  SOURCES
     opt_ut.cpp
-  LINK_LIBRARIES
-    getopt
-    cpp-testing-unittest_main
-  LABELS
-    unit
-)
-
-add_ydb_test(NAME getopt-posix_getopt_ut
-  SOURCES
     posix_getopt_ut.cpp
-  LINK_LIBRARIES
-    getopt
-    cpp-testing-unittest_main
-  LABELS
-    unit
-)
-
-add_ydb_test(NAME getopt-wrap_ut
-  SOURCES
     wrap.cpp
-  LINK_LIBRARIES
-    getopt-small
-    cpp-testing-unittest_main
-  LABELS
-    unit
-)
-
-add_ydb_test(NAME getopt-ygetopt_ut
-  SOURCES
     ygetopt_ut.cpp
   LINK_LIBRARIES
     getopt
diff --git a/library/cpp/getopt/ut/last_getopt_ut.cpp b/library/cpp/getopt/ut/last_getopt_ut.cpp
index b517ea359d2..31fc923d31e 100644
--- a/library/cpp/getopt/ut/last_getopt_ut.cpp
+++ b/library/cpp/getopt/ut/last_getopt_ut.cpp
@@ -28,8 +28,6 @@ namespace {
             Init(opts, (int)Argv_.size(), Argv_.data());
         }
     };
-
-    using V = TVector<const char*>;
 }
 
 struct TOptsParserTester {
@@ -137,7 +135,7 @@ Y_UNIT_TEST_SUITE(TLastGetoptTests) {
         TOptsNoDefault opts;
         opts.AddLongOption("from");
         opts.AddLongOption("to");
-        TOptsParseResultTestWrapper r(&opts, V({"copy", "--from=/", "--to=/etc"}));
+        TOptsParseResultTestWrapper r(&opts, {"copy", "--from=/", "--to=/etc"});
 
         UNIT_ASSERT_VALUES_EQUAL("copy", r.GetProgramName());
         UNIT_ASSERT_VALUES_EQUAL("/", r.Get("from"));
@@ -154,7 +152,7 @@ Y_UNIT_TEST_SUITE(TLastGetoptTests) {
         opts.AddCharOption('R', NO_ARGUMENT);
         opts.AddCharOption('l', NO_ARGUMENT);
         opts.AddCharOption('h', NO_ARGUMENT);
-        TOptsParseResultTestWrapper r(&opts, V({"cp", "/etc", "-Rl", "/tmp/etc"}));
+        TOptsParseResultTestWrapper r(&opts, {"cp", "/etc", "-Rl", "/tmp/etc"});
         UNIT_ASSERT(r.Has('R'));
         UNIT_ASSERT(r.Has('l'));
         UNIT_ASSERT(!r.Has('h'));
@@ -168,20 +166,36 @@ Y_UNIT_TEST_SUITE(TLastGetoptTests) {
     Y_UNIT_TEST(TestFreeArgs) {
         TOptsNoDefault opts;
         opts.SetFreeArgsNum(1, 3);
-        TOptsParseResultTestWrapper r11(&opts, V({"cp", "/etc"}));
-        TOptsParseResultTestWrapper r12(&opts, V({"cp", "/etc", "/tmp/etc"}));
-        TOptsParseResultTestWrapper r13(&opts, V({"cp", "/etc", "/tmp/etc", "verbose"}));
+        TOptsParseResultTestWrapper r11(&opts, {"cp", "/etc"});
+        TOptsParseResultTestWrapper r12(&opts, {"cp", "/etc", "/tmp/etc"});
+        TOptsParseResultTestWrapper r13(&opts, {"cp", "/etc", "/tmp/etc", "verbose"});
 
         UNIT_ASSERT_EXCEPTION(
-            TOptsParseResultTestWrapper(&opts, V({"cp", "/etc", "/tmp/etc", "verbose", "nosymlink"})),
+            TOptsParseResultTestWrapper(&opts, {"cp", "/etc", "/tmp/etc", "verbose", "nosymlink"}),
             yexception);
 
         UNIT_ASSERT_EXCEPTION(
-            TOptsParseResultTestWrapper(&opts, V({"cp"})),
+            TOptsParseResultTestWrapper(&opts, {"cp"}),
             yexception);
 
         opts.SetFreeArgsNum(2);
-        TOptsParseResultTestWrapper r22(&opts, V({"cp", "/etc", "/var/tmp"}));
+        TOptsParseResultTestWrapper r22(&opts, {"cp", "/etc", "/var/tmp"});
+    }
+
+    Y_UNIT_TEST(TestProgramSubcommandPathSetter) {
+        TOptsNoDefault opts;
+        TOptsParseResultTestWrapper r(&opts, {"tool"});
+        const TVector<TString> parts = {"tool", "sub", "command"};
+        r.SetProgramSubcommandPath(parts);
+        UNIT_ASSERT_VALUES_EQUAL(parts, r.GetProgramSubcommandPath());
+    }
+
+    Y_UNIT_TEST(TestProgramCanonicalNameCompat) {
+        TOptsNoDefault opts;
+        TOptsParseResultTestWrapper r(&opts, {"tool"});
+        r.SetProgramSubcommandPath({"tool", "outer", "inner"});
+        const TVector<TString> expected = {"tool", "outer", "inner"};
+        UNIT_ASSERT_VALUES_EQUAL(expected, r.GetProgramSubcommandPath());
     }
 
     Y_UNIT_TEST(TestCharOptionsRequiredOptional) {
@@ -191,7 +205,7 @@ Y_UNIT_TEST_SUITE(TLastGetoptTests) {
         opts.AddCharOption('x', REQUIRED_ARGUMENT);
         opts.AddCharOption('y', REQUIRED_ARGUMENT);
         opts.AddCharOption('l', NO_ARGUMENT);
-        TOptsParseResultTestWrapper r(&opts, V({"cmd", "-ld11", "-e", "22", "-lllx33", "-y", "44"}));
+        TOptsParseResultTestWrapper r(&opts, {"cmd", "-ld11", "-e", "22", "-lllx33", "-y", "44"});
         UNIT_ASSERT_VALUES_EQUAL("11", r.Get('d'));
         UNIT_ASSERT_VALUES_EQUAL("22", r.Get('e'));
         UNIT_ASSERT_VALUES_EQUAL("33", r.Get('x'));
@@ -449,6 +463,19 @@ Y_UNIT_TEST_SUITE(TLastGetoptTests) {
         tester.AcceptEndOfFreeArgs();
     }
 
+    Y_UNIT_TEST(TestEqParseOnlyRequiredArgument) {
+        TOptsNoDefault opts;
+
+        opts.AddLongOption("eq-only").RequiredArgument().DisableSpaceParse();
+
+        TOptsParseResultTestWrapper res(&opts, {"cmd", "--eq-only=value"});
+        UNIT_ASSERT_EQUAL(res.Get("eq-only"), "value"sv);
+
+        UNIT_ASSERT_EXCEPTION(
+            TOptsParseResultTestWrapper(&opts, {"cmd", "--eq-only", "value"}),
+            TUsageException);
+    }
+
     Y_UNIT_TEST(TestStoreResult) {
         TOptsNoDefault opts;
         TString data;
@@ -461,7 +488,7 @@ Y_UNIT_TEST_SUITE(TLastGetoptTests) {
         opts.AddLongOption("optional-number-0").StoreResult(&optionalNumber0);
         opts.AddLongOption("optional-string-1").StoreResult(&optionalString1);
         opts.AddLongOption("optional-number-1").StoreResult(&optionalNumber1);
-        TOptsParseResultTestWrapper r(&opts, V({"cmd", "--data=jjhh", "-n", "11", "--optional-number-1=8", "--optional-string-1=os1"}));
+        TOptsParseResultTestWrapper r(&opts, {"cmd", "--data=jjhh", "-n", "11", "--optional-number-1=8", "--optional-string-1=os1"});
         UNIT_ASSERT_VALUES_EQUAL("jjhh", data);
         UNIT_ASSERT_VALUES_EQUAL(11, number);
         UNIT_ASSERT(!optionalString0.Defined());
@@ -480,7 +507,7 @@ Y_UNIT_TEST_SUITE(TLastGetoptTests) {
         opts.AddLongOption('b', "beta").NoArgument().StoreValue(&b, 24);
         opts.AddLongOption('e', "enum").NoArgument().StoreValue(&e, REQUIRED_ARGUMENT).StoreValue(&c, 12345);
 
-        TOptsParseResultTestWrapper r(&opts, V({"cmd", "-a", "-e"}));
+        TOptsParseResultTestWrapper r(&opts, {"cmd", "-a", "-e"});
 
         UNIT_ASSERT_VALUES_EQUAL(42, a);
         UNIT_ASSERT_VALUES_EQUAL(0, b);
@@ -497,7 +524,7 @@ Y_UNIT_TEST_SUITE(TLastGetoptTests) {
         opts.AddCharOption('c').StoreTrue(&c);
         opts.AddCharOption('d').StoreTrue(&d);
 
-        TOptsParseResultTestWrapper r(&opts, V({"cmd", "-a", "-c"}));
+        TOptsParseResultTestWrapper r(&opts, {"cmd", "-a", "-c"});
 
         UNIT_ASSERT(a);
         UNIT_ASSERT(!b);
@@ -510,7 +537,7 @@ Y_UNIT_TEST_SUITE(TLastGetoptTests) {
         opts.AddLongOption("path").DefaultValue("/etc");
         int value = 42;
         opts.AddLongOption("value").StoreResult(&value).DefaultValue(32);
-        TOptsParseResultTestWrapper r(&opts, V({"cmd", "dfdf"}));
+        TOptsParseResultTestWrapper r(&opts, {"cmd", "dfdf"});
         UNIT_ASSERT_VALUES_EQUAL("/etc", r.Get("path"));
         UNIT_ASSERT_VALUES_EQUAL(32, value);
     }
@@ -519,7 +546,7 @@ Y_UNIT_TEST_SUITE(TLastGetoptTests) {
         TOptsNoDefault opts;
         TVector<TString> vals;
         opts.AddLongOption('s', "split").SplitHandler(&vals, ',');
-        TOptsParseResultTestWrapper r(&opts, V({"prog", "--split=a,b,c"}));
+        TOptsParseResultTestWrapper r(&opts, {"prog", "--split=a,b,c"});
         UNIT_ASSERT_EQUAL(vals.size(), 3);
         UNIT_ASSERT_EQUAL(vals[0], "a");
         UNIT_ASSERT_EQUAL(vals[1], "b");
@@ -530,7 +557,7 @@ Y_UNIT_TEST_SUITE(TLastGetoptTests) {
         TOptsNoDefault opts;
         TVector<ui32> vals;
         opts.AddLongOption('s', "split").RangeSplitHandler(&vals, ',', '-');
-        TOptsParseResultTestWrapper r(&opts, V({"prog", "--split=1,8-10", "--split=12-14"}));
+        TOptsParseResultTestWrapper r(&opts, {"prog", "--split=1,8-10", "--split=12-14"});
         UNIT_ASSERT_EQUAL(vals.size(), 7);
         UNIT_ASSERT_EQUAL(vals[0], 1);
         UNIT_ASSERT_EQUAL(vals[1], 8);
@@ -557,15 +584,15 @@ Y_UNIT_TEST_SUITE(TLastGetoptTests) {
 
         // test 'not required'
         // makes sure that the problem will only be in 'required'
-        TOptsParseResultTestWrapper r1(&opts, V({"cmd"}));
+        TOptsParseResultTestWrapper r1(&opts, {"cmd"});
 
         // test 'required'
         opt_d.Required();
         UNIT_ASSERT_EXCEPTION(
-            TOptsParseResultTestWrapper(&opts, V({"cmd"})),
+            TOptsParseResultTestWrapper(&opts, {"cmd"}),
             TUsageException);
 
-        TOptsParseResultTestWrapper r3(&opts, V({"cmd", "-d11"}));
+        TOptsParseResultTestWrapper r3(&opts, {"cmd", "-d11"});
         UNIT_ASSERT_VALUES_EQUAL("11", r3.Get('d'));
     }
 
@@ -581,12 +608,13 @@ Y_UNIT_TEST_SUITE(TLastGetoptTests) {
             *Flag = true;
         }
     };
+
     Y_UNIT_TEST(TestHandlers) {
         {
             TOptsNoDefault opts;
             bool flag = false;
             opts.AddLongOption("flag").Handler0(HandlerStoreTrue(&flag)).NoArgument();
-            TOptsParseResultTestWrapper r(&opts, V({"cmd", "--flag"}));
+            TOptsParseResultTestWrapper r(&opts, {"cmd", "--flag"});
             UNIT_ASSERT(flag);
         }
         {
@@ -598,11 +626,11 @@ Y_UNIT_TEST_SUITE(TLastGetoptTests) {
             opts.AddLongOption("flag3").RequiredArgument().StoreMappedResult(&fval, (double (*)(double))fabs);
             opts.AddLongOption("flag4").RequiredArgument().StoreMappedResult(&fval, (double (*)(double))sqrt);
             UNIT_ASSERT_EXCEPTION(
-                TOptsParseResultTestWrapper(&opts, V({"cmd", "--flag3", "-2.0", "--flag1", "-1"})),
+                TOptsParseResultTestWrapper(&opts, {"cmd", "--flag3", "-2.0", "--flag1", "-1"}),
                 yexception);
             UNIT_ASSERT_VALUES_EQUAL(uval, 5u);
             UNIT_ASSERT_VALUES_EQUAL(fval, 2.0);
-            TOptsParseResultTestWrapper r1(&opts, V({"cmd", "--flag4", "9.0", "--flag2", "-1"}));
+            TOptsParseResultTestWrapper r1(&opts, {"cmd", "--flag4", "9.0", "--flag2", "-1"});
             UNIT_ASSERT_VALUES_EQUAL(uval, Max<unsigned>());
             UNIT_ASSERT_VALUES_EQUAL(fval, 3.0);
         }
@@ -742,7 +770,7 @@ Y_UNIT_TEST_SUITE(TLastGetoptTests) {
         opts.AddLongOption("size").AppendTo(&ints);
         opts.AddLongOption("value").AppendTo(&strings);
 
-        TOptsParseResultTestWrapper r(&opts, V({"cmd", "--size=17", "--size=19", "--value=v1", "--value=v2"}));
+        TOptsParseResultTestWrapper r(&opts, {"cmd", "--size=17", "--size=19", "--value=v1", "--value=v2"});
 
         UNIT_ASSERT_VALUES_EQUAL(size_t(2), ints.size());
         UNIT_ASSERT_VALUES_EQUAL(17, ints.at(0));
@@ -759,7 +787,7 @@ Y_UNIT_TEST_SUITE(TLastGetoptTests) {
         TOptsNoDefault opts;
         opts.AddLongOption("path").EmplaceTo(&richPaths);
 
-        TOptsParseResultTestWrapper r(&opts, V({"cmd", "--path=<a=b>//cool", "--path=//nice"}));
+        TOptsParseResultTestWrapper r(&opts, {"cmd", "--path=<a=b>//cool", "--path=//nice"});
 
         UNIT_ASSERT_VALUES_EQUAL(size_t(2), richPaths.size());
         UNIT_ASSERT_VALUES_EQUAL("<a=b>//cool", std::get<0>(richPaths.at(0)));
@@ -772,7 +800,7 @@ Y_UNIT_TEST_SUITE(TLastGetoptTests) {
         TOptsNoDefault opts;
         opts.AddLongOption("set").KVHandler([&keyvals](TString k, TString v) { keyvals << k << ":" << v << ","; });
 
-        TOptsParseResultTestWrapper r(&opts, V({"cmd", "--set", "x=1", "--set", "y=2", "--set=z=3"}));
+        TOptsParseResultTestWrapper r(&opts, {"cmd", "--set", "x=1", "--set", "y=2", "--set=z=3"});
 
         UNIT_ASSERT_VALUES_EQUAL(keyvals, "x:1,y:2,z:3,");
     }
@@ -784,25 +812,25 @@ Y_UNIT_TEST_SUITE(TLastGetoptTests) {
 
         {
             gSimpleFlag = false;
-            TOptsParseResultTestWrapper r(&opts, V({"cmd", "--abstract"}));
+            TOptsParseResultTestWrapper r(&opts, {"cmd", "--abstract"});
             UNIT_ASSERT(!flag);
             UNIT_ASSERT(!gSimpleFlag);
         }
 
         {
-            TOptsParseResultTestWrapper r(&opts, V({"cmd", "--abstract", "--global", "-t"}));
+            TOptsParseResultTestWrapper r(&opts, {"cmd", "--abstract", "--global", "-t"});
             UNIT_ASSERT(flag);
             UNIT_ASSERT(gSimpleFlag);
         }
 
         {
             UNIT_ASSERT_EXCEPTION(
-                TOptsParseResultTestWrapper(&opts, V({"cmd", "--true"})),
+                TOptsParseResultTestWrapper(&opts, {"cmd", "--true"}),
                 TUsageException);
         }
 
         {
-            TOptsParseResultTestWrapper r(&opts, V({"cmd", "--abstract", "--buffer=512"}));
+            TOptsParseResultTestWrapper r(&opts, {"cmd", "--abstract", "--buffer=512"});
             UNIT_ASSERT(r.Has('b'));
             UNIT_ASSERT_VALUES_EQUAL(r.Get('b', 0), "512");
         }
@@ -826,12 +854,81 @@ Y_UNIT_TEST_SUITE(TLastGetoptTests) {
         int number = 0;
         opts.AddFreeArgBinding("data", data);
         opts.AddFreeArgBinding("number", number);
-        TOptsParseResultTestWrapper r(&opts, V({"cmd", "hello", "25"}));
+        TOptsParseResultTestWrapper r(&opts, {"cmd", "hello", "25"});
         UNIT_ASSERT_VALUES_EQUAL("hello", data);
         UNIT_ASSERT_VALUES_EQUAL(25, number);
         UNIT_ASSERT_VALUES_EQUAL(2, r.GetFreeArgCount());
     }
 
+    Y_UNIT_TEST(TestFreeArgsTaggedAccess) {
+        enum class EFreeArgTag {
+            Unknown,
+            Src,
+            Dst,
+        };
+
+        TOptsNoDefault opts;
+        opts.SetFreeArgsNum(2);
+        opts.GetFreeArgSpec(0).SetTag(EFreeArgTag::Src);
+        opts.GetFreeArgSpec(1).SetTag(EFreeArgTag::Dst);
+
+        TOptsParseResultTestWrapper r(&opts, {"cmd", "input.txt", "output.txt"});
+
+        const auto allArgs = r.GetFreeArgs();
+        UNIT_ASSERT_VALUES_EQUAL(2u, allArgs.size());
+
+        const auto srcArgs = r.GetFreeArgs(EFreeArgTag::Src);
+        UNIT_ASSERT_VALUES_EQUAL(1u, srcArgs.size());
+        UNIT_ASSERT_VALUES_EQUAL("input.txt", srcArgs.front());
+
+        const auto dstArgs = r.GetFreeArgs(EFreeArgTag::Dst);
+        UNIT_ASSERT_VALUES_EQUAL(1u, dstArgs.size());
+        UNIT_ASSERT_VALUES_EQUAL("output.txt", dstArgs.front());
+
+        UNIT_ASSERT(r.GetFreeArgs(EFreeArgTag::Unknown).empty());
+    }
+
+    Y_UNIT_TEST(TestTrailingFreeArgsTagger) {
+        enum class EFreeArgTag {
+            Unknown,
+            Primary,
+            Logs,
+            Temp,
+        };
+
+        TOptsNoDefault opts;
+        opts.SetFreeArgsMin(1);
+        opts.SetFreeArgsMax(TOpts::UNLIMITED_ARGS);
+
+        opts.GetFreeArgSpec(0).SetTag(EFreeArgTag::Primary);
+        opts.GetTrailingArgSpec().SetTag<EFreeArgTag>([](const TString& value) {
+            if (value.EndsWith(".log")) {
+                return EFreeArgTag::Logs;
+            }
+            if (value.EndsWith(".tmp")) {
+                return EFreeArgTag::Temp;
+            }
+            return EFreeArgTag::Unknown;
+        });
+
+        TOptsParseResultTestWrapper r(&opts, {"cmd", "config.yaml", "db.log", "cache.tmp", "service.log"});
+
+        const auto primary = r.GetFreeArgs(EFreeArgTag::Primary);
+        UNIT_ASSERT_VALUES_EQUAL(1u, primary.size());
+        UNIT_ASSERT_VALUES_EQUAL("config.yaml", primary.front());
+
+        const auto logs = r.GetFreeArgs(EFreeArgTag::Logs);
+        UNIT_ASSERT_VALUES_EQUAL(2u, logs.size());
+        UNIT_ASSERT_VALUES_EQUAL("db.log", logs[0]);
+        UNIT_ASSERT_VALUES_EQUAL("service.log", logs[1]);
+
+        const auto temp = r.GetFreeArgs(EFreeArgTag::Temp);
+        UNIT_ASSERT_VALUES_EQUAL(1u, temp.size());
+        UNIT_ASSERT_VALUES_EQUAL("cache.tmp", temp.front());
+
+        UNIT_ASSERT_VALUES_EQUAL(4u, r.GetFreeArgCount());
+    }
+
     Y_UNIT_TEST(TestCheckUserTypos) {
         {
             TOptsNoDefault opts;
@@ -840,10 +937,10 @@ Y_UNIT_TEST_SUITE(TLastGetoptTests) {
             opts.AddLongOption("to");
 
             UNIT_ASSERT_EXCEPTION(
-                    TOptsParseResultTestWrapper(&opts, V({"copy", "-from", "/home", "--to=/etc"})),
+                    TOptsParseResultTestWrapper(&opts, {"copy", "-from", "/home", "--to=/etc"}),
                     TUsageException);
             UNIT_ASSERT_NO_EXCEPTION(
-                    TOptsParseResultTestWrapper(&opts, V({"copy", "--from", "from", "--to=/etc"})));
+                    TOptsParseResultTestWrapper(&opts, {"copy", "--from", "from", "--to=/etc"}));
         }
 
         {
@@ -853,7 +950,39 @@ Y_UNIT_TEST_SUITE(TLastGetoptTests) {
             opts.AddLongOption('r', "read", "");
             opts.AddLongOption("fr");
             UNIT_ASSERT_NO_EXCEPTION(
-                    TOptsParseResultTestWrapper(&opts, V({"copy", "-fr"})));
+                    TOptsParseResultTestWrapper(&opts, {"copy", "-fr"}));
         }
     }
+
+    Y_UNIT_TEST(TestMutuallyExclusive) {
+        // FIXME: somehow MutuallyExclusive() does not work without SetFlag()
+        bool flag;
+        TOptsNoDefault opts;
+        opts.AddLongOption("do").SetFlag(&flag);
+        opts.AddLongOption("dont").SetFlag(&flag);
+        opts.AddLongOption("maybe-do-maybe-dont").SetFlag(&flag);
+
+        opts.MutuallyExclusive("do", "dont", "maybe-do-maybe-dont");
+
+        UNIT_ASSERT_EXCEPTION(
+            TOptsParseResultTestWrapper(&opts, {"--do", "--dont"}),
+            TUsageException
+        );
+        UNIT_ASSERT_EXCEPTION(
+            TOptsParseResultTestWrapper(&opts, {"--dont", "--maybe-do-maybe-dont"}),
+            TUsageException
+        );
+        UNIT_ASSERT_EXCEPTION(
+            TOptsParseResultTestWrapper(&opts, {"--do", "--maybe-do-maybe-dont"}),
+            TUsageException
+        );
+        UNIT_ASSERT_EXCEPTION(
+            TOptsParseResultTestWrapper(&opts, {"-d", "-n"}),
+            TUsageException
+        );
+        UNIT_ASSERT_EXCEPTION(
+            TOptsParseResultTestWrapper(&opts, {"--do", "--dont", "--maybe-do-maybe-dont"}),
+            TUsageException
+        );
+    }
 }
diff --git a/library/cpp/getopt/ut/modchooser_ut.cpp b/library/cpp/getopt/ut/modchooser_ut.cpp
index a14c8a58535..24776f47fc6 100644
--- a/library/cpp/getopt/ut/modchooser_ut.cpp
+++ b/library/cpp/getopt/ut/modchooser_ut.cpp
@@ -39,6 +39,42 @@ static const F_PTR FUNCTIONS[] = {One, Two, Three, Four, Five};
 static const char* NAMES[] = {"one", "two", "three", "four", "five"};
 static_assert(Y_ARRAY_SIZE(FUNCTIONS) == Y_ARRAY_SIZE(NAMES), "Incorrect input tests data");
 
+class TRecordingAction: public TMainClassArgs {
+public:
+    int DoRun(NLastGetopt::TOptsParseResult&& /*res*/) override {
+        CapturedSubcommandPath = GetSubcommandPath();
+        return 0;
+    }
+
+    void RegisterOptions(NLastGetopt::TOpts& opts) override {
+        opts.SetFreeArgsMax(2);
+        opts.AddLongOption("options-flag")
+            .Optional()
+            .NoArgument()
+            .StoreTrue(&OptionsFlag);
+    }
+
+public:
+    bool OptionsFlag = false;
+    TVector<TString> CapturedSubcommandPath;
+};
+
+class TOuterModes: public TMainClassModes {
+public:
+    explicit TOuterModes(TMainClass* inner)
+        : Inner_(inner)
+    {
+    }
+
+protected:
+    void RegisterModes(TModChooser& modes) override {
+        modes.AddMode("inner", Inner_, "inner");
+    }
+
+private:
+    TMainClass* Inner_;
+};
+
 Y_UNIT_TEST_SUITE(TModChooserTest) {
     Y_UNIT_TEST(TestModesSimpleRunner) {
         TModChooser chooser;
@@ -68,4 +104,18 @@ Y_UNIT_TEST_SUITE(TModChooserTest) {
 
         chooser.Run(argc, argv);
     }
+
+    Y_UNIT_TEST(TestSubcommandPathPropagation) {
+        TRecordingAction innerAction;
+        TOuterModes outer(&innerAction);
+        TModChooser chooser;
+        chooser.AddMode("outer", &outer, "outer");
+
+        const char* argv[] = {"UNITTEST", "outer", "inner", "--options-flag", "free-arg1", "free-arg2", nullptr};
+        UNIT_ASSERT_NO_EXCEPTION(chooser.Run(6, argv));
+
+        const TVector<TString> expected = {"outer", "inner"};
+        UNIT_ASSERT_EQUAL(innerAction.OptionsFlag, true);
+        UNIT_ASSERT_VALUES_EQUAL(expected, innerAction.CapturedSubcommandPath);
+    }
 }
diff --git a/library/cpp/html/escape/CMakeLists.txt b/library/cpp/html/escape/CMakeLists.txt
new file mode 100644
index 00000000000..ddb97a14252
--- /dev/null
+++ b/library/cpp/html/escape/CMakeLists.txt
@@ -0,0 +1,25 @@
+if (YDB_SDK_TESTS)
+  add_ydb_test(NAME html-escape-ut
+    SOURCES
+      ut/escape_ut.cpp
+    LINK_LIBRARIES
+      html-escape
+      cpp-testing-unittest_main
+    LABELS
+      unit
+  )
+endif()
+
+_ydb_sdk_add_library(html-escape)
+
+target_link_libraries(html-escape
+  PUBLIC
+    yutil
+)
+
+target_sources(html-escape
+  PRIVATE
+    escape.cpp
+)
+
+_ydb_sdk_install_targets(TARGETS html-escape)
diff --git a/library/cpp/html/escape/escape.cpp b/library/cpp/html/escape/escape.cpp
new file mode 100644
index 00000000000..5b8ed60f045
--- /dev/null
+++ b/library/cpp/html/escape/escape.cpp
@@ -0,0 +1,66 @@
+#include "escape.h"
+
+#include <util/generic/array_size.h>
+#include <util/generic/strbuf.h>
+
+namespace NHtml {
+    namespace {
+        struct TReplace {
+            char Char;
+            bool ForText;
+            TStringBuf Entity;
+        };
+
+        TReplace Escapable[] = {
+            {'"', false, TStringBuf("&quot;")},
+            {'&', true, TStringBuf("&amp;")},
+            {'<', true, TStringBuf("&lt;")},
+            {'>', true, TStringBuf("&gt;")},
+        };
+
+        TString EscapeImpl(const TString& value, bool isText) {
+            auto ci = value.begin();
+            // Looking for escapable characters.
+            for (; ci != value.end(); ++ci) {
+                for (size_t i = (isText ? 1 : 0); i < Y_ARRAY_SIZE(Escapable); ++i) {
+                    if (*ci == Escapable[i].Char) {
+                        goto escape;
+                    }
+                }
+            }
+
+            // There is no escapable characters, so return original value.
+            return value;
+
+        escape:
+            TString tmp = TString(value.begin(), ci);
+
+            for (; ci != value.end(); ++ci) {
+                size_t i = (isText ? 1 : 0);
+
+                for (; i < Y_ARRAY_SIZE(Escapable); ++i) {
+                    if (*ci == Escapable[i].Char) {
+                        tmp += Escapable[i].Entity;
+                        break;
+                    }
+                }
+
+                if (i == Y_ARRAY_SIZE(Escapable)) {
+                    tmp += *ci;
+                }
+            }
+
+            return tmp;
+        }
+
+    }
+
+    TString EscapeAttributeValue(const TString& value) {
+        return EscapeImpl(value, false);
+    }
+
+    TString EscapeText(const TString& value) {
+        return EscapeImpl(value, true);
+    }
+
+}
diff --git a/library/cpp/html/escape/escape.h b/library/cpp/html/escape/escape.h
new file mode 100644
index 00000000000..1c45fc51933
--- /dev/null
+++ b/library/cpp/html/escape/escape.h
@@ -0,0 +1,9 @@
+#pragma once
+
+#include <util/generic/string.h>
+
+namespace NHtml {
+    TString EscapeAttributeValue(const TString& value);
+    TString EscapeText(const TString& value);
+
+}
diff --git a/library/cpp/html/escape/ut/escape_ut.cpp b/library/cpp/html/escape/ut/escape_ut.cpp
new file mode 100644
index 00000000000..cd7b9551385
--- /dev/null
+++ b/library/cpp/html/escape/ut/escape_ut.cpp
@@ -0,0 +1,16 @@
+#include <library/cpp/html/escape/escape.h>
+#include <library/cpp/testing/unittest/registar.h>
+
+using namespace NHtml;
+
+Y_UNIT_TEST_SUITE(TEscapeHtml) {
+    Y_UNIT_TEST(Escape) {
+        UNIT_ASSERT_EQUAL(EscapeText("in & out"), "in &amp; out");
+        UNIT_ASSERT_EQUAL(EscapeText("&&"), "&amp;&amp;");
+        UNIT_ASSERT_EQUAL(EscapeText("&amp;"), "&amp;amp;");
+
+        UNIT_ASSERT_EQUAL(EscapeText("<script>"), "&lt;script&gt;");
+
+        UNIT_ASSERT_EQUAL(EscapeText("text"), "text");
+    }
+}
diff --git a/library/cpp/http/misc/httpcodes.h b/library/cpp/http/misc/httpcodes.h
index 4565b1c581b..b9407ec8eec 100644
--- a/library/cpp/http/misc/httpcodes.h
+++ b/library/cpp/http/misc/httpcodes.h
@@ -57,6 +57,7 @@ enum HttpCodes {
     HTTP_PRECONDITION_REQUIRED = 428,
     HTTP_TOO_MANY_REQUESTS = 429,
     HTTP_REQUEST_HEADER_FIELDS_TOO_LARGE = 431,
+    HTTP_REQUESTED_HOST_UNAVAILABLE = 434,
     HTTP_UNAVAILABLE_FOR_LEGAL_REASONS = 451,
 
     HTTP_INTERNAL_SERVER_ERROR = 500,
diff --git a/library/cpp/http/misc/httpreqdata.cpp b/library/cpp/http/misc/httpreqdata.cpp
index ed5e8872c92..028418bc4a0 100644
--- a/library/cpp/http/misc/httpreqdata.cpp
+++ b/library/cpp/http/misc/httpreqdata.cpp
@@ -81,6 +81,8 @@ TStringBuf TBaseServerRequestData::Environment(TStringBuf key) const {
         return ip ? *ip : RemoteAddr();
     } else if (ciKey == "QUERY_STRING") {
         return Query();
+    } else if (ciKey == "BODY") {
+        return Body();
     } else if (ciKey == "SERVER_NAME") {
         return ServerName();
     } else if (ciKey == "SERVER_PORT") {
diff --git a/library/cpp/http/misc/httpreqdata.h b/library/cpp/http/misc/httpreqdata.h
index b5c9e446a99..99f3614098e 100644
--- a/library/cpp/http/misc/httpreqdata.h
+++ b/library/cpp/http/misc/httpreqdata.h
@@ -7,6 +7,7 @@
 #include <util/system/defaults.h>
 #include <util/string/cast.h>
 #include <library/cpp/cgiparam/cgiparam.h>
+#include <util/memory/blob.h>
 #include <util/network/address.h>
 #include <util/network/socket.h>
 #include <util/generic/hash.h>
@@ -52,6 +53,10 @@ class TBaseServerRequestData {
         return OrigQuery_;
     }
 
+    TStringBuf Body() const {
+        return Body_.AsStringBuf();
+    }
+
     void AppendQueryString(TStringBuf str);
     TStringBuf RemoteAddr() const;
     void SetRemoteAddr(TStringBuf addr);
@@ -77,8 +82,15 @@ class TBaseServerRequestData {
         Socket_ = s;
     }
 
+    void SetBody(const TBlob& body) noexcept {
+        Body_ = body;
+    }
+
     ui64 RequestBeginTime() const noexcept {
-        return BeginTime_;
+        return BeginTime_; // in microseconds
+    }
+    TInstant RequestBeginTimestamp() const noexcept {
+        return TInstant::MicroSeconds(BeginTime_);
     }
 
     void SetPath(TString path);
@@ -93,6 +105,7 @@ class TBaseServerRequestData {
     TString Path_;
     TStringBuf Query_;
     TStringBuf OrigQuery_;
+    TBlob Body_;
     THttpHeadersContainer HeadersIn_;
     SOCKET Socket_;
     ui64 BeginTime_;
diff --git a/library/cpp/http/misc/parsed_request.cpp b/library/cpp/http/misc/parsed_request.cpp
index e332a24e917..5ce6d3ddc6c 100644
--- a/library/cpp/http/misc/parsed_request.cpp
+++ b/library/cpp/http/misc/parsed_request.cpp
@@ -4,16 +4,16 @@
 #include <util/generic/yexception.h>
 #include <util/string/cast.h>
 
-static inline TStringBuf StripLeft(const TStringBuf& s) noexcept {
-    const char* b = s.begin();
-    const char* e = s.end();
+static TStringBuf StripLeft(const TStringBuf s Y_LIFETIME_BOUND) noexcept {
+    auto b = s.begin();
+    auto e = s.end();
 
     StripRangeBegin(b, e);
 
     return TStringBuf(b, e);
 }
 
-TParsedHttpRequest::TParsedHttpRequest(const TStringBuf& str) {
+TParsedHttpRequest::TParsedHttpRequest(const TStringBuf str Y_LIFETIME_BOUND) {
     TStringBuf tmp;
 
     if (!StripLeft(str).TrySplit(' ', Method, tmp)) {
@@ -27,6 +27,6 @@ TParsedHttpRequest::TParsedHttpRequest(const TStringBuf& str) {
     Proto = StripLeft(Proto);
 }
 
-TParsedHttpLocation::TParsedHttpLocation(const TStringBuf& req) {
+TParsedHttpLocation::TParsedHttpLocation(const TStringBuf req Y_LIFETIME_BOUND) {
     req.Split('?', Path, Cgi);
 }
diff --git a/library/cpp/http/misc/parsed_request.h b/library/cpp/http/misc/parsed_request.h
index d4df7054951..27e8c37c0ee 100644
--- a/library/cpp/http/misc/parsed_request.h
+++ b/library/cpp/http/misc/parsed_request.h
@@ -3,7 +3,7 @@
 #include <util/generic/strbuf.h>
 
 struct TParsedHttpRequest {
-    TParsedHttpRequest(const TStringBuf& str);
+    TParsedHttpRequest(const TStringBuf str Y_LIFETIME_BOUND);
 
     TStringBuf Method;
     TStringBuf Request;
@@ -11,14 +11,14 @@ struct TParsedHttpRequest {
 };
 
 struct TParsedHttpLocation {
-    TParsedHttpLocation(const TStringBuf& req);
+    TParsedHttpLocation(const TStringBuf req Y_LIFETIME_BOUND);
 
     TStringBuf Path;
     TStringBuf Cgi;
 };
 
 struct TParsedHttpFull: public TParsedHttpRequest, public TParsedHttpLocation {
-    inline TParsedHttpFull(const TStringBuf& line)
+    TParsedHttpFull(const TStringBuf line Y_LIFETIME_BOUND)
         : TParsedHttpRequest(line)
         , TParsedHttpLocation(Request)
     {
diff --git a/library/cpp/http/server/conn.cpp b/library/cpp/http/server/conn.cpp
index 38a76c4c309..4b72c3f77f0 100644
--- a/library/cpp/http/server/conn.cpp
+++ b/library/cpp/http/server/conn.cpp
@@ -1,47 +1,38 @@
 #include "conn.h"
 
 #include <util/network/socket.h>
-#include <util/stream/buffered.h>
 
-class THttpServerConn::TImpl {
-public:
-    inline TImpl(const TSocket& s, size_t outputBufferSize)
-        : S_(s)
-        , SI_(S_)
-        , SO_(S_)
-        , BO_(&SO_, outputBufferSize)
-        , HI_(&SI_)
-        , HO_(&BO_, &HI_)
-    {
-    }
-
-    inline ~TImpl() {
-    }
-
-    inline THttpInput* Input() noexcept {
-        return &HI_;
-    }
+namespace {
+    class TBlockingSocketStreams: public THttpServerConn::ISocketStreams {
+    public:
+        explicit TBlockingSocketStreams(const TSocket& s)
+            : Socket_(s)
+            , Input_(Socket_)
+            , Output_(Socket_)
+        {
+        }
 
-    inline THttpOutput* Output() noexcept {
-        return &HO_;
-    }
+        IInputStream* Input() override {
+            return &Input_;
+        }
 
-    inline void Reset() {
-        if (S_ != INVALID_SOCKET) {
-            // send RST packet to client
-            S_.SetLinger(true, 0);
-            S_.Close();
+        IOutputStream* Output() override {
+            return &Output_;
         }
-    }
 
-private:
-    TSocket S_;
-    TSocketInput SI_;
-    TSocketOutput SO_;
-    TBufferedOutput BO_;
-    THttpInput HI_;
-    THttpOutput HO_;
-};
+        void Reset() override {
+            if (Socket_ != INVALID_SOCKET) {
+                // send RST packet to client
+                Socket_.SetLinger(true, 0);
+                Socket_.Close();
+           }
+        }
+    private:
+        TSocket Socket_;
+        TSocketInput Input_;
+        TSocketOutput Output_;
+    };
+}
 
 THttpServerConn::THttpServerConn(const TSocket& s)
     : THttpServerConn(s, s.MaximumTransferUnit())
@@ -49,21 +40,21 @@ THttpServerConn::THttpServerConn(const TSocket& s)
 }
 
 THttpServerConn::THttpServerConn(const TSocket& s, size_t outputBufferSize)
-    : Impl_(new TImpl(s, outputBufferSize))
+    : THttpServerConn(MakeHolder<TBlockingSocketStreams>(s), outputBufferSize)
 {
 }
 
-THttpServerConn::~THttpServerConn() {
-}
-
-THttpInput* THttpServerConn::Input() noexcept {
-    return Impl_->Input();
+THttpServerConn::THttpServerConn(THolder<ISocketStreams> socketStreams, size_t outputBufferSize)
+    : SocketStreams_(std::move(socketStreams))
+    , BufferedOutput_(SocketStreams_->Output(), outputBufferSize)
+    , HttpInput_(SocketStreams_->Input())
+    , HttpOutput_(&BufferedOutput_, &HttpInput_)
+{
 }
 
-THttpOutput* THttpServerConn::Output() noexcept {
-    return Impl_->Output();
+THttpServerConn::~THttpServerConn() {
 }
 
 void THttpServerConn::Reset() {
-    return Impl_->Reset();
+    return SocketStreams_->Reset();
 }
diff --git a/library/cpp/http/server/conn.h b/library/cpp/http/server/conn.h
index 3aa5329af42..62a3e86ac95 100644
--- a/library/cpp/http/server/conn.h
+++ b/library/cpp/http/server/conn.h
@@ -2,18 +2,37 @@
 
 #include <library/cpp/http/io/stream.h>
 #include <util/generic/ptr.h>
+#include <util/stream/buffered.h>
 
+class IInputStream;
+class IOutputStream;
 class TSocket;
 
 /// Потоки ввода/вывода для получения запросов и отправки ответов HTTP-сервера.
 class THttpServerConn {
 public:
-    explicit THttpServerConn(const TSocket& s);
+    class ISocketStreams {
+    public:
+        virtual ~ISocketStreams() {}
+
+        virtual IInputStream* Input() = 0;
+        virtual IOutputStream* Output() = 0;
+        virtual void Reset() = 0;
+    };
+public:
+    THttpServerConn(const TSocket& s);
     THttpServerConn(const TSocket& s, size_t outputBufferSize);
+    THttpServerConn(THolder<ISocketStreams> socketStreams, size_t outputBufferSize);
+
     ~THttpServerConn();
 
-    THttpInput* Input() noexcept;
-    THttpOutput* Output() noexcept;
+    THttpInput* Input() noexcept {
+        return &HttpInput_;
+    }
+
+    THttpOutput* Output() noexcept {
+        return &HttpOutput_;
+    }
 
     inline const THttpInput* Input() const noexcept {
         return const_cast<THttpServerConn*>(this)->Input();
@@ -30,8 +49,10 @@ class THttpServerConn {
     }
 
     void Reset();
-
 private:
-    class TImpl;
-    THolder<TImpl> Impl_;
+    THolder<ISocketStreams> SocketStreams_;
+
+    TBufferedOutput BufferedOutput_;
+    THttpInput HttpInput_;
+    THttpOutput HttpOutput_;
 };
diff --git a/library/cpp/http/server/http.cpp b/library/cpp/http/server/http.cpp
index a5dfe08e55a..79a1194c770 100644
--- a/library/cpp/http/server/http.cpp
+++ b/library/cpp/http/server/http.cpp
@@ -273,7 +273,7 @@ class THttpServer::TImpl {
         TGuard<TMutex> g(StopMutex);
         JoinListenerThreads();
 
-        while (ConnectionCount) {
+        while (AtomicGet(ConnectionCount)) {
             usleep(10000);
             Connections->Clear();
         }
@@ -725,6 +725,10 @@ void TClientRequest::ResetConnection() {
     }
 }
 
+THolder<THttpServerConn> TClientRequest::CreateHttpConnection(const TSocket& s, size_t outputBufferSize) {
+    return MakeHolder<THttpServerConn>(s, outputBufferSize);
+}
+
 void TClientRequest::Process(void* ThreadSpecificResource) {
     THolder<TClientRequest> this_(this);
 
@@ -733,11 +737,7 @@ void TClientRequest::Process(void* ThreadSpecificResource) {
     try {
         if (!HttpConn_) {
             const size_t outputBufferSize = HttpServ()->Options().OutputBufferSize;
-            if (outputBufferSize) {
-                HttpConn_.Reset(new THttpServerConn(Socket(), outputBufferSize));
-            } else {
-                HttpConn_.Reset(new THttpServerConn(Socket()));
-            }
+            HttpConn_ = CreateHttpConnection(Socket(), outputBufferSize ? outputBufferSize : Socket().MaximumTransferUnit());
 
             auto maxRequestsPerConnection = HttpServ()->Options().MaxRequestsPerConnection;
             HttpConn_->Output()->EnableKeepAlive(HttpServ()->Options().KeepAliveEnabled && (!maxRequestsPerConnection || Conn_->ReceivedRequests < maxRequestsPerConnection));
diff --git a/library/cpp/http/server/http.h b/library/cpp/http/server/http.h
index 62dfd5a50fa..5b23cb21a00 100644
--- a/library/cpp/http/server/http.h
+++ b/library/cpp/http/server/http.h
@@ -141,6 +141,8 @@ class TClientRequest: public IObjectInQueue {
         Y_UNUSED(ThreadSpecificResource);
         return true;
     }
+    virtual THolder<THttpServerConn> CreateHttpConnection(const TSocket& s, size_t outputBuffer);
+
     void Process(void* ThreadSpecificResource) override;
 
 public:
diff --git a/library/cpp/http/server/http_ex.cpp b/library/cpp/http/server/http_ex.cpp
index fc43d2defc7..ead37da56d5 100644
--- a/library/cpp/http/server/http_ex.cpp
+++ b/library/cpp/http/server/http_ex.cpp
@@ -87,11 +87,13 @@ bool THttpClientRequestExtension::ProcessHeaders(TBaseServerRequestData& rd, TBl
                     }
 
                     TBuffer buf(SafeIntegerCast<size_t>(contentLength));
-                    buf.Resize(Input().Load(buf.Data(), (size_t)contentLength));
+                    Input().LoadOrFail(buf.Data(), (size_t)contentLength);
+                    buf.Resize((size_t)contentLength);
                     postData = TBlob::FromBuffer(buf);
                 } else {
                     postData = TBlob::FromStream(Input());
                 }
+                rd.SetBody(postData);
             } catch (...) {
                 Output() << "HTTP/1.1 400 Bad request\r\n\r\n";
                 return false;
diff --git a/library/cpp/http/server/http_ut.cpp b/library/cpp/http/server/http_ut.cpp
index 0fc44fa5983..b3280745929 100644
--- a/library/cpp/http/server/http_ut.cpp
+++ b/library/cpp/http/server/http_ut.cpp
@@ -7,6 +7,7 @@
 #include <util/generic/cast.h>
 #include <util/stream/output.h>
 #include <util/stream/zlib.h>
+#include <util/stream/tee.h>
 #include <util/system/datetime.h>
 #include <util/system/mutex.h>
 #include <util/random/random.h>
@@ -1016,4 +1017,112 @@ Y_UNIT_TEST_SUITE(THttpServerTest) {
         t2->Join();
         UNIT_ASSERT_EQUAL_C(results, (THashSet<TString>({"Zoooo", "TTL Exceed"})), "Results is {" + ToString(results) + "}");
     }
+
+    Y_UNIT_TEST(TestCustomSocketStreams) {
+        // Check that TClientRequest::CreateHttpConnection override works
+
+        class TCustomSocketStreamsServer: public THttpServer::ICallBack {
+        public:
+            TStringStream InputCopy;
+            TStringStream OutputCopy;
+        private:
+            class TTeeInput
+                : public IInputStream
+            {
+            public:
+                TTeeInput(IInputStream* s, IOutputStream* copy)
+                    : S_(s)
+                    , Copy_(copy)
+                {
+                }
+
+                size_t DoRead(void* buf, size_t len) override {
+                    void* begin = buf;
+                    size_t res = S_->Read(buf, len);
+                    Copy_->Write(begin, res);
+                    return res;
+                }
+
+            private:
+                IInputStream* const S_;
+                IOutputStream* const Copy_;
+            };
+
+            class TBlockingSocketStreams: public THttpServerConn::ISocketStreams {
+            public:
+                explicit TBlockingSocketStreams(const TSocket& s, TCustomSocketStreamsServer* server)
+                    : Socket_(s)
+                    , Input_(Socket_)
+                    , TI_(&Input_, &server->InputCopy)
+                    , Output_(Socket_)
+                    , TO_(&Output_, &server->OutputCopy)
+                {
+                }
+
+                IInputStream* Input() override {
+                    return &TI_;
+                }
+
+                IOutputStream* Output() override {
+                    return &TO_;
+                }
+
+                void Reset() override {}
+            private:
+                TSocket Socket_;
+                TSocketInput Input_;
+                TTeeInput TI_;
+                TSocketOutput Output_;
+                TTeeOutput TO_;
+            };
+
+            class TRequest: public TClientRequest {
+            public:
+                TRequest(TCustomSocketStreamsServer* server)
+                    : Server_(server)
+                {
+                }
+
+                bool Reply(void* /*tsr*/) override {
+                    Output() << "HTTP/1.1 200 Ok\r\n\r\n";
+                    Output().Finish();
+                    return true;
+                }
+
+                THolder<THttpServerConn> CreateHttpConnection(const TSocket& s, size_t outputBuffer) override {
+                    return MakeHolder<THttpServerConn>(MakeHolder<TBlockingSocketStreams>(s, Server_), outputBuffer);
+                }
+            private:
+                TCustomSocketStreamsServer* const Server_;
+            };
+
+        public:
+            TClientRequest* CreateClient() override {
+                return new TRequest(this);
+            }
+
+            void OnException() override {
+                ExceptionMessage = CurrentExceptionMessage();
+            }
+
+            TString ExceptionMessage;
+        };
+
+        TPortManager portManager;
+        const ui16 port = portManager.GetPort();
+        TCustomSocketStreamsServer server;
+        THttpServer::TOptions options(port);
+        options.nThreads = 1;
+        options.MaxConnections = 2;
+        THttpServer srv(&server, options);
+
+        UNIT_ASSERT(srv.Start());
+
+        TSocket socket(TNetworkAddress("localhost", port), TDuration::Seconds(10));
+
+        SendRequest(socket, port);
+
+        UNIT_ASSERT_STRINGS_EQUAL(server.InputCopy.Str(), TStringBuilder() << "GET / HTTP/1.1\r\nHost: localhost:" << port << "\r\nConnection: Keep-Alive\r\n\r\n");
+        UNIT_ASSERT_STRINGS_EQUAL(server.OutputCopy.Str(), TStringBuilder() << "HTTP/1.1 200 Ok\r\nConnection: Keep-Alive\r\nTransfer-Encoding: chunked\r\n\r\n0\r\n\r\n");
+    }
 }
diff --git a/library/cpp/http/simple/http_client.cpp b/library/cpp/http/simple/http_client.cpp
index 342236f9a33..87bbabc3f83 100644
--- a/library/cpp/http/simple/http_client.cpp
+++ b/library/cpp/http/simple/http_client.cpp
@@ -1,21 +1,30 @@
 #include "http_client.h"
 
 #include <library/cpp/string_utils/url/url.h>
-#include <library/cpp/uri/http_url.h>
 
 #include <util/stream/output.h>
 #include <util/string/cast.h>
 #include <util/string/join.h>
 #include <util/string/split.h>
+#include <util/system/spinlock.h>
+#include <library/cpp/cache/cache.h>
+
+
+TSpinLock TKeepAliveHttpClient::ConnectionQuarantineMutex;
+TQueue<THolder<NPrivate::THttpConnection>> TKeepAliveHttpClient::ConnectionQuarantine;
 
 TKeepAliveHttpClient::TKeepAliveHttpClient(const TString& host,
                                            ui32 port,
                                            TDuration socketTimeout,
-                                           TDuration connectTimeout)
+                                           TDuration connectTimeout,
+                                           bool useKeepAlive,
+                                           bool useConnectionPool)
     : Host(CutHttpPrefix(host))
     , Port(port)
     , SocketTimeout(socketTimeout)
     , ConnectTimeout(connectTimeout)
+    , UseKeepAlive(useKeepAlive)
+    , UseConnectionPool(useConnectionPool)
     , IsHttps(host.StartsWith("https"))
     , IsClosingRequired(false)
     , HttpsVerification(TVerifyCert{Host})
@@ -26,26 +35,30 @@ TKeepAliveHttpClient::TKeepAliveHttpClient(const TString& host,
 TKeepAliveHttpClient::THttpCode TKeepAliveHttpClient::DoGet(const TStringBuf relativeUrl,
                                                             IOutputStream* output,
                                                             const THeaders& headers,
-                                                            THttpHeaders* outHeaders) {
+                                                            THttpHeaders* outHeaders,
+                                                            NThreading::TCancellationToken cancellation) {
     return DoRequest(TStringBuf("GET"),
                      relativeUrl,
                      {},
                      output,
                      headers,
-                     outHeaders);
+                     outHeaders,
+                     std::move(cancellation));
 }
 
 TKeepAliveHttpClient::THttpCode TKeepAliveHttpClient::DoPost(const TStringBuf relativeUrl,
                                                              const TStringBuf body,
                                                              IOutputStream* output,
                                                              const THeaders& headers,
-                                                             THttpHeaders* outHeaders) {
+                                                             THttpHeaders* outHeaders,
+                                                             NThreading::TCancellationToken cancellation) {
     return DoRequest(TStringBuf("POST"),
                      relativeUrl,
                      body,
                      output,
                      headers,
-                     outHeaders);
+                     outHeaders,
+                     std::move(cancellation));
 }
 
 TKeepAliveHttpClient::THttpCode TKeepAliveHttpClient::DoRequest(const TStringBuf method,
@@ -53,15 +66,17 @@ TKeepAliveHttpClient::THttpCode TKeepAliveHttpClient::DoRequest(const TStringBuf
                                                                 const TStringBuf body,
                                                                 IOutputStream* output,
                                                                 const THeaders& inHeaders,
-                                                                THttpHeaders* outHeaders) {
+                                                                THttpHeaders* outHeaders,
+                                                                NThreading::TCancellationToken cancellation) {
     const TString contentLength = IntToString<10, size_t>(body.size());
-    return DoRequestReliable(FormRequest(method, relativeUrl, body, inHeaders, contentLength), output, outHeaders);
+    return DoRequestReliable(FormRequest(method, relativeUrl, body, inHeaders, contentLength), output, outHeaders, std::move(cancellation));
 }
 
 TKeepAliveHttpClient::THttpCode TKeepAliveHttpClient::DoRequestRaw(const TStringBuf raw,
                                                                    IOutputStream* output,
-                                                                   THttpHeaders* outHeaders) {
-    return DoRequestReliable(raw, output, outHeaders);
+                                                                   THttpHeaders* outHeaders,
+                                                                   NThreading::TCancellationToken cancellation) {
+    return DoRequestReliable(raw, output, outHeaders, std::move(cancellation));
 }
 
 void TKeepAliveHttpClient::DisableVerificationForHttps() {
@@ -154,13 +169,29 @@ bool TKeepAliveHttpClient::CreateNewConnectionIfNeeded() {
                                                            ConnectTimeout,
                                                            IsHttps,
                                                            ClientCertificate,
-                                                           HttpsVerification);
+                                                           HttpsVerification,
+                                                           UseKeepAlive);
         IsClosingRequired = false;
         return true;
     }
     return false;
 }
 
+TKeepAliveHttpClient::~TKeepAliveHttpClient() {
+    if (UseConnectionPool) {
+        THolder<NPrivate::THttpConnection> oldConnection;
+        with_lock(ConnectionQuarantineMutex) {
+            while (ConnectionQuarantine.size() > 100) {
+                oldConnection = std::move(ConnectionQuarantine.front());
+
+                ConnectionQuarantine.pop();
+                oldConnection.Reset();
+            }
+            ConnectionQuarantine.push(std::move(Connection));
+        }
+    }
+}
+
 THttpRequestException::THttpRequestException(int statusCode)
     : StatusCode(statusCode)
 {
@@ -175,6 +206,8 @@ TSimpleHttpClient::TSimpleHttpClient(const TOptions& options)
     , Port(options.Port())
     , SocketTimeout(options.SocketTimeout())
     , ConnectTimeout(options.ConnectTimeout())
+    , UseKeepAlive(options.UseKeepAlive())
+    , UseConnectionPool(options.UseConnectionPool())
 {
 }
 
@@ -190,28 +223,28 @@ void TSimpleHttpClient::EnableVerificationForHttps() {
     HttpsVerification = true;
 }
 
-void TSimpleHttpClient::DoGet(const TStringBuf relativeUrl, IOutputStream* output, const THeaders& headers) const {
+void TSimpleHttpClient::DoGet(const TStringBuf relativeUrl, IOutputStream* output, const THeaders& headers, THttpHeaders* outHeaders, NThreading::TCancellationToken cancellation) const {
     TKeepAliveHttpClient cl = CreateClient();
 
-    TKeepAliveHttpClient::THttpCode code = cl.DoGet(relativeUrl, output, headers);
+    TKeepAliveHttpClient::THttpCode code = cl.DoGet(relativeUrl, output, headers, outHeaders, std::move(cancellation));
 
     Y_ENSURE(cl.GetHttpInput());
     ProcessResponse(relativeUrl, *cl.GetHttpInput(), output, code);
 }
 
-void TSimpleHttpClient::DoPost(const TStringBuf relativeUrl, TStringBuf body, IOutputStream* output, const THashMap<TString, TString>& headers) const {
+void TSimpleHttpClient::DoPost(const TStringBuf relativeUrl, TStringBuf body, IOutputStream* output, const THashMap<TString, TString>& headers, THttpHeaders* outHeaders, NThreading::TCancellationToken cancellation) const {
     TKeepAliveHttpClient cl = CreateClient();
 
-    TKeepAliveHttpClient::THttpCode code = cl.DoPost(relativeUrl, body, output, headers);
+    TKeepAliveHttpClient::THttpCode code = cl.DoPost(relativeUrl, body, output, headers, outHeaders, std::move(cancellation));
 
     Y_ENSURE(cl.GetHttpInput());
     ProcessResponse(relativeUrl, *cl.GetHttpInput(), output, code);
 }
 
-void TSimpleHttpClient::DoPostRaw(const TStringBuf relativeUrl, const TStringBuf rawRequest, IOutputStream* output) const {
+void TSimpleHttpClient::DoPostRaw(const TStringBuf relativeUrl, const TStringBuf rawRequest, IOutputStream* output, THttpHeaders* outHeaders, NThreading::TCancellationToken cancellation) const {
     TKeepAliveHttpClient cl = CreateClient();
 
-    TKeepAliveHttpClient::THttpCode code = cl.DoRequestRaw(rawRequest, output);
+    TKeepAliveHttpClient::THttpCode code = cl.DoRequestRaw(rawRequest, output, outHeaders, std::move(cancellation));
 
     Y_ENSURE(cl.GetHttpInput());
     ProcessResponse(relativeUrl, *cl.GetHttpInput(), output, code);
@@ -224,7 +257,8 @@ namespace NPrivate {
                                      TDuration connTimeout,
                                      bool isHttps,
                                      const TMaybe<TOpenSslClientIO::TOptions::TClientCert>& clientCert,
-                                     const TMaybe<TOpenSslClientIO::TOptions::TVerifyCert>& verifyCert)
+                                     const TMaybe<TOpenSslClientIO::TOptions::TVerifyCert>& verifyCert,
+                                     bool keepAlive)
         : Addr(Resolve(host, port))
         , Socket(Connect(Addr, sockTimeout, connTimeout, host, port))
         , SocketIn(Socket)
@@ -244,8 +278,9 @@ namespace NPrivate {
         } else {
             HttpOut = MakeHolder<THttpOutput>(&SocketOut);
         }
-
-        HttpOut->EnableKeepAlive(true);
+        if (keepAlive) {
+            HttpOut->EnableKeepAlive(true);
+        }
     }
 
     TNetworkAddress THttpConnection::Resolve(const TString& host, ui32 port) {
@@ -287,7 +322,7 @@ TSimpleHttpClient::~TSimpleHttpClient() {
 }
 
 TKeepAliveHttpClient TSimpleHttpClient::CreateClient() const {
-    TKeepAliveHttpClient cl(Host, Port, SocketTimeout, ConnectTimeout);
+    TKeepAliveHttpClient cl(Host, Port, SocketTimeout, ConnectTimeout, UseKeepAlive, UseConnectionPool);
 
     if (!HttpsVerification) {
         cl.DisableVerificationForHttps();
@@ -325,32 +360,24 @@ void TRedirectableHttpClient::ProcessResponse(const TStringBuf relativeUrl, THtt
                 ythrow THttpRequestException(statusCode) << "Exceeds MaxRedirectCount limit, code " << statusCode << " at " << Host << relativeUrl;
             }
 
-            TVector<TString> request_url_parts, request_body_parts;
-
-            size_t splitted_index = 0;
-            for (auto& iter : StringSplitter(i->Value()).Split('/')) {
-                if (splitted_index < 3) {
-                    request_url_parts.push_back(TString(iter.Token()));
+            TStringBuf schemeHostPort = GetSchemeHostAndPort(i->Value());
+            TStringBuf scheme("http://");
+            TStringBuf host("unknown");
+            ui16 port = 0;
+            GetSchemeHostAndPort(schemeHostPort, scheme, host, port);
+            TStringBuf body = GetPathAndQuery(i->Value(), false);
+            if (port == 0) {
+                if (scheme.StartsWith("https")) {
+                    port = 443;
+                } else if (scheme.StartsWith("http")) {
+                    port = 80;
                 } else {
-                    request_body_parts.push_back(TString(iter.Token()));
-                }
-                ++splitted_index;
-            }
-
-            TString url = JoinSeq("/", request_url_parts);
-            ui16 port = 443;
-
-            THttpURL u;
-            if (THttpURL::ParsedOK == u.Parse(url)) {
-                const char* p = u.Get(THttpURL::FieldPort);
-                if (p) {
-                    port = FromString<ui16>(p);
-                    url = u.PrintS(THttpURL::FlagScheme | THttpURL::FlagHost);
+                    port = 80;
                 }
             }
 
             auto opts = Opts;
-            opts.Host(url);
+            opts.Host(TString(scheme) + TString(host));
             opts.Port(port);
             opts.MaxRedirectCount(opts.MaxRedirectCount() - 1);
 
@@ -358,7 +385,7 @@ void TRedirectableHttpClient::ProcessResponse(const TStringBuf relativeUrl, THtt
             if (HttpsVerification) {
                 cl.EnableVerificationForHttps();
             }
-            cl.DoGet(TString("/") + JoinSeq("/", request_body_parts), output);
+            cl.DoGet(body, output);
             return;
         }
     }
diff --git a/library/cpp/http/simple/http_client.h b/library/cpp/http/simple/http_client.h
index eab92d42da5..d208e0ae055 100644
--- a/library/cpp/http/simple/http_client.h
+++ b/library/cpp/http/simple/http_client.h
@@ -8,10 +8,13 @@
 #include <util/generic/strbuf.h>
 #include <util/generic/yexception.h>
 #include <util/network/socket.h>
+#include <util/generic/queue.h>
+#include <util/system/spinlock.h>
 
 #include <library/cpp/http/io/stream.h>
 #include <library/cpp/http/misc/httpcodes.h>
 #include <library/cpp/openssl/io/stream.h>
+#include <library/cpp/threading/cancellation/cancellation_token.h>
 
 class TNetworkAddress;
 class IOutputStream;
@@ -49,19 +52,26 @@ class TKeepAliveHttpClient {
     TKeepAliveHttpClient(const TString& host,
                          ui32 port,
                          TDuration socketTimeout = TDuration::Seconds(5),
-                         TDuration connectTimeout = TDuration::Seconds(30));
+                         TDuration connectTimeout = TDuration::Seconds(30),
+                         bool useKeepAlive = true,
+                         bool useConnectionPool = false);
+
+    TKeepAliveHttpClient(TKeepAliveHttpClient&&) = default;
+    ~TKeepAliveHttpClient();
 
     THttpCode DoGet(const TStringBuf relativeUrl,
                     IOutputStream* output = nullptr,
                     const THeaders& headers = THeaders(),
-                    THttpHeaders* outHeaders = nullptr);
+                    THttpHeaders* outHeaders = nullptr,
+                    NThreading::TCancellationToken cancellation = NThreading::TCancellationToken::Default());
 
     // builds post request from headers and body
     THttpCode DoPost(const TStringBuf relativeUrl,
                      const TStringBuf body,
                      IOutputStream* output = nullptr,
                      const THeaders& headers = THeaders(),
-                     THttpHeaders* outHeaders = nullptr);
+                     THttpHeaders* outHeaders = nullptr,
+                     NThreading::TCancellationToken cancellation = NThreading::TCancellationToken::Default());
 
     // builds request with any HTTP method from headers and body
     THttpCode DoRequest(const TStringBuf method,
@@ -69,12 +79,14 @@ class TKeepAliveHttpClient {
                         const TStringBuf body,
                         IOutputStream* output = nullptr,
                         const THeaders& inHeaders = THeaders(),
-                        THttpHeaders* outHeaders = nullptr);
+                        THttpHeaders* outHeaders = nullptr,
+                        NThreading::TCancellationToken cancellation = NThreading::TCancellationToken::Default());
 
     // requires already well-formed request
     THttpCode DoRequestRaw(const TStringBuf raw,
                            IOutputStream* output = nullptr,
-                           THttpHeaders* outHeaders = nullptr);
+                           THttpHeaders* outHeaders = nullptr,
+                           NThreading::TCancellationToken cancellation = NThreading::TCancellationToken::Default());
 
     void DisableVerificationForHttps();
     void SetClientCertificate(const TOpenSslClientIO::TOptions::TClientCert& options);
@@ -93,7 +105,8 @@ class TKeepAliveHttpClient {
     template <class T>
     THttpCode DoRequestReliable(const T& raw,
                                 IOutputStream* output,
-                                THttpHeaders* outHeaders);
+                                THttpHeaders* outHeaders,
+                                NThreading::TCancellationToken cancellation);
 
     TVector<IOutputStream::TPart> FormRequest(TStringBuf method, const TStringBuf relativeUrl,
                                               TStringBuf body,
@@ -111,8 +124,13 @@ class TKeepAliveHttpClient {
     const ui32 Port;
     const TDuration SocketTimeout;
     const TDuration ConnectTimeout;
+    const bool UseKeepAlive;
+    const bool UseConnectionPool;
     const bool IsHttps;
 
+    static TSpinLock ConnectionQuarantineMutex;
+    static TQueue<THolder<NPrivate::THttpConnection>> ConnectionQuarantine;
+
     THolder<NPrivate::THttpConnection> Connection;
     bool IsClosingRequired;
     TMaybe<TClientCert> ClientCertificate;
@@ -152,6 +170,8 @@ class TSimpleHttpClient {
     const ui32 Port;
     const TDuration SocketTimeout;
     const TDuration ConnectTimeout;
+    const bool UseKeepAlive = true;
+    const bool UseConnectionPool = false;
     bool HttpsVerification = false;
 
 public:
@@ -166,13 +186,13 @@ class TSimpleHttpClient {
 
     void EnableVerificationForHttps();
 
-    void DoGet(const TStringBuf relativeUrl, IOutputStream* output, const THeaders& headers = THeaders()) const;
+    void DoGet(const TStringBuf relativeUrl, IOutputStream* output, const THeaders& headers = THeaders(), THttpHeaders* outHeaders = nullptr, NThreading::TCancellationToken cancellation = NThreading::TCancellationToken::Default()) const;
 
     // builds post request from headers and body
-    void DoPost(const TStringBuf relativeUrl, TStringBuf body, IOutputStream* output, const THeaders& headers = THeaders()) const;
+    void DoPost(const TStringBuf relativeUrl, TStringBuf body, IOutputStream* output, const THeaders& headers = THeaders(), THttpHeaders* outHeaders = nullptr, NThreading::TCancellationToken cancellation = NThreading::TCancellationToken::Default()) const;
 
     // requires already well-formed post request
-    void DoPostRaw(const TStringBuf relativeUrl, TStringBuf rawRequest, IOutputStream* output) const;
+    void DoPostRaw(const TStringBuf relativeUrl, TStringBuf rawRequest, IOutputStream* output, THttpHeaders* outHeaders = nullptr, NThreading::TCancellationToken cancellation = NThreading::TCancellationToken::Default()) const;
 
     virtual ~TSimpleHttpClient();
 
@@ -209,7 +229,8 @@ namespace NPrivate {
                         TDuration connTimeout,
                         bool isHttps,
                         const TMaybe<TOpenSslClientIO::TOptions::TClientCert>& clientCert,
-                        const TMaybe<TOpenSslClientIO::TOptions::TVerifyCert>& verifyCert);
+                        const TMaybe<TOpenSslClientIO::TOptions::TVerifyCert>& verifyCert,
+                        bool keepAlive = true);
 
         bool IsOk() const {
             return IsNotSocketClosedByOtherSide(Socket);
@@ -227,6 +248,10 @@ namespace NPrivate {
             return HttpIn.Get();
         }
 
+        void Shutdown() {
+            Socket.ShutDown(SHUT_RDWR);
+        }
+
     private:
         static TNetworkAddress Resolve(const TString& host, ui32 port);
 
@@ -250,11 +275,23 @@ namespace NPrivate {
 template <class T>
 TKeepAliveHttpClient::THttpCode TKeepAliveHttpClient::DoRequestReliable(const T& raw,
                                                                         IOutputStream* output,
-                                                                        THttpHeaders* outHeaders) {
+                                                                        THttpHeaders* outHeaders,
+                                                                        NThreading::TCancellationToken cancellation) {
+
     for (int i = 0; i < 2; ++i) {
         const bool haveNewConnection = CreateNewConnectionIfNeeded();
         const bool couldRetry = !haveNewConnection && i == 0; // Actually old connection could be already closed by server,
                                                               // so we should try one more time in this case.
+        TAtomicSharedPtr<TManualEvent> cancellationEndEvent = MakeAtomicShared<TManualEvent>();
+        auto cancelSub = cancellation.Future().Subscribe([this, cancellationEndEvent](auto&) {
+            if (cancellationEndEvent.RefCount() > 1) {
+                if (Connection && Connection->IsOk()) {
+                    Connection->Shutdown();
+                }
+                cancellationEndEvent->Signal();
+            }
+        });
+
         try {
             Connection->Write(raw);
 
@@ -264,16 +301,28 @@ TKeepAliveHttpClient::THttpCode TKeepAliveHttpClient::DoRequestReliable(const T&
             }
             return code;
         } catch (const TSystemError& e) {
+            if (cancellation.IsCancellationRequested()) {
+                cancellationEndEvent->WaitI();
+                cancellation.ThrowIfCancellationRequested();
+            }
             Connection.Reset();
             if (!couldRetry || e.Status() != EPIPE) {
                 throw;
             }
         } catch (const THttpReadException&) { // Actually old connection is already closed by server
+            if (cancellation.IsCancellationRequested()) {
+                cancellationEndEvent->WaitI();
+                cancellation.ThrowIfCancellationRequested();
+            }
             Connection.Reset();
             if (!couldRetry) {
                 throw;
             }
         } catch (const std::exception&) {
+            if (cancellation.IsCancellationRequested()) {
+                cancellationEndEvent->WaitI();
+                cancellation.ThrowIfCancellationRequested();
+            }
             Connection.Reset();
             throw;
         }
diff --git a/library/cpp/http/simple/http_client_options.h b/library/cpp/http/simple/http_client_options.h
index 603ca5103af..f237a3770a9 100644
--- a/library/cpp/http/simple/http_client_options.h
+++ b/library/cpp/http/simple/http_client_options.h
@@ -1,6 +1,7 @@
 #pragma once
 
 #include <util/datetime/base.h>
+#include <util/string/cast.h>
 #include <library/cpp/string_utils/url/url.h>
 
 class TSimpleHttpClientOptions {
@@ -60,10 +61,30 @@ class TSimpleHttpClientOptions {
         return MaxRedirectCount_;
     }
 
+    TSelf& UseKeepAlive(bool useKeepAlive) {
+        UseKeepAlive_ = useKeepAlive;
+        return *this;
+    }
+
+    bool UseKeepAlive() const noexcept {
+        return UseKeepAlive_;
+    }
+
+    TSelf& UseConnectionPool(bool useConnectionPool) {
+        UseConnectionPool_ = useConnectionPool;
+        return *this;
+    }
+
+    bool UseConnectionPool() const noexcept {
+        return UseConnectionPool_;
+    }
+
 private:
     TString Host_;
     ui16 Port_;
     TDuration SocketTimeout_ = TDuration::Seconds(5);
     TDuration ConnectTimeout_ = TDuration::Seconds(30);
     int MaxRedirectCount_ = INT_MAX;
+    bool UseKeepAlive_ = true;
+    bool UseConnectionPool_ = false;
 };
diff --git a/library/cpp/http/simple/ut/http_ut.cpp b/library/cpp/http/simple/ut/http_ut.cpp
index 20bef65a09d..e175f1e795c 100644
--- a/library/cpp/http/simple/ut/http_ut.cpp
+++ b/library/cpp/http/simple/ut/http_ut.cpp
@@ -6,6 +6,9 @@
 #include <library/cpp/testing/unittest/registar.h>
 #include <library/cpp/testing/unittest/tests_data.h>
 
+#include <library/cpp/threading/future/async.h>
+#include <util/thread/pool.h>
+
 #include <util/system/event.h>
 #include <util/system/thread.h>
 
@@ -264,6 +267,45 @@ Y_UNIT_TEST_SUITE(SimpleHttp) {
         }
     }
 
+    Y_UNIT_TEST(simpleCancel) {
+        TPortManager pm;
+        ui16 port = pm.GetPort(80);
+        NMock::TMockServer server(createOptions(port, false), []() { return new TPong(TDuration::Seconds(1)); });
+
+        TSimpleHttpClient cl("localhost", port);
+        UNIT_ASSERT_VALUES_EQUAL(0, server.GetClientCount());
+
+        auto tp = CreateThreadPool(3);
+
+        {
+            TStringStream s;
+            NThreading::TCancellationTokenSource cancel;
+            UNIT_ASSERT_NO_EXCEPTION(cl.DoGet("/ping", &s, TKeepAliveHttpClient::THeaders(), nullptr, cancel.Token()));
+            cancel.Cancel();
+            UNIT_ASSERT_VALUES_EQUAL("pong", s.Str());
+            Sleep(TDuration::MilliSeconds(500));
+            UNIT_ASSERT_VALUES_EQUAL(0, server.GetClientCount());
+        }
+
+        {
+            TStringStream s;
+            NThreading::TCancellationTokenSource cancel;
+            auto reqFuture = NThreading::Async([&] {
+                // Если DoGet() при отмене кидает исключение — оно “переедет” в future.
+                return cl.DoGet("/ping",
+                                &s,
+                                TKeepAliveHttpClient::THeaders(),
+                                nullptr,
+                                cancel.Token());
+            }, *tp);
+            Sleep(TDuration::MilliSeconds(50));
+            cancel.Cancel();
+            UNIT_ASSERT_EXCEPTION(reqFuture.GetValueSync(), NThreading::TOperationCancelledException);
+            Sleep(TDuration::MilliSeconds(1000));
+            UNIT_ASSERT_VALUES_EQUAL(0, server.GetClientCount());
+        }
+    }
+
     Y_UNIT_TEST(simpleMessages) {
         TPortManager pm;
         ui16 port = pm.GetPort(80);
diff --git a/library/cpp/int128/int128.h b/library/cpp/int128/int128.h
index 41f143e2959..2a4d77c00e3 100644
--- a/library/cpp/int128/int128.h
+++ b/library/cpp/int128/int128.h
@@ -243,6 +243,8 @@ class TInteger128 {
         return ret;
     }
 
+    bool operator==(const TInteger128& a) const = default;
+
     explicit constexpr operator bool() const noexcept {
         return Low_ || High_;
     }
@@ -357,6 +359,8 @@ template <bool IsSigned>
 size_t MostSignificantBit(const TInteger128<IsSigned> v);
 
 namespace std {
+    Y_PRAGMA_DIAGNOSTIC_PUSH
+    Y_PRAGMA("GCC diagnostic ignored \"-Winvalid-specialization\"")
     //// type traits
     template <bool IsSigned>
     struct is_integral<TInteger128<IsSigned>> : public std::true_type{};
@@ -369,6 +373,7 @@ namespace std {
 
     template <>
     struct is_signed<i128> : public std::true_type{};
+    Y_PRAGMA_DIAGNOSTIC_POP
 }
 
 template <bool IsSigned>
@@ -478,14 +483,6 @@ namespace std {
     };
 }
 
-constexpr bool operator==(const ui128 lhs, const ui128 rhs) noexcept {
-    return GetLow(lhs) == GetLow(rhs) && GetHigh(lhs) == GetHigh(rhs);
-}
-
-constexpr bool operator==(const i128 lhs, const i128 rhs) noexcept {
-    return GetLow(lhs) == GetLow(rhs) && GetHigh(lhs) == GetHigh(rhs);
-}
-
 constexpr bool operator!=(const ui128 lhs, const ui128 rhs) noexcept {
     return !(lhs == rhs);
 }
diff --git a/library/cpp/int128/ut/i128_find_ut.cpp b/library/cpp/int128/ut/i128_find_ut.cpp
new file mode 100644
index 00000000000..afc19b6dbae
--- /dev/null
+++ b/library/cpp/int128/ut/i128_find_ut.cpp
@@ -0,0 +1,16 @@
+#include <library/cpp/testing/unittest/registar.h>
+
+#include <library/cpp/int128/int128.h>
+
+#include <util/generic/cast.h>
+#include <util/generic/vector.h>
+
+#include <type_traits>
+
+Y_UNIT_TEST_SUITE(Int128FindSuite) {
+    Y_UNIT_TEST(Int128Find) {
+        const ui128 value = 10;
+        TVector<ui128> list = {1, 2, 3, 4, 5, 11, 10};
+        UNIT_ASSERT(Find(list, value) != list.end());
+    }
+}
diff --git a/library/cpp/iterator/enumerate.h b/library/cpp/iterator/enumerate.h
index 2c83fb41bfc..4b6a43dad78 100644
--- a/library/cpp/iterator/enumerate.h
+++ b/library/cpp/iterator/enumerate.h
@@ -8,11 +8,11 @@
 
 namespace NPrivate {
 
-    template <typename TContainer>
+    template <typename TContainer, typename TSize>
     struct TEnumerator {
     private:
         using TStorage = TAutoEmbedOrPtrPolicy<TContainer>;
-        using TValue = std::tuple<const std::size_t, decltype(*std::begin(std::declval<TContainer&>()))>;
+        using TValue = std::tuple<const TSize, decltype(*std::begin(std::declval<TContainer&>()))>;
         using TIteratorState = decltype(std::begin(std::declval<TContainer&>()));
         using TSentinelState = decltype(std::end(std::declval<TContainer&>()));
 
@@ -27,30 +27,38 @@ namespace NPrivate {
         struct TIterator {
             using difference_type = std::ptrdiff_t;
             using value_type = TValue;
-            using pointer = TValue*;
-            using reference = TValue&;
+            using pointer = void;
+            using reference = value_type;
             using iterator_category = std::input_iterator_tag;
 
-            TValue operator*() {
+            reference operator*() const {
                 return {Index_, *Iterator_};
             }
-            TValue operator*() const {
-                return {Index_, *Iterator_};
-            }
-            void operator++() {
+
+            TIterator& operator++() {
                 ++Index_;
                 ++Iterator_;
+                return *this;
             }
+
+            TIterator operator++(int) {
+                TIterator result = *this;
+                ++(*this);
+                return result;
+            }
+
             bool operator!=(const TSentinel& other) const {
                 return Iterator_ != other.Iterator_;
             }
+
             bool operator==(const TSentinel& other) const {
                 return Iterator_ == other.Iterator_;
             }
 
-            std::size_t Index_;
+            TSize Index_;
             TIteratorState Iterator_;
         };
+
     public:
         using iterator = TIterator;
         using const_iterator = TIterator;
@@ -64,7 +72,7 @@ namespace NPrivate {
 
         TSentinel end() const {
             if constexpr (TrivialSentinel) {
-                return TIterator{std::numeric_limits<std::size_t>::max(), std::end(*Storage_.Ptr())};
+                return TIterator{std::numeric_limits<TSize>::max(), std::end(*Storage_.Ptr())};
             } else {
                 return TSentinel{std::end(*Storage_.Ptr())};
             }
@@ -78,5 +86,12 @@ namespace NPrivate {
 //! Usage: for (auto [i, x] : Enumerate(container)) {...}
 template <typename TContainerOrRef>
 auto Enumerate(TContainerOrRef&& container) {
-    return NPrivate::TEnumerator<TContainerOrRef>{std::forward<TContainerOrRef>(container)};
+    return NPrivate::TEnumerator<TContainerOrRef, std::size_t>{std::forward<TContainerOrRef>(container)};
+}
+
+//! Usage: for (auto [i, x] : SEnumerate(container)) {...}
+// The index is signed for codebases that prefer signed numerics (such as YTsaurus).
+template <typename TContainerOrRef>
+auto SEnumerate(TContainerOrRef&& container) {
+    return NPrivate::TEnumerator<TContainerOrRef, std::ptrdiff_t>{std::forward<TContainerOrRef>(container)};
 }
diff --git a/library/cpp/iterator/filtering.h b/library/cpp/iterator/filtering.h
index c28e3bc6c44..23cfef6d70e 100644
--- a/library/cpp/iterator/filtering.h
+++ b/library/cpp/iterator/filtering.h
@@ -2,6 +2,7 @@
 
 #include <util/generic/iterator_range.h>
 #include <util/generic/store_policy.h>
+#include <util/system/compiler.h>
 #include <iterator>
 
 
@@ -53,7 +54,7 @@ class TFilteringIterator {
     }
     TIterator Iter;
     TIterator Last;
-    TCondition Condition;
+    Y_NO_UNIQUE_ADDRESS TCondition Condition;
 };
 
 
@@ -87,7 +88,7 @@ class TFilteringRange {
 
 private:
     mutable TContainerStorage Container;
-    mutable TConditionStorage Condition;
+    Y_NO_UNIQUE_ADDRESS mutable TConditionStorage Condition;
 };
 
 
diff --git a/library/cpp/iterator/mapped.h b/library/cpp/iterator/mapped.h
index d78371a9e5d..348aa200bf2 100644
--- a/library/cpp/iterator/mapped.h
+++ b/library/cpp/iterator/mapped.h
@@ -2,6 +2,7 @@
 
 #include <util/generic/iterator_range.h>
 #include <util/generic/store_policy.h>
+#include <util/system/compiler.h>
 
 #include <iterator>
 
@@ -91,7 +92,7 @@ class TMappedIterator {
 
 private:
     TIterator Iter;
-    TMapper Mapper;
+    Y_NO_UNIQUE_ADDRESS TMapper Mapper;
 };
 
 
@@ -130,7 +131,7 @@ class TInputMappedRange {
 
 protected:
     mutable TContainerStorage Container;
-    mutable TMapperStorage Mapper;
+    Y_NO_UNIQUE_ADDRESS mutable TMapperStorage Mapper;
 };
 
 
diff --git a/library/cpp/iterator/ut/functools_ut.cpp b/library/cpp/iterator/ut/functools_ut.cpp
index 2dee9a55c85..b11a715e0c4 100644
--- a/library/cpp/iterator/ut/functools_ut.cpp
+++ b/library/cpp/iterator/ut/functools_ut.cpp
@@ -99,7 +99,7 @@ using namespace NFuncTools;
 
     struct TTestSentinel {};
     struct TTestIterator {
-        int operator*() {
+        int operator*() const {
             return X;
         }
         void operator++() {
@@ -139,6 +139,18 @@ using namespace NFuncTools;
             EXPECT_EQ(j, v.size());
         }
 
+        // Test correctness of iterator traits.
+        auto enumerated = Enumerate(a);
+        static_assert(std::ranges::input_range<decltype(enumerated)>);
+        static_assert(
+            std::is_same_v<decltype(enumerated.begin())::pointer,
+            std::iterator_traits<decltype(enumerated.begin())>::pointer>);
+
+        // Post-increment test.
+        auto it = enumerated.begin();
+        EXPECT_EQ(*(it++), (std::tuple{0, 1}));
+        EXPECT_EQ(*it, (std::tuple{1, 2}));
+
         TVector<size_t> d = {0, 0, 0};
         FOR_DISPATCH_2(i, x, Enumerate(d)) {
             x = i;
diff --git a/library/cpp/iterator/ut/mapped_ut.cpp b/library/cpp/iterator/ut/mapped_ut.cpp
index 440cd37945a..15a8196eded 100644
--- a/library/cpp/iterator/ut/mapped_ut.cpp
+++ b/library/cpp/iterator/ut/mapped_ut.cpp
@@ -7,12 +7,29 @@
 
 using namespace testing;
 
+namespace {
+    struct TSelectFirst {
+        const auto& operator()(const auto& pair) const {
+            return pair.first;
+        }
+    };
+}
+
 TEST(TIterator, TMappedIteratorTest) {
     TVector<int> x = {1, 2, 3, 4, 5};
     auto it = MakeMappedIterator(x.begin(), [](int x) { return x + 7; });
 
     EXPECT_EQ(*it, 8);
     EXPECT_EQ(it[2], 10);
+
+    TVector<std::pair<int, int>> pairs = {{1, 2}, {3, 4}, {5, 6}};
+    auto firstIt = MakeMappedIterator(pairs.begin(), TSelectFirst{});
+    EXPECT_EQ(*std::next(firstIt, 0), 1);
+    EXPECT_EQ(*std::next(firstIt, 1), 3);
+    EXPECT_EQ(*std::next(firstIt, 2), 5);
+#if defined(_compiler_clang_) && defined(_linux_)
+    static_assert(sizeof(pairs.begin()) == sizeof(firstIt), "empty mapper should not add size overhead");  // this check expected to hold, but not guaranteed to
+#endif
 }
 
 TEST(TIterator, TMappedRangeTest) {
diff --git a/library/cpp/json/common/defs.h b/library/cpp/json/common/defs.h
index ae3985508be..331c687665f 100644
--- a/library/cpp/json/common/defs.h
+++ b/library/cpp/json/common/defs.h
@@ -35,8 +35,9 @@ namespace NJson {
         bool GetHaveErrors() const {
             return HaveErrors;
         }
+
     protected:
         bool ThrowException;
         bool HaveErrors = false;
     };
-}
+} // namespace NJson
diff --git a/library/cpp/json/converter/converter.h b/library/cpp/json/converter/converter.h
index 4e92b2e0cf0..e741b54247a 100644
--- a/library/cpp/json/converter/converter.h
+++ b/library/cpp/json/converter/converter.h
@@ -10,21 +10,20 @@
 #include <util/generic/map.h>
 #include <util/generic/maybe.h>
 
-
 namespace NJson {
-    template<typename T>
+    template <typename T>
     struct TConverter {
     };
 
     namespace {
-        template<typename T>
+        template <typename T>
         struct TDefaultEncoder {
             static inline TJsonValue Encode(T value) {
                 return TJsonValue(value);
             }
         };
 
-        template<typename T, typename E>
+        template <typename T, typename E>
         struct TDefaultArrayEncoder {
             static TJsonValue Encode(const T& value) {
                 TJsonValue result(NJson::JSON_ARRAY);
@@ -36,7 +35,7 @@ namespace NJson {
             }
         };
 
-        template<typename T, typename E>
+        template <typename T, typename E>
         struct TDefaultArrayDecoder {
             static T Decode(const TJsonValue& value) {
                 T result;
@@ -47,11 +46,11 @@ namespace NJson {
             }
         };
 
-        template<typename T, typename E>
+        template <typename T, typename E>
         struct TDefaultArrayConverter: public TDefaultArrayEncoder<T, E>, public TDefaultArrayDecoder<T, E> {
         };
 
-        template<typename T, typename E>
+        template <typename T, typename E>
         struct TDefaultMapEncoder {
             static TJsonValue Encode(const T& value) {
                 TJsonValue result(NJson::JSON_MAP);
@@ -63,7 +62,7 @@ namespace NJson {
             }
         };
 
-        template<typename T, typename E>
+        template <typename T, typename E>
         struct TDefaultMapDecoder {
             static T Decode(const TJsonValue& value) {
                 T result;
@@ -74,12 +73,12 @@ namespace NJson {
             }
         };
 
-        template<typename T, typename E>
+        template <typename T, typename E>
         struct TDefaultMapConverter: public TDefaultMapEncoder<T, E>, public TDefaultMapDecoder<T, E> {
         };
-    }
+    } // namespace
 
-    template<>
+    template <>
     struct TConverter<TJsonValue> {
         static TJsonValue Encode(const TJsonValue& value) {
             return value;
@@ -90,15 +89,15 @@ namespace NJson {
         }
     };
 
-    template<>
+    template <>
     struct TConverter<bool>: public TDefaultEncoder<bool> {
         static inline bool Decode(const TJsonValue& value) {
             return value.GetBooleanSafe();
         }
     };
 
-    template<typename T>
-    requires std::is_integral_v<T> && (!std::is_same_v<T, bool>)
+    template <typename T>
+        requires std::is_integral_v<T> && (!std::is_same_v<T, bool>)
     struct TConverter<T>: public TDefaultEncoder<T> {
         static T Decode(const TJsonValue& value) {
             if constexpr (std::is_signed_v<T>) {
@@ -117,26 +116,26 @@ namespace NJson {
         }
     };
 
-    template<typename T>
-    requires std::is_floating_point_v<T>
+    template <typename T>
+        requires std::is_floating_point_v<T>
     struct TConverter<T>: public TDefaultEncoder<T> {
         static inline T Decode(const TJsonValue& value) {
             return static_cast<T>(value.GetDoubleSafe());
         }
     };
 
-    template<>
+    template <>
     struct TConverter<TStringBuf>: public TDefaultEncoder<TStringBuf> {
     };
 
-    template<>
+    template <>
     struct TConverter<TString>: public TDefaultEncoder<TString> {
         static inline TString Decode(const TJsonValue& value) {
             return value.GetStringSafe();
         }
     };
 
-    template<typename T>
+    template <typename T>
     struct TConverter<TMaybe<T>> {
         static TJsonValue Encode(const TMaybe<T>& value) {
             if (value.Defined()) {
@@ -155,35 +154,35 @@ namespace NJson {
         }
     };
 
-    template<typename T>
+    template <typename T>
     struct TConverter<TArrayRef<T>>: public TDefaultArrayEncoder<TArrayRef<T>, T> {
     };
 
-    template<typename T>
+    template <typename T>
     struct TConverter<TVector<T>>: public TDefaultArrayConverter<TVector<T>, T> {
     };
 
-    template<typename T>
+    template <typename T>
     struct TConverter<TList<T>>: public TDefaultArrayConverter<TList<T>, T> {
     };
 
-    template<typename T>
+    template <typename T>
     struct TConverter<TDeque<T>>: public TDefaultArrayConverter<TDeque<T>, T> {
     };
 
-    template<typename T>
+    template <typename T>
     struct TConverter<THashMap<TStringBuf, T>>: public TDefaultMapEncoder<THashMap<TStringBuf, T>, T> {
     };
 
-    template<typename T>
+    template <typename T>
     struct TConverter<THashMap<TString, T>>: public TDefaultMapConverter<THashMap<TString, T>, T> {
     };
 
-    template<typename T>
+    template <typename T>
     struct TConverter<TMap<TStringBuf, T>>: public TDefaultMapEncoder<TMap<TStringBuf, T>, T> {
     };
 
-    template<typename T>
+    template <typename T>
     struct TConverter<TMap<TString, T>>: public TDefaultMapConverter<TMap<TString, T>, T> {
     };
-}
+} // namespace NJson
diff --git a/library/cpp/json/converter/ut/test_conversion.cpp b/library/cpp/json/converter/ut/test_conversion.cpp
index 84027dda75a..4d092759a47 100644
--- a/library/cpp/json/converter/ut/test_conversion.cpp
+++ b/library/cpp/json/converter/ut/test_conversion.cpp
@@ -11,7 +11,6 @@
 #include <util/generic/map.h>
 #include <util/generic/maybe.h>
 
-
 namespace NJson {
     void AssertJsonsEqual(const TJsonValue& actualJson, const TJsonValue& expectedJson) {
         const auto actualString = WriteJson(actualJson, /*formatOutput*/ true, /*sortkeys*/ true, /*validateUtf8*/ true);
@@ -24,7 +23,7 @@ namespace NJson {
         AssertJsonsEqual(actualJson, expectedJson);
     }
 
-    template<typename T>
+    template <typename T>
     struct TConverterTester {
         using TValues = THashMap<TStringBuf, T>;
 
@@ -62,8 +61,8 @@ namespace NJson {
         }
     };
 
-    template<typename T>
-    requires std::is_floating_point_v<T>
+    template <typename T>
+        requires std::is_floating_point_v<T>
     struct TConverterTester<T> {
         using TValues = THashMap<TStringBuf, T>;
 
@@ -202,5 +201,5 @@ namespace NJson {
                 },
             });
         }
-    }
-}
+    } // Y_UNIT_TEST_SUITE(ConversionTests)
+} // namespace NJson
diff --git a/library/cpp/json/easy_parse/json_easy_parser.cpp b/library/cpp/json/easy_parse/json_easy_parser.cpp
index 3c781f544bc..ddd9412955c 100644
--- a/library/cpp/json/easy_parse/json_easy_parser.cpp
+++ b/library/cpp/json/easy_parse/json_easy_parser.cpp
@@ -54,21 +54,26 @@ namespace NJson {
 
     private:
         static bool PathElementMatch(const TPathElem& templ, const TPathElem& real) {
-            if (templ.Type != real.Type)
+            if (templ.Type != real.Type) {
                 return false;
-            if (templ.Type == NImpl::ARRAY)
+            }
+            if (templ.Type == NImpl::ARRAY) {
                 return templ.ArrayCounter == -1 || templ.ArrayCounter == real.ArrayCounter;
-            if (templ.Type == NImpl::MAP_KEY)
+            }
+            if (templ.Type == NImpl::MAP_KEY) {
                 return templ.Key == ANY_IDENTIFIER || templ.Key == real.Key;
+            }
             return true;
         }
 
         bool CheckFilter(const TVector<TPathElem>& path) const {
-            if (Stack.size() < path.size())
+            if (Stack.size() < path.size()) {
                 return false;
+            }
             for (size_t n = 0; n < path.size(); ++n) {
-                if (!PathElementMatch(path[n], Stack[n]))
+                if (!PathElementMatch(path[n], Stack[n])) {
                     return false;
+                }
             }
             return true;
         }
@@ -90,8 +95,9 @@ namespace NJson {
         void IncreaseArrayCounter() {
             if (!Stack.empty() && Stack.back().Type == NImpl::ARRAY) {
                 ++Stack.back().ArrayCounter;
-                if (ShouldUpdateOnArrayChange)
+                if (ShouldUpdateOnArrayChange) {
                     UpdateRule();
+                }
             }
         }
 
@@ -114,43 +120,49 @@ namespace NJson {
             , HasFormatError(false)
         {
             for (size_t n = 0; n < Parent.Fields.size(); ++n) {
-                if (!Parent.Fields[n].Path.empty() && Parent.Fields[n].Path.back().Type == NImpl::ARRAY)
+                if (!Parent.Fields[n].Path.empty() && Parent.Fields[n].Path.back().Type == NImpl::ARRAY) {
                     ShouldUpdateOnArrayChange = true;
+                }
             }
         }
 
         bool OnOpenMap() override {
             IncreaseArrayCounter();
             Stack.push_back(TPathElem(NImpl::MAP));
-            if (CurrentFieldIdx >= 0)
+            if (CurrentFieldIdx >= 0) {
                 HasFormatError = true;
-            else
+            } else {
                 UpdateRule();
+            }
             return true;
         }
 
         bool OnOpenArray() override {
             IncreaseArrayCounter();
             Stack.push_back(TPathElem(-1));
-            if (CurrentFieldIdx >= 0)
+            if (CurrentFieldIdx >= 0) {
                 HasFormatError = true;
-            else
+            } else {
                 UpdateRule();
+            }
             return true;
         }
 
         bool OnCloseMap() override {
-            while (!Stack.empty() && Stack.back().Type != NImpl::MAP)
+            while (!Stack.empty() && Stack.back().Type != NImpl::MAP) {
                 Pop();
-            if (!Stack.empty())
+            }
+            if (!Stack.empty()) {
                 Pop();
+            }
             UpdateRule();
             return true;
         }
 
         bool OnCloseArray() override {
-            if (!Stack.empty())
+            if (!Stack.empty()) {
                 Pop();
+            }
             UpdateRule();
             return true;
         }
@@ -161,10 +173,11 @@ namespace NJson {
                 UpdateRule();
             }
             Stack.push_back(TPathElem(TString{key}));
-            if (CurrentFieldIdx >= 0)
+            if (CurrentFieldIdx >= 0) {
                 HasFormatError = true;
-            else
+            } else {
                 UpdateRule();
+            }
             return true;
         }
 
@@ -185,17 +198,21 @@ namespace NJson {
         }
 
         bool IsOK() const {
-            if (HasFormatError)
+            if (HasFormatError) {
                 return false;
-            for (size_t n = 0; n < FieldValues.size(); ++n)
-                if (Parent.Fields[n].NonEmpty && FieldValues[n].empty())
+            }
+            for (size_t n = 0; n < FieldValues.size(); ++n) {
+                if (Parent.Fields[n].NonEmpty && FieldValues[n].empty()) {
                     return false;
+                }
+            }
             return true;
         }
 
         void WriteTo(IOutputStream& out) const {
-            for (size_t n = 0; n < FieldValues.size(); ++n)
+            for (size_t n = 0; n < FieldValues.size(); ++n) {
                 out << "\t" << FieldValues[n];
+            }
         }
 
         void WriteTo(TVector<TString>* res) const {
@@ -220,17 +237,18 @@ namespace NJson {
         if (impl.IsOK()) {
             impl.WriteTo(res);
             return true;
-        } else
+        } else {
             return false;
+        }
     }
 
-    //struct TTestMe {
-    //    TTestMe() {
-    //        TJsonParser worker;
-    //        worker.AddField("/x/y/z", true);
-    //        TString ret1 = worker.ConvertToTabDelimited("{ \"x\" : { \"y\" : { \"w\" : 1, \"z\" : 2 } } }");
-    //        TString ret2 = worker.ConvertToTabDelimited(" [1, 2, 3, 4, 5] ");
-    //    }
-    //} testMe;
+    // struct TTestMe {
+    //     TTestMe() {
+    //         TJsonParser worker;
+    //         worker.AddField("/x/y/z", true);
+    //         TString ret1 = worker.ConvertToTabDelimited("{ \"x\" : { \"y\" : { \"w\" : 1, \"z\" : 2 } } }");
+    //         TString ret2 = worker.ConvertToTabDelimited(" [1, 2, 3, 4, 5] ");
+    //     }
+    // } testMe;
 
-}
+} // namespace NJson
diff --git a/library/cpp/json/easy_parse/json_easy_parser.h b/library/cpp/json/easy_parse/json_easy_parser.h
index 59d7791ab14..0cd668e6fe6 100644
--- a/library/cpp/json/easy_parse/json_easy_parser.h
+++ b/library/cpp/json/easy_parse/json_easy_parser.h
@@ -43,4 +43,4 @@ namespace NJson {
         TString ConvertToTabDelimited(const TString& json) const;
         bool Parse(const TString& json, TVector<TString>* res) const;
     };
-}
+} // namespace NJson
diff --git a/library/cpp/json/easy_parse/json_easy_parser_impl.h b/library/cpp/json/easy_parse/json_easy_parser_impl.h
index ec55d838b32..3106a11b414 100644
--- a/library/cpp/json/easy_parse/json_easy_parser_impl.h
+++ b/library/cpp/json/easy_parse/json_easy_parser_impl.h
@@ -9,7 +9,7 @@ namespace NJson {
             MAP,
             MAP_KEY
         };
-    }
+    } // namespace NImpl
     template <class TStringType>
     struct TPathElemImpl {
         NImpl::EType Type;
@@ -37,4 +37,4 @@ namespace NJson {
     };
 
     typedef TPathElemImpl<TString> TPathElem;
-}
+} // namespace NJson
diff --git a/library/cpp/json/fast_sax/parser.h b/library/cpp/json/fast_sax/parser.h
index b5f031dd9eb..8f7cea7b7f0 100644
--- a/library/cpp/json/fast_sax/parser.h
+++ b/library/cpp/json/fast_sax/parser.h
@@ -10,4 +10,4 @@ namespace NJson {
         TJsonCallbacks c(throwOnError);
         return ReadJsonFast(in, &c);
     }
-}
+} // namespace NJson
diff --git a/library/cpp/json/fuzzy_test/main.cpp b/library/cpp/json/fuzzy_test/main.cpp
index 29a53aac142..afa410cd6d9 100644
--- a/library/cpp/json/fuzzy_test/main.cpp
+++ b/library/cpp/json/fuzzy_test/main.cpp
@@ -10,20 +10,20 @@ extern "C" int LLVMFuzzerTestOneInput(const ui8* data, size_t size) {
         NJson::TJsonValue value;
         NJson::ReadJsonFastTree(json, &value, true);
     } catch (...) {
-        //Cout << json << " -> " << CurrentExceptionMessage() << Endl;
+        // Cout << json << " -> " << CurrentExceptionMessage() << Endl;
     }
 
     try {
         NJson::TJsonCallbacks cb;
         NJson::ReadJsonFast(json, &cb);
     } catch (...) {
-        //Cout << json << " -> " << CurrentExceptionMessage() << Endl;
+        // Cout << json << " -> " << CurrentExceptionMessage() << Endl;
     }
 
     try {
         NJson::ValidateJson(json);
     } catch (...) {
-        //Cout << json << " -> " << CurrentExceptionMessage() << Endl;
+        // Cout << json << " -> " << CurrentExceptionMessage() << Endl;
     }
 
     return 0;
diff --git a/library/cpp/json/json_prettifier.cpp b/library/cpp/json/json_prettifier.cpp
index bb16aab44e5..a433e1887cc 100644
--- a/library/cpp/json/json_prettifier.cpp
+++ b/library/cpp/json/json_prettifier.cpp
@@ -26,8 +26,9 @@ namespace NJson {
         }
 
         void Hold(char c) {
-            if (Dirty)
+            if (Dirty) {
                 Flush();
+            }
             Last = c;
             Dirty = true;
         }
@@ -221,8 +222,9 @@ namespace NJson {
         }
 
         bool OnClose(char c) {
-            if (!Level)
+            if (!Level) {
                 return false;
+            }
 
             Level--;
 
@@ -237,16 +239,18 @@ namespace NJson {
         }
 
         bool OnCloseMap() override {
-            if (!OnClose('{'))
+            if (!OnClose('{')) {
                 return false;
+            }
             Out.Write("}");
             AfterVal();
             return true;
         }
 
         bool OnCloseArray() override {
-            if (!OnClose('['))
+            if (!OnClose('[')) {
                 return false;
+            }
             Out.Write("]");
             AfterVal();
             return true;
@@ -269,9 +273,10 @@ namespace NJson {
 
     TString TJsonPrettifier::Prettify(TStringBuf in) const {
         TStringStream s;
-        if (Prettify(in, s))
+        if (Prettify(in, s)) {
             return s.Str();
+        }
         return TString();
     }
 
-}
+} // namespace NJson
diff --git a/library/cpp/json/json_prettifier.h b/library/cpp/json/json_prettifier.h
index 27d611b0b43..d614db56c9a 100644
--- a/library/cpp/json/json_prettifier.h
+++ b/library/cpp/json/json_prettifier.h
@@ -55,4 +55,4 @@ namespace NJson {
         return TJsonPrettifier::Compactifier(unquote, sq).Prettify(in);
     }
 
-}
+} // namespace NJson
diff --git a/library/cpp/json/json_reader.cpp b/library/cpp/json/json_reader.cpp
index 05fcd32c43d..538bfa331bd 100644
--- a/library/cpp/json/json_reader.cpp
+++ b/library/cpp/json/json_reader.cpp
@@ -18,7 +18,7 @@ namespace NJson {
                                     << TStringBuf(", Code: ") << (int)result.Code()
                                     << TStringBuf(", Error: ") << GetParseError_En(result.Code());
         }
-    }
+    } // namespace
 
     static const size_t DEFAULT_BUFFER_LEN = 65536;
 
@@ -101,8 +101,9 @@ namespace NJson {
 
     bool TParserCallbacks::OnOpenArray() {
         bool res = OpenComplexValue(JSON_ARRAY);
-        if (res)
+        if (res) {
             CurrentState = IN_ARRAY;
+        }
         return res;
     }
 
@@ -112,8 +113,9 @@ namespace NJson {
 
     bool TParserCallbacks::OnOpenMap() {
         bool res = OpenComplexValue(JSON_MAP);
-        if (res)
+        if (res) {
             CurrentState = IN_MAP;
+        }
         return res;
     }
 
@@ -134,7 +136,7 @@ namespace NJson {
     }
 
     bool TParserCallbacks::OnEnd() {
-        if (NotClosedBracketIsError){
+        if (NotClosedBracketIsError) {
             return ValuesStack.empty();
         }
         return true;
@@ -336,6 +338,9 @@ namespace NJson {
         constexpr ui32 ConvertToRapidJsonFlags(ui8 flags) {
             ui32 rapidjsonFlags = rapidjson::kParseNoFlags;
 
+            if (flags & ReaderConfigFlags::NANINF) {
+                rapidjsonFlags |= rapidjson::kParseNanAndInfFlag;
+            }
             if (flags & ReaderConfigFlags::ITERATIVE) {
                 rapidjsonFlags |= rapidjson::kParseIterativeFlag;
             }
@@ -364,13 +369,13 @@ namespace NJson {
                 return reader.Parse<ConvertToRapidJsonFlags(currentFlags)>(is, handler);
             }
 
-#define TRY_EXTRACT_FLAG(flag) \
-    if (runtimeFlags & flag) { \
+#define TRY_EXTRACT_FLAG(flag)                                                                      \
+    if (runtimeFlags & flag) {                                                                      \
         return ReadWithRuntimeFlags<TRapidJsonCompliantInputStream, THandler, currentFlags | flag>( \
-            runtimeFlags ^ flag, reader, is, handler \
-        ); \
+            runtimeFlags ^ flag, reader, is, handler);                                              \
     }
 
+            TRY_EXTRACT_FLAG(ReaderConfigFlags::NANINF);
             TRY_EXTRACT_FLAG(ReaderConfigFlags::ITERATIVE);
             TRY_EXTRACT_FLAG(ReaderConfigFlags::COMMENTS);
             TRY_EXTRACT_FLAG(ReaderConfigFlags::VALIDATE);
@@ -388,7 +393,6 @@ namespace NJson {
                   rapidjson::Reader& reader,
                   TRapidJsonCompliantInputStream& is,
                   THandler& handler) {
-
             // validate by default
             ui8 flags = ReaderConfigFlags::VALIDATE;
 
@@ -408,6 +412,9 @@ namespace NJson {
                 flags |= ReaderConfigFlags::ESCAPE;
             }
 #endif
+            if (config.AllowReadNanInf) {
+                flags |= ReaderConfigFlags::NANINF;
+            }
 
             return ReadWithRuntimeFlags(flags, reader, is, handler);
         }
@@ -433,7 +440,7 @@ namespace NJson {
         bool ReadJsonTree(TRapidJsonCompliantInputStream& is, const TJsonReaderConfig* config, TJsonValue* out, bool throwOnError) {
             out->SetType(NJson::JSON_NULL);
 
-            TJsonValueBuilder handler(*out, { .MaxDepth = config->MaxDepth });
+            TJsonValueBuilder handler(*out, {.MaxDepth = config->MaxDepth});
 
             return ReadJson(is, config, handler, throwOnError);
         }
@@ -455,7 +462,7 @@ namespace NJson {
         bool ReadJsonTreeImpl(TData* in, TJsonValue* out, bool throwOnError) {
             return ReadJsonTreeImpl(in, false, out, throwOnError);
         }
-    } //namespace
+    } // namespace
 
     bool ReadJsonTree(TStringBuf in, TJsonValue* out, bool throwOnError) {
         return ReadJsonTreeImpl(&in, out, throwOnError);
@@ -576,7 +583,7 @@ namespace NJson {
                 return Impl.OnCloseArray();
             }
         };
-    }
+    } // namespace
 
     bool ReadJson(IInputStream* in, TJsonCallbacks* cbs) {
         return ReadJson(in, false, cbs);
@@ -629,4 +636,4 @@ namespace NJson {
         return out;
     }
 
-}
+} // namespace NJson
diff --git a/library/cpp/json/json_reader.h b/library/cpp/json/json_reader.h
index 88308f50f57..7423621f6b3 100644
--- a/library/cpp/json/json_reader.h
+++ b/library/cpp/json/json_reader.h
@@ -22,6 +22,8 @@ namespace NJson {
 #ifndef DISABLE_JSON_ESCAPE
         bool AllowEscapedApostrophe = false;
 #endif
+        // Allow to read Nan and Inf as integer values
+        bool AllowReadNanInf = false;
 
         ui64 MaxDepth = 0;
 
@@ -32,6 +34,11 @@ namespace NJson {
         size_t BufferSize;
     };
 
+    /*
+      The return value of the following functions indicates whether the JSON parsing is successful
+      unless 'throwOnError' parameter is set to 'true'.
+      In the latter case TJsonException is thrown in case of parsing errors.
+    */
     bool ReadJsonTree(TStringBuf in, TJsonValue* out, bool throwOnError = false);
     bool ReadJsonTree(TStringBuf in, bool allowComments, TJsonValue* out, bool throwOnError = false);
     bool ReadJsonTree(TStringBuf in, const TJsonReaderConfig* config, TJsonValue* out, bool throwOnError = false);
@@ -40,10 +47,18 @@ namespace NJson {
     bool ReadJsonTree(IInputStream* in, bool allowComments, TJsonValue* out, bool throwOnError = false);
     bool ReadJsonTree(IInputStream* in, const TJsonReaderConfig* config, TJsonValue* out, bool throwOnError = false);
 
+    /*
+      In case of parsing errors the behavior of the following functions will be:
+        If 'throwOnError' parameter is set to 'true' then TJsonException is thrown.
+        Otherwise an error is not reported and the return value is undefined.
+    */
     TJsonValue ReadJsonTree(IInputStream* in, bool throwOnError = false);
     TJsonValue ReadJsonTree(IInputStream* in, bool allowComments, bool throwOnError);
     TJsonValue ReadJsonTree(IInputStream* in, const TJsonReaderConfig* config, bool throwOnError = false);
 
+    /*
+      The return value of the following functions indicates whether the JSON parsing is successful
+    */
     bool ReadJson(IInputStream* in, TJsonCallbacks* callbacks);
     bool ReadJson(IInputStream* in, bool allowComments, TJsonCallbacks* callbacks);
 #ifndef DISABLE_JSON_ESCAPE
@@ -52,6 +67,7 @@ namespace NJson {
     bool ReadJson(IInputStream* in, const TJsonReaderConfig* config, TJsonCallbacks* callbacks);
 
     enum ReaderConfigFlags {
+        NANINF = 0b10000,
         ITERATIVE = 0b1000,
         COMMENTS = 0b0100,
         VALIDATE = 0b0010,
@@ -60,6 +76,11 @@ namespace NJson {
 #endif
     };
 
+    /*
+      The return value of the following functions indicates whether the JSON parsing is successful
+      unless 'throwOnError' parameter is set to 'true'.
+      In the latter case TJsonException is thrown in case of parsing errors.
+    */
     inline bool ValidateJson(IInputStream* in, const TJsonReaderConfig* config, bool throwOnError = false) {
         TJsonCallbacks c(throwOnError);
         return ReadJson(in, config, &c);
@@ -70,6 +91,9 @@ namespace NJson {
         return ValidateJson(&min, &config, throwOnError);
     }
 
+    /*
+      The following functions return 'true' if the JSON parsing is successful or throw TJsonException otherwise.
+    */
     inline bool ValidateJsonThrow(IInputStream* in, const TJsonReaderConfig* config) {
         return ValidateJson(in, config, true);
     }
@@ -137,4 +161,4 @@ namespace NJson {
     //// relaxed json, used in library/cpp/scheme
     bool ReadJsonFastTree(TStringBuf in, TJsonValue* out, bool throwOnError = false, bool notClosedBracketIsError = false);
     TJsonValue ReadJsonFastTree(TStringBuf in, bool notClosedBracketIsError = false);
-}
+} // namespace NJson
diff --git a/library/cpp/json/json_value.h b/library/cpp/json/json_value.h
index f70f4d2ee86..fb6f17d4500 100644
--- a/library/cpp/json/json_value.h
+++ b/library/cpp/json/json_value.h
@@ -1,3 +1,3 @@
 #pragma once
 
-#include <library/cpp/json/writer/json_value.h>
+#include <library/cpp/json/writer/json_value.h> // IWYU pragma: export
diff --git a/library/cpp/json/json_writer.cpp b/library/cpp/json/json_writer.cpp
index 3d058bae360..c185bc6389e 100644
--- a/library/cpp/json/json_writer.cpp
+++ b/library/cpp/json/json_writer.cpp
@@ -69,8 +69,9 @@ namespace NJson {
     }
 
     void TJsonWriter::Write(const TStringBuf& value) {
-        if (ValidateUtf8 && !IsUtf(value))
+        if (ValidateUtf8 && !IsUtf(value)) {
             throw yexception() << "JSON writer: invalid UTF-8";
+        }
         if (Buf.KeyExpected()) {
             Buf.WriteKey(value);
         } else {
@@ -106,14 +107,6 @@ namespace NJson {
         Buf.WriteBool(value);
     }
 
-    namespace {
-        struct TLessStrPtr {
-            bool operator()(const TString* a, const TString* b) const {
-                return *a < *b;
-            }
-        };
-    }
-
     void TJsonWriter::Write(const TJsonValue* v) {
         Buf.WriteJsonValue(v, SortKeys, FloatToStringMode, DoubleNDigits);
     }
@@ -125,13 +118,11 @@ namespace NJson {
     TString WriteJson(const TJsonValue* value, bool formatOutput, bool sortkeys, bool validateUtf8) {
         TStringStream ss;
         WriteJson(&ss, value, formatOutput, sortkeys, validateUtf8);
-        return ss.Str();
+        return std::move(ss).Str();
     }
 
     TString WriteJson(const TJsonValue& value, bool formatOutput, bool sortkeys, bool validateUtf8) {
-        TStringStream ss;
-        WriteJson(&ss, &value, formatOutput, sortkeys, validateUtf8);
-        return ss.Str();
+        return WriteJson(&value, formatOutput, sortkeys, validateUtf8);
     }
 
     void WriteJson(IOutputStream* out, const TJsonValue* val, bool formatOutput, bool sortkeys, bool validateUtf8) {
@@ -146,4 +137,4 @@ namespace NJson {
         w.Flush();
     }
 
-}
+} // namespace NJson
diff --git a/library/cpp/json/json_writer.h b/library/cpp/json/json_writer.h
index c7f5c9499a4..f7f380e545b 100644
--- a/library/cpp/json/json_writer.h
+++ b/library/cpp/json/json_writer.h
@@ -193,4 +193,4 @@ namespace NJson {
     TString WriteJson(const TJsonValue*, bool formatOutput = true, bool sortkeys = false, bool validateUtf8 = false);
     TString WriteJson(const TJsonValue&, bool formatOutput = true, bool sortkeys = false, bool validateUtf8 = false);
     void WriteJson(IOutputStream*, const TJsonValue*, const TJsonWriterConfig& config);
-}
+} // namespace NJson
diff --git a/library/cpp/json/rapidjson_helpers.h b/library/cpp/json/rapidjson_helpers.h
index aeb96ff6703..8fb1741f5e2 100644
--- a/library/cpp/json/rapidjson_helpers.h
+++ b/library/cpp/json/rapidjson_helpers.h
@@ -26,7 +26,7 @@ namespace NJson {
         }
     };
 
-    struct TInputStreamWrapper : TReadOnlyStreamBase {
+    struct TInputStreamWrapper: TReadOnlyStreamBase {
         Ch Peek() const {
             if (!Eof) {
                 if (Pos >= Sz) {
@@ -77,7 +77,7 @@ namespace NJson {
         size_t Count;
     };
 
-    struct TStringBufStreamWrapper : TReadOnlyStreamBase {
+    struct TStringBufStreamWrapper: TReadOnlyStreamBase {
         Ch Peek() const {
             return Pos < Data.size() ? Data[Pos] : 0;
         }
@@ -101,4 +101,4 @@ namespace NJson {
         TStringBuf Data;
         size_t Pos;
     };
-}
+} // namespace NJson
diff --git a/library/cpp/json/ut/json_prettifier_ut.cpp b/library/cpp/json/ut/json_prettifier_ut.cpp
index ae5f8dd81a4..03a3b09ee23 100644
--- a/library/cpp/json/ut/json_prettifier_ut.cpp
+++ b/library/cpp/json/ut/json_prettifier_ut.cpp
@@ -201,4 +201,4 @@ Y_UNIT_TEST_SUITE(JsonPrettifier) {
                                       true),
                                   "{g:{x:{a:{b:c,e:f},q:{x:y}},y:fff}}");
     }
-}
+} // Y_UNIT_TEST_SUITE(JsonPrettifier)
diff --git a/library/cpp/json/ut/json_reader_fast_ut.cpp b/library/cpp/json/ut/json_reader_fast_ut.cpp
index 60dffc91c73..7ec516bd838 100644
--- a/library/cpp/json/ut/json_reader_fast_ut.cpp
+++ b/library/cpp/json/ut/json_reader_fast_ut.cpp
@@ -86,7 +86,7 @@ namespace NJson {
 
         using TEvents = TVector<TEvent>;
 
-        struct TTestHandler : TJsonCallbacks {
+        struct TTestHandler: TJsonCallbacks {
             TEvents Events;
 
             bool OnOpenMap() override {
@@ -167,8 +167,8 @@ namespace NJson {
                 }
             }
         };
-    }
-}
+    } // namespace NTest
+} // namespace NJson
 
 class TFastJsonTest: public TTestBase {
     UNIT_TEST_SUITE(TFastJsonTest)
@@ -263,14 +263,14 @@ class TFastJsonTest: public TTestBase {
         DoTestParse<true>("{}", 2, E_DICT_OPEN, E_DICT_CLOSE);
         DoTestParse<true>("{ a : x, b : [ c, d, ] }", 9, E_DICT_OPEN, E_KEY, "a", E_STR, "x", E_KEY, "b", E_ARR_OPEN, E_STR, "c", E_STR, "d", E_ARR_CLOSE, E_DICT_CLOSE);
         DoTestParse<false>("{ a : x, b : [ c, d,, ] }", 8, E_DICT_OPEN, E_KEY, "a", E_STR, "x", E_KEY, "b", E_ARR_OPEN, E_STR, "c", E_STR, "d", E_ERROR, "invalid syntax at token: ','");
-        //        DoTestParse<false>("{ a : x : y }", 4, E_DICT_OPEN
-        //                    , E_KEY, "a", E_STR, "x"
-        //                    , E_ERROR
-        //                    , ":");
-        //        DoTestParse<false>("{queries:{ref:[]},{nonref:[]}}", 8, E_DICT_OPEN
-        //                           , E_KEY, "queries", E_DICT_OPEN
-        //                               , E_KEY, "ref", E_ARR_OPEN, E_ARR_CLOSE
-        //                               , E_DICT_CLOSE, E_ERROR, "");
+        // DoTestParse<false>("{ a : x : y }", 4, E_DICT_OPEN
+        //             , E_KEY, "a", E_STR, "x"
+        //             , E_ERROR
+        //             , ":");
+        // DoTestParse<false>("{queries:{ref:[]},{nonref:[]}}", 8, E_DICT_OPEN
+        //                    , E_KEY, "queries", E_DICT_OPEN
+        //                        , E_KEY, "ref", E_ARR_OPEN, E_ARR_CLOSE
+        //                        , E_DICT_CLOSE, E_ERROR, "");
         DoTestParse<true>("'100x00'", 1, E_STR, "100x00");
         DoTestParse<true>("-1", 1, E_INT, -1);
         DoTestParse<true>("-9223372036854775808", 1, E_LONG_LONG, (long long)Min<i64>());
diff --git a/library/cpp/json/ut/json_reader_nan_ut.cpp b/library/cpp/json/ut/json_reader_nan_ut.cpp
new file mode 100644
index 00000000000..2b1582b77f0
--- /dev/null
+++ b/library/cpp/json/ut/json_reader_nan_ut.cpp
@@ -0,0 +1,27 @@
+#include <library/cpp/json/json_reader.h>
+#include <library/cpp/testing/unittest/registar.h>
+
+using namespace NJson;
+
+namespace {
+
+    constexpr TStringBuf JSON_NAN_TEST = "{ \"Value1\": 0.0, \"Value2\": 1, \"Value3\": NaN }";
+
+} // namespace
+
+Y_UNIT_TEST_SUITE(TJsonReaderNanTest) {
+    Y_UNIT_TEST(WithoutNanTest) {
+        TJsonReaderConfig cfg;
+        TJsonValue out;
+        // This read will fail
+        UNIT_ASSERT(!ReadJsonTree(JSON_NAN_TEST, &cfg, &out, /* throwOnError */ false));
+    }
+    Y_UNIT_TEST(WithNanTest) {
+        TJsonReaderConfig cfg;
+        cfg.AllowReadNanInf = true;
+
+        TJsonValue out;
+        // This read will ok
+        UNIT_ASSERT(ReadJsonTree(JSON_NAN_TEST, &cfg, &out, /* throwOnError */ false));
+    }
+} // Y_UNIT_TEST_SUITE(TJsonReaderNanTest)
diff --git a/library/cpp/json/ut/json_reader_ut.cpp b/library/cpp/json/ut/json_reader_ut.cpp
index fa93f0ca79d..585e6643676 100644
--- a/library/cpp/json/ut/json_reader_ut.cpp
+++ b/library/cpp/json/ut/json_reader_ut.cpp
@@ -374,7 +374,7 @@ Y_UNIT_TEST_SUITE(TJsonReaderTest) {
             UNIT_ASSERT_EQUAL(value["test"].GetDouble(), 0.0);
             UNIT_ASSERT_EQUAL(value["test"].GetDoubleRobust(), static_cast<double>(Max<ui64>()));
         } // Max<ui64>()
-    }     // TJsonDoubleTest
+    } // TJsonDoubleTest
 
     Y_UNIT_TEST(TJsonInvalidTest) {
         {
@@ -473,12 +473,10 @@ Y_UNIT_TEST_SUITE(TJsonReaderTest) {
             UNIT_ASSERT(!ReadJsonTree(&jsonStream, &config, &v));
         }
     }
-}
-
+} // Y_UNIT_TEST_SUITE(TJsonReaderTest)
 
 static const TString YANDEX_STREAMING_JSON("{\"a\":1}//d{\"b\":2}");
 
-
 Y_UNIT_TEST_SUITE(TCompareReadJsonFast) {
     Y_UNIT_TEST(NoEndl) {
         NJson::TJsonValue parsed;
@@ -504,4 +502,4 @@ Y_UNIT_TEST_SUITE(TCompareReadJsonFast) {
         bool fast_success = NJson::ReadJsonFastTree(streamingJson, &parsed, false);
         UNIT_ASSERT(success != fast_success);
     }
-}
+} // Y_UNIT_TEST_SUITE(TCompareReadJsonFast)
diff --git a/library/cpp/json/ut/json_saveload_ut.cpp b/library/cpp/json/ut/json_saveload_ut.cpp
index b480a80fe4c..979469dfda0 100644
--- a/library/cpp/json/ut/json_saveload_ut.cpp
+++ b/library/cpp/json/ut/json_saveload_ut.cpp
@@ -7,7 +7,6 @@
 
 Y_UNIT_TEST_SUITE(JsonSaveLoad) {
     Y_UNIT_TEST(Serialize) {
-
         NJson::TJsonValue expected;
 
         expected["ui64"] = ui64(1);
@@ -33,4 +32,4 @@ Y_UNIT_TEST_SUITE(JsonSaveLoad) {
 
         UNIT_ASSERT_EQUAL_C(expected, load, "expected: " << expected << ", got: " << load);
     }
-}
+} // Y_UNIT_TEST_SUITE(JsonSaveLoad)
diff --git a/library/cpp/json/ut/json_writer_ut.cpp b/library/cpp/json/ut/json_writer_ut.cpp
index ca11d34dad9..4dcee17230a 100644
--- a/library/cpp/json/ut/json_writer_ut.cpp
+++ b/library/cpp/json/ut/json_writer_ut.cpp
@@ -120,7 +120,7 @@ Y_UNIT_TEST_SUITE(TJsonWriterTest) {
             WriteJson(&out, &v);
             UNIT_ASSERT_VALUES_EQUAL(out.Str(), expected);
         } // 18446744073709551615
-    }     // SimpleUnsignedIntegerWriteTest
+    } // SimpleUnsignedIntegerWriteTest
 
     Y_UNIT_TEST(WriteOptionalTest) {
         {
@@ -225,4 +225,4 @@ Y_UNIT_TEST_SUITE(TJsonWriterTest) {
             UNIT_ASSERT_VALUES_EQUAL(actual, expected);
         }
     }
-}
+} // Y_UNIT_TEST_SUITE(TJsonWriterTest)
diff --git a/library/cpp/json/writer/fwd.h b/library/cpp/json/writer/fwd.h
new file mode 100644
index 00000000000..752083547c7
--- /dev/null
+++ b/library/cpp/json/writer/fwd.h
@@ -0,0 +1,5 @@
+#pragma once
+
+namespace NJson {
+    class TJsonValue;
+} // namespace NJson
diff --git a/library/cpp/json/writer/json.cpp b/library/cpp/json/writer/json.cpp
index a732e470521..0b2a6e1b47b 100644
--- a/library/cpp/json/writer/json.cpp
+++ b/library/cpp/json/writer/json.cpp
@@ -25,7 +25,6 @@ namespace NJsonWriter {
             StringStream.Reset(new TStringStream);
             Stream = StringStream.Get();
         }
-
         Stack.reserve(64); // should be enough for most cases
         StackPush(JE_OUTER_SPACE);
     }
@@ -84,12 +83,13 @@ namespace NJsonWriter {
     }
 
     void TBuf::PrintIndentation(bool closing) {
-        if (!IndentSpaces)
+        if (!IndentSpaces) {
             return;
+        }
         const int indentation = IndentSpaces * (Stack.size() - 1);
-        if (!indentation && !closing)
+        if (!indentation && !closing) {
             return;
-
+        }
         PrintWhitespaces(Max(0, indentation), true);
     }
 
@@ -103,7 +103,7 @@ namespace NJsonWriter {
             const TStringBuf buffer = whitespacesTemplate.SubString(prependWithNewLine ? 0 : 1, count);
             count -= buffer.size();
             UnsafeWriteRawBytes(buffer);
-            prependWithNewLine = false;  // skip '\n' in subsequent writes
+            prependWithNewLine = false; // skip '\n' in subsequent writes
         } while (count > 0);
     }
 
@@ -282,7 +282,7 @@ namespace NJsonWriter {
                 }
             }
         };
-    }
+    } // namespace
 
     inline void TBuf::WriteBareString(const TStringBuf s, EHtmlEscapeMode hem) {
         RawWriteChar('"');
@@ -320,10 +320,10 @@ namespace NJsonWriter {
         RawWriteChar(hexDigits[(c & 0x0f)]);
     }
 
-#define MATCH(sym, string)                        \
-    case sym:                                     \
-        UnsafeWriteRawBytes(beg, cur - beg);      \
-        UnsafeWriteRawBytes(TStringBuf(string));  \
+#define MATCH(sym, string)                       \
+    case sym:                                    \
+        UnsafeWriteRawBytes(beg, cur - beg);     \
+        UnsafeWriteRawBytes(TStringBuf(string)); \
         return true
 
     inline bool TBuf::EscapedWriteChar(const char* beg, const char* cur, EHtmlEscapeMode hem) {
@@ -336,12 +336,11 @@ namespace NJsonWriter {
                 MATCH('>', "&gt;");
                 MATCH('&', "&amp;");
             }
-            //for other characters, we fall through to the non-HTML-escaped part
+            // for other characters, we fall through to the non-HTML-escaped part
         }
-
-        if (hem == HEM_RELAXED && c == '/')
+        if (hem == HEM_RELAXED && c == '/') {
             return false;
-
+        }
         if (hem != HEM_UNSAFE) {
             switch (c) {
                 case '/':
@@ -357,7 +356,6 @@ namespace NJsonWriter {
             }
             // for other characters, fall through to the non-escaped part
         }
-
         switch (c) {
             MATCH('"', "\\\"");
             MATCH('\\', "\\\\");
@@ -372,7 +370,6 @@ namespace NJsonWriter {
             WriteHexEscape(c);
             return true;
         }
-
         return false;
     }
 
@@ -407,8 +404,9 @@ namespace NJsonWriter {
             case JSON_ARRAY: {
                 BeginList();
                 const TJsonValue::TArray& arr = v->GetArray();
-                for (const auto& it : arr)
+                for (const auto& it : arr) {
                     WriteJsonValue(&it, sortKeys, mode, ndigits);
+                }
                 EndList();
                 break;
             }
@@ -513,5 +511,4 @@ namespace NJsonWriter {
         NeedNewline = from.NeedNewline;
         Stack.swap(from.Stack);
     }
-
-}
+} // namespace NJsonWriter
diff --git a/library/cpp/json/writer/json.h b/library/cpp/json/writer/json.h
index 0aae2531b94..6e2f6c28f9c 100644
--- a/library/cpp/json/writer/json.h
+++ b/library/cpp/json/writer/json.h
@@ -1,5 +1,7 @@
 #pragma once
 
+#include <library/cpp/json/writer/fwd.h>
+
 #include <util/generic/noncopyable.h>
 #include <util/generic/ptr.h>
 #include <util/generic/string.h>
@@ -8,12 +10,8 @@
 #include <util/stream/str.h>
 #include <util/string/cast.h>
 
-namespace NJson {
-    class TJsonValue;
-}
-
 namespace NJsonWriter {
-    enum EJsonEntity : ui8 {
+    enum EJsonEntity: ui8 {
         JE_OUTER_SPACE = 1,
         JE_LIST,
         JE_OBJECT,
@@ -39,7 +37,7 @@ namespace NJsonWriter {
         TVector<EJsonEntity> Stack;
     };
 
-    class TBuf : TNonCopyable {
+    class TBuf: TNonCopyable {
     public:
         TBuf(EHtmlEscapeMode mode = HEM_DONT_ESCAPE_HTML, IOutputStream* stream = nullptr);
 
@@ -71,49 +69,49 @@ namespace NJsonWriter {
         TBuf& EndObject();
 
         /*** Indent the resulting JSON with spaces.
-           * By default (spaces==0) no formatting is done.                */
+         * By default (spaces==0) no formatting is done.                */
         TBuf& SetIndentSpaces(int spaces) {
             IndentSpaces = spaces;
             return *this;
         }
 
         /*** NaN and Inf are not valid json values,
-           * so if WriteNanAsString is set, writer would write string
-           * intead of throwing exception (default case)                  */
+         * so if WriteNanAsString is set, writer would write string
+         * intead of throwing exception (default case)                  */
         TBuf& SetWriteNanAsString(bool writeNanAsString = true) {
             WriteNanAsString = writeNanAsString;
             return *this;
         }
 
         /*** Return the string formed in the internal TStringStream.
-           * You may only call it if the `stream' parameter was NULL
-           * at construction time.                                        */
+         * You may only call it if the `stream' parameter was NULL
+         * at construction time.                                        */
         const TString& Str() const;
 
         /*** Dump and forget the string constructed so far.
-           * You may only call it if the `stream' parameter was NULL
-           * at construction time.                                        */
+         * You may only call it if the `stream' parameter was NULL
+         * at construction time.                                        */
         void FlushTo(IOutputStream* stream);
 
         /*** Write a literal string that represents a JSON value
-           * (string, number, object, array, bool, or null).
-           *
-           * Example:
-           * j.UnsafeWriteValue("[1, 2, 3, \"o'clock\", 4, \"o'clock rock\"]");
-           *
-           * As in all of the Unsafe* functions, no escaping is done.     */
+         * (string, number, object, array, bool, or null).
+         *
+         * Example:
+         * j.UnsafeWriteValue("[1, 2, 3, \"o'clock\", 4, \"o'clock rock\"]");
+         *
+         * As in all of the Unsafe* functions, no escaping is done.     */
         void UnsafeWriteValue(const TStringBuf& s);
         void UnsafeWriteValue(const char* s, size_t len);
 
         /*** When in the context of an object, write a literal string
-           * that represents a key:value pair (or several pairs).
-           *
-           * Example:
-           * j.BeginObject();
-           * j.UnsafeWritePair("\"adam\": \"male\", \"eve\": \"female\"");
-           * j.EndObject();
-           *
-           * As in all of the Unsafe* functions, no escaping is done.     */
+         * that represents a key:value pair (or several pairs).
+         *
+         * Example:
+         * j.BeginObject();
+         * j.UnsafeWritePair("\"adam\": \"male\", \"eve\": \"female\"");
+         * j.EndObject();
+         *
+         * As in all of the Unsafe* functions, no escaping is done.     */
         TPairContext UnsafeWritePair(const TStringBuf& s);
 
         /*** Copy the supplied string directly into the output stream.    */
@@ -286,4 +284,4 @@ namespace NJsonWriter {
     }
 
     TString WrapJsonToCallback(const TBuf& buf, TStringBuf callback);
-}
+} // namespace NJsonWriter
diff --git a/library/cpp/json/writer/json_ut.cpp b/library/cpp/json/writer/json_ut.cpp
index 1768e912249..564b9ac8adf 100644
--- a/library/cpp/json/writer/json_ut.cpp
+++ b/library/cpp/json/writer/json_ut.cpp
@@ -265,4 +265,4 @@ Y_UNIT_TEST_SUITE(JsonWriter) {
             UNIT_ASSERT_STRINGS_EQUAL(buf.Str(), R"({"\u003C\u003E&":"Ololo","<>&":"Ololo2"})");
         }
     }
-}
+} // Y_UNIT_TEST_SUITE(JsonWriter)
diff --git a/library/cpp/json/writer/json_value.cpp b/library/cpp/json/writer/json_value.cpp
index 6d57ef669a7..a5f23170a09 100644
--- a/library/cpp/json/writer/json_value.cpp
+++ b/library/cpp/json/writer/json_value.cpp
@@ -12,7 +12,7 @@
 #include <util/string/vector.h>
 #include <util/system/yassert.h>
 #include <util/ysaveload.h>
-#include <util/generic/bt_exception.h>
+#include <util/generic/yexception.h>
 
 static bool
 AreJsonMapsEqual(const NJson::TJsonValue& lhs, const NJson::TJsonValue& rhs) {
@@ -20,25 +20,25 @@ AreJsonMapsEqual(const NJson::TJsonValue& lhs, const NJson::TJsonValue& rhs) {
 
     Y_ABORT_UNLESS(lhs.GetType() == JSON_MAP, "lhs has not a JSON_MAP type.");
 
-    if (rhs.GetType() != JSON_MAP)
+    if (rhs.GetType() != JSON_MAP) {
         return false;
-
+    }
     typedef TJsonValue::TMapType TMapType;
     const TMapType& lhsMap = lhs.GetMap();
     const TMapType& rhsMap = rhs.GetMap();
 
-    if (lhsMap.size() != rhsMap.size())
+    if (lhsMap.size() != rhsMap.size()) {
         return false;
-
+    }
     for (const auto& lhsIt : lhsMap) {
         TMapType::const_iterator rhsIt = rhsMap.find(lhsIt.first);
-        if (rhsIt == rhsMap.end())
+        if (rhsIt == rhsMap.end()) {
             return false;
-
-        if (lhsIt.second != rhsIt->second)
+        }
+        if (lhsIt.second != rhsIt->second) {
             return false;
+        }
     }
-
     return true;
 }
 
@@ -48,22 +48,22 @@ AreJsonArraysEqual(const NJson::TJsonValue& lhs, const NJson::TJsonValue& rhs) {
 
     Y_ABORT_UNLESS(lhs.GetType() == JSON_ARRAY, "lhs has not a JSON_ARRAY type.");
 
-    if (rhs.GetType() != JSON_ARRAY)
+    if (rhs.GetType() != JSON_ARRAY) {
         return false;
-
+    }
     typedef TJsonValue::TArray TArray;
     const TArray& lhsArray = lhs.GetArray();
     const TArray& rhsArray = rhs.GetArray();
 
-    if (lhsArray.size() != rhsArray.size())
+    if (lhsArray.size() != rhsArray.size()) {
         return false;
-
+    }
     for (TArray::const_iterator lhsIt = lhsArray.begin(), rhsIt = rhsArray.begin();
          lhsIt != lhsArray.end(); ++lhsIt, ++rhsIt) {
-        if (*lhsIt != *rhsIt)
+        if (*lhsIt != *rhsIt) {
             return false;
+        }
     }
-
     return true;
 }
 
@@ -106,16 +106,18 @@ namespace NJson {
     }
 
     TJsonValue& TJsonValue::operator=(const TJsonValue& val) {
-        if (this == &val)
+        if (this == &val) {
             return *this;
+        }
         TJsonValue tmp(val);
         tmp.Swap(*this);
         return *this;
     }
 
     TJsonValue& TJsonValue::operator=(TJsonValue&& val) noexcept {
-        if (this == &val)
+        if (this == &val) {
             return *this;
+        }
         TJsonValue tmp(std::move(val));
         tmp.Swap(*this);
         return *this;
@@ -181,12 +183,11 @@ namespace NJson {
     }
 
     TJsonValue& TJsonValue::SetType(const EJsonValueType type) {
-        if (Type == type)
+        if (Type == type) {
             return *this;
-
+        }
         Clear();
         Type = type;
-
         switch (Type) {
             case JSON_STRING:
                 new (&Value.String) TString();
@@ -205,7 +206,6 @@ namespace NJson {
             case JSON_DOUBLE:
                 break;
         }
-
         return *this;
     }
 
@@ -273,8 +273,9 @@ namespace NJson {
     void TJsonValue::EraseValue(const TStringBuf key) {
         if (IsMap()) {
             TMapType::iterator it = Value.Map->find(key);
-            if (it != Value.Map->end())
+            if (it != Value.Map->end()) {
                 Value.Map->erase(it);
+            }
         }
     }
 
@@ -313,8 +314,9 @@ namespace NJson {
 
     TJsonValue& TJsonValue::operator[](const size_t idx) {
         SetType(JSON_ARRAY);
-        if (Value.Array->size() <= idx)
+        if (Value.Array->size() <= idx) {
             Value.Array->resize(idx + 1);
+        }
         return (*Value.Array)[idx];
     }
 
@@ -330,21 +332,21 @@ namespace NJson {
             const TJsonValue::TArray Array{};
             const TJsonValue Value{};
         };
-    }
+    } // namespace
 
     const TJsonValue& TJsonValue::operator[](const size_t idx) const noexcept {
         const TJsonValue* ret = nullptr;
-        if (GetValuePointer(idx, &ret))
+        if (GetValuePointer(idx, &ret)) {
             return *ret;
-
+        }
         return Singleton<TDefaultsHolder>()->Value;
     }
 
     const TJsonValue& TJsonValue::operator[](const TStringBuf& key) const noexcept {
         const TJsonValue* ret = nullptr;
-        if (GetValuePointer(key, &ret))
+        if (GetValuePointer(key, &ret)) {
             return *ret;
-
+        }
         return Singleton<TDefaultsHolder>()->Value;
     }
 
@@ -353,9 +355,9 @@ namespace NJson {
     }
 
     long long TJsonValue::GetInteger() const {
-        if (!IsInteger())
+        if (!IsInteger()) {
             return 0;
-
+        }
         switch (Type) {
             case JSON_INTEGER:
                 return Value.Integer;
@@ -373,19 +375,16 @@ namespace NJson {
     }
 
     unsigned long long TJsonValue::GetUInteger() const {
-        if (!IsUInteger())
+        if (!IsUInteger()) {
             return 0;
-
+        }
         switch (Type) {
             case JSON_UINTEGER:
                 return Value.UInteger;
-
             case JSON_INTEGER:
                 return Value.Integer;
-
             case JSON_DOUBLE:
                 return Value.Double;
-
             default:
                 Y_ASSERT(false && "Unexpected type.");
                 return 0;
@@ -393,19 +392,16 @@ namespace NJson {
     }
 
     double TJsonValue::GetDouble() const {
-        if (!IsDouble())
+        if (!IsDouble()) {
             return 0.0;
-
+        }
         switch (Type) {
             case JSON_DOUBLE:
                 return Value.Double;
-
             case JSON_INTEGER:
                 return Value.Integer;
-
             case JSON_UINTEGER:
                 return Value.UInteger;
-
             default:
                 Y_ASSERT(false && "Unexpected type.");
                 return 0.0;
@@ -425,79 +421,86 @@ namespace NJson {
     }
 
     bool TJsonValue::GetBooleanSafe() const {
-        if (Type != JSON_BOOLEAN)
+        if (Type != JSON_BOOLEAN) {
             ythrow TJsonException() << "Not a boolean";
-
+        }
         return Value.Boolean;
     }
 
     long long TJsonValue::GetIntegerSafe() const {
-        if (!IsInteger())
+        if (!IsInteger()) {
             ythrow TJsonException() << "Not an integer";
-
+        }
         return GetInteger();
     }
 
     unsigned long long TJsonValue::GetUIntegerSafe() const {
-        if (!IsUInteger())
+        if (!IsUInteger()) {
             ythrow TJsonException() << "Not an unsigned integer";
-
+        }
         return GetUInteger();
     }
 
     double TJsonValue::GetDoubleSafe() const {
-        if (!IsDouble())
+        if (!IsDouble()) {
             ythrow TJsonException() << "Not a double";
-
+        }
         return GetDouble();
     }
 
     const TString& TJsonValue::GetStringSafe() const {
-        if (Type != JSON_STRING)
+        if (Type != JSON_STRING) {
             ythrow TJsonException() << "Not a string";
+        }
+        return Value.String;
+    }
 
+    TString& TJsonValue::GetStringSafe() {
+        if (!IsString()) {
+            ythrow TJsonException() << "Not a string";
+        }
         return Value.String;
     }
 
     bool TJsonValue::GetBooleanSafe(const bool defaultValue) const {
-        if (Type == JSON_UNDEFINED)
+        if (Type == JSON_UNDEFINED) {
             return defaultValue;
-
+        }
         return GetBooleanSafe();
     }
 
     long long TJsonValue::GetIntegerSafe(const long long defaultValue) const {
-        if (Type == JSON_UNDEFINED)
+        if (Type == JSON_UNDEFINED) {
             return defaultValue;
-
+        }
         return GetIntegerSafe();
     }
 
     unsigned long long TJsonValue::GetUIntegerSafe(const unsigned long long defaultValue) const {
-        if (Type == JSON_UNDEFINED)
+        if (Type == JSON_UNDEFINED) {
             return defaultValue;
-
+        }
         return GetUIntegerSafe();
     }
 
     double TJsonValue::GetDoubleSafe(const double defaultValue) const {
-        if (Type == JSON_UNDEFINED)
+        if (Type == JSON_UNDEFINED) {
             return defaultValue;
-
+        }
         return GetDoubleSafe();
     }
 
     TString TJsonValue::GetStringSafe(const TString& defaultValue) const {
-        if (Type == JSON_UNDEFINED)
+        if (Type == JSON_UNDEFINED) {
             return defaultValue;
-
+        }
         return GetStringSafe();
     }
 
     const TJsonValue::TMapType& TJsonValue::GetMapSafe() const {
-        if (Type != JSON_MAP)
+        if (Type != JSON_MAP) {
             ythrow TJsonException() << "Not a map";
-
+        }
         return *Value.Map;
     }
 
@@ -506,9 +509,9 @@ namespace NJson {
     }
 
     const TJsonValue::TArray& TJsonValue::GetArraySafe() const {
-        if (Type != JSON_ARRAY)
+        if (Type != JSON_ARRAY) {
             ythrow TJsonException() << "Not an array";
-
+        }
         return *Value.Array;
     }
 
@@ -646,73 +649,73 @@ namespace NJson {
     }
 
     bool TJsonValue::GetBoolean(bool* value) const noexcept {
-        if (Type != JSON_BOOLEAN)
+        if (Type != JSON_BOOLEAN) {
             return false;
-
+        }
         *value = Value.Boolean;
         return true;
     }
 
     bool TJsonValue::GetInteger(long long* value) const noexcept {
-        if (!IsInteger())
+        if (!IsInteger()) {
             return false;
-
+        }
         *value = GetInteger();
         return true;
     }
 
     bool TJsonValue::GetUInteger(unsigned long long* value) const noexcept {
-        if (!IsUInteger())
+        if (!IsUInteger()) {
             return false;
-
+        }
         *value = GetUInteger();
         return true;
     }
 
     bool TJsonValue::GetDouble(double* value) const noexcept {
-        if (!IsDouble())
+        if (!IsDouble()) {
             return false;
-
+        }
         *value = GetDouble();
         return true;
     }
 
     bool TJsonValue::GetString(TString* value) const {
-        if (Type != JSON_STRING)
+        if (Type != JSON_STRING) {
             return false;
-
+        }
         *value = Value.String;
         return true;
     }
 
     bool TJsonValue::GetMap(TJsonValue::TMapType* value) const {
-        if (Type != JSON_MAP)
+        if (Type != JSON_MAP) {
             return false;
-
+        }
         *value = *Value.Map;
         return true;
     }
 
     bool TJsonValue::GetArray(TJsonValue::TArray* value) const {
-        if (Type != JSON_ARRAY)
+        if (Type != JSON_ARRAY) {
             return false;
-
+        }
         *value = *Value.Array;
         return true;
     }
 
     bool TJsonValue::GetMapPointer(const TJsonValue::TMapType** value) const noexcept {
-        if (Type != JSON_MAP)
+        if (Type != JSON_MAP) {
             return false;
-
+        }
         *value = Value.Map;
         return true;
     }
 
     bool TJsonValue::GetArrayPointer(const TJsonValue::TArray** value) const noexcept {
-        if (Type != JSON_ARRAY)
+        if (Type != JSON_ARRAY) {
             return false;
-
+        }
         *value = Value.Array;
         return true;
     }
@@ -770,13 +773,10 @@ namespace NJson {
         switch (Type) {
             case JSON_INTEGER:
                 return true;
-
             case JSON_UINTEGER:
                 return (Value.UInteger <= static_cast<unsigned long long>(Max<long long>()));
-
             case JSON_DOUBLE:
                 return ((long long)Value.Double == Value.Double);
-
             default:
                 return false;
         }
@@ -786,13 +786,10 @@ namespace NJson {
         switch (Type) {
             case JSON_UINTEGER:
                 return true;
-
             case JSON_INTEGER:
                 return (Value.Integer >= 0);
-
             case JSON_DOUBLE:
                 return ((unsigned long long)Value.Double == Value.Double);
-
             default:
                 return false;
         }
@@ -804,13 +801,10 @@ namespace NJson {
         switch (Type) {
             case JSON_DOUBLE:
                 return true;
-
             case JSON_INTEGER:
                 return (1ll << std::numeric_limits<double>::digits) >= Abs(Value.Integer);
-
             case JSON_UINTEGER:
                 return (1ull << std::numeric_limits<double>::digits) >= Value.UInteger;
-
             default:
                 return false;
         }
@@ -825,7 +819,7 @@ namespace NJson {
         template <class TPtr, class T>
         TPtr* CreateOrNullptr(const TPtr* p, T key, std::false_type /*create*/) noexcept {
             const TPtr* const next = &(*p)[key];
-            return next->IsDefined() ? const_cast<TPtr*>(next) : nullptr;
+            return next->GetType() != JSON_UNDEFINED ? const_cast<TPtr*>(next) : nullptr;
         }
 
         template <bool Create, class TJsonPtr>
@@ -836,19 +830,34 @@ namespace NJson {
             constexpr std::integral_constant<bool, Create> create_tag{};
 
             while (!path.empty()) {
-                size_t index = 0;
+                i64 index = 0;
                 const TStringBuf step = path.NextTok(delimiter);
                 if (step.size() > 2 && *step.begin() == '[' && step.back() == ']' && TryFromString(step.substr(1, step.size() - 2), index)) {
+                    if (index < 0) {
+                        if constexpr (Create) {
+                            currentJson->SetType(JSON_ARRAY);
+                            TJsonArray::TArray& dst = currentJson->GetArraySafe();
+                            while (i64(dst.size()) < -index) {
+                                dst.push_front({JSON_NULL});
+                            }
+                        }
+                        index = i64(currentJson->GetArray().size()) - (-index);
+                    }
+                    if (index < 0) {
+                        return nullptr;
+                    }
                     currentJson = CreateOrNullptr(currentJson, index, create_tag);
+                } else if (Create && step == "[]") {
+                    if constexpr (Create) {
+                        currentJson = &currentJson->AppendValue({});
+                    }
                 } else {
                     currentJson = CreateOrNullptr(currentJson, step, create_tag);
                 }
-
                 if (!currentJson) {
                     return nullptr;
                 }
             }
-
             return currentJson;
         }
     } // anonymous namespace
@@ -883,6 +892,11 @@ namespace NJson {
     const TJsonValue* TJsonValue::GetValueByPath(const TStringBuf key, char delim) const noexcept {
         return GetValuePtrByPath<false>(this, key, delim);
     }
+    TJsonValue& TJsonValue::GetValueByPathOrCreate(TStringBuf path, char delimiter) noexcept {
+        TJsonValue* const ptr = GetValuePtrByPath<true>(this, path, delimiter);
+        Y_ASSERT(ptr);
+        return *ptr;
+    }
 
     TJsonValue* TJsonValue::GetValueByPath(const TStringBuf key, char delim) noexcept {
         return GetValuePtrByPath<false>(this, key, delim);
@@ -892,7 +906,6 @@ namespace NJson {
         if (!callback.Do(path, parent, *this)) {
             return;
         }
-
         if (Type == JSON_MAP) {
             for (auto&& i : *Value.Map) {
                 i.second.DoScan(!!path ? TString::Join(path, ".", i.first) : i.first, this, callback);
@@ -930,40 +943,24 @@ namespace NJson {
 
     bool TJsonValue::operator==(const TJsonValue& rhs) const {
         switch (Type) {
-            case JSON_UNDEFINED: {
+            case JSON_UNDEFINED:
                 return (rhs.GetType() == JSON_UNDEFINED);
-            }
-
-            case JSON_NULL: {
+            case JSON_NULL:
                 return rhs.IsNull();
-            }
-
-            case JSON_BOOLEAN: {
+            case JSON_BOOLEAN:
                 return (rhs.IsBoolean() && Value.Boolean == rhs.Value.Boolean);
-            }
-
-            case JSON_INTEGER: {
+            case JSON_INTEGER:
                 return (rhs.IsInteger() && GetInteger() == rhs.GetInteger());
-            }
-
-            case JSON_UINTEGER: {
+            case JSON_UINTEGER:
                 return (rhs.IsUInteger() && GetUInteger() == rhs.GetUInteger());
-            }
-
-            case JSON_STRING: {
+            case JSON_STRING:
                 return (rhs.IsString() && Value.String == rhs.Value.String);
-            }
-
-            case JSON_DOUBLE: {
+            case JSON_DOUBLE:
                 return (rhs.IsDouble() && fabs(GetDouble() - rhs.GetDouble()) <= FLT_EPSILON);
-            }
-
             case JSON_MAP:
                 return AreJsonMapsEqual(*this, rhs);
-
             case JSON_ARRAY:
                 return AreJsonArraysEqual(*this, rhs);
-
             default:
                 Y_ASSERT(false && "Unknown type.");
                 return false;
@@ -978,7 +975,6 @@ namespace NJson {
         } else {
             std::memcpy(&output.Value, &Value, sizeof(Value));
         }
-
         output.Type = Type;
         Type = JSON_UNDEFINED;
     }
@@ -992,8 +988,10 @@ namespace NJson {
     void TJsonValue::Save(IOutputStream* s) const {
         ::Save(s, static_cast<ui8>(Type));
         switch (Type) {
-            case JSON_UNDEFINED:break;
-            case JSON_NULL:break;
+            case JSON_UNDEFINED:
+                break;
+            case JSON_NULL:
+                break;
             case JSON_BOOLEAN:
                 ::Save(s, Value.Boolean);
                 break;
@@ -1025,8 +1023,10 @@ namespace NJson {
             SetType(static_cast<EJsonValueType>(loadedType));
         }
         switch (Type) {
-            case JSON_UNDEFINED:break;
-            case JSON_NULL:break;
+            case JSON_UNDEFINED:
+                break;
+            case JSON_NULL:
+                break;
             case JSON_BOOLEAN:
                 ::Load(s, Value.Boolean);
                 break;
@@ -1055,48 +1055,49 @@ namespace NJson {
 
     bool GetMapPointer(const TJsonValue& jv, const size_t index, const TJsonValue::TMapType** value) {
         const TJsonValue* v;
-        if (!jv.GetValuePointer(index, &v) || !v->IsMap())
+        if (!jv.GetValuePointer(index, &v) || !v->IsMap()) {
             return false;
-
+        }
         *value = &v->GetMap();
         return true;
     }
 
     bool GetArrayPointer(const TJsonValue& jv, const size_t index, const TJsonValue::TArray** value) {
         const TJsonValue* v;
-        if (!jv.GetValuePointer(index, &v) || !v->IsArray())
+        if (!jv.GetValuePointer(index, &v) || !v->IsArray()) {
             return false;
-
+        }
         *value = &v->GetArray();
         return true;
     }
 
     bool GetMapPointer(const TJsonValue& jv, const TStringBuf key, const TJsonValue::TMapType** value) {
         const TJsonValue* v;
-        if (!jv.GetValuePointer(key, &v) || !v->IsMap())
+        if (!jv.GetValuePointer(key, &v) || !v->IsMap()) {
             return false;
-
+        }
         *value = &v->GetMap();
         return true;
     }
 
     bool GetArrayPointer(const TJsonValue& jv, const TStringBuf key, const TJsonValue::TArray** value) {
         const TJsonValue* v;
-        if (!jv.GetValuePointer(key, &v) || !v->IsArray())
+        if (!jv.GetValuePointer(key, &v) || !v->IsArray()) {
             return false;
-
+        }
         *value = &v->GetArray();
         return true;
     }
 
     void TJsonValue::BackChecks() const {
-        if (Type != JSON_ARRAY)
+        if (Type != JSON_ARRAY) {
             ythrow TJsonException() << "Not an array";
-
-        if (Value.Array->empty())
+        }
+        if (Value.Array->empty()) {
             ythrow TJsonException() << "Get back on empty array";
+        }
     }
-}
+} // namespace NJson
 
 template <>
 void Out<NJson::TJsonValue>(IOutputStream& out, const NJson::TJsonValue& v) {
diff --git a/library/cpp/json/writer/json_value.h b/library/cpp/json/writer/json_value.h
index 80aa59b985c..f833b005669 100644
--- a/library/cpp/json/writer/json_value.h
+++ b/library/cpp/json/writer/json_value.h
@@ -1,5 +1,6 @@
 #pragma once
 
+#include <library/cpp/json/writer/fwd.h>
 #include <library/cpp/json/common/defs.h>
 
 #include <util/generic/string.h>
@@ -8,6 +9,7 @@
 #include <util/generic/deque.h>
 #include <util/generic/utility.h>
 #include <util/generic/yexception.h>
+#include <util/system/compiler.h>
 
 namespace NJson {
     enum EJsonValueType {
@@ -22,8 +24,6 @@ namespace NJson {
         JSON_UINTEGER /* "UInteger" */
     };
 
-    class TJsonValue;
-
     class IScanCallback {
     public:
         virtual ~IScanCallback() = default;
@@ -32,8 +32,6 @@ namespace NJson {
     };
 
     class TJsonValue {
-        void Clear() noexcept;
-
     public:
         typedef THashMap<TString, TJsonValue> TMapType;
         typedef TDeque<TJsonValue> TArray;
@@ -62,67 +60,75 @@ namespace NJson {
         TJsonValue(const TJsonValue& vval);
         TJsonValue(TJsonValue&& vval) noexcept;
 
-        TJsonValue& operator=(const TJsonValue& val);
-        TJsonValue& operator=(TJsonValue&& val) noexcept;
+        TJsonValue& operator=(const TJsonValue& val) Y_LIFETIME_BOUND;
+        TJsonValue& operator=(TJsonValue&& val) noexcept Y_LIFETIME_BOUND;
 
         ~TJsonValue() {
             Clear();
         }
 
         EJsonValueType GetType() const noexcept;
-        TJsonValue& SetType(EJsonValueType type);
+        TJsonValue& SetType(EJsonValueType type) Y_LIFETIME_BOUND;
 
-        TJsonValue& SetValue(const TJsonValue& value);
-        TJsonValue& SetValue(TJsonValue&& value);
+        TJsonValue& SetValue(const TJsonValue& value) Y_LIFETIME_BOUND;
+        TJsonValue& SetValue(TJsonValue&& value) Y_LIFETIME_BOUND;
 
         // for Map
-        TJsonValue& InsertValue(const TString& key, const TJsonValue& value);
-        TJsonValue& InsertValue(TStringBuf key, const TJsonValue& value);
-        TJsonValue& InsertValue(const char* key, const TJsonValue& value);
-        TJsonValue& InsertValue(const TString& key, TJsonValue&& value);
-        TJsonValue& InsertValue(TStringBuf key, TJsonValue&& value);
-        TJsonValue& InsertValue(const char* key, TJsonValue&& value);
+        TJsonValue& InsertValue(const TString& key, const TJsonValue& value) Y_LIFETIME_BOUND;
+        TJsonValue& InsertValue(TStringBuf key, const TJsonValue& value) Y_LIFETIME_BOUND;
+        TJsonValue& InsertValue(const char* key, const TJsonValue& value) Y_LIFETIME_BOUND;
+        TJsonValue& InsertValue(const TString& key, TJsonValue&& value) Y_LIFETIME_BOUND;
+        TJsonValue& InsertValue(TStringBuf key, TJsonValue&& value) Y_LIFETIME_BOUND;
+        TJsonValue& InsertValue(const char* key, TJsonValue&& value) Y_LIFETIME_BOUND;
 
         // for Array
-        TJsonValue& AppendValue(const TJsonValue& value);
-        TJsonValue& AppendValue(TJsonValue&& value);
-        TJsonValue& Back();
-        const TJsonValue& Back() const;
-
+        TJsonValue& AppendValue(const TJsonValue& value) Y_LIFETIME_BOUND;
+        TJsonValue& AppendValue(TJsonValue&& value) Y_LIFETIME_BOUND;
+        TJsonValue& Back() Y_LIFETIME_BOUND;
+        const TJsonValue& Back() const Y_LIFETIME_BOUND;
+
+        // path lookup syntax
+        //  1. steps delimited by delimiter char
+        //  2. if step is use square brackets `[1]` - array lookup by index will be performed
+        //    2.1 negative `[-1]` indexes allow to lookup array-items from end
+        //    2.2 empty brackets `[]` in modification methods allow to create an item
+        //  3. otherwise - dict lookup by string-key will be performed
         bool GetValueByPath(TStringBuf path, TJsonValue& result, char delimiter = '.') const;
         bool SetValueByPath(TStringBuf path, const TJsonValue& value, char delimiter = '.');
         bool SetValueByPath(TStringBuf path, TJsonValue&& value, char delimiter = '.');
 
         // returns NULL on failure
-        const TJsonValue* GetValueByPath(TStringBuf path, char delimiter = '.') const noexcept;
-        TJsonValue* GetValueByPath(TStringBuf path, char delimiter = '.') noexcept;
+        const TJsonValue* GetValueByPath(TStringBuf path, char delimiter = '.') const noexcept Y_LIFETIME_BOUND;
+        TJsonValue* GetValueByPath(TStringBuf path, char delimiter = '.') noexcept Y_LIFETIME_BOUND;
+        TJsonValue& GetValueByPathOrCreate(TStringBuf path, char delimiter = '.') noexcept Y_LIFETIME_BOUND;
 
         void EraseValue(TStringBuf key);
         void EraseValue(size_t index);
 
-        TJsonValue& operator[](size_t idx);
-        TJsonValue& operator[](const TStringBuf& key);
-        const TJsonValue& operator[](size_t idx) const noexcept;
-        const TJsonValue& operator[](const TStringBuf& key) const noexcept;
+        TJsonValue& operator[](size_t idx) Y_LIFETIME_BOUND;
+        TJsonValue& operator[](const TStringBuf& key) Y_LIFETIME_BOUND;
+        const TJsonValue& operator[](size_t idx) const noexcept Y_LIFETIME_BOUND;
+        const TJsonValue& operator[](const TStringBuf& key) const noexcept Y_LIFETIME_BOUND;
 
         bool GetBoolean() const;
         long long GetInteger() const;
         unsigned long long GetUInteger() const;
         double GetDouble() const;
-        const TString& GetString() const;
-        const TMapType& GetMap() const;
-        const TArray& GetArray() const;
+        const TString& GetString() const Y_LIFETIME_BOUND;
+        const TMapType& GetMap() const Y_LIFETIME_BOUND;
+        const TArray& GetArray() const Y_LIFETIME_BOUND;
 
-        //throwing TJsonException possible
+        // throwing TJsonException possible
         bool GetBooleanSafe() const;
         long long GetIntegerSafe() const;
         unsigned long long GetUIntegerSafe() const;
         double GetDoubleSafe() const;
-        const TString& GetStringSafe() const;
-        const TMapType& GetMapSafe() const;
-        TMapType& GetMapSafe();
-        const TArray& GetArraySafe() const;
-        TArray& GetArraySafe();
+        const TString& GetStringSafe() const Y_LIFETIME_BOUND;
+        TString& GetStringSafe() Y_LIFETIME_BOUND;
+        const TMapType& GetMapSafe() const Y_LIFETIME_BOUND;
+        TMapType& GetMapSafe() Y_LIFETIME_BOUND;
+        const TArray& GetArraySafe() const Y_LIFETIME_BOUND;
+        TArray& GetArraySafe() Y_LIFETIME_BOUND;
 
         bool GetBooleanSafe(bool defaultValue) const;
         long long GetIntegerSafe(long long defaultValue) const;
@@ -187,6 +193,18 @@ namespace NJson {
         // load using util/ysaveload.h serialization (not as JSON stream)
         void Load(IInputStream* s);
 
+    private:
+        void Clear() noexcept;
+
+        void DoScan(const TString& path, TJsonValue* parent, IScanCallback& callback);
+        void SwapWithUndefined(TJsonValue& output) noexcept;
+
+        /**
+            @throw yexception if Back shouldn't be called on the object.
+         */
+        void BackChecks() const;
+
+    public:
         static const TJsonValue UNDEFINED;
 
     private:
@@ -207,13 +225,6 @@ namespace NJson {
             }
         };
         TValueUnion Value;
-        void DoScan(const TString& path, TJsonValue* parent, IScanCallback& callback);
-        void SwapWithUndefined(TJsonValue& output) noexcept;
-
-        /**
-            @throw yexception if Back shouldn't be called on the object.
-         */
-        void BackChecks() const;
     };
 
     inline bool GetBoolean(const TJsonValue& jv, size_t index, bool* value) noexcept {
@@ -266,7 +277,8 @@ namespace NJson {
     public:
         TJsonMap()
             : TJsonValue(NJson::JSON_MAP)
-        {}
+        {
+        }
 
         TJsonMap(const std::initializer_list<std::pair<TString, TJsonValue>>& list)
             : TJsonValue(NJson::JSON_MAP)
@@ -279,7 +291,8 @@ namespace NJson {
     public:
         TJsonArray()
             : TJsonValue(NJson::JSON_ARRAY)
-        {}
+        {
+        }
 
         TJsonArray(const std::initializer_list<TJsonValue>& list)
             : TJsonValue(NJson::JSON_ARRAY)
@@ -287,4 +300,4 @@ namespace NJson {
             GetArraySafe() = TJsonValue::TArray(list);
         }
     };
-}
+} // namespace NJson
diff --git a/library/cpp/json/writer/json_value_ut.cpp b/library/cpp/json/writer/json_value_ut.cpp
index ef62d87abac..a7b0df5450b 100644
--- a/library/cpp/json/writer/json_value_ut.cpp
+++ b/library/cpp/json/writer/json_value_ut.cpp
@@ -8,10 +8,10 @@ using namespace NJson;
 
 Y_UNIT_TEST_SUITE(TJsonValueTest) {
     Y_UNIT_TEST(Equal) {
-         UNIT_ASSERT(1 == TJsonValue(1));
-         UNIT_ASSERT(TJsonValue(1) == 1);
-         UNIT_ASSERT(2 != TJsonValue(1));
-         UNIT_ASSERT(TJsonValue(1) != 2);
+        UNIT_ASSERT(1 == TJsonValue(1));
+        UNIT_ASSERT(TJsonValue(1) == 1);
+        UNIT_ASSERT(2 != TJsonValue(1));
+        UNIT_ASSERT(TJsonValue(1) != 2);
     }
 
     Y_UNIT_TEST(UndefTest) {
@@ -175,15 +175,16 @@ Y_UNIT_TEST_SUITE(TJsonValueTest) {
             const int NUM_KEYS = 1000;
 
             TJsonValue lhs;
-            for (int i = 0; i < NUM_KEYS; ++i)
+            for (int i = 0; i < NUM_KEYS; ++i) {
                 lhs.InsertValue(ToString(i), i);
-
+            }
             TJsonValue rhs;
-            for (int i = 0; i < NUM_KEYS; i += 2)
+            for (int i = 0; i < NUM_KEYS; i += 2) {
                 rhs.InsertValue(ToString(i), i);
-            for (int i = 1; i < NUM_KEYS; i += 2)
+            }
+            for (int i = 1; i < NUM_KEYS; i += 2) {
                 rhs.InsertValue(ToString(i), i);
-
+            }
             UNIT_ASSERT(lhs == rhs);
             UNIT_ASSERT(rhs == lhs);
         }
@@ -286,9 +287,43 @@ Y_UNIT_TEST_SUITE(TJsonValueTest) {
             UNIT_ASSERT(third.GetValueByPath("t.[2]", result));
             UNIT_ASSERT(result.GetStringRobust() == "g");
 
+            third.GetValueByPathOrCreate("t.[3]") = "7";
+            third.GetValueByPathOrCreate("t.[2]") = "4";
+            UNIT_ASSERT(third.GetValueByPath("t.[2]", result));
+            UNIT_ASSERT(result.GetStringRobust() == "4");
+            UNIT_ASSERT(third.GetValueByPath("t.[3]", result));
+            UNIT_ASSERT(result.GetStringRobust() == "7");
+
             UNIT_ASSERT(lhs.SetValueByPath("l/a/c/se", "h", '/'));
             UNIT_ASSERT(lhs.GetValueByPath("l/a/c/se", result, '/'));
             UNIT_ASSERT(result.GetStringRobust() == "h");
+
+            UNIT_ASSERT(lhs.SetValueByPath("l/b/[]", "new_array_elem1", '/'));
+            UNIT_ASSERT(lhs.SetValueByPath("l/b/[]", "new_array_elem2", '/'));
+            UNIT_ASSERT(lhs.GetValueByPath("l/b/[0]", result, '/'));
+            UNIT_ASSERT(result.GetStringRobust() == "new_array_elem1");
+            UNIT_ASSERT(lhs.GetValueByPath("l/b/[1]", result, '/'));
+            UNIT_ASSERT(result.GetStringRobust() == "new_array_elem2");
+
+            UNIT_ASSERT(lhs.GetValueByPath("l/b/[-1]", result, '/'));
+            UNIT_ASSERT(result.GetStringRobust() == "new_array_elem2");
+            UNIT_ASSERT(lhs.GetValueByPath("l/b/[-2]", result, '/'));
+            UNIT_ASSERT(result.GetStringRobust() == "new_array_elem1");
+            UNIT_ASSERT(!lhs.GetValueByPath("l/b/[-5]", result, '/'));
+
+            UNIT_ASSERT(lhs.SetValueByPath("l/b/[-5]", "new_array_elem_min5", '/'));
+
+            UNIT_ASSERT(lhs.GetValueByPath("l/b/[-1]", result, '/'));
+            UNIT_ASSERT(result.GetStringRobust() == "new_array_elem2");
+            UNIT_ASSERT(lhs.GetValueByPath("l/b/[-2]", result, '/'));
+            UNIT_ASSERT(result.GetStringRobust() == "new_array_elem1");
+            UNIT_ASSERT(lhs.GetValueByPath("l/b/[-5]", result, '/'));
+            UNIT_ASSERT(result.GetStringRobust() == "new_array_elem_min5");
+
+            UNIT_ASSERT(lhs.GetValueByPath("l/b/[-4]", result, '/'));
+            UNIT_ASSERT(result.GetStringRobust() == "null");
+            UNIT_ASSERT(lhs.GetValueByPath("l/b/[-3]", result, '/'));
+            UNIT_ASSERT(result.GetStringRobust() == "null");
         }
     }
 
@@ -654,4 +689,12 @@ Y_UNIT_TEST_SUITE(TJsonValueTest) {
         UNIT_ASSERT_VALUES_EQUAL(filled["4"].GetMapSafe().size(), 1);
         UNIT_ASSERT_VALUES_EQUAL(filled["4"]["5"], TJsonValue{5});
     }
-} // TJsonValueTest
+
+    Y_UNIT_TEST(GetStringSafeTest) {
+        TJsonValue json;
+        json["key"] = "value";
+        TString& valueRef = json["key"].GetStringSafe();
+        valueRef = "new_value";
+        UNIT_ASSERT_VALUES_EQUAL(json["key"].GetString(), "new_value");
+    }
+} // Y_UNIT_TEST_SUITE(TJsonValueTest)
diff --git a/library/cpp/logger/backend_creator.cpp b/library/cpp/logger/backend_creator.cpp
index ea430edb83a..f239fa57e28 100644
--- a/library/cpp/logger/backend_creator.cpp
+++ b/library/cpp/logger/backend_creator.cpp
@@ -2,7 +2,7 @@
 #include "stream.h"
 #include "uninitialized_creator.h"
 #include <util/system/yassert.h>
-#include <util/stream/debug.h>
+#include <util/stream/output.h>
 #include <util/stream/output.h>
 
 
diff --git a/library/cpp/logger/rotating_file.cpp b/library/cpp/logger/rotating_file.cpp
index bab6f0067c6..aa27e9a79bb 100644
--- a/library/cpp/logger/rotating_file.cpp
+++ b/library/cpp/logger/rotating_file.cpp
@@ -6,7 +6,8 @@
 #include <util/system/fstat.h>
 #include <util/system/rwlock.h>
 #include <util/system/fs.h>
-#include <library/cpp/deprecated/atomic/atomic.h>
+
+#include <atomic>
 
 /*
  * rotating file log
@@ -29,10 +30,10 @@ class TRotatingFileLogBackend::TImpl {
         Y_ENSURE(RotatedFilesCount_ != 0);
     }
 
-    inline void WriteData(const TLogRecord& rec) {
-        if (static_cast<ui64>(AtomicGet(Size_)) > MaxSizeBytes_) {
+    void WriteData(const TLogRecord& rec) {
+        if (Size_.load() > MaxSizeBytes_) {
             TWriteGuard guard(Lock_);
-            if (static_cast<ui64>(AtomicGet(Size_)) > MaxSizeBytes_) {
+            if (Y_LIKELY(Size_.load() > MaxSizeBytes_)) {
                 TString newLogPath(TStringBuilder{} << Path_ << "." << RotatedFilesCount_);
                 for (size_t fileId = RotatedFilesCount_ - 1; fileId; --fileId) {
                     TString oldLogPath(TStringBuilder{} << Path_ << "." << fileId);
@@ -41,19 +42,19 @@ class TRotatingFileLogBackend::TImpl {
                 }
                 NFs::Rename(Path_, newLogPath);
                 Log_.ReopenLog();
-                AtomicSet(Size_, 0);
+                Size_.store(0);
             }
         }
         TReadGuard guard(Lock_);
         Log_.WriteData(rec);
-        AtomicAdd(Size_, rec.Len);
+        Size_ += rec.Len;
     }
 
-    inline void ReopenLog() {
+    void ReopenLog() {
         TWriteGuard guard(Lock_);
 
         Log_.ReopenLog();
-        AtomicSet(Size_, TFileStat(Path_).Size);
+        Size_.store(TFileStat(Path_).Size);
     }
 
 private:
@@ -61,7 +62,7 @@ class TRotatingFileLogBackend::TImpl {
     TFileLogBackend Log_;
     const TString Path_;
     const ui64 MaxSizeBytes_;
-    TAtomic Size_;
+    std::atomic<ui64> Size_;
     const ui32 RotatedFilesCount_;
 };
 
@@ -70,8 +71,7 @@ TRotatingFileLogBackend::TRotatingFileLogBackend(const TString& path, const ui64
 {
 }
 
-TRotatingFileLogBackend::~TRotatingFileLogBackend() {
-}
+TRotatingFileLogBackend::~TRotatingFileLogBackend() = default;
 
 void TRotatingFileLogBackend::WriteData(const TLogRecord& rec) {
     Impl_->WriteData(rec);
diff --git a/library/cpp/logger/sync_page_cache_file.cpp b/library/cpp/logger/sync_page_cache_file.cpp
index 1424159af74..7f262c7ee7b 100644
--- a/library/cpp/logger/sync_page_cache_file.cpp
+++ b/library/cpp/logger/sync_page_cache_file.cpp
@@ -1,26 +1,44 @@
 #include "sync_page_cache_file.h"
+
 #include "record.h"
 
 #include <util/generic/buffer.h>
 #include <util/generic/yexception.h>
+#include <util/system/align.h>
+#include <util/system/event.h>
 #include <util/system/file.h>
 #include <util/system/info.h>
 #include <util/system/mutex.h>
-#include <util/system/align.h>
+#include <util/system/thread.h>
 
 class TSyncPageCacheFileLogBackend::TImpl: public TNonCopyable {
 public:
-    TImpl(const TString& path, size_t maxBufferSize, size_t maxPendingCacheSize)
+    TImpl(
+        const TString& path,
+        size_t maxBufferSize,
+        size_t maxPendingCacheSize,
+        TMaybe<TDuration> bufferFlushPeriod
+    )
         : File_{OpenFile(path)}
         , MaxBufferSize_{maxBufferSize}
         , MaxPendingCacheSize_{maxPendingCacheSize}
         , Buffer_{maxBufferSize}
+        , BufferFlushPeriod_{bufferFlushPeriod}
     {
         ResetPtrs();
+
+        if (BufferFlushPeriod_) {
+            BufferFlushThreadPtr_ = MakeHolder<TThread>([this] {RunBufferFlushThread();});
+            BufferFlushThreadPtr_->Start();
+        }
     }
 
     ~TImpl() noexcept {
         try {
+            if (BufferFlushThreadPtr_) {
+                BufferFlushThreadExitWaiter_.Signal();
+            }
+
             Write();
             FlushSync(GuaranteedWrittenPtr_, WrittenPtr_);
         } catch (...) {
@@ -32,17 +50,7 @@ class TSyncPageCacheFileLogBackend::TImpl: public TNonCopyable {
 
         Buffer_.Append(rec.Data, rec.Len);
         if (Buffer_.size() >= MaxBufferSize_) {
-            const i64 prevAlignedEndPtr = PageAlignedWrittenPtr_;
-            Write();
-
-            if (prevAlignedEndPtr < PageAlignedWrittenPtr_) {
-                FlushAsync(prevAlignedEndPtr, PageAlignedWrittenPtr_);
-            }
-
-            const i64 minPendingCacheOffset = PageAlignedWrittenPtr_ - MaxPendingCacheSize_;
-            if (minPendingCacheOffset > GuaranteedWrittenPtr_) {
-                FlushSync(GuaranteedWrittenPtr_, minPendingCacheOffset);
-            }
+            WriteAndFlush();
         }
     }
 
@@ -101,6 +109,36 @@ class TSyncPageCacheFileLogBackend::TImpl: public TNonCopyable {
         GuaranteedWrittenPtr_ = to;
     }
 
+    void WriteAndFlush() {
+        const i64 prevAlignedEndPtr = PageAlignedWrittenPtr_;
+        Write();
+
+        if (prevAlignedEndPtr < PageAlignedWrittenPtr_) {
+            FlushAsync(prevAlignedEndPtr, PageAlignedWrittenPtr_);
+        }
+
+        const i64 minPendingCacheOffset = PageAlignedWrittenPtr_ - MaxPendingCacheSize_;
+        if (minPendingCacheOffset > GuaranteedWrittenPtr_) {
+            FlushSync(GuaranteedWrittenPtr_, minPendingCacheOffset);
+        }
+    }
+
+    void RunBufferFlushThread() {
+        Y_ENSURE(BufferFlushPeriod_);
+        TInstant deadline;
+        do {
+            deadline = TInstant::Now() + *BufferFlushPeriod_;
+            try {
+                TGuard guard{Lock_};
+                if (!Buffer_.Empty()) {
+                    WriteAndFlush();
+                }
+            } catch (...) {
+                Cerr << "Failed to flush eventlog buffer: " << CurrentExceptionMessage() << Endl;
+            }
+        } while (!BufferFlushThreadExitWaiter_.WaitD(deadline));
+    }
+
 private:
     TMutex Lock_;
     TFile File_;
@@ -112,10 +150,26 @@ class TSyncPageCacheFileLogBackend::TImpl: public TNonCopyable {
     i64 WrittenPtr_ = 0;
     i64 PageAlignedWrittenPtr_ = 0;
     i64 GuaranteedWrittenPtr_ = 0;
+
+    const TMaybe<TDuration> BufferFlushPeriod_;
+    TManualEvent BufferFlushThreadExitWaiter_;
+
+    // thread should be declared last to be destroyed before other props
+    THolder<TThread> BufferFlushThreadPtr_;
 };
 
-TSyncPageCacheFileLogBackend::TSyncPageCacheFileLogBackend(const TString& path, size_t maxBufferSize, size_t maxPengingCacheSize)
-    : Impl_(MakeHolder<TImpl>(path, maxBufferSize, maxPengingCacheSize))
+TSyncPageCacheFileLogBackend::TSyncPageCacheFileLogBackend(
+    const TString& path,
+    size_t maxBufferSize,
+    size_t maxPengingCacheSize,
+    TMaybe<TDuration> bufferFlushPeriod
+)
+    : Impl_(MakeHolder<TImpl>(
+        path,
+        maxBufferSize,
+        maxPengingCacheSize,
+        bufferFlushPeriod
+    ))
 {}
 
 TSyncPageCacheFileLogBackend::~TSyncPageCacheFileLogBackend() {
diff --git a/library/cpp/logger/sync_page_cache_file.h b/library/cpp/logger/sync_page_cache_file.h
index a36340651c7..e50aade08f9 100644
--- a/library/cpp/logger/sync_page_cache_file.h
+++ b/library/cpp/logger/sync_page_cache_file.h
@@ -2,12 +2,19 @@
 
 #include "backend.h"
 
+#include <util/datetime/base.h>
 #include <util/generic/fwd.h>
+#include <util/generic/maybe.h>
 #include <util/generic/ptr.h>
 
 class TSyncPageCacheFileLogBackend final: public TLogBackend {
 public:
-    TSyncPageCacheFileLogBackend(const TString& path, size_t maxBufferSize, size_t maxPendingCacheSize);
+    TSyncPageCacheFileLogBackend(
+        const TString& path,
+        size_t maxBufferSize,
+        size_t maxPendingCacheSize,
+        TMaybe<TDuration> bufferFlushPeriod = Nothing()
+    );
     ~TSyncPageCacheFileLogBackend();
 
     void WriteData(const TLogRecord& rec) override;
diff --git a/library/cpp/mime/types/mime.cpp b/library/cpp/mime/types/mime.cpp
index 39e5f2706cc..c56a3c5a3a2 100644
--- a/library/cpp/mime/types/mime.cpp
+++ b/library/cpp/mime/types/mime.cpp
@@ -78,7 +78,7 @@ const TMimeTypes::TRecord TMimeTypes::Records[] = {
     {MIME_ARCHIVE, "application/x-archive\0application/x-tar\0application/x-ustar\0application/x-gtar\0application/x-bzip2\0application/x-rar\0", "tar\0rar\0bzip2\0"},
     {MIME_EXE, "application/exe\0application/octet-stream\0application/x-dosexec\0application/x-msdownload\0", "exe\0"},
     {MIME_ODG, "application/vnd.oasis.opendocument.graphics\0", "odg\0"},
-    {MIME_GZIP, "application/x-gzip\0", "gz\0gzip\0"},
+    {MIME_GZIP, "application/x-gzip\0application/gzip\0", "gz\0gzip\0"},
     {MIME_XLSX, "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet\0", "xlsx\0"},
     {MIME_PPTX, "application/vnd.openxmlformats-officedocument.presentationml.presentation\0", "pptx\0"},
     {MIME_JAVASCRIPT, "application/javascript\0text/javascript\0", "js\0"},
@@ -103,6 +103,8 @@ const TMimeTypes::TRecord TMimeTypes::Records[] = {
     {MIME_CSV, "text/csv\0", "csv\0"},
     {MIME_VIDEO_MP4, "video/mp4\0", "mp4\0"},
     {MIME_VIDEO_AVI, "video/x-msvideo\0", "avi\0"},
+    {MIME_IMAGE_AVIF, "image/avif\0", "avif\0"},
+    {MIME_IMAGE_HEIC, "image/heic\0image/heif\0", "heic\0"},
     {MIME_MAX, nullptr, nullptr},
 
     // Additional records
@@ -258,4 +260,6 @@ const char* MimeNames[MIME_MAX] = {
     "csv",     // MIME_CSV             // 48
     "mp4",     // MIME_VIDEO_MP4       // 49
     "avi",     // MIME_VIDEO_AVI       // 50
+    "avif",    // MIME_IMAGE_AVIF      // 51
+    "heic",    // MIME_IMAGE_HEIC      // 52
 };
diff --git a/library/cpp/mime/types/mime.h b/library/cpp/mime/types/mime.h
index 8eaedd001b6..ea56c2ae4a7 100644
--- a/library/cpp/mime/types/mime.h
+++ b/library/cpp/mime/types/mime.h
@@ -62,6 +62,8 @@ enum MimeTypes {
     MIME_CSV = 48,
     MIME_VIDEO_MP4 = 49,
     MIME_VIDEO_AVI = 50,
+    MIME_IMAGE_AVIF = 51,
+    MIME_IMAGE_HEIC = 52,
     MIME_MAX
 };
 
diff --git a/library/cpp/monlib/dynamic_counters/CMakeLists.txt b/library/cpp/monlib/dynamic_counters/CMakeLists.txt
index eb288beb012..1de447b1caf 100644
--- a/library/cpp/monlib/dynamic_counters/CMakeLists.txt
+++ b/library/cpp/monlib/dynamic_counters/CMakeLists.txt
@@ -11,6 +11,7 @@ target_link_libraries(monlib-dynamic_counters
     monlib-encode-json
     monlib-encode-spack
     monlib-encode-prometheus
+    html-escape
     string_utils-quote
 )
 target_sources(monlib-dynamic_counters
diff --git a/library/cpp/monlib/dynamic_counters/counters.cpp b/library/cpp/monlib/dynamic_counters/counters.cpp
index 09455be2d78..3a1ceac70de 100644
--- a/library/cpp/monlib/dynamic_counters/counters.cpp
+++ b/library/cpp/monlib/dynamic_counters/counters.cpp
@@ -141,6 +141,18 @@ TIntrusivePtr<TDynamicCounters> TDynamicCounters::GetSubgroup(const TString& nam
     return res;
 }
 
+TIntrusivePtr<TDynamicCounters> TDynamicCounters::FindSubgroup(const TString& name) const {
+    TReadGuard g(Lock);
+    const auto it = Counters.lower_bound({name, TString()});
+    if (it != Counters.end() && it->first.LabelName == name) {
+        const auto it2 = std::next(it);
+        if (it2 == Counters.end() || it2->first.LabelName != name) {
+            return AsDynamicCounters(it->second);
+        }
+    }
+    return nullptr;
+}
+
 TIntrusivePtr<TDynamicCounters> TDynamicCounters::FindSubgroup(const TString& name, const TString& value) const {
     TReadGuard g(Lock);
     const auto it = Counters.find({name, value});
diff --git a/library/cpp/monlib/dynamic_counters/counters.h b/library/cpp/monlib/dynamic_counters/counters.h
index b15566c0342..d0e409f4b50 100644
--- a/library/cpp/monlib/dynamic_counters/counters.h
+++ b/library/cpp/monlib/dynamic_counters/counters.h
@@ -137,7 +137,7 @@ namespace NMonitoring {
             Visibility_ = vis;
         }
 
-        void Collect(i64 value) {
+        void Collect(double value) {
             Collector_->Collect(value);
         }
 
@@ -331,6 +331,7 @@ namespace NMonitoring {
         void RemoveSubgroupChain(const std::vector<std::pair<TString, TString>>& chain);
 
         TIntrusivePtr<TDynamicCounters> GetSubgroup(const TString& name, const TString& value);
+        TIntrusivePtr<TDynamicCounters> FindSubgroup(const TString& name) const;
         TIntrusivePtr<TDynamicCounters> FindSubgroup(const TString& name, const TString& value) const;
         bool RemoveSubgroup(const TString& name, const TString& value);
         void ReplaceSubgroup(const TString& name, const TString& value, TIntrusivePtr<TDynamicCounters> subgroup);
diff --git a/library/cpp/monlib/dynamic_counters/counters_ut.cpp b/library/cpp/monlib/dynamic_counters/counters_ut.cpp
index 3591037e0a7..f6041095851 100644
--- a/library/cpp/monlib/dynamic_counters/counters_ut.cpp
+++ b/library/cpp/monlib/dynamic_counters/counters_ut.cpp
@@ -339,4 +339,30 @@ Y_UNIT_TEST_SUITE(TDynamicCountersTest) {
         histogram = rootGroup->FindNamedHistogram("name", "histogram2");
         UNIT_ASSERT(histogram);
     }
+
+    Y_UNIT_TEST(FindSubgroup) {
+        TDynamicCounterPtr rootGroup(new TDynamicCounters());
+
+        auto a = rootGroup->GetSubgroup("a", "1");
+        auto b1 = rootGroup->GetSubgroup("b", "1");
+        auto b2 = rootGroup->GetSubgroup("b", "2");
+        auto c = rootGroup->GetSubgroup("c", "1");
+        auto e = rootGroup->GetSubgroup("e", "1");
+
+        UNIT_ASSERT(a == rootGroup->FindSubgroup("a"));
+        UNIT_ASSERT(a == rootGroup->FindSubgroup("a", "1"));
+        UNIT_ASSERT(nullptr == rootGroup->FindSubgroup("a", "2"));
+
+        UNIT_ASSERT(nullptr == rootGroup->FindSubgroup("b"));
+        UNIT_ASSERT(b1 == rootGroup->FindSubgroup("b", "1"));
+        UNIT_ASSERT(b2 == rootGroup->FindSubgroup("b", "2"));
+        UNIT_ASSERT(nullptr == rootGroup->FindSubgroup("b", "3"));
+
+        UNIT_ASSERT(c == rootGroup->FindSubgroup("c"));
+        UNIT_ASSERT(c == rootGroup->FindSubgroup("c", "1"));
+        UNIT_ASSERT(nullptr == rootGroup->FindSubgroup("c", "2"));
+
+        UNIT_ASSERT(nullptr == rootGroup->FindSubgroup("d"));
+        UNIT_ASSERT(nullptr == rootGroup->FindSubgroup("f"));
+    }
 }
diff --git a/library/cpp/monlib/dynamic_counters/encode_ut.cpp b/library/cpp/monlib/dynamic_counters/encode_ut.cpp
index 52d77b6b413..b1ef7df93a8 100644
--- a/library/cpp/monlib/dynamic_counters/encode_ut.cpp
+++ b/library/cpp/monlib/dynamic_counters/encode_ut.cpp
@@ -8,6 +8,7 @@
 #include <library/cpp/testing/unittest/registar.h>
 
 #include <util/generic/buffer.h>
+#include <util/generic/yexception.h>
 #include <util/stream/buffer.h>
 
 namespace NMonitoring {
@@ -221,6 +222,36 @@ namespace NMonitoring {
 
             AssertResult(samples);
         }
+
+        Y_UNIT_TEST(InvalidUtf8) {
+            TDynamicCounterPtr rootGroup1(new TDynamicCounters());
+            rootGroup1->GetNamedCounter("invalid\x80Utf8Name", "validUtf8");
+
+            {
+                TString result;
+                TStringOutput out(result);
+                auto encoder = CreateEncoder(&out, EFormat::JSON);
+                UNIT_ASSERT_EXCEPTION_CONTAINS(
+                    rootGroup1->Accept(TString(), TString(), *encoder),
+                    yexception,
+                    "label name is not valid UTF-8 string: 'invalid\\x80Utf8Name'"
+                );
+            }
+
+            TDynamicCounterPtr rootGroup2(new TDynamicCounters());
+            rootGroup2->GetNamedCounter("validUtf8Name", "invalid\x80Utf8");
+
+            {
+                TString result;
+                TStringOutput out(result);
+                auto encoder = CreateEncoder(&out, EFormat::JSON);
+                UNIT_ASSERT_EXCEPTION_CONTAINS(
+                    rootGroup2->Accept(TString(), TString(), *encoder),
+                    yexception,
+                    "label value is not valid UTF-8 string, name: 'validUtf8Name', value: 'invalid\\x80Utf8'"
+                );
+            }
+        }
     }
 
 }
diff --git a/library/cpp/monlib/dynamic_counters/page.cpp b/library/cpp/monlib/dynamic_counters/page.cpp
index c0d523248a7..eba8535fc18 100644
--- a/library/cpp/monlib/dynamic_counters/page.cpp
+++ b/library/cpp/monlib/dynamic_counters/page.cpp
@@ -1,9 +1,11 @@
 #include "page.h"
 #include "encode.h"
 
+#include <library/cpp/html/escape/escape.h>
 #include <library/cpp/monlib/service/pages/templates.h>
 #include <library/cpp/string_utils/quote/quote.h>
 
+#include <util/string/builder.h>
 #include <util/string/split.h>
 #include <util/system/tls.h>
 
@@ -26,6 +28,19 @@ TMaybe<EFormat> ParseFormat(TStringBuf str) {
     }
 }
 
+namespace {
+
+TStringBuf GetParams(NMonitoring::IMonHttpRequest& request) {
+    TStringBuf uri = request.GetUri();
+    TStringBuf params = uri.After('?');
+    if (params.Size() == uri.Size()) {
+        params.Clear();
+    }
+    return params;
+}
+
+}
+
 void TDynamicCountersPage::Output(NMonitoring::IMonHttpRequest& request) {
     if (OutputCallback) {
         OutputCallback();
@@ -37,28 +52,55 @@ void TDynamicCountersPage::Output(NMonitoring::IMonHttpRequest& request) {
     };
 
     TVector<TStringBuf> parts;
-    StringSplitter(request.GetPathInfo())
-        .Split('/')
-        .SkipEmpty()
-        .Collect(&parts);
-
-    TMaybe<EFormat> format = !parts.empty() ? ParseFormat(parts.back()) : Nothing();
-    if (format) {
-        parts.pop_back();
+    TMaybe<EFormat> format;
+    TString set;
+    TStringBuf params = GetParams(request);
+
+    if (!params.empty()) {
+        StringSplitter(params).Split('&').SkipEmpty().Consume([&](TStringBuf part) {
+            TStringBuf name;
+            TStringBuf value;
+            part.Split('=', name, value);
+            if (name.StartsWith("@")) {
+                if (name == "@format") {
+                    format = ParseFormat(value);
+                } else if (name == "@name_label") {
+                    nameLabel = value;
+                } else if (name == "@private") {
+                    visibility = TCountableBase::EVisibility::Private;
+                } else if (name == "@set") {
+                    set = value;
+                }
+            } else if (name == "labels") {
+                StringSplitter(value).Split(',').SkipEmpty().AddTo(&parts);
+            }
+            return true;
+        });
     }
+    if (!request.GetPathInfo().empty()) {
+        StringSplitter(request.GetPathInfo())
+            .Split('/')
+            .SkipEmpty()
+            .Collect(&parts);
 
-    if (!parts.empty() && parts.back().StartsWith(TStringBuf("name_label="))) {
-        TVector<TString> labels;
-        StringSplitter(parts.back()).Split('=').SkipEmpty().Collect(&labels);
-        if (labels.size() == 2U) {
-            nameLabel = labels.back();
+        format = !parts.empty() ? ParseFormat(parts.back()) : Nothing();
+        if (format) {
+            parts.pop_back();
         }
-        parts.pop_back();
-   }
 
-    if (!parts.empty() && parts.back() == TStringBuf("private")) {
-        visibility = TCountableBase::EVisibility::Private;
-        parts.pop_back();
+        if (!parts.empty() && parts.back().StartsWith(TStringBuf("name_label="))) {
+            TVector<TString> labels;
+            StringSplitter(parts.back()).Split('=').SkipEmpty().Collect(&labels);
+            if (labels.size() == 2U) {
+                nameLabel = labels.back();
+            }
+            parts.pop_back();
+        }
+
+        if (!parts.empty() && parts.back() == TStringBuf("private")) {
+            visibility = TCountableBase::EVisibility::Private;
+            parts.pop_back();
+        }
     }
 
     auto counters = Counters;
@@ -101,10 +143,18 @@ void TDynamicCountersPage::Output(NMonitoring::IMonHttpRequest& request) {
     }
 
     auto encoder = CreateEncoder(&out, *format, nameLabel, visibility);
+    if (FilterCallback) {
+        encoder = FilterCallback(set, std::move(encoder));
+    }
+
     counters->Accept(TString(), TString(), *encoder);
     out.Flush();
 }
 
+THolder<ICountableConsumer> TDynamicCountersPage::CreateEncoder(IOutputStream* out, EFormat format, TStringBuf nameLabel, TCountableBase::EVisibility visibility) const {
+    return ::CreateEncoder(out, format, nameLabel, visibility);
+}
+
 void TDynamicCountersPage::HandleAbsentSubgroup(IMonHttpRequest& request) {
     if (UnknownGroupPolicy == EUnknownGroupPolicy::Error) {
         NotFound(request);
@@ -117,9 +167,53 @@ void TDynamicCountersPage::HandleAbsentSubgroup(IMonHttpRequest& request) {
 
 void TDynamicCountersPage::BeforePre(IMonHttpRequest& request) {
     IOutputStream& out = request.Output();
+    TStringBuf params = GetParams(request);
+    TStringBuilder base;
+    TString labels;
+    bool wasParam = false;
+    base << Path;
+    StringSplitter(params).Split('&').SkipEmpty().Consume([&](TStringBuf part) {
+        TStringBuf name;
+        TStringBuf value;
+        part.Split('=', name, value);
+        if (name == "labels") {
+            if (!labels.empty()) {
+                labels += ',';
+            }
+            labels += value;
+        }
+        if (name != "labels") {
+            if (!wasParam) {
+                base << '?';
+                wasParam = true;
+            } else {
+                base << '&';
+            }
+            base << part;
+        }
+    });
+
+    if (!labels.empty()) {
+        if (!wasParam) {
+            base << '?';
+            wasParam = true;
+        } else {
+            base << '&';
+        }
+        base << "labels=" << labels;
+    }
+
+    const TString escapedBase = NHtml::EscapeAttributeValue(base);
+
     HTML(out) {
         DIV() {
-            out << "<a href='" << request.GetPath() << "/json'>Counters as JSON</a>";
+            out << "<a href=\"" << escapedBase;
+            if (!wasParam) {
+                out << '?';
+            } else {
+                out << "&amp;";
+            }
+            out << "@format=json\">Counters as JSON</a>";
             out << " for Solomon";
         }
 
@@ -129,9 +223,22 @@ void TDynamicCountersPage::BeforePre(IMonHttpRequest& request) {
         UL() {
             currentCounters->EnumerateSubgroups([&](const TString& name, const TString& value) {
                 LI() {
-                    TString pathPart = name + "=" + value;
-                    Quote(pathPart, "");
-                    out << "\n<a href='" << request.GetPath() << "/" << pathPart << "'>" << name << " " << value << "</a>";
+                    auto escName = name;
+                    auto escValue = value;
+                    Quote(escName);
+                    Quote(escValue);
+                    out << "\n<a href=\"" << escapedBase;
+                    if (labels.empty()) {
+                        if (!wasParam) {
+                            out << '?';
+                        } else {
+                            out << "&amp;";
+                        }
+                        out << "labels=";
+                    } else {
+                        out << ',';
+                    }
+                    out << escName << '=' << escValue << "\">" << NHtml::EscapeText(name) << " " << NHtml::EscapeText(value) << "</a>";
                 }
             });
         }
diff --git a/library/cpp/monlib/dynamic_counters/page.h b/library/cpp/monlib/dynamic_counters/page.h
index 1f0ef6a5eaf..562b76dd49a 100644
--- a/library/cpp/monlib/dynamic_counters/page.h
+++ b/library/cpp/monlib/dynamic_counters/page.h
@@ -2,6 +2,7 @@
 
 #include "counters.h"
 
+#include <library/cpp/monlib/encode/format.h>
 #include <library/cpp/monlib/service/pages/pre_mon_page.h>
 
 #include <util/generic/ptr.h>
@@ -17,10 +18,12 @@ namespace NMonitoring {
     struct TDynamicCountersPage: public TPreMonPage {
     public:
         using TOutputCallback = std::function<void()>;
+        using TFilterCallback = std::function<THolder<ICountableConsumer>(const TString& setName, THolder<ICountableConsumer>&& nextConsumer)>;
 
     private:
         const TIntrusivePtr<TDynamicCounters> Counters;
         TOutputCallback OutputCallback;
+        TFilterCallback FilterCallback;
         EUnknownGroupPolicy UnknownGroupPolicy {EUnknownGroupPolicy::Error};
 
     private:
@@ -30,10 +33,12 @@ namespace NMonitoring {
         TDynamicCountersPage(const TString& path,
                              const TString& title,
                              TIntrusivePtr<TDynamicCounters> counters,
-                             TOutputCallback outputCallback = nullptr)
+                             TOutputCallback outputCallback = nullptr,
+                             TFilterCallback filterCallback = nullptr)
             : TPreMonPage(path, title)
             , Counters(counters)
             , OutputCallback(outputCallback)
+            , FilterCallback(filterCallback)
         {
         }
 
@@ -46,5 +51,8 @@ namespace NMonitoring {
         /// If set to Error, responds with 404 if the requested subgroup is not found. This is the default.
         /// If set to Ignore, responds with 204 if the requested subgroup is not found
         void SetUnknownGroupPolicy(EUnknownGroupPolicy value);
+
+    protected:
+        virtual THolder<ICountableConsumer> CreateEncoder(IOutputStream* out, EFormat format, TStringBuf nameLabel, TCountableBase::EVisibility visibility) const;
     };
 }
diff --git a/library/cpp/monlib/encode/buffered/buffered_encoder_base.cpp b/library/cpp/monlib/encode/buffered/buffered_encoder_base.cpp
index 87c832d642b..c0449a10ff0 100644
--- a/library/cpp/monlib/encode/buffered/buffered_encoder_base.cpp
+++ b/library/cpp/monlib/encode/buffered/buffered_encoder_base.cpp
@@ -144,6 +144,12 @@ void TBufferedEncoderBase::OnLogHistogram(TInstant time, TLogHistogramSnapshotPt
     metric.TimeSeries.Add(time, s.Get());
 }
 
+void TBufferedEncoderBase::OnMemOnly(bool isMemOnly) {
+    State_.Expect(TEncoderState::EState::METRIC);
+    TMetric& metric = Metrics_.back();
+    metric.IsMemOnly = isMemOnly;
+}
+
 TString TBufferedEncoderBase::FormatLabels(const TPooledLabels& labels) const {
     auto formattedLabels = TVector<TString>(Reserve(labels.size() + CommonLabels_.size()));
     auto addLabel = [&](const TPooledLabel& l) {
diff --git a/library/cpp/monlib/encode/buffered/buffered_encoder_base.h b/library/cpp/monlib/encode/buffered/buffered_encoder_base.h
index fe3714e58f0..dab5671ad42 100644
--- a/library/cpp/monlib/encode/buffered/buffered_encoder_base.h
+++ b/library/cpp/monlib/encode/buffered/buffered_encoder_base.h
@@ -37,6 +37,8 @@ class TBufferedEncoderBase : public IMetricEncoder {
     void OnSummaryDouble(TInstant time, ISummaryDoubleSnapshotPtr snapshot) override;
     void OnLogHistogram(TInstant, TLogHistogramSnapshotPtr) override;
 
+    void OnMemOnly(bool isMemOnly) override;
+
 protected:
     using TPooledStr = TStringPoolBuilder::TValue;
 
@@ -80,6 +82,7 @@ class TBufferedEncoderBase : public IMetricEncoder {
         EMetricType MetricType = EMetricType::UNKNOWN;
         TPooledLabels Labels;
         TMetricTimeSeries TimeSeries;
+        bool IsMemOnly;
     };
 
 protected:
diff --git a/library/cpp/monlib/encode/buffered/string_pool.cpp b/library/cpp/monlib/encode/buffered/string_pool.cpp
index b4c7988ba33..0ac5c780fc5 100644
--- a/library/cpp/monlib/encode/buffered/string_pool.cpp
+++ b/library/cpp/monlib/encode/buffered/string_pool.cpp
@@ -1,5 +1,7 @@
 #include "string_pool.h"
 
+#include <util/generic/ylimits.h>
+
 namespace NMonitoring {
     ////////////////////////////////////////////////////////////////////////////////
     // TStringPoolBuilder
diff --git a/library/cpp/monlib/encode/buffered/string_pool.h b/library/cpp/monlib/encode/buffered/string_pool.h
index b7ab01d2a11..4c41b82258d 100644
--- a/library/cpp/monlib/encode/buffered/string_pool.h
+++ b/library/cpp/monlib/encode/buffered/string_pool.h
@@ -78,6 +78,13 @@ namespace NMonitoring {
             InitIndex(data, size);
         }
 
+        TStringPool(const char* data, const TVector<std::pair<ui32, ui32>>& segments) {
+            Index_.reserve(segments.size());
+            for (const auto& [offset, length] : segments) {
+                Index_.emplace_back(data + offset, length);
+            }
+        }
+
         TStringBuf Get(ui32 i) const {
             return Index_.at(i);
         }
diff --git a/library/cpp/monlib/encode/fake/fake.cpp b/library/cpp/monlib/encode/fake/fake.cpp
index 69d691361ae..e3db20cbd1e 100644
--- a/library/cpp/monlib/encode/fake/fake.cpp
+++ b/library/cpp/monlib/encode/fake/fake.cpp
@@ -43,6 +43,9 @@ namespace NMonitoring {
 
         void Close() override {
         }
+
+        void OnMemOnly(bool) override {
+        }
     };
 
     IMetricEncoderPtr EncoderFake() {
diff --git a/library/cpp/monlib/encode/format.cpp b/library/cpp/monlib/encode/format.cpp
index 63f9932aad2..dbcc2411f46 100644
--- a/library/cpp/monlib/encode/format.cpp
+++ b/library/cpp/monlib/encode/format.cpp
@@ -97,6 +97,21 @@ namespace NMonitoring {
         return CompressionFromHeader(value);
     }
 
+    ECompression FastestCompressionFromAcceptEncodingHeader(TStringBuf value) {
+        if (value.empty()) {
+            return ECompression::UNKNOWN;
+        }
+
+        for (const auto& it : StringSplitter(value).Split(',').SkipEmpty()) {
+            TStringBuf token = StripString(it.Token());
+            if (AsciiEqualsIgnoreCase(token, NFormatContentEncoding::LZ4)) {
+                return ECompression::LZ4;
+            }
+        }
+
+        return CompressionFromAcceptEncodingHeader(value);
+    }
+
     TStringBuf ContentEncodingByCompression(ECompression compression) {
         switch (compression) {
             case ECompression::IDENTITY:
diff --git a/library/cpp/monlib/encode/format.h b/library/cpp/monlib/encode/format.h
index d363945ec3d..08c59e192d9 100644
--- a/library/cpp/monlib/encode/format.h
+++ b/library/cpp/monlib/encode/format.h
@@ -151,6 +151,16 @@ namespace NMonitoring {
      */
     ECompression CompressionFromAcceptEncodingHeader(TStringBuf value);
 
+    /**
+     * Matches fasters compression algorithm by the given "Accept-Encoding"
+     * header value. Currently fastest accepted algorithm is lz4. If lz4 is not
+     * found in header fallbacks to CompressionFromAcceptEncodingHeader
+     *
+     * @param value  value of the "Accept-Encoding" header.
+     * @return fastest accepted compression algorithm
+     */
+    ECompression FastestCompressionFromAcceptEncodingHeader(TStringBuf value);
+
     /**
      * Matches compression algorithm by the given "Content-Encoding" header value.
      *
diff --git a/library/cpp/monlib/encode/format_ut.cpp b/library/cpp/monlib/encode/format_ut.cpp
index 644a36ee532..92bcddc86bb 100644
--- a/library/cpp/monlib/encode/format_ut.cpp
+++ b/library/cpp/monlib/encode/format_ut.cpp
@@ -122,6 +122,48 @@ Y_UNIT_TEST_SUITE(TFormatTest) {
             ECompression::LZ4);
     }
 
+    Y_UNIT_TEST(FastestAcceptEncodingHeader) {
+        UNIT_ASSERT_EQUAL(
+            FastestCompressionFromAcceptEncodingHeader(""),
+            ECompression::UNKNOWN);
+
+        UNIT_ASSERT_EQUAL(
+            FastestCompressionFromAcceptEncodingHeader("br"),
+            ECompression::UNKNOWN);
+
+        UNIT_ASSERT_EQUAL(
+            FastestCompressionFromAcceptEncodingHeader("identity"),
+            ECompression::IDENTITY);
+
+        UNIT_ASSERT_EQUAL(
+            FastestCompressionFromAcceptEncodingHeader("zlib"),
+            ECompression::ZLIB);
+
+        UNIT_ASSERT_EQUAL(
+            FastestCompressionFromAcceptEncodingHeader("lz4"),
+            ECompression::LZ4);
+
+        UNIT_ASSERT_EQUAL(
+            FastestCompressionFromAcceptEncodingHeader("zstd"),
+            ECompression::ZSTD);
+
+        UNIT_ASSERT_EQUAL(
+            FastestCompressionFromAcceptEncodingHeader("zstd, zlib"),
+            ECompression::ZSTD);
+
+        UNIT_ASSERT_EQUAL(
+            FastestCompressionFromAcceptEncodingHeader(" ,, , zstd , zlib"),
+            ECompression::ZSTD);
+
+        UNIT_ASSERT_EQUAL(
+            FastestCompressionFromAcceptEncodingHeader("br, deflate,lz4, zlib"),
+            ECompression::LZ4);
+
+        UNIT_ASSERT_EQUAL(
+            FastestCompressionFromAcceptEncodingHeader("zstd, zlib, lz4"),
+            ECompression::LZ4);
+    }
+
     Y_UNIT_TEST(CompressionToStrFromStr) {
         const std::array<ECompression, 5> algs = {{
             ECompression::UNKNOWN,
diff --git a/library/cpp/monlib/encode/json/json_decoder.cpp b/library/cpp/monlib/encode/json/json_decoder.cpp
index 37189900759..801ff0833d2 100644
--- a/library/cpp/monlib/encode/json/json_decoder.cpp
+++ b/library/cpp/monlib/encode/json/json_decoder.cpp
@@ -193,6 +193,7 @@ struct TMetricCollector {
     TLogHistogramBuilder LogHistBuilder;
     TTypedPoint LastPoint;
     TVector<TTypedPoint> TimeSeries;
+    bool IsMemOnly = false;
 
     bool SeenTsOrValue = false;
     bool SeenTimeseries = false;
@@ -207,6 +208,7 @@ struct TMetricCollector {
         HistogramBuilder.Clear();
         SummaryBuilder.Clear();
         LogHistBuilder.Clear();
+        IsMemOnly = false;
     }
 
     void AddLabel(const TLabel& label) {
@@ -222,6 +224,10 @@ struct TMetricCollector {
         LastPoint.SetValue(value);
     }
 
+    void SetMemOnly(bool isMemOnly) {
+        IsMemOnly = isMemOnly;
+    }
+
     void SaveLastPoint() {
         DECODE_ENSURE(LastPoint.GetTime() != TInstant::Zero(),
                  "cannot add point without or zero timestamp");
@@ -419,6 +425,10 @@ class TCommonPartsProxy: public IHaltableMetricConsumer {
         Consumer_->OnSummaryDouble(time, std::move(snapshot));
     }
 
+    void OnMemOnly(bool isMemOnly) override{
+        Consumer_->OnMemOnly(isMemOnly);
+    }
+
 private:
     const TCommonParts CommonParts_;
     IMetricConsumer* Consumer_;
@@ -442,6 +452,7 @@ class TDecoderJson final: public NJson::TJsonCallbacks {
             METRIC_LABELS,
             METRIC_TYPE,
             METRIC_MODE, // TODO: must be deleted
+            METRIC_MEMONLY,
             METRIC_TIMESERIES,
             METRIC_TS,
             METRIC_VALUE,
@@ -858,7 +869,7 @@ if (Y_UNLIKELY(!(CONDITION))) {                  \
                 } else if (key == TStringBuf("log_hist")) {
                     State_.ToNext(TState::METRIC_LOG_HIST);
                 } else if (key == TStringBuf("memOnly")) {
-                    // deprecated. Skip it without errors for backward compatibility
+                    State_.ToNext(TState::METRIC_MEMONLY);
                 } else {
                     ErrorMsg_ = TStringBuilder() << "unexpected key \"" << key << "\" in a metric schema";
                     return false;
@@ -1033,6 +1044,18 @@ if (Y_UNLIKELY(!(CONDITION))) {                  \
         return true;
     }
 
+    bool OnBoolean(bool value) override {
+        switch (State_.Current()) {
+            case TState::METRIC_MEMONLY:
+                LastMetric_.IsMemOnly = value;
+                State_.ToPrev();
+                break;
+            default:
+                return false;
+        }
+        return true;
+    }
+
     void ConsumeMetric() {
         // for backwad compatibility all unknown metrics treated as gauges
         if (LastMetric_.Type == EMetricType::UNKNOWN) {
@@ -1055,7 +1078,12 @@ if (Y_UNLIKELY(!(CONDITION))) {                  \
             MetricConsumer_->OnLabelsEnd();
         }
 
-        // (3) values
+        // (3) flags
+        if (LastMetric_.IsMemOnly) {
+            MetricConsumer_->OnMemOnly(true);
+        }
+
+        // (4) values
         switch (LastMetric_.Type) {
             case EMetricType::GAUGE:
                 LastMetric_.Consume([this](TInstant time, EMetricValueType valueType, TMetricValue value) {
diff --git a/library/cpp/monlib/encode/json/json_encoder.cpp b/library/cpp/monlib/encode/json/json_encoder.cpp
index 20d2bb6283f..4394685512c 100644
--- a/library/cpp/monlib/encode/json/json_encoder.cpp
+++ b/library/cpp/monlib/encode/json/json_encoder.cpp
@@ -11,6 +11,7 @@
 
 #include <util/charset/utf8.h>
 #include <util/generic/algorithm.h>
+#include <util/string/escape.h>
 
 namespace NMonitoring {
     namespace {
@@ -174,8 +175,12 @@ namespace NMonitoring {
             }
 
             void WriteLabel(TStringBuf name, TStringBuf value) {
-                Y_ENSURE(IsUtf(name), "label name is not valid UTF-8 string");
-                Y_ENSURE(IsUtf(value), "label value is not valid UTF-8 string");
+                if (!IsUtf(name)) {
+                    ythrow yexception() << "label name is not valid UTF-8 string: '" << EscapeC(name.SubStr(0, 100)) << "'";
+                } else if (!IsUtf(value)) {
+                    ythrow yexception() << "label value is not valid UTF-8 string, name: '" << name << "', value: '" << EscapeC(value.SubStr(0, 100)) << "'";
+                }
+
                 if (Style_ == EJsonStyle::Cloud && name == MetricNameLabel_) {
                     CurrentMetricName_ = value;
                 } else {
@@ -198,7 +203,7 @@ namespace NMonitoring {
                 if (Style_ != EJsonStyle::Cloud) {
                     return;
                 }
-                if (CurrentMetricName_.Empty()) {
+                if (CurrentMetricName_.empty()) {
                     ythrow yexception() << "label '" << MetricNameLabel_ << "' is not defined";
                 }
                 Buf_.WriteKey("name");
@@ -274,6 +279,14 @@ namespace NMonitoring {
                 WriteMetricType(type);
             }
 
+            void OnMemOnly(bool isMemOnly) override {
+                State_.Expect(TEncoderState::EState::METRIC);
+                if (isMemOnly) {
+                    Buf_.WriteKey("memOnly");
+                    Buf_.WriteBool(isMemOnly);
+                }
+            }
+
             void OnMetricEnd() override {
                 State_.Switch(TEncoderState::EState::METRIC, TEncoderState::EState::ROOT);
                 if (!Buf_.KeyExpected()) {
@@ -493,6 +506,7 @@ namespace NMonitoring {
                 Buf_.WriteKey(TStringBuf("labels"));
                 WriteLabels(metric.Labels, false);
 
+                WriteFlags(metric);
                 metric.TimeSeries.SortByTs();
                 if (metric.TimeSeries.Size() == 1) {
                     const auto& point = metric.TimeSeries[0];
@@ -532,6 +546,13 @@ namespace NMonitoring {
                 }
             }
 
+            void WriteFlags(const TMetric& metric) {
+                if (metric.IsMemOnly) {
+                    Buf_.WriteKey("memOnly");
+                    Buf_.WriteBool(true);
+                }
+            }
+
         private:
             bool Closed_{false};
             bool EmptyLabels_ = false;
diff --git a/library/cpp/monlib/encode/json/json_ut.cpp b/library/cpp/monlib/encode/json/json_ut.cpp
index 49de352062b..78103a42b5c 100644
--- a/library/cpp/monlib/encode/json/json_ut.cpp
+++ b/library/cpp/monlib/encode/json/json_ut.cpp
@@ -136,7 +136,7 @@ Y_UNIT_TEST_SUITE(TJsonTest) {
     const TInstant now = TInstant::ParseIso8601Deprecated("2017-11-05T01:02:03Z");
 
     Y_UNIT_TEST(Encode) {
-        auto check = [](bool cloud, bool buffered, TStringBuf expectedResourceKey) {
+        auto check = [](bool cloud, bool buffered, bool memOnly, TStringBuf expectedResourceKey) {
             TString json;
             TStringOutput out(json);
             auto e = cloud
@@ -158,6 +158,7 @@ Y_UNIT_TEST_SUITE(TJsonTest) {
                     e->OnLabel("metric", "single");
                     e->OnLabel("labels", "l1");
                     e->OnLabelsEnd();
+                    e->OnMemOnly(memOnly);
                 }
                 e->OnUint64(now, 17);
                 e->OnMetricEnd();
@@ -219,6 +220,7 @@ Y_UNIT_TEST_SUITE(TJsonTest) {
                     e->OnLabel("labels", "l6");
                     e->OnLabelsEnd();
                 }
+                e->OnMemOnly(memOnly);
                 e->OnMetricEnd();
             }
             e->OnStreamEnd();
@@ -235,10 +237,12 @@ Y_UNIT_TEST_SUITE(TJsonTest) {
             UNIT_ASSERT_EQUAL(parseJson(json), parseJson(expectedJson));
         };
 
-        check(false, false, "/expected.json");
-        check(false, true, "/expected_buffered.json");
-        check(true, false, "/expected_cloud.json");
-        check(true, true, "/expected_cloud_buffered.json");
+        check(false, false, false, "/expected.json");
+        check(true, false, false, "/expected_cloud.json");
+        check(false, true, false, "/expected_buffered.json");
+        check(true, true, false, "/expected_cloud_buffered.json");
+        check(false, false, true, "/expected_memOnly.json");
+        check(false, true, true, "/expected_buffered_memOnly.json");
     }
 
     TLogHistogramSnapshotPtr TestLogHistogram(ui32 v = 1) {
@@ -478,7 +482,7 @@ Y_UNIT_TEST_SUITE(TJsonTest) {
             UNIT_ASSERT_VALUES_EQUAL(s.LabelsSize(), 2);
             AssertLabelEqual(s.GetLabels(0), "export", "Oxygen");
             AssertLabelEqual(s.GetLabels(1), "metric", "QueueSize");
-
+            UNIT_ASSERT_EQUAL(s.GetIsMemOnly(), true);
             UNIT_ASSERT_VALUES_EQUAL(s.PointsSize(), 1);
             auto ts = TInstant::ParseIso8601Deprecated("2017-11-05T12:34:56.000Z");
             AssertPointEqual(s.GetPoints(0), ts, 3.14159);
@@ -487,6 +491,7 @@ Y_UNIT_TEST_SUITE(TJsonTest) {
             const NProto::TMultiSample& s = samples.GetSamples(3);
             UNIT_ASSERT_EQUAL(s.GetMetricType(), NProto::GAUGE);
             UNIT_ASSERT_VALUES_EQUAL(s.LabelsSize(), 1);
+            UNIT_ASSERT_EQUAL(s.GetIsMemOnly(), true);
             AssertLabelEqual(s.GetLabels(0), "metric", "Writes");
 
             UNIT_ASSERT_VALUES_EQUAL(s.PointsSize(), 2);
@@ -1286,5 +1291,4 @@ Y_UNIT_TEST_SUITE(TJsonTest) {
             AssertLabelEqual(s.GetLabels(1), "export", "Oxygen");
         }
     }
-
 }
diff --git a/library/cpp/monlib/encode/json/ut/expected_buffered_memOnly.json b/library/cpp/monlib/encode/json/ut/expected_buffered_memOnly.json
new file mode 100644
index 00000000000..7273c2e4779
--- /dev/null
+++ b/library/cpp/monlib/encode/json/ut/expected_buffered_memOnly.json
@@ -0,0 +1,95 @@
+{
+    "ts":1500000000,
+    "commonLabels":
+      {
+        "project":"solomon"
+      },
+    "sensors":
+      [
+        {
+          "kind":"COUNTER",
+          "labels":
+            {
+              "labels":"l1",
+              "metric":"single"
+            },
+          "memOnly":true,
+          "ts":1509843723,
+          "value":17
+        },
+        {
+          "kind":"RATE",
+          "labels":
+            {
+              "labels":"l2",
+              "metric":"single"
+            },
+          "ts":1509843723,
+          "value":17
+        },
+        {
+          "kind":"GAUGE",
+          "labels":
+            {
+              "labels":"l3",
+              "metric":"single"
+            },
+          "ts":1509843723,
+          "value":3.14
+        },
+        {
+          "kind":"IGAUGE",
+          "labels":
+            {
+              "labels":"l4",
+              "metric":"single_igauge"
+            },
+          "ts":1509843723,
+          "value":42
+        },
+        {
+          "kind":"GAUGE",
+          "labels":
+            {
+              "labels":"l5",
+              "metric":"multiple"
+            },
+          "timeseries":
+            [
+              {
+                "ts":1509843723,
+                "value":"nan"
+              },
+              {
+                "ts":1509843738,
+                "value":"inf"
+              },
+              {
+                "ts":1509843753,
+                "value":"-inf"
+              }
+            ]
+        },
+        {
+          "kind":"COUNTER",
+          "labels":
+            {
+              "labels":"l6",
+              "metric":"multiple"
+            },
+          "memOnly":true,
+          "timeseries":
+            [
+              {
+                "ts":1509843723,
+                "value":1337
+              },
+              {
+                "ts":1509843738,
+                "value":1338
+              }
+            ]
+        }
+      ]
+  }
+  
\ No newline at end of file
diff --git a/library/cpp/monlib/encode/json/ut/expected_memOnly.json b/library/cpp/monlib/encode/json/ut/expected_memOnly.json
new file mode 100644
index 00000000000..ee3398427b9
--- /dev/null
+++ b/library/cpp/monlib/encode/json/ut/expected_memOnly.json
@@ -0,0 +1,95 @@
+{
+    "ts":1500000000,
+    "commonLabels":
+      {
+        "project":"solomon"
+      },
+    "sensors":
+      [
+        {
+          "kind":"COUNTER",
+          "labels":
+            {
+              "metric":"single",
+              "labels":"l1"
+            },
+          "memOnly":true,
+          "ts":1509843723,
+          "value":17
+        },
+        {
+          "kind":"RATE",
+          "labels":
+            {
+              "metric":"single",
+              "labels":"l2"
+            },
+          "ts":1509843723,
+          "value":17
+        },
+        {
+          "kind":"GAUGE",
+          "labels":
+            {
+              "metric":"single",
+              "labels":"l3"
+            },
+          "ts":1509843723,
+          "value":3.14
+        },
+        {
+          "kind":"IGAUGE",
+          "labels":
+            {
+              "metric":"single_igauge",
+              "labels":"l4"
+            },
+          "ts":1509843723,
+          "value":42
+        },
+        {
+          "kind":"GAUGE",
+          "labels":
+            {
+              "metric":"multiple",
+              "labels":"l5"
+            },
+          "timeseries":
+            [
+              {
+                "ts":1509843723,
+                "value":"nan"
+              },
+              {
+                "ts":1509843738,
+                "value":"inf"
+              },
+              {
+                "ts":1509843753,
+                "value":"-inf"
+              }
+            ]
+        },
+        {
+          "kind":"COUNTER",
+          "memOnly":true,
+          "timeseries":
+            [
+              {
+                "ts":1509843723,
+                "value":1337
+              },
+              {
+                "ts":1509843738,
+                "value":1338
+              }
+            ],
+          "labels":
+            {
+              "metric":"multiple",
+              "labels":"l6"
+            }
+        }
+      ]
+  }
+  
\ No newline at end of file
diff --git a/library/cpp/monlib/encode/json/ut/metrics.json b/library/cpp/monlib/encode/json/ut/metrics.json
index 2be4617d515..80547792aea 100644
--- a/library/cpp/monlib/encode/json/ut/metrics.json
+++ b/library/cpp/monlib/encode/json/ut/metrics.json
@@ -27,6 +27,7 @@
     {
       "type": "GAUGE",
       "labels": { "metric": "Writes" },
+      "memOnly": true,
       "timeseries": [
         {
           "ts": "2017-08-28T12:32:11Z",
diff --git a/library/cpp/monlib/encode/prometheus/prometheus.h b/library/cpp/monlib/encode/prometheus/prometheus.h
index c6982996990..6467836a6a6 100644
--- a/library/cpp/monlib/encode/prometheus/prometheus.h
+++ b/library/cpp/monlib/encode/prometheus/prometheus.h
@@ -1,5 +1,7 @@
 #pragma once
 
+#include <functional>
+
 #include <library/cpp/monlib/encode/encoder.h>
 #include <library/cpp/monlib/encode/format.h>
 
@@ -18,6 +20,12 @@ namespace NMonitoring {
 
     struct TPrometheusDecodeSettings {
         EPrometheusDecodeMode Mode{EPrometheusDecodeMode::DEFAULT};
+        /*
+         * Mangles the label that is equal to metricNameLabel. The
+         * new name must be not equal to any already present in the
+         * metric sample.
+         */
+        std::function<TString(TStringBuf)> NameMangler{};
     };
 
     IMetricEncoderPtr EncoderPrometheus(IOutputStream* out, TStringBuf metricNameLabel = "sensor");
diff --git a/library/cpp/monlib/encode/prometheus/prometheus_decoder.cpp b/library/cpp/monlib/encode/prometheus/prometheus_decoder.cpp
index 313651ba8fa..2467abc8f26 100644
--- a/library/cpp/monlib/encode/prometheus/prometheus_decoder.cpp
+++ b/library/cpp/monlib/encode/prometheus/prometheus_decoder.cpp
@@ -22,7 +22,7 @@
 
 namespace NMonitoring {
     namespace {
-        constexpr ui32 MAX_LABEL_VALUE_LEN = 256;
+        constexpr ui32 MAX_LABEL_VALUE_LEN = 1024;
 
         using TLabelsMap = THashMap<TString, TString>;
 
@@ -219,7 +219,7 @@ namespace NMonitoring {
 
         private:
             bool HasRemaining() const noexcept {
-                return CurrentPos_ < Data_.Size();
+                return CurrentPos_ < Data_.size();
             }
 
             // # 'TYPE' metric_name {counter|gauge|histogram|summary|untyped}
@@ -234,7 +234,7 @@ namespace NMonitoring {
                     SkipSpaces();
 
                     TStringBuf nextName = ReadTokenAsMetricName();
-                    Y_PARSER_ENSURE(!nextName.Empty(), "invalid metric name");
+                    Y_PARSER_ENSURE(!nextName.empty(), "invalid metric name");
 
                     SkipSpaces();
                     EPrometheusMetricType nextType = ReadType();
@@ -525,14 +525,27 @@ namespace NMonitoring {
             }
 
             void ConsumeLabels(TStringBuf name, const TLabelsMap& labels) {
-                Y_PARSER_ENSURE(labels.count(MetricNameLabel_) == 0,
-                    "label name '" << MetricNameLabel_ <<
-                    "' is reserved, but is used with metric: " << name << LabelsToStr(labels));
+                auto it = labels.find(MetricNameLabel_);
+                if(it != labels.end() && !Settings_.NameMangler) {
+                    Y_PARSER_ENSURE(false,
+                        "label name '" << MetricNameLabel_ <<
+                        "' is reserved, but is used with metric: " << name << LabelsToStr(labels));
+                }
+                const bool labelClashPresent = it != labels.end();
 
                 Consumer_->OnLabelsBegin();
                 Consumer_->OnLabel(MetricNameLabel_, TString(name)); // TODO: remove this string allocation
-                for (const auto& it: labels) {
-                    Consumer_->OnLabel(it.first, it.second);
+                for (const auto& [k, v]: labels) {
+                    if(labelClashPresent && k == MetricNameLabel_) {
+                        auto newKey = Settings_.NameMangler(k);
+                            Y_PARSER_ENSURE(!labels.contains(newKey),
+                                "after mangling label name: " << MetricNameLabel_ <<
+                                " the resulting label is: " << newKey <<
+                                "but it is already used in: " << LabelsToStr(labels));
+                        Consumer_->OnLabel(newKey, v);
+                        continue;
+                    }
+                    Consumer_->OnLabel(k, v);
                 }
                 Consumer_->OnLabelsEnd();
             }
@@ -576,7 +589,7 @@ namespace NMonitoring {
                     return std::numeric_limits<double>::infinity();
                 } else if (str == TStringBuf("-Inf")) {
                     return -std::numeric_limits<double>::infinity();
-                } else if (str == TStringBuf("NaN")) {
+                } else if (str == TStringBuf("NaN") || str == TStringBuf("Nan")) {
                     return NAN;
                 }
 
diff --git a/library/cpp/monlib/encode/prometheus/prometheus_decoder_ut.cpp b/library/cpp/monlib/encode/prometheus/prometheus_decoder_ut.cpp
index 9299076f933..834c3295741 100644
--- a/library/cpp/monlib/encode/prometheus/prometheus_decoder_ut.cpp
+++ b/library/cpp/monlib/encode/prometheus/prometheus_decoder_ut.cpp
@@ -68,12 +68,13 @@ Y_UNIT_TEST_SUITE(TPrometheusDecoderTest) {
     Y_UNIT_TEST(Minimal) {
         auto samples = Decode(
                 "minimal_metric 1.234\n"
+                "big_num 1.04671344e+10\n"
                 "another_metric -3e3 103948\n"
                 "# Even that:\n"
                 "no_labels{} 3\n"
                 "# HELP line for non-existing metric will be ignored.\n");
 
-        UNIT_ASSERT_EQUAL(samples.SamplesSize(), 3);
+        UNIT_ASSERT_EQUAL(samples.SamplesSize(), 4);
         {
             auto& s = samples.GetSamples(0);
             UNIT_ASSERT_EQUAL(s.GetMetricType(), NProto::EMetricType::GAUGE);
@@ -84,12 +85,19 @@ Y_UNIT_TEST_SUITE(TPrometheusDecoderTest) {
         {
             auto& s = samples.GetSamples(1);
             UNIT_ASSERT_EQUAL(s.GetMetricType(), NProto::EMetricType::GAUGE);
+            UNIT_ASSERT_EQUAL(1, s.LabelsSize());
+            ASSERT_LABEL_EQUAL(s.GetLabels(0), "sensor", "big_num");
+            ASSERT_DOUBLE_POINT(s, TInstant::Zero(), 1.04671344e+10);
+        }
+        {
+            auto& s = samples.GetSamples(2);
+            UNIT_ASSERT_EQUAL(s.GetMetricType(), NProto::EMetricType::GAUGE);
             UNIT_ASSERT_EQUAL(s.LabelsSize(), 1);
             ASSERT_LABEL_EQUAL(s.GetLabels(0), "sensor", "another_metric");
             ASSERT_DOUBLE_POINT(s, TInstant::MilliSeconds(103948), -3000.0);
         }
         {
-            auto& s = samples.GetSamples(2);
+            auto& s = samples.GetSamples(3);
             UNIT_ASSERT_EQUAL(s.GetMetricType(), NProto::EMetricType::GAUGE);
             UNIT_ASSERT_EQUAL(1, s.LabelsSize());
             ASSERT_LABEL_EQUAL(s.GetLabels(0), "sensor", "no_labels");
@@ -97,18 +105,100 @@ Y_UNIT_TEST_SUITE(TPrometheusDecoderTest) {
         }
     }
 
+    // ReadTokenAsLabelValue's loop runs MAX_LABEL_VALUE_LEN times: one iteration per
+    // appended character plus one final iteration to detect the closing quote. So the
+    // longest value it can successfully parse is (MAX_LABEL_VALUE_LEN - 1) characters.
+    Y_UNIT_TEST(LabelValueAtNewLimitIsAccepted) {
+        const auto value = TString(1023, 'a');
+        const auto inputMetrics = TString("m{l=\"") + value + "\"} 1\n";
+
+        auto samples = Decode(inputMetrics);
+
+        UNIT_ASSERT_VALUES_EQUAL(samples.SamplesSize(), 1);
+        auto& s = samples.GetSamples(0);
+        UNIT_ASSERT_VALUES_EQUAL(s.LabelsSize(), 2);
+        ASSERT_LABEL_EQUAL(s.GetLabels(0), "sensor", "m");
+        ASSERT_LABEL_EQUAL(s.GetLabels(1), "l", value);
+    }
+
+    Y_UNIT_TEST(LabelValueOverNewLimitStillThrows) {
+        const auto value = TString(1024, 'a');
+        const auto inputMetrics = TString("m{l=\"") + value + "\"} 1\n";
+
+        UNIT_ASSERT_EXCEPTION_CONTAINS(Decode(inputMetrics), TPrometheusDecodeException,
+            "trying to parse too long label value, size >= 1024");
+    }
+
+    Y_UNIT_TEST(NameAlreadyPresent) {
+        constexpr auto inputMetrics =
+            "# A normal comment.\n"
+            "#\n"
+            "# TYPE name counter\n"
+            "name{sensor=\"some_name\",labelname=\"val1\",basename=\"basevalue\"} NaN\n"
+            "name{labelname=\"val2\",basename=\"basevalue\"} Nan\n"
+            "name {labelname=\"val3\",basename=\"basevalue\"} 2.3 1234567890\n"
+            "# HELP name two-line\\n doc  str\\\\ing\n";
+
+        try {
+            auto samples = Decode(inputMetrics);
+        } catch(...) {
+            return;
+        }
+        UNIT_ASSERT(false);
+    }
+
+    Y_UNIT_TEST(NameAlreadyPresentButMangled) {
+        constexpr auto inputMetrics =
+            "# A normal comment.\n"
+            "#\n"
+            "# TYPE name counter\n"
+            "name{sensor=\"some_name\",labelname=\"val1\",basename=\"basevalue\"} NaN\n"
+            "name{labelname=\"val2\",basename=\"basevalue\"} Nan\n"
+            "name {labelname=\"val3\",basename=\"basevalue\"} 2.3 1234567890\n"
+            "# HELP name two-line\\n doc  str\\\\ing\n";
+
+        try {
+            auto samples = Decode(inputMetrics, TPrometheusDecodeSettings{.NameMangler = [](auto s) -> TString {
+                                      return TStringBuilder{}<<"mm_" << s;
+                                  }});
+        } catch(...) {
+            UNIT_ASSERT(false);
+        }
+    }
+
+    Y_UNIT_TEST(MangledNameClash) {
+        constexpr auto inputMetrics =
+            "# A normal comment.\n"
+            "#\n"
+            "# TYPE name counter\n"
+            "name{mm_sensor=\"other\",sensor=\"some_name\",labelname=\"val1\",basename=\"basevalue\"} NaN\n"
+            "name{labelname=\"val2\",basename=\"basevalue\"} Nan\n"
+            "name {labelname=\"val3\",basename=\"basevalue\"} 2.3 1234567890\n"
+            "# HELP name two-line\\n doc  str\\\\ing\n";
+
+        try {
+            auto samples = Decode(inputMetrics, TPrometheusDecodeSettings{.NameMangler = [](auto s) -> TString {
+                                      return TStringBuilder{}<<"mm_" << s;
+                                  }});
+        } catch(...) {
+            return;
+        }
+        UNIT_ASSERT(false);
+    }
+
     Y_UNIT_TEST(Counter) {
         constexpr auto inputMetrics =
             "# A normal comment.\n"
             "#\n"
             "# TYPE name counter\n"
             "name{labelname=\"val1\",basename=\"basevalue\"} NaN\n"
-            "name {labelname=\"val2\",basename=\"basevalue\"} 2.3 1234567890\n"
+            "name{labelname=\"val2\",basename=\"basevalue\"} Nan\n"
+            "name {labelname=\"val3\",basename=\"basevalue\"} 2.3 1234567890\n"
             "# HELP name two-line\\n doc  str\\\\ing\n";
 
         {
             auto samples = Decode(inputMetrics);
-            UNIT_ASSERT_EQUAL(samples.SamplesSize(), 2);
+            UNIT_ASSERT_EQUAL(samples.SamplesSize(), 3);
 
             {
                 auto& s = samples.GetSamples(0);
@@ -126,6 +216,15 @@ Y_UNIT_TEST_SUITE(TPrometheusDecoderTest) {
                 ASSERT_LABEL_EQUAL(s.GetLabels(0), "sensor", "name");
                 ASSERT_LABEL_EQUAL(s.GetLabels(1), "basename", "basevalue");
                 ASSERT_LABEL_EQUAL(s.GetLabels(2), "labelname", "val2");
+                ASSERT_UINT_POINT(s, TInstant::Zero(), ui64(0));
+            }
+            {
+                auto& s = samples.GetSamples(2);
+                UNIT_ASSERT_EQUAL(s.GetMetricType(), NProto::EMetricType::RATE);
+                UNIT_ASSERT_EQUAL(s.LabelsSize(), 3);
+                ASSERT_LABEL_EQUAL(s.GetLabels(0), "sensor", "name");
+                ASSERT_LABEL_EQUAL(s.GetLabels(1), "basename", "basevalue");
+                ASSERT_LABEL_EQUAL(s.GetLabels(2), "labelname", "val3");
                 ASSERT_UINT_POINT(s, TInstant::MilliSeconds(1234567890), i64(2));
             }
         }
@@ -133,7 +232,7 @@ Y_UNIT_TEST_SUITE(TPrometheusDecoderTest) {
             TPrometheusDecodeSettings settings;
             settings.Mode = EPrometheusDecodeMode::RAW;
             auto samples = Decode(inputMetrics, settings);
-            UNIT_ASSERT_EQUAL(samples.SamplesSize(), 2);
+            UNIT_ASSERT_EQUAL(samples.SamplesSize(), 3);
 
             {
                 auto& s = samples.GetSamples(0);
@@ -151,6 +250,15 @@ Y_UNIT_TEST_SUITE(TPrometheusDecoderTest) {
                 ASSERT_LABEL_EQUAL(s.GetLabels(0), "sensor", "name");
                 ASSERT_LABEL_EQUAL(s.GetLabels(1), "basename", "basevalue");
                 ASSERT_LABEL_EQUAL(s.GetLabels(2), "labelname", "val2");
+                ASSERT_DOUBLE_POINT(s, TInstant::MilliSeconds(0), NAN);
+            }
+            {
+                auto& s = samples.GetSamples(2);
+                UNIT_ASSERT_EQUAL(s.GetMetricType(), NProto::EMetricType::GAUGE);
+                UNIT_ASSERT_EQUAL(s.LabelsSize(), 3);
+                ASSERT_LABEL_EQUAL(s.GetLabels(0), "sensor", "name");
+                ASSERT_LABEL_EQUAL(s.GetLabels(1), "basename", "basevalue");
+                ASSERT_LABEL_EQUAL(s.GetLabels(2), "labelname", "val3");
                 ASSERT_DOUBLE_POINT(s, TInstant::MilliSeconds(1234567890), 2.3);
             }
         }
diff --git a/library/cpp/monlib/encode/prometheus/prometheus_encoder.cpp b/library/cpp/monlib/encode/prometheus/prometheus_encoder.cpp
index fc482a45707..66c0f55b436 100644
--- a/library/cpp/monlib/encode/prometheus/prometheus_encoder.cpp
+++ b/library/cpp/monlib/encode/prometheus/prometheus_encoder.cpp
@@ -106,14 +106,16 @@ namespace NMonitoring {
         private:
             // will replace invalid chars with '_'
             void WriteMetricName(TStringBuf name) {
-                Y_ENSURE(!name.Empty(), "trying to write metric with empty name");
+                Y_ENSURE(!name.empty(), "trying to write metric with empty name");
 
                 char ch = name[0];
-                if (!NPrometheus::IsValidMetricNameStart(ch)) {
+                if (NPrometheus::IsValidMetricNameStart(ch)) {
+                    Out_->Write(ch);
+                } else {
                     Out_->Write('_');
                 }
 
-                for (size_t i = 0, len = name.length(); i < len; i++) {
+                for (size_t i = 1, len = name.length(); i < len; i++) {
                     ch = name[i];
                     if (NPrometheus::IsValidMetricNameContinuation(ch)) {
                         Out_->Write(ch);
@@ -131,7 +133,7 @@ namespace NMonitoring {
                     WriteLabelValue(l.Value());
                     Out_->Write(", "); // trailign comma is supported in parsers
                 }
-                if (!addLabelKey.Empty() && !addLabelValue.Empty()) {
+                if (!addLabelKey.empty() && !addLabelValue.empty()) {
                     Out_->Write(addLabelKey);
                     Out_->Write('=');
                     WriteLabelValue(addLabelValue);
@@ -162,12 +164,12 @@ namespace NMonitoring {
             {
                 // (1) name
                 WriteMetricName(name);
-                if (!suffix.Empty()) {
+                if (!suffix.empty()) {
                     Out_->Write(suffix);
                 }
 
                 // (2) labels
-                if (!labels.Empty() || !addLabelKey.Empty()) {
+                if (!labels.Empty() || !addLabelKey.empty()) {
                     WriteLabels(labels, addLabelKey, addLabelValue);
                 }
                 Out_->Write(' ');
diff --git a/library/cpp/monlib/encode/prometheus/prometheus_encoder_ut.cpp b/library/cpp/monlib/encode/prometheus/prometheus_encoder_ut.cpp
index fe4bbcaf0a1..fd9debb060e 100644
--- a/library/cpp/monlib/encode/prometheus/prometheus_encoder_ut.cpp
+++ b/library/cpp/monlib/encode/prometheus/prometheus_encoder_ut.cpp
@@ -411,105 +411,4 @@ two{labels="l2", project="solomon", } 42 1500000000000
 
 )");
     }
-
-    Y_UNIT_TEST(FirstCharacterShouldNotBeReplaced) {
-        auto result = EncodeToString([](IMetricEncoder* e) {
-            e->OnStreamBegin();
-            const TVector<std::pair<TString, double>> sensors = {
-                {"0", 0.0},
-                {"50", 50.0},
-                {"90", 90.0},
-                {"99", 99.0},
-                {"100", 100},
-                {"012345", 123.45},
-                {"abc0123", 123.0},
-                {"0123abc", 123.0},
-                };
-
-            for (const auto& [name, value]: sensors) {
-                e->OnMetricBegin(EMetricType::COUNTER);
-                {
-                    e->OnLabelsBegin();
-                    e->OnLabel("sensor", name);
-                    e->OnLabelsEnd();
-                }
-                e->OnDouble(TInstant::Zero(), value);
-                e->OnMetricEnd();
-            }
-            e->OnStreamEnd();
-        });
-
-        UNIT_ASSERT_STRINGS_EQUAL(result,
-R"(# TYPE _0 counter
-_0 0
-# TYPE _50 counter
-_50 50
-# TYPE _90 counter
-_90 90
-# TYPE _99 counter
-_99 99
-# TYPE _100 counter
-_100 100
-# TYPE _012345 counter
-_012345 123.45
-# TYPE abc0123 counter
-abc0123 123
-# TYPE _0123abc counter
-_0123abc 123
-
-)");
-    }
-
-    Y_UNIT_TEST(InvalidCharactersShouldBeReplaced) {
-        auto result = EncodeToString([](IMetricEncoder* e) {
-            e->OnStreamBegin();
-            const TVector<std::pair<TString, double>> sensors = {
-                {"abc/def", 1.0},
-                {"a+-*/=&{}()|bc", 0.1},
-                {"0.0", 0.0},
-                {"99.9", 99.9}};
-
-            for (const auto& [name, value]: sensors) {
-                e->OnMetricBegin(EMetricType::COUNTER);
-                {
-                    e->OnLabelsBegin();
-                    e->OnLabel("sensor", name);
-                    e->OnLabelsEnd();
-                }
-                e->OnDouble(TInstant::Zero(), value);
-                e->OnMetricEnd();
-            }
-            e->OnStreamEnd();
-        });
-
-        UNIT_ASSERT_STRINGS_EQUAL(result,
-R"(# TYPE abc_def counter
-abc_def 1
-# TYPE a___________bc counter
-a___________bc 0.1
-# TYPE _0_0 counter
-_0_0 0
-# TYPE _99_9 counter
-_99_9 99.9
-
-)");
-    }
-
-    Y_UNIT_TEST(ShouldNotFailOnMetricWithoutSensorLabel) {
-        auto result = EncodeToString([](IMetricEncoder* e) {
-            e->OnStreamBegin();
-            e->OnStreamEnd();
-            {
-                e->OnMetricBegin(EMetricType::GAUGE);
-                {
-                    e->OnLabelsBegin();
-                    e->OnLabel("name", "cpuUsage");
-                    e->OnLabelsEnd();
-                }
-                e->OnInt64(TInstant::Zero(), 0);
-                e->OnMetricEnd();
-            }
-        });
-        UNIT_ASSERT_STRINGS_EQUAL(result, "\n");
-    }
 }
diff --git a/library/cpp/monlib/encode/protobuf/protobuf_encoder.cpp b/library/cpp/monlib/encode/protobuf/protobuf_encoder.cpp
index 2d11b9d5ba3..2cffda13ac5 100644
--- a/library/cpp/monlib/encode/protobuf/protobuf_encoder.cpp
+++ b/library/cpp/monlib/encode/protobuf/protobuf_encoder.cpp
@@ -227,6 +227,11 @@ namespace NMonitoring {
                 FillLogHistogram(*snapshot, point->MutableLogHistogram());
             }
 
+            void OnMemOnly(bool isMemOnly) override {
+                Y_ENSURE(Sample_, "metric not started");
+                Sample_->SetIsMemOnly(isMemOnly);
+            }
+
             void Close() override {
             }
 
diff --git a/library/cpp/monlib/encode/protobuf/protos/samples.proto b/library/cpp/monlib/encode/protobuf/protos/samples.proto
index 371f4181d23..a3ca9172212 100644
--- a/library/cpp/monlib/encode/protobuf/protos/samples.proto
+++ b/library/cpp/monlib/encode/protobuf/protos/samples.proto
@@ -59,7 +59,7 @@ message TPoint {
 message TSingleSample {
     repeated TLabel Labels = 1;
     EMetricType MetricType = 2;
-
+    bool IsMemOnly = 10;
     // inlined TPoint
     uint64 Time = 3;
     oneof Value {
@@ -76,6 +76,7 @@ message TMultiSample {
     repeated TLabel Labels = 1;
     EMetricType MetricType = 2;
     repeated TPoint Points = 3;
+    bool IsMemOnly = 4;
 }
 
 message TSingleSamplesList {
diff --git a/library/cpp/monlib/encode/spack/spack_v1.h b/library/cpp/monlib/encode/spack/spack_v1.h
index cf1c9417b90..ce516626e31 100644
--- a/library/cpp/monlib/encode/spack/spack_v1.h
+++ b/library/cpp/monlib/encode/spack/spack_v1.h
@@ -92,7 +92,8 @@ namespace NMonitoring {
     enum ESpackV1Version: ui16 {
         SV1_00 = 0x0100,
         SV1_01 = 0x0101,
-        SV1_02 = 0x0102
+        SV1_02 = 0x0102,
+        SV1_03 = 0x0103
     };
 
     IMetricEncoderPtr EncoderSpackV1(
@@ -110,6 +111,13 @@ namespace NMonitoring {
         TStringBuf metricNameLabel = "name"
     );
 
+    IMetricEncoderPtr EncoderSpackV13(
+        IOutputStream* out,
+        ETimePrecision timePrecision,
+        ECompression compression,
+        EMetricsMergingMode mergingMode = EMetricsMergingMode::DEFAULT
+    );
+
     void DecodeSpackV1(IInputStream* in, IMetricConsumer* c, TStringBuf metricNameLabel = "name");
 
 }
diff --git a/library/cpp/monlib/encode/spack/spack_v1_decoder.cpp b/library/cpp/monlib/encode/spack/spack_v1_decoder.cpp
index 384ef456dd1..7d04aa0d555 100644
--- a/library/cpp/monlib/encode/spack/spack_v1_decoder.cpp
+++ b/library/cpp/monlib/encode/spack/spack_v1_decoder.cpp
@@ -62,22 +62,48 @@ namespace NMonitoring {
 
                 TimePrecision_ = DecodeTimePrecision(Header_.TimePrecision);
 
-                const ui64 labelSizeTotal = ui64(Header_.LabelNamesSize) + Header_.LabelValuesSize;
+                // (2) read string pools
+                TVector<char> namesBuf;
+                TVector<char> valuesBuf;
+
+                if (Header_.Version == SV1_03) {
+                    auto namesResult = ReadLengthDelimitedStringPool(Header_.LabelNamesSize);
+                    namesBuf = std::move(namesResult.first);
+                    auto valuesResult = ReadLengthDelimitedStringPool(Header_.LabelValuesSize);
+                    valuesBuf = std::move(valuesResult.first);
+
+                    TStringPool labelNames(namesBuf.data(), namesResult.second);
+                    TStringPool labelValues(valuesBuf.data(), valuesResult.second);
+
+                    DecodeBody(labelNames, labelValues, c);
+                    return;
+                }
 
+                const ui64 labelSizeTotal = ui64(Header_.LabelNamesSize) + Header_.LabelValuesSize;
                 DECODE_ENSURE(labelSizeTotal <= LABEL_SIZE_LIMIT, "Label names & values size of " << HumanReadableSize(labelSizeTotal, SF_BYTES)
                     << " exceeds the limit which is " << HumanReadableSize(LABEL_SIZE_LIMIT, SF_BYTES));
 
-                // (2) read string pools
-                TVector<char> namesBuf(Header_.LabelNamesSize);
+                namesBuf.resize(Header_.LabelNamesSize);
                 readBytes = In_->Load(namesBuf.data(), namesBuf.size());
                 DECODE_ENSURE(readBytes == Header_.LabelNamesSize, "not enough data to read label names pool");
-                TStringPool labelNames(namesBuf.data(), namesBuf.size());
+                {
+                    TStringPool labelNames(namesBuf.data(), namesBuf.size());
+
+                    valuesBuf.resize(Header_.LabelValuesSize);
+                    readBytes = In_->Load(valuesBuf.data(), valuesBuf.size());
+                    DECODE_ENSURE(readBytes == Header_.LabelValuesSize, "not enough data to read label values pool");
+                    TStringPool labelValues(valuesBuf.data(), valuesBuf.size());
 
-                TVector<char> valuesBuf(Header_.LabelValuesSize);
-                readBytes = In_->Load(valuesBuf.data(), valuesBuf.size());
-                DECODE_ENSURE(readBytes == Header_.LabelValuesSize, "not enough data to read label values pool");
-                TStringPool labelValues(valuesBuf.data(), valuesBuf.size());
+                    DecodeBody(labelNames, labelValues, c);
+                }
+            }
 
+        private:
+            void DecodeBody(
+                    const TStringPool& labelNames,
+                    const TStringPool& labelValues,
+                    IMetricConsumer* c)
+            {
                 // (3) read common time
                 c->OnCommonTime(ReadTime());
 
@@ -93,7 +119,6 @@ namespace NMonitoring {
                 c->OnStreamEnd();
             }
 
-        private:
             void ReadMetrics(
                     const TStringPool& labelNames,
                     const TStringPool& labelValues,
@@ -107,25 +132,25 @@ namespace NMonitoring {
 
                     c->OnMetricBegin(metricType);
 
-                    // TODO: use it
-                    ReadFixed<ui8>(); // skip flags byte
+                    // (5.2) flags byte
+                    c->OnMemOnly(ReadFixed<ui8>() & 0x01);
 
                     auto metricNameValueIndex = std::numeric_limits<ui32>::max();
-                    if (Header_.Version >= SV1_02) {
+                    if (Header_.Version == SV1_02) {
                         metricNameValueIndex = ReadVarint();
                     }
 
-                    // (5.2) labels
+                    // (5.3) labels
                     ui32 labelsCount = ReadVarint();
-                    DECODE_ENSURE(Header_.Version >= SV1_02 || labelsCount > 0, "metric #" << i << " has no labels");
+                    DECODE_ENSURE(Header_.Version == SV1_02 || labelsCount > 0, "metric #" << i << " has no labels");
                     c->OnLabelsBegin();
-                    if (Header_.Version >= SV1_02) {
+                    if (Header_.Version == SV1_02) {
                         c->OnLabel(MetricNameLabel_, labelValues.Get(metricNameValueIndex));
                     }
                     ReadLabels(labelNames, labelValues, labelsCount, c);
                     c->OnLabelsEnd();
 
-                    // (5.3) values
+                    // (5.4) values
                     switch (valueType) {
                         case EValueType::NONE:
                             break;
@@ -273,6 +298,26 @@ namespace NMonitoring {
                 return ReadVarUInt32(In_);
             }
 
+            std::pair<TVector<char>, TVector<std::pair<ui32, ui32>>> ReadLengthDelimitedStringPool(ui32 count) {
+                TVector<char> storage;
+                TVector<std::pair<ui32, ui32>> segments;
+                segments.reserve(count);
+
+                for (ui32 i = 0; i < count; i++) {
+                    ui32 len = ReadVarint();
+                    ui32 offset = static_cast<ui32>(storage.size());
+                    storage.resize(offset + len);
+                    if (len > 0) {
+                        size_t readBytes = In_->Load(storage.data() + offset, len);
+                        DECODE_ENSURE(readBytes == len, "not enough data to read string #" << i
+                            << " (expected " << len << " bytes, got " << readBytes << ")");
+                    }
+                    segments.emplace_back(offset, len);
+                }
+
+                return {std::move(storage), std::move(segments)};
+            }
+
         private:
             IInputStream* In_;
             TString MetricNameLabel_;
diff --git a/library/cpp/monlib/encode/spack/spack_v1_encoder.cpp b/library/cpp/monlib/encode/spack/spack_v1_encoder.cpp
index a2b0bb5f50a..ac9934b0593 100644
--- a/library/cpp/monlib/encode/spack/spack_v1_encoder.cpp
+++ b/library/cpp/monlib/encode/spack/spack_v1_encoder.cpp
@@ -31,7 +31,7 @@ namespace NMonitoring {
                 , TimePrecision_(timePrecision)
                 , Compression_(compression)
                 , Version_(version)
-                , MetricName_(Version_ >= SV1_02 ? LabelNamesPool_.PutIfAbsent(metricNameLabel) : nullptr)
+                , MetricName_(Version_ == SV1_02 ? LabelNamesPool_.PutIfAbsent(metricNameLabel) : nullptr)
             {
                 MetricsMergingMode_ = mergingMode;
 
@@ -68,6 +68,10 @@ namespace NMonitoring {
                 TBufferedEncoderBase::OnLogHistogram(time, snapshot);
             }
 
+            void OnMemOnly(bool isMemOnly) override {
+                TBufferedEncoderBase::OnMemOnly(isMemOnly);
+            }
+
             void Close() override {
                 if (Closed_) {
                     return;
@@ -92,10 +96,15 @@ namespace NMonitoring {
                 header.Version = Version_;
                 header.TimePrecision = EncodeTimePrecision(TimePrecision_);
                 header.Compression = EncodeCompression(Compression_);
-                header.LabelNamesSize = static_cast<ui32>(
-                    LabelNamesPool_.BytesSize() + LabelNamesPool_.Count());
-                header.LabelValuesSize = static_cast<ui32>(
-                    LabelValuesPool_.BytesSize() + LabelValuesPool_.Count());
+                if (Version_ == SV1_03) {
+                    header.LabelNamesSize = static_cast<ui32>(LabelNamesPool_.Count());
+                    header.LabelValuesSize = static_cast<ui32>(LabelValuesPool_.Count());
+                } else {
+                    header.LabelNamesSize = static_cast<ui32>(
+                        LabelNamesPool_.BytesSize() + LabelNamesPool_.Count());
+                    header.LabelValuesSize = static_cast<ui32>(
+                        LabelValuesPool_.BytesSize() + LabelValuesPool_.Count());
+                }
                 header.MetricCount = Metrics_.size();
                 header.PointsCount = pointsCount;
                 Out_->Write(&header, sizeof(header));
@@ -107,13 +116,21 @@ namespace NMonitoring {
                 }
 
                 // (2) write string pools
-                auto strPoolWrite = [this](TStringBuf str, ui32, ui32) {
-                    Out_->Write(str);
-                    Out_->Write('\0');
-                };
-
-                LabelNamesPool_.ForEach(strPoolWrite);
-                LabelValuesPool_.ForEach(strPoolWrite);
+                if (Version_ == SV1_03) {
+                    auto strPoolWrite = [this](TStringBuf str, ui32, ui32) {
+                        WriteVarUInt32(Out_, static_cast<ui32>(str.size()));
+                        Out_->Write(str);
+                    };
+                    LabelNamesPool_.ForEach(strPoolWrite);
+                    LabelValuesPool_.ForEach(strPoolWrite);
+                } else {
+                    auto strPoolWrite = [this](TStringBuf str, ui32, ui32) {
+                        Out_->Write(str);
+                        Out_->Write('\0');
+                    };
+                    LabelNamesPool_.ForEach(strPoolWrite);
+                    LabelValuesPool_.ForEach(strPoolWrite);
+                }
 
                 // (3) write common time
                 WriteTime(CommonTime_);
@@ -128,12 +145,12 @@ namespace NMonitoring {
                     ui8 typesByte = PackTypes(metric);
                     Out_->Write(&typesByte, sizeof(typesByte));
 
-                    // TODO: implement
-                    ui8 flagsByte = 0x00;
+                    // (5.2) flags byte
+                    ui8 flagsByte = metric.IsMemOnly & 0x01;
                     Out_->Write(&flagsByte, sizeof(flagsByte));
 
                     // v1.2 format addition — metric name
-                    if (Version_ >= SV1_02) {
+                    if (Version_ == SV1_02) {
                         const auto it = FindIf(metric.Labels, [&](const auto& l) {
                             return l.Key == MetricName_;
                         });
@@ -143,10 +160,10 @@ namespace NMonitoring {
                         WriteVarUInt32(Out_, it->Value->Index);
                     }
 
-                    // (5.2) labels
+                    // (5.3) labels
                     WriteLabels(metric.Labels, MetricName_);
 
-                    // (5.3) values
+                    // (5.4) values
                     switch (metric.TimeSeries.Size()) {
                         case 0:
                             break;
@@ -312,7 +329,16 @@ namespace NMonitoring {
         EMetricsMergingMode mergingMode,
         TStringBuf metricNameLabel
     ) {
-        Y_ENSURE(!metricNameLabel.Empty(), "metricNameLabel can't be empty");
+        Y_ENSURE(!metricNameLabel.empty(), "metricNameLabel can't be empty");
         return MakeHolder<TEncoderSpackV1>(out, timePrecision, compression, mergingMode, SV1_02, metricNameLabel);
     }
+
+    IMetricEncoderPtr EncoderSpackV13(
+        IOutputStream* out,
+        ETimePrecision timePrecision,
+        ECompression compression,
+        EMetricsMergingMode mergingMode
+    ) {
+        return MakeHolder<TEncoderSpackV1>(out, timePrecision, compression, mergingMode, SV1_03, "");
+    }
 }
diff --git a/library/cpp/monlib/encode/spack/spack_v1_ut.cpp b/library/cpp/monlib/encode/spack/spack_v1_ut.cpp
index fe778eb7e02..2a75f441f2d 100644
--- a/library/cpp/monlib/encode/spack/spack_v1_ut.cpp
+++ b/library/cpp/monlib/encode/spack/spack_v1_ut.cpp
@@ -2,6 +2,7 @@
 
 #include <library/cpp/monlib/encode/protobuf/protobuf.h>
 #include <library/cpp/monlib/metrics/labels.h>
+#include <library/cpp/monlib/metrics/histogram_snapshot.h>
 #include <library/cpp/monlib/metrics/metric.h>
 
 #include <library/cpp/testing/unittest/registar.h>
@@ -104,7 +105,7 @@ Y_UNIT_TEST_SUITE(TSpackTest) {
 
     ui8 expectedMetric1[] = {
         0x0C, // types (RATE | NONE)                     (fixed ui8)
-        0x00, // flags                                   (fixed ui8)
+        0x01, // flags                                   (fixed ui8)
         0x01, // metric labels count                     (varint)
         0x00, // label name index                        (varint)
         0x01, // label value index                       (varint)
@@ -282,6 +283,7 @@ Y_UNIT_TEST_SUITE(TSpackTest) {
                 e->OnLabelsBegin();
                 e->OnLabel("name", "q1");
                 e->OnLabelsEnd();
+                e->OnMemOnly(true);
             }
             e->OnMetricEnd();
         }
@@ -513,12 +515,14 @@ Y_UNIT_TEST_SUITE(TSpackTest) {
         {
             const NProto::TMultiSample& s = samples.GetSamples(0);
             UNIT_ASSERT_EQUAL(s.GetMetricType(), NProto::RATE);
+            UNIT_ASSERT_EQUAL(s.GetIsMemOnly(), true);
             UNIT_ASSERT_VALUES_EQUAL(s.LabelsSize(), 1);
             AssertLabelEqual(s.GetLabels(0), "name", "q1");
         }
         {
             const NProto::TMultiSample& s = samples.GetSamples(1);
             UNIT_ASSERT_EQUAL(s.GetMetricType(), NProto::COUNTER);
+            UNIT_ASSERT_EQUAL(s.GetIsMemOnly(), false);
             UNIT_ASSERT_VALUES_EQUAL(s.LabelsSize(), 1);
             AssertLabelEqual(s.GetLabels(0), "name", "q2");
 
@@ -528,6 +532,7 @@ Y_UNIT_TEST_SUITE(TSpackTest) {
         {
             const NProto::TMultiSample& s = samples.GetSamples(2);
             UNIT_ASSERT_EQUAL(s.GetMetricType(), NProto::COUNTER);
+            UNIT_ASSERT_EQUAL(s.GetIsMemOnly(), false);
             UNIT_ASSERT_VALUES_EQUAL(s.LabelsSize(), 1);
             AssertLabelEqual(s.GetLabels(0), "name", "q3");
 
@@ -537,6 +542,7 @@ Y_UNIT_TEST_SUITE(TSpackTest) {
         {
             const NProto::TMultiSample& s = samples.GetSamples(3);
             UNIT_ASSERT_EQUAL(s.GetMetricType(), NProto::GAUGE);
+            UNIT_ASSERT_EQUAL(s.GetIsMemOnly(), false);
             UNIT_ASSERT_VALUES_EQUAL(s.LabelsSize(), 1);
             AssertLabelEqual(s.GetLabels(0), "name", "answer");
 
@@ -547,6 +553,7 @@ Y_UNIT_TEST_SUITE(TSpackTest) {
         {
             const NProto::TMultiSample& s = samples.GetSamples(4);
             UNIT_ASSERT_EQUAL(s.GetMetricType(), NProto::HISTOGRAM);
+            UNIT_ASSERT_EQUAL(s.GetIsMemOnly(), false);
             UNIT_ASSERT_VALUES_EQUAL(s.LabelsSize(), 1);
             AssertLabelEqual(s.GetLabels(0), "name", "responseTimeMillis");
 
@@ -570,6 +577,7 @@ Y_UNIT_TEST_SUITE(TSpackTest) {
         {
             const NProto::TMultiSample& s = samples.GetSamples(5);
             UNIT_ASSERT_EQUAL(s.GetMetricType(), NProto::IGAUGE);
+            UNIT_ASSERT_EQUAL(s.GetIsMemOnly(), false);
             UNIT_ASSERT_VALUES_EQUAL(s.LabelsSize(), 1);
             AssertLabelEqual(s.GetLabels(0), "name", "bytes");
 
@@ -579,6 +587,7 @@ Y_UNIT_TEST_SUITE(TSpackTest) {
         {
             const NProto::TMultiSample& s = samples.GetSamples(6);
             UNIT_ASSERT_EQUAL(s.GetMetricType(), NProto::DSUMMARY);
+            UNIT_ASSERT_EQUAL(s.GetIsMemOnly(), false);
             UNIT_ASSERT_VALUES_EQUAL(s.LabelsSize(), 1);
             AssertLabelEqual(s.GetLabels(0), "name", "temperature");
 
@@ -601,6 +610,7 @@ Y_UNIT_TEST_SUITE(TSpackTest) {
         {
             const NProto::TMultiSample& s = samples.GetSamples(7);
             UNIT_ASSERT_EQUAL(s.GetMetricType(), NProto::LOGHISTOGRAM);
+            UNIT_ASSERT_EQUAL(s.GetIsMemOnly(), false);
             UNIT_ASSERT_VALUES_EQUAL(s.LabelsSize(), 1);
             AssertLabelEqual(s.GetLabels(0), "name", "ms");
 
@@ -802,6 +812,417 @@ Y_UNIT_TEST_SUITE(TSpackTest) {
         }
     }
 
+    Y_UNIT_TEST(SimpleV13) {
+        ui8 expectedSerialized[] = {
+            // header
+            0x53, 0x50,             // magic "SP"                     (fixed ui16)
+        // minor, major
+            0x03, 0x01,             // version                        (fixed ui16)
+            0x18, 0x00,             // header size                    (fixed ui16)
+            0x00,                   // time precision                 (fixed ui8)
+            0x00,                   // compression algorithm          (fixed ui8)
+            0x02, 0x00, 0x00, 0x00, // label names count  (fixed ui32) -- 2 names: "project", "name"
+            0x03, 0x00, 0x00, 0x00, // label values count (fixed ui32) -- 3 values: "solomon", "temperature", "speed"
+            0x02, 0x00, 0x00, 0x00, // metric count       (fixed ui32)
+            0x02, 0x00, 0x00, 0x00, // points count       (fixed ui32)
+
+            // string pools (length-delimited)
+            // label names (sorted by frequency: "name" appears 2x, "project" 1x)
+            0x04, 0x6e, 0x61, 0x6d, 0x65,                   // varint(4) + "name"
+            0x07, 0x70, 0x72, 0x6f, 0x6a, 0x65, 0x63, 0x74, // varint(7) + "project"
+            // label values (sorted by frequency: all appear 1x, insertion order preserved)
+            0x07, 0x73, 0x6f, 0x6c, 0x6f, 0x6d, 0x6f, 0x6e, // varint(7) + "solomon"
+            0x0b, 0x74, 0x65, 0x6d, 0x70, 0x65, 0x72, 0x61, // varint(11) + "temperature"
+            0x74, 0x75, 0x72, 0x65,
+            0x05, 0x73, 0x70, 0x65, 0x65, 0x64,              // varint(5) + "speed"
+
+            // common time
+            0x00, 0x2f, 0x68, 0x59, // common time in seconds         (fixed ui32)
+
+            // common labels
+            0x01,                   // common labels count             (varint)
+            0x01,                   // label name index (project)      (varint)
+            0x00,                   // label value index (solomon)     (varint)
+
+            // metric 1: COUNTER, ONE_WITHOUT_TS
+            0x09,                                           // types (COUNTER | ONE_WITHOUT_TS)        (fixed ui8)
+            0x00,                                           // flags                                   (fixed ui8)
+            // no metric name index (v1_3 does not have it)
+            0x01,                                           // metric labels count                     (varint)
+            0x00,                                           // label name index (name)                 (varint)
+            0x01,                                           // label value index (temperature)         (varint)
+            0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // value 17 (fixed ui64)
+
+            // metric 2: GAUGE, ONE_WITH_TS
+            0x06,                                           // types (GAUGE | ONE_WITH_TS)             (fixed ui8)
+            0x00,                                           // flags                                   (fixed ui8)
+            0x01,                                           // metric labels count                     (varint)
+            0x00,                                           // label name index (name)                 (varint)
+            0x02,                                           // label value index (speed)               (varint)
+            0x0b, 0x63, 0xfe, 0x59,                         // time in seconds                         (fixed ui32)
+            0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x45, 0x40, // value 42.0 (double IEEE754)
+        };
+
+        // encode
+        {
+            TBuffer actualSerialized;
+            {
+                TBufferOutput out(actualSerialized);
+                auto e = EncoderSpackV13(
+                    &out,
+                    ETimePrecision::SECONDS,
+                    ECompression::IDENTITY);
+
+                e->OnStreamBegin();
+                e->OnCommonTime(TInstant::Seconds(1500000000));
+                {
+                    e->OnLabelsBegin();
+                    e->OnLabel("project", "solomon");
+                    e->OnLabelsEnd();
+                }
+
+                {
+                    e->OnMetricBegin(EMetricType::COUNTER);
+                    {
+                        e->OnLabelsBegin();
+                        e->OnLabel("name", "temperature");
+                        e->OnLabelsEnd();
+                    }
+                    e->OnUint64(TInstant::Zero(), 17);
+                    e->OnMetricEnd();
+                }
+
+                {
+                    e->OnMetricBegin(EMetricType::GAUGE);
+                    {
+                        e->OnLabelsBegin();
+                        e->OnLabel("name", "speed");
+                        e->OnLabelsEnd();
+                    }
+                    e->OnDouble(now, 42);
+                    e->OnMetricEnd();
+                }
+
+                e->OnStreamEnd();
+                e->Close();
+            }
+
+            UNIT_ASSERT_VALUES_EQUAL(actualSerialized.Size(), Y_ARRAY_SIZE(expectedSerialized));
+            UNIT_ASSERT_BINARY_EQUALS(actualSerialized.Data(), expectedSerialized);
+        }
+
+        // decode
+        {
+            NProto::TMultiSamplesList samples;
+            {
+                auto input = TMemoryInput(expectedSerialized, Y_ARRAY_SIZE(expectedSerialized));
+                auto encoder = EncoderProtobuf(&samples);
+                DecodeSpackV1(&input, encoder.Get());
+            }
+
+            UNIT_ASSERT_VALUES_EQUAL(TInstant::MilliSeconds(samples.GetCommonTime()),
+                                     TInstant::Seconds(1500000000));
+
+            UNIT_ASSERT_VALUES_EQUAL(samples.CommonLabelsSize(), 1);
+            AssertLabelEqual(samples.GetCommonLabels(0), "project", "solomon");
+
+            UNIT_ASSERT_VALUES_EQUAL(samples.SamplesSize(), 2);
+            {
+                const auto& s = samples.GetSamples(0);
+                UNIT_ASSERT_EQUAL(s.GetMetricType(), NProto::COUNTER);
+                UNIT_ASSERT_VALUES_EQUAL(s.LabelsSize(), 1);
+                AssertLabelEqual(s.GetLabels(0), "name", "temperature");
+                UNIT_ASSERT_VALUES_EQUAL(s.PointsSize(), 1);
+                AssertPointEqual(s.GetPoints(0), TInstant::Zero(), ui64(17));
+            }
+            {
+                const auto& s = samples.GetSamples(1);
+                UNIT_ASSERT_EQUAL(s.GetMetricType(), NProto::GAUGE);
+                UNIT_ASSERT_VALUES_EQUAL(s.LabelsSize(), 1);
+                AssertLabelEqual(s.GetLabels(0), "name", "speed");
+                UNIT_ASSERT_VALUES_EQUAL(s.PointsSize(), 1);
+                AssertPointEqual(s.GetPoints(0), now, double(42));
+            }
+        }
+    }
+
+    // Ported from Java MetricSpackEncoderTest.doEncodeDecode
+    void V13EncodeDecodeImpl(ETimePrecision timePrecision, ECompression compression) {
+        const TInstant commonTime = TInstant::Seconds(1500000000);
+        const TInstant alignedNow = (timePrecision == ETimePrecision::SECONDS)
+            ? TInstant::Seconds(now.Seconds())
+            : now;
+
+        // label value with embedded null bytes (v1_3 feature)
+        TStringBuilder nullLabelBuilder;
+        nullLabelBuilder << "thįs";
+        nullLabelBuilder << '\0';
+        nullLabelBuilder << "īs";
+        nullLabelBuilder << '\0';
+        nullLabelBuilder << "fïne";
+
+        TString nullLabel = nullLabelBuilder;
+        UNIT_ASSERT_VALUES_EQUAL(nullLabel.size(), 15u);
+
+        TBuffer buffer;
+        {
+            TBufferOutput out(buffer);
+            auto e = EncoderSpackV13(&out, timePrecision, compression);
+
+            e->OnStreamBegin();
+            e->OnCommonTime(commonTime);
+            {
+                e->OnLabelsBegin();
+                e->OnLabel("project", "solomon");
+                e->OnLabel("cluster", "production");
+                e->OnLabel("service", "stockpile");
+                e->OnLabelsEnd();
+            }
+            { // metric #1 (no values)
+                e->OnMetricBegin(EMetricType::GAUGE);
+                {
+                    e->OnLabelsBegin();
+                    e->OnLabel("sensor", "q1");
+                    e->OnLabelsEnd();
+                }
+                e->OnMetricEnd();
+            }
+            { // metric #2 (one value without ts)
+                e->OnMetricBegin(EMetricType::COUNTER);
+                {
+                    e->OnLabelsBegin();
+                    e->OnLabel("sensor", "q2");
+                    e->OnLabelsEnd();
+                }
+                e->OnUint64(TInstant::Zero(), 42);
+                e->OnMetricEnd();
+            }
+            { // metric #3 (one value with ts)
+                e->OnMetricBegin(EMetricType::GAUGE);
+                {
+                    e->OnLabelsBegin();
+                    e->OnLabel("sensor", "q3");
+                    e->OnLabelsEnd();
+                }
+                e->OnDouble(alignedNow + TDuration::Seconds(5), 3.14159);
+                e->OnMetricEnd();
+            }
+            { // metric #4 (many values with ts)
+                e->OnMetricBegin(EMetricType::COUNTER);
+                {
+                    e->OnLabelsBegin();
+                    e->OnLabel("sensor", "q4");
+                    e->OnLabelsEnd();
+                }
+                e->OnUint64(alignedNow + TDuration::Seconds(5), 43);
+                e->OnUint64(alignedNow + TDuration::Seconds(10), 44);
+                e->OnUint64(alignedNow + TDuration::Seconds(15), 45);
+                e->OnMetricEnd();
+            }
+            { // metric #5 (igauge)
+                e->OnMetricBegin(EMetricType::IGAUGE);
+                {
+                    e->OnLabelsBegin();
+                    e->OnLabel("sensor", "q5");
+                    e->OnLabelsEnd();
+                }
+                e->OnInt64(alignedNow, 46);
+                e->OnMetricEnd();
+            }
+            { // metric #6 (hist_rate)
+                e->OnMetricBegin(EMetricType::HIST_RATE);
+                {
+                    e->OnLabelsBegin();
+                    e->OnLabel("sensor", "q6");
+                    e->OnLabelsEnd();
+                }
+                auto h = ExplicitHistogramSnapshot({10, 20, 30, Max<double>()}, {0, 1, 0, 100});
+                e->OnHistogram(alignedNow, h);
+                e->OnMetricEnd();
+            }
+            { // metric #7 (hist, many values)
+                e->OnMetricBegin(EMetricType::HIST);
+                {
+                    e->OnLabelsBegin();
+                    e->OnLabel("sensor", "q7");
+                    e->OnLabelsEnd();
+                }
+                {
+                    auto h = ExplicitHistogramSnapshot({10, 20, 30, Max<double>()}, {0, 1, 0, 13});
+                    e->OnHistogram(alignedNow + TDuration::Seconds(5), h);
+                }
+                {
+                    auto h = ExplicitHistogramSnapshot({10, 20, 30, Max<double>()}, {1, 0, 2, 42});
+                    e->OnHistogram(alignedNow + TDuration::Seconds(10), h);
+                }
+                e->OnMetricEnd();
+            }
+            { // metric #8 (counter with embedded null bytes in label)
+                e->OnMetricBegin(EMetricType::COUNTER);
+                {
+                    e->OnLabelsBegin();
+                    e->OnLabel("sensor", nullLabel);
+                    e->OnLabelsEnd();
+                }
+                e->OnUint64(TInstant::Zero(), 1234);
+                e->OnMetricEnd();
+            }
+            { // metric #9 (mem-only)
+                e->OnMetricBegin(EMetricType::COUNTER);
+                {
+                    e->OnLabelsBegin();
+                    e->OnLabel("sensor", "aggregate");
+                    e->OnLabelsEnd();
+                }
+                e->OnUint64(TInstant::Zero(), 42);
+                e->OnMemOnly(true);
+                e->OnMetricEnd();
+            }
+            e->OnStreamEnd();
+            e->Close();
+        }
+
+        // verify header
+        auto* header = reinterpret_cast<const TSpackHeader*>(buffer.Data());
+        UNIT_ASSERT_VALUES_EQUAL(header->Version, static_cast<ui16>(SV1_03));
+        UNIT_ASSERT_VALUES_EQUAL(DecodeCompression(header->Compression), compression);
+        UNIT_ASSERT_VALUES_EQUAL(header->MetricCount, 9u);
+        UNIT_ASSERT_VALUES_EQUAL(header->PointsCount, 11u);
+
+        // decode and verify
+        NProto::TMultiSamplesList samples;
+        {
+            IMetricEncoderPtr e = EncoderProtobuf(&samples);
+            TBufferInput in(buffer);
+            DecodeSpackV1(&in, e.Get());
+        }
+
+        UNIT_ASSERT_VALUES_EQUAL(
+            TInstant::MilliSeconds(samples.GetCommonTime()),
+            commonTime);
+
+        UNIT_ASSERT_VALUES_EQUAL(samples.CommonLabelsSize(), 3);
+        AssertLabelEqual(samples.GetCommonLabels(0), "project", "solomon");
+        AssertLabelEqual(samples.GetCommonLabels(1), "cluster", "production");
+        AssertLabelEqual(samples.GetCommonLabels(2), "service", "stockpile");
+
+        UNIT_ASSERT_VALUES_EQUAL(samples.SamplesSize(), 9);
+        { // #1 no values
+            const auto& s = samples.GetSamples(0);
+            UNIT_ASSERT_EQUAL(s.GetMetricType(), NProto::GAUGE);
+            UNIT_ASSERT_VALUES_EQUAL(s.LabelsSize(), 1);
+            AssertLabelEqual(s.GetLabels(0), "sensor", "q1");
+            UNIT_ASSERT_VALUES_EQUAL(s.PointsSize(), 0);
+        }
+        { // #2 one value without ts
+            const auto& s = samples.GetSamples(1);
+            UNIT_ASSERT_EQUAL(s.GetMetricType(), NProto::COUNTER);
+            UNIT_ASSERT_VALUES_EQUAL(s.LabelsSize(), 1);
+            AssertLabelEqual(s.GetLabels(0), "sensor", "q2");
+            UNIT_ASSERT_VALUES_EQUAL(s.PointsSize(), 1);
+            AssertPointEqual(s.GetPoints(0), TInstant::Zero(), ui64(42));
+        }
+        { // #3 one value with ts
+            const auto& s = samples.GetSamples(2);
+            UNIT_ASSERT_EQUAL(s.GetMetricType(), NProto::GAUGE);
+            UNIT_ASSERT_VALUES_EQUAL(s.LabelsSize(), 1);
+            AssertLabelEqual(s.GetLabels(0), "sensor", "q3");
+            UNIT_ASSERT_VALUES_EQUAL(s.PointsSize(), 1);
+            AssertPointEqual(s.GetPoints(0), alignedNow + TDuration::Seconds(5), 3.14159);
+        }
+        { // #4 many values with ts
+            const auto& s = samples.GetSamples(3);
+            UNIT_ASSERT_EQUAL(s.GetMetricType(), NProto::COUNTER);
+            UNIT_ASSERT_VALUES_EQUAL(s.LabelsSize(), 1);
+            AssertLabelEqual(s.GetLabels(0), "sensor", "q4");
+            UNIT_ASSERT_VALUES_EQUAL(s.PointsSize(), 3);
+            AssertPointEqual(s.GetPoints(0), alignedNow + TDuration::Seconds(5), ui64(43));
+            AssertPointEqual(s.GetPoints(1), alignedNow + TDuration::Seconds(10), ui64(44));
+            AssertPointEqual(s.GetPoints(2), alignedNow + TDuration::Seconds(15), ui64(45));
+        }
+        { // #5 igauge
+            const auto& s = samples.GetSamples(4);
+            UNIT_ASSERT_EQUAL(s.GetMetricType(), NProto::IGAUGE);
+            UNIT_ASSERT_VALUES_EQUAL(s.LabelsSize(), 1);
+            AssertLabelEqual(s.GetLabels(0), "sensor", "q5");
+            UNIT_ASSERT_VALUES_EQUAL(s.PointsSize(), 1);
+            AssertPointEqual(s.GetPoints(0), alignedNow, i64(46));
+        }
+        { // #6 hist_rate
+            const auto& s = samples.GetSamples(5);
+            UNIT_ASSERT_EQUAL(s.GetMetricType(), NProto::HIST_RATE);
+            UNIT_ASSERT_VALUES_EQUAL(s.LabelsSize(), 1);
+            AssertLabelEqual(s.GetLabels(0), "sensor", "q6");
+            UNIT_ASSERT_VALUES_EQUAL(s.PointsSize(), 1);
+
+            const auto& h = s.GetPoints(0).GetHistogram();
+            UNIT_ASSERT_VALUES_EQUAL(h.BoundsSize(), 4u);
+            UNIT_ASSERT_VALUES_EQUAL(h.ValuesSize(), 4u);
+        }
+        { // #7 hist, many
+            const auto& s = samples.GetSamples(6);
+            UNIT_ASSERT_EQUAL(s.GetMetricType(), NProto::HISTOGRAM);
+            UNIT_ASSERT_VALUES_EQUAL(s.LabelsSize(), 1);
+            AssertLabelEqual(s.GetLabels(0), "sensor", "q7");
+            UNIT_ASSERT_VALUES_EQUAL(s.PointsSize(), 2);
+        }
+        { // #8 embedded null bytes in label
+            const auto& s = samples.GetSamples(7);
+            UNIT_ASSERT_EQUAL(s.GetMetricType(), NProto::COUNTER);
+            UNIT_ASSERT_VALUES_EQUAL(s.LabelsSize(), 1);
+            UNIT_ASSERT_STRINGS_EQUAL(s.GetLabels(0).GetName(), "sensor");
+            UNIT_ASSERT_VALUES_EQUAL(s.GetLabels(0).GetValue().size(), nullLabel.size());
+            UNIT_ASSERT_VALUES_EQUAL(s.GetLabels(0).GetValue(), nullLabel);
+            UNIT_ASSERT_VALUES_EQUAL(s.PointsSize(), 1);
+            AssertPointEqual(s.GetPoints(0), TInstant::Zero(), ui64(1234));
+        }
+        { // #9 mem-only
+            const auto& s = samples.GetSamples(8);
+            UNIT_ASSERT_EQUAL(s.GetMetricType(), NProto::COUNTER);
+            UNIT_ASSERT_EQUAL(s.GetIsMemOnly(), true);
+            UNIT_ASSERT_VALUES_EQUAL(s.LabelsSize(), 1);
+            AssertLabelEqual(s.GetLabels(0), "sensor", "aggregate");
+            UNIT_ASSERT_VALUES_EQUAL(s.PointsSize(), 1);
+            AssertPointEqual(s.GetPoints(0), TInstant::Zero(), ui64(42));
+        }
+    }
+
+    Y_UNIT_TEST(V13EncodeDecodeSeconds) {
+        V13EncodeDecodeImpl(ETimePrecision::SECONDS, ECompression::IDENTITY);
+    }
+
+    Y_UNIT_TEST(V13EncodeDecodeMillis) {
+        V13EncodeDecodeImpl(ETimePrecision::MILLIS, ECompression::IDENTITY);
+    }
+
+    Y_UNIT_TEST(V13EncodeDecodeZlib) {
+        V13EncodeDecodeImpl(ETimePrecision::SECONDS, ECompression::ZLIB);
+    }
+
+    Y_UNIT_TEST(V13EncodeDecodeZstd) {
+        V13EncodeDecodeImpl(ETimePrecision::SECONDS, ECompression::ZSTD);
+    }
+
+    Y_UNIT_TEST(V13EncodeDecodeLz4) {
+        V13EncodeDecodeImpl(ETimePrecision::SECONDS, ECompression::LZ4);
+    }
+
+    Y_UNIT_TEST(V13EmptyStream) {
+        TBuffer buffer;
+        {
+            TBufferOutput out(buffer);
+            auto e = EncoderSpackV13(&out, ETimePrecision::SECONDS, ECompression::IDENTITY);
+            e->OnStreamBegin();
+            e->OnStreamEnd();
+            e->Close();
+        }
+
+        auto* header = reinterpret_cast<const TSpackHeader*>(buffer.Data());
+        UNIT_ASSERT_VALUES_EQUAL(header->Version, static_cast<ui16>(SV1_03));
+        UNIT_ASSERT_VALUES_EQUAL(header->MetricCount, 0u);
+        UNIT_ASSERT_VALUES_EQUAL(header->PointsCount, 0u);
+    }
+
     Y_UNIT_TEST(V12MissingNameForOneMetric) {
         TBuffer b;
         TBufferOutput out(b);
diff --git a/library/cpp/monlib/encode/unistat/unistat.h b/library/cpp/monlib/encode/unistat/unistat.h
index 300fb6270fa..2847c2c1b17 100644
--- a/library/cpp/monlib/encode/unistat/unistat.h
+++ b/library/cpp/monlib/encode/unistat/unistat.h
@@ -6,8 +6,18 @@
 namespace NMonitoring {
     /// Decodes unistat-style metrics
     /// https://wiki.yandex-team.ru/golovan/stat-handle
-    void DecodeUnistat(TStringBuf data, class IMetricConsumer* c, TStringBuf metricNameLabel = "sensor", TInstant ts = TInstant::Zero());
+    void DecodeUnistat(
+            TStringBuf data,
+            class IMetricConsumer* c,
+            TStringBuf metricNameLabel = "sensor",
+            TStringBuf metricNamePrefix = "",
+            TInstant ts = TInstant::Zero());
 
     /// Assumes consumer's stream is open by the caller
-    void DecodeUnistatToStream(TStringBuf data, class IMetricConsumer* c, TStringBuf metricNameLabel = "sensor", TInstant ts = TInstant::Zero());
-}
+    void DecodeUnistatToStream(
+            TStringBuf data,
+            class IMetricConsumer* c,
+            TStringBuf metricNameLabel = "sensor",
+            TStringBuf metricNamePrefix = "",
+            TInstant ts = TInstant::Zero());
+} // namespace NMonitoring
diff --git a/library/cpp/monlib/encode/unistat/unistat_decoder.cpp b/library/cpp/monlib/encode/unistat/unistat_decoder.cpp
index a2b787365cb..9b56e0b6a22 100644
--- a/library/cpp/monlib/encode/unistat/unistat_decoder.cpp
+++ b/library/cpp/monlib/encode/unistat/unistat_decoder.cpp
@@ -15,7 +15,7 @@
 
 using namespace NJson;
 
-const re2::RE2 NAME_RE{R"((?:[a-zA-Z0-9\.\-/@_]+_)+(?:[ad][vehmntx]{3}|summ|hgram|max))"};
+const re2::RE2 NAME_RE{R"((?:[a-zA-Z0-9\.\-/@_]+_)+(?:[advehmntx][vehmntx]{3}|summ|hgram|max))"};
 
 namespace NMonitoring {
     namespace {
@@ -116,9 +116,15 @@ namespace NMonitoring {
         class TDecoderUnistat {
         private:
         public:
-            explicit TDecoderUnistat(IMetricConsumer* consumer, IInputStream* is, TStringBuf metricNameLabel, TInstant ts)
+            explicit TDecoderUnistat(
+                    IMetricConsumer* consumer,
+                    IInputStream* is,
+                    TStringBuf metricNameLabel,
+                    TStringBuf metricNamePrefix,
+                    TInstant ts)
                 : Consumer_{consumer},
-                MetricNameLabel(metricNameLabel),
+                MetricNameLabel_(metricNameLabel),
+                MetricNamePrefix_(metricNamePrefix),
                 Timestamp_{ts} {
                 ReadJsonTree(is, &Json_, /* throw */ true);
             }
@@ -144,7 +150,7 @@ namespace NMonitoring {
                             OnHistogram(value);
                         }
                     } else if (IsNumber(value)) {
-                        if (MetricContext_.Name.EndsWith("_ahhh")) {
+                        if (MetricContext_.Name.EndsWith("hhh") && !MetricContext_.IsDeriv) {
                             OnLogHistogram(value);
                         } else {
                             OnScalar(value);
@@ -169,7 +175,8 @@ namespace NMonitoring {
             }
 
             void OnLogHistogram(const TJsonValue& value) {
-                Y_ENSURE(MetricContext_.Name.EndsWith("_ahhh"), "Values list is supported only for _ahhh metrics");
+                Y_ENSURE(MetricContext_.Name.EndsWith("hhh") && !MetricContext_.IsDeriv,
+                        "Values list is supported only for histogram metrics");
                 MetricContext_.Type = EMetricType::HIST;
 
                 LogHistogramBuilder histogramBuilder;
@@ -251,7 +258,7 @@ namespace NMonitoring {
                 Consumer_->OnMetricBegin(MetricContext_.Type);
 
                 Consumer_->OnLabelsBegin();
-                Consumer_->OnLabel(MetricNameLabel, TString{MetricContext_.Name});
+                Consumer_->OnLabel(MetricNameLabel_, TStringBuilder{} << MetricNamePrefix_ << MetricContext_.Name);
                 for (auto&& l : MetricContext_.Labels) {
                     Consumer_->OnLabel(l.Name(), l.Value());
                 }
@@ -283,7 +290,8 @@ namespace NMonitoring {
         private:
             IMetricConsumer* Consumer_;
             NJson::TJsonValue Json_;
-            TStringBuf MetricNameLabel;
+            TStringBuf MetricNameLabel_;
+            TStringBuf MetricNamePrefix_;
             TInstant Timestamp_;
 
             struct {
@@ -298,15 +306,27 @@ namespace NMonitoring {
 
     }
 
-    void DecodeUnistat(TStringBuf data, IMetricConsumer* c, TStringBuf metricNameLabel, TInstant ts) {
-        c->OnStreamBegin();
-        DecodeUnistatToStream(data, c, metricNameLabel, ts);
-        c->OnStreamEnd();
+    void DecodeUnistat(
+            TStringBuf data,
+            IMetricConsumer* c,
+            TStringBuf metricNameLabel,
+            TStringBuf metricNamePrefix,
+            TInstant ts)
+    {
+      c->OnStreamBegin();
+      DecodeUnistatToStream(data, c, metricNameLabel, metricNamePrefix, ts);
+      c->OnStreamEnd();
     }
 
-    void DecodeUnistatToStream(TStringBuf data, IMetricConsumer* c, TStringBuf metricNameLabel, TInstant ts) {
-        TMemoryInput in{data.data(), data.size()};
-        TDecoderUnistat decoder(c, &in, metricNameLabel, ts);
-        decoder.Decode();
+    void DecodeUnistatToStream(
+            TStringBuf data,
+            IMetricConsumer* c,
+            TStringBuf metricNameLabel,
+            TStringBuf metricNamePrefix,
+            TInstant ts)
+    {
+      TMemoryInput in{data.data(), data.size()};
+      TDecoderUnistat decoder(c, &in, metricNameLabel, metricNamePrefix, ts);
+      decoder.Decode();
     }
 }
diff --git a/library/cpp/monlib/encode/unistat/unistat_ut.cpp b/library/cpp/monlib/encode/unistat/unistat_ut.cpp
index f15fc7c5b79..da314690535 100644
--- a/library/cpp/monlib/encode/unistat/unistat_ut.cpp
+++ b/library/cpp/monlib/encode/unistat/unistat_ut.cpp
@@ -23,6 +23,22 @@ Y_UNIT_TEST_SUITE(TUnistatDecoderTest) {
         UNIT_ASSERT_VALUES_EQUAL(label.GetName(), "metric_name_label");
     }
 
+    Y_UNIT_TEST(MetricNamePrefix) {
+        constexpr auto input = TStringBuf(R"([["something_axxx", 42]])");
+
+        NProto::TMultiSamplesList samples;
+        auto encoder = EncoderProtobuf(&samples);
+
+        DecodeUnistat(input, encoder.Get(), "metric_name_label", "prefix.");
+
+        UNIT_ASSERT_VALUES_EQUAL(samples.SamplesSize(), 1);
+        auto sample = samples.GetSamples(0);
+
+        auto label = sample.GetLabels(0);
+        UNIT_ASSERT_VALUES_EQUAL(label.GetName(), "metric_name_label");
+        UNIT_ASSERT_VALUES_EQUAL(label.GetValue(), "prefix.something_axxx");
+    }
+
     Y_UNIT_TEST(ScalarMetric) {
         constexpr auto input = TStringBuf(R"([["something_axxx", 42]])");
 
@@ -338,4 +354,35 @@ Y_UNIT_TEST_SUITE(TUnistatDecoderTest) {
         UNIT_ASSERT_VALUES_EQUAL(label.GetName(), "sensor");
         UNIT_ASSERT_VALUES_EQUAL(label.GetValue(), "something_anything_max");
     }
+
+    Y_UNIT_TEST(AllowClientAggregations) {
+        constexpr auto input = TStringBuf(R"(
+                [
+                    ["signal_dmmm", 1],
+                    ["signal_ammm", 1],
+                    ["signal_xmmm", 1],
+                    ["signal_emmm", 1],
+                    ["signal_tmmm", 1]
+                ])");
+        NProto::TMultiSamplesList samples;
+        auto encoder = EncoderProtobuf(&samples);
+        DecodeUnistat(input, encoder.Get());
+
+        UNIT_ASSERT_EQUAL(samples.SamplesSize(), 5);
+        UNIT_ASSERT_EQUAL(samples.GetSamples(0).GetMetricType(), NProto::RATE);
+        for (size_t i = 1; i < samples.SamplesSize(); ++i) {
+            UNIT_ASSERT_EQUAL(samples.GetSamples(i).GetMetricType(), NProto::GAUGE);
+        }
+    }
+
+    Y_UNIT_TEST(AllowClientHistAggregation) {
+        constexpr auto input = TStringBuf(R"([["something_hhhh", 1]])");
+        NProto::TMultiSamplesList samples;
+        auto encoder = EncoderProtobuf(&samples);
+        DecodeUnistat(input, encoder.Get());
+
+        UNIT_ASSERT_EQUAL(samples.SamplesSize(), 1);
+        UNIT_ASSERT_EQUAL(samples.GetSamples(0).GetMetricType(), NProto::HISTOGRAM);
+        UNIT_ASSERT_EQUAL(samples.GetSamples(0).PointsSize(), 1);
+    }
 }
diff --git a/library/cpp/monlib/metrics/ewma.cpp b/library/cpp/monlib/metrics/ewma.cpp
index e8ed49131b3..a1fcc448961 100644
--- a/library/cpp/monlib/metrics/ewma.cpp
+++ b/library/cpp/monlib/metrics/ewma.cpp
@@ -106,7 +106,7 @@ namespace {
         ui64 old = LastTick_.load();
         const auto secondsSinceLastTick = now - old;
 
-        if (secondsSinceLastTick > INTERVAL_SECONDS) {
+        if (now > old && secondsSinceLastTick > INTERVAL_SECONDS) {
             // round to the interval grid
             const ui64 newLast = now - (secondsSinceLastTick % INTERVAL_SECONDS);
             if (LastTick_.compare_exchange_strong(old, newLast)) {
diff --git a/library/cpp/monlib/metrics/fake.h b/library/cpp/monlib/metrics/fake.h
index b61f80fb419..a058e1d99a1 100644
--- a/library/cpp/monlib/metrics/fake.h
+++ b/library/cpp/monlib/metrics/fake.h
@@ -82,6 +82,8 @@ namespace NMonitoring {
         i64 Get() const noexcept override {
             return 0;
         }
+
+        void Reset() noexcept override {}
     };
 
     struct TFakeRate final: public TFakeAcceptor<IRate> {
@@ -102,6 +104,8 @@ namespace NMonitoring {
         ui64 Get() const noexcept override {
             return 0;
         }
+
+        void Reset() noexcept override {}
     };
 
     struct TFakeGauge final: public TFakeAcceptor<IGauge> {
@@ -117,12 +121,16 @@ namespace NMonitoring {
         double Get() const noexcept override {
             return 0;
         }
+
+        void Reset() noexcept override {}
     };
 
     struct TFakeLazyGauge final: public TFakeAcceptor<ILazyGauge> {
         double Get() const noexcept override {
             return 0;
         }
+
+        void Reset() noexcept override {}
     };
 
     struct TFakeHistogram final: public IHistogram {
@@ -131,11 +139,11 @@ namespace NMonitoring {
         {
         }
 
-        void Record(double value) override {
+        void Record(double value) noexcept override {
             Y_UNUSED(value);
         }
 
-        void Record(double value, ui32 count) override {
+        void Record(double value, ui32 count) noexcept override {
             Y_UNUSED(value, count);
         }
 
@@ -147,7 +155,7 @@ namespace NMonitoring {
             Y_UNUSED(time, consumer);
         }
 
-        void Reset() override {
+        void Reset() noexcept override {
         }
     };
 
@@ -169,5 +177,7 @@ namespace NMonitoring {
         ui64 Get() const noexcept override {
             return 0;
         }
+
+        void Reset() noexcept override {}
     };
 } // namespace NMonitoring
diff --git a/library/cpp/monlib/metrics/histogram_collector.h b/library/cpp/monlib/metrics/histogram_collector.h
index 177d7796342..18b9633b870 100644
--- a/library/cpp/monlib/metrics/histogram_collector.h
+++ b/library/cpp/monlib/metrics/histogram_collector.h
@@ -14,12 +14,12 @@ namespace NMonitoring {
         /**
          * Store {@code count} times given {@code value} in this collector.
          */
-        virtual void Collect(double value, ui64 count) = 0;
+        virtual void Collect(double value, ui64 count) noexcept = 0;
 
         /**
          * Store given {@code value} in this collector.
          */
-        void Collect(double value) {
+        void Collect(double value) noexcept {
             Collect(value, 1);
         }
 
@@ -35,12 +35,17 @@ namespace NMonitoring {
         /**
          * Reset collector values
          */
-        virtual void Reset() = 0;
+        virtual void Reset() noexcept = 0;
 
         /**
          * @return snapshot of the state of this collector.
          */
         virtual IHistogramSnapshotPtr Snapshot() const = 0;
+
+        /**
+        * @return copy of collector implementation
+        */
+        virtual THolder<IHistogramCollector> Clone() = 0;
     };
 
     using IHistogramCollectorPtr = THolder<IHistogramCollector>;
@@ -87,7 +92,7 @@ namespace NMonitoring {
      *
      * @param bucketsCount the total number of buckets. The value must be >= 2.
      * @param base         the exponential growth factor for the buckets width.
-     *                     The value must be >= 1.0.
+     *                     The value must be > 1.0.
      * @param scale        the linear scale for the buckets. The value must be >= 1.0.
      */
     IHistogramCollectorPtr ExponentialHistogram(
diff --git a/library/cpp/monlib/metrics/histogram_collector_explicit.cpp b/library/cpp/monlib/metrics/histogram_collector_explicit.cpp
index a567573a022..3c2ba01f725 100644
--- a/library/cpp/monlib/metrics/histogram_collector_explicit.cpp
+++ b/library/cpp/monlib/metrics/histogram_collector_explicit.cpp
@@ -21,13 +21,13 @@ namespace NMonitoring {
             Bounds_.push_back(Max<TBucketBound>());
         }
 
-        void Collect(double value, ui64 count) override {
+        void Collect(double value, ui64 count) noexcept override {
             auto it = LowerBound(Bounds_.begin(), Bounds_.end(), value);
             auto index = std::distance(Bounds_.begin(), it);
             Values_.Add(index, count);
         }
 
-        void Reset() override {
+        void Reset() noexcept override {
             Values_.Reset();
         }
 
@@ -36,6 +36,21 @@ namespace NMonitoring {
             return ExplicitHistogramSnapshot(Bounds_, values);
         }
 
+        THolder<IHistogramCollector> Clone() override {
+            TBucketBounds copyBounds(Bounds_);
+            return MakeHolder<TExplicitHistogramCollector>(TExplicitHistogramCollector(copyBounds, Values_));
+        }
+
+    private:
+        TExplicitHistogramCollector(TBucketBounds bounds, TAtomicsArray const& values)
+            : Values_(bounds.size())
+            , Bounds_(std::move(bounds))
+        {
+            for(size_t i = 0; i < Values_.Size(); ++i) {
+                Values_.Add(i, values[i]);
+            }
+        }
+
     private:
         TAtomicsArray Values_;
         TBucketBounds Bounds_;
diff --git a/library/cpp/monlib/metrics/histogram_collector_exponential.cpp b/library/cpp/monlib/metrics/histogram_collector_exponential.cpp
index c6bbfcfc697..702ac204375 100644
--- a/library/cpp/monlib/metrics/histogram_collector_exponential.cpp
+++ b/library/cpp/monlib/metrics/histogram_collector_exponential.cpp
@@ -22,7 +22,7 @@ namespace NMonitoring {
         {
         }
 
-        void Collect(double value, ui64 count) override {
+        void Collect(double value, ui64 count) noexcept override {
             ui32 index = Max<ui32>();
             if (value <= MinValue_) {
                 index = 0;
@@ -35,7 +35,7 @@ namespace NMonitoring {
             Values_.Add(index, count);
         }
 
-        void Reset() override {
+        void Reset() noexcept override {
             Values_.Reset();
         }
 
@@ -43,6 +43,24 @@ namespace NMonitoring {
             return new TExponentialHistogramSnapshot(Base_, Scale_, Values_.Copy());
         }
 
+        THolder<IHistogramCollector> Clone() override {
+            return MakeHolder<TExponentialHistogramCollector>(TExponentialHistogramCollector(Values_, Base_, Scale_));
+        }
+
+    private:
+        TExponentialHistogramCollector(TAtomicsArray const& values, double base, double scale)
+            : Values_(values.Size())
+            , Base_(base)
+            , Scale_(scale)
+            , MinValue_(scale)
+            , MaxValue_(scale * std::pow(base, values.Size() - 2))
+            , LogOfBase_(std::log(base))
+        {
+            for(size_t i = 0; i < Values_.Size(); ++i) {
+                Values_.Add(i, values[i]);
+            }
+        }
+
     private:
         TAtomicsArray Values_;
         double Base_;
diff --git a/library/cpp/monlib/metrics/histogram_collector_linear.cpp b/library/cpp/monlib/metrics/histogram_collector_linear.cpp
index 83424853209..c6c430ab4e3 100644
--- a/library/cpp/monlib/metrics/histogram_collector_linear.cpp
+++ b/library/cpp/monlib/metrics/histogram_collector_linear.cpp
@@ -23,7 +23,7 @@ namespace NMonitoring {
         {
         }
 
-        void Collect(double value, ui64 count) override {
+        void Collect(double value, ui64 count) noexcept override {
             ui32 index = Max<ui32>();
             if (value <= StartValue_) {
                 index = 0;
@@ -36,7 +36,7 @@ namespace NMonitoring {
             Values_.Add(index, count);
         }
 
-        void Reset() override {
+        void Reset() noexcept override {
             Values_.Reset();
         }
 
@@ -45,6 +45,21 @@ namespace NMonitoring {
                     StartValue_, BucketWidth_, Values_.Copy());
         }
 
+        THolder<IHistogramCollector> Clone() override {
+            return MakeHolder<TLinearHistogramCollector>(TLinearHistogramCollector(Values_, StartValue_, BucketWidth_));
+        }
+
+    private:
+        TLinearHistogramCollector(TAtomicsArray const& values, TBucketBound startValue, TBucketBound bucketWidth)
+            : Values_(values.Size())
+            , StartValue_(startValue)
+            , BucketWidth_(bucketWidth)
+            , MaxValue_(startValue + bucketWidth * (values.Size() - 2))
+        {
+            for(size_t i = 0; i < Values_.Size(); ++i) {
+                Values_.Add(i, values[i]);
+            }
+        }
     private:
         TAtomicsArray Values_;
         TBucketBound StartValue_;
diff --git a/library/cpp/monlib/metrics/histogram_snapshot.h b/library/cpp/monlib/metrics/histogram_snapshot.h
index 6cd9f1dab5f..88ea07cafd8 100644
--- a/library/cpp/monlib/metrics/histogram_snapshot.h
+++ b/library/cpp/monlib/metrics/histogram_snapshot.h
@@ -4,6 +4,7 @@
 #include <util/generic/ptr.h>
 #include <util/generic/vector.h>
 #include <util/generic/yexception.h>
+#include <util/generic/ylimits.h>
 
 #include <cmath>
 #include <limits>
diff --git a/library/cpp/monlib/metrics/labels.cpp b/library/cpp/monlib/metrics/labels.cpp
index 1eaadb7cba0..f1210f54eda 100644
--- a/library/cpp/monlib/metrics/labels.cpp
+++ b/library/cpp/monlib/metrics/labels.cpp
@@ -35,7 +35,7 @@ Y_MONLIB_DEFINE_LABEL_OUT(NMonitoring::TLabel);
 
 namespace NMonitoring {
     bool TryLoadLabelsFromString(TStringBuf sb, ILabels& labels) {
-        if (sb.Empty()) {
+        if (sb.empty()) {
             return false;
         }
 
@@ -46,7 +46,7 @@ namespace NMonitoring {
         sb.Skip(1);
         sb.Chop(1);
 
-        if (sb.Empty()) {
+        if (sb.empty()) {
             return true;
         }
 
diff --git a/library/cpp/monlib/metrics/metric.h b/library/cpp/monlib/metrics/metric.h
index cf736e8d808..bb5fda322ea 100644
--- a/library/cpp/monlib/metrics/metric.h
+++ b/library/cpp/monlib/metrics/metric.h
@@ -15,6 +15,7 @@ namespace NMonitoring {
 
         virtual EMetricType Type() const noexcept = 0;
         virtual void Accept(TInstant time, IMetricConsumer* consumer) const = 0;
+        virtual void Reset() noexcept = 0;
     };
 
     using IMetricPtr = TIntrusivePtr<IMetric>;
@@ -28,7 +29,7 @@ namespace NMonitoring {
         virtual double Add(double n) noexcept = 0;
         virtual void Set(double n) noexcept = 0;
         virtual double Get() const noexcept = 0;
-        virtual void Reset() noexcept {
+        void Reset() noexcept override {
             Set(0);
         }
     };
@@ -58,7 +59,7 @@ namespace NMonitoring {
 
         virtual void Set(i64 value) noexcept = 0;
         virtual i64 Get() const noexcept = 0;
-        virtual void Reset() noexcept {
+        void Reset() noexcept override {
             Set(0);
         }
     };
@@ -84,7 +85,6 @@ namespace NMonitoring {
 
         virtual ui64 Add(ui64 n) noexcept = 0;
         virtual ui64 Get() const noexcept = 0;
-        virtual void Reset() noexcept = 0;
     };
 
     class ILazyCounter: public IMetric {
@@ -108,7 +108,6 @@ namespace NMonitoring {
 
         virtual ui64 Add(ui64 n) noexcept = 0;
         virtual ui64 Get() const noexcept = 0;
-        virtual void Reset() noexcept = 0;
     };
 
     class ILazyRate: public IMetric {
@@ -131,10 +130,9 @@ namespace NMonitoring {
             return IsRate_ ? EMetricType::HIST_RATE : EMetricType::HIST;
         }
 
-        virtual void Record(double value) = 0;
-        virtual void Record(double value, ui32 count) = 0;
+        virtual void Record(double value) noexcept = 0;
+        virtual void Record(double value, ui32 count) noexcept = 0;
         virtual IHistogramSnapshotPtr TakeSnapshot() const = 0;
-        virtual void Reset() = 0;
 
     protected:
         const bool IsRate_;
@@ -194,6 +192,8 @@ namespace NMonitoring {
             consumer->OnDouble(time, Get());
         }
 
+        void Reset() noexcept override {}
+
     private:
         std::function<double()> Supplier_;
     };
@@ -245,6 +245,8 @@ namespace NMonitoring {
             consumer->OnInt64(time, Get());
         }
 
+        void Reset() noexcept override {}
+
     private:
         std::function<i64()> Supplier_;
     };
@@ -296,6 +298,8 @@ namespace NMonitoring {
             consumer->OnUint64(time, Get());
         }
 
+        void Reset() noexcept override {}
+
     private:
         std::function<ui64()> Supplier_;
     };
@@ -347,6 +351,8 @@ namespace NMonitoring {
             consumer->OnUint64(time, Get());
         }
 
+        void Reset() noexcept override {}
+
     private:
         std::function<ui64()> Supplier_;
     };
@@ -368,11 +374,11 @@ namespace NMonitoring {
         {
         }
 
-        void Record(double value) override {
+        void Record(double value) noexcept override {
             Collector_->Collect(value);
         }
 
-        void Record(double value, ui32 count) override {
+        void Record(double value, ui32 count) noexcept override {
             Collector_->Collect(value, count);
         }
 
@@ -384,7 +390,7 @@ namespace NMonitoring {
             return Collector_->Snapshot();
         }
 
-        void Reset() override {
+        void Reset() noexcept override {
             Collector_->Reset();
         }
 
diff --git a/library/cpp/monlib/metrics/metric_consumer.h b/library/cpp/monlib/metrics/metric_consumer.h
index f7a727585ad..1152b51c4af 100644
--- a/library/cpp/monlib/metrics/metric_consumer.h
+++ b/library/cpp/monlib/metrics/metric_consumer.h
@@ -33,6 +33,10 @@ namespace NMonitoring {
         virtual void OnHistogram(TInstant time, IHistogramSnapshotPtr snapshot) = 0;
         virtual void OnLogHistogram(TInstant time, TLogHistogramSnapshotPtr snapshot) = 0;
         virtual void OnSummaryDouble(TInstant time, ISummaryDoubleSnapshotPtr snapshot) = 0;
+
+        virtual void OnMemOnly(bool isMemOnly) {
+            Y_UNUSED(isMemOnly);
+        }
     };
 
     using IMetricConsumerPtr = THolder<IMetricConsumer>;
diff --git a/library/cpp/monlib/metrics/metric_registry.cpp b/library/cpp/monlib/metrics/metric_registry.cpp
index c747ae2b74f..fa8d8b8ec5d 100644
--- a/library/cpp/monlib/metrics/metric_registry.cpp
+++ b/library/cpp/monlib/metrics/metric_registry.cpp
@@ -11,16 +11,17 @@ namespace NMonitoring {
         }
 
         template <typename TLabelsConsumer>
-        void ConsumeMetric(TInstant time, IMetricConsumer* consumer, IMetric* metric, TLabelsConsumer&& labelsConsumer) {
+        void ConsumeMetric(TInstant time, IMetricConsumer* consumer, IMetric* metric, TLabelsConsumer&& labelsConsumer, TMetricOpts opts = {}) {
             consumer->OnMetricBegin(metric->Type());
 
             // (1) add labels
             consumer->OnLabelsBegin();
             labelsConsumer();
             consumer->OnLabelsEnd();
-
             // (2) add time and value
             metric->Accept(time, consumer);
+            // (3) add flag
+            consumer->OnMemOnly(opts.MemOnly);
             consumer->OnMetricEnd();
         }
     }
@@ -55,126 +56,177 @@ namespace NMonitoring {
     }
 
     TGauge* TMetricRegistry::Gauge(TLabels labels) {
-        return Metric<TGauge, EMetricType::GAUGE>(std::move(labels));
+        return GaugeWithOpts(std::move(labels));
+    }
+    TGauge* TMetricRegistry::GaugeWithOpts(TLabels labels, TMetricOpts opts) {
+        return Metric<TGauge, EMetricType::GAUGE>(std::move(labels), std::move(opts));
     }
 
     TGauge* TMetricRegistry::Gauge(ILabelsPtr labels) {
-        return Metric<TGauge, EMetricType::GAUGE>(std::move(labels));
+        return GaugeWithOpts(std::move(labels));
+    }
+    TGauge* TMetricRegistry::GaugeWithOpts(ILabelsPtr labels, TMetricOpts opts) {
+        return Metric<TGauge, EMetricType::GAUGE>(std::move(labels), std::move(opts));
     }
 
     TLazyGauge* TMetricRegistry::LazyGauge(TLabels labels, std::function<double()> supplier) {
-        return Metric<TLazyGauge, EMetricType::GAUGE>(std::move(labels), std::move(supplier));
+        return LazyGaugeWithOpts(std::move(labels), std::move(supplier));
+    }
+    TLazyGauge* TMetricRegistry::LazyGaugeWithOpts(TLabels labels, std::function<double()> supplier, TMetricOpts opts) {
+        return Metric<TLazyGauge, EMetricType::GAUGE>(std::move(labels),std::move(opts), std::move(supplier));
     }
 
     TLazyGauge* TMetricRegistry::LazyGauge(ILabelsPtr labels, std::function<double()> supplier) {
-        return Metric<TLazyGauge, EMetricType::GAUGE>(std::move(labels), std::move(supplier));
+        return LazyGaugeWithOpts(std::move(labels), std::move(supplier));
+    }
+    TLazyGauge* TMetricRegistry::LazyGaugeWithOpts(ILabelsPtr labels, std::function<double()> supplier, TMetricOpts opts) {
+        return Metric<TLazyGauge, EMetricType::GAUGE>(std::move(labels), std::move(opts), std::move(supplier));
     }
 
     TIntGauge* TMetricRegistry::IntGauge(TLabels labels) {
-        return Metric<TIntGauge, EMetricType::IGAUGE>(std::move(labels));
+        return IntGaugeWithOpts(std::move(labels));
+    }
+    TIntGauge* TMetricRegistry::IntGaugeWithOpts(TLabels labels, TMetricOpts opts) {
+        return Metric<TIntGauge, EMetricType::IGAUGE>(std::move(labels), std::move(opts));
     }
 
     TIntGauge* TMetricRegistry::IntGauge(ILabelsPtr labels) {
-        return Metric<TIntGauge, EMetricType::IGAUGE>(std::move(labels));
+        return IntGaugeWithOpts(std::move(labels));
+    }
+    TIntGauge* TMetricRegistry::IntGaugeWithOpts(ILabelsPtr labels, TMetricOpts opts) {
+        return Metric<TIntGauge, EMetricType::IGAUGE>(std::move(labels), std::move(opts));
     }
 
     TLazyIntGauge* TMetricRegistry::LazyIntGauge(TLabels labels, std::function<i64()> supplier) {
-        return Metric<TLazyIntGauge, EMetricType::IGAUGE>(std::move(labels), std::move(supplier));
+        return LazyIntGaugeWithOpts(std::move(labels), std::move(supplier));
+    }
+    TLazyIntGauge* TMetricRegistry::LazyIntGaugeWithOpts(TLabels labels, std::function<i64()> supplier, TMetricOpts opts) {
+        return Metric<TLazyIntGauge, EMetricType::IGAUGE>(std::move(labels), std::move(opts), std::move(supplier));
     }
 
     TLazyIntGauge* TMetricRegistry::LazyIntGauge(ILabelsPtr labels, std::function<i64()> supplier) {
-        return Metric<TLazyIntGauge, EMetricType::IGAUGE>(std::move(labels), std::move(supplier));
+        return LazyIntGaugeWithOpts(std::move(labels), std::move(supplier));
+    }
+    TLazyIntGauge* TMetricRegistry::LazyIntGaugeWithOpts(ILabelsPtr labels, std::function<i64()> supplier, TMetricOpts opts) {
+        return Metric<TLazyIntGauge, EMetricType::IGAUGE>(std::move(labels), std::move(opts), std::move(supplier));
     }
 
     TCounter* TMetricRegistry::Counter(TLabels labels) {
-        return Metric<TCounter, EMetricType::COUNTER>(std::move(labels));
+        return CounterWithOpts(std::move(labels));
+    }
+    TCounter* TMetricRegistry::CounterWithOpts(TLabels labels, TMetricOpts opts) {
+        return Metric<TCounter, EMetricType::COUNTER>(std::move(labels), std::move(opts));
     }
 
     TCounter* TMetricRegistry::Counter(ILabelsPtr labels) {
-        return Metric<TCounter, EMetricType::COUNTER>(std::move(labels));
+        return CounterWithOpts(std::move(labels));
+    }
+    TCounter* TMetricRegistry::CounterWithOpts(ILabelsPtr labels, TMetricOpts opts) {
+        return Metric<TCounter, EMetricType::COUNTER>(std::move(labels), std::move(opts));
     }
 
     TLazyCounter* TMetricRegistry::LazyCounter(TLabels labels, std::function<ui64()> supplier) {
-        return Metric<TLazyCounter, EMetricType::COUNTER>(std::move(labels), std::move(supplier));
+        return LazyCounterWithOpts(std::move(labels), std::move(supplier));
+    }
+    TLazyCounter* TMetricRegistry::LazyCounterWithOpts(TLabels labels, std::function<ui64()> supplier, TMetricOpts opts) {
+        return Metric<TLazyCounter, EMetricType::COUNTER>(std::move(labels), std::move(opts), std::move(supplier));
     }
 
     TLazyCounter* TMetricRegistry::LazyCounter(ILabelsPtr labels, std::function<ui64()> supplier) {
-        return Metric<TLazyCounter, EMetricType::COUNTER>(std::move(labels), std::move(supplier));
+        return LazyCounterWithOpts(std::move(labels), std::move(supplier));
+    }
+    TLazyCounter* TMetricRegistry::LazyCounterWithOpts(ILabelsPtr labels, std::function<ui64()> supplier, TMetricOpts opts) {
+        return Metric<TLazyCounter, EMetricType::COUNTER>(std::move(labels), std::move(opts), std::move(supplier));
     }
 
     TRate* TMetricRegistry::Rate(TLabels labels) {
-        return Metric<TRate, EMetricType::RATE>(std::move(labels));
+        return RateWithOpts(std::move(labels));
+    }
+    TRate* TMetricRegistry::RateWithOpts(TLabels labels, TMetricOpts opts) {
+        return Metric<TRate, EMetricType::RATE>(std::move(labels), std::move(opts));
     }
 
     TRate* TMetricRegistry::Rate(ILabelsPtr labels) {
-        return Metric<TRate, EMetricType::RATE>(std::move(labels));
+        return RateWithOpts(std::move(labels));
+    }
+    TRate* TMetricRegistry::RateWithOpts(ILabelsPtr labels, TMetricOpts opts) {
+        return Metric<TRate, EMetricType::RATE>(std::move(labels), std::move(opts));
     }
 
     TLazyRate* TMetricRegistry::LazyRate(TLabels labels, std::function<ui64()> supplier) {
-        return Metric<TLazyRate, EMetricType::RATE>(std::move(labels), std::move(supplier));
+        return LazyRateWithOpts(std::move(labels), std::move(supplier));
+    }
+    TLazyRate* TMetricRegistry::LazyRateWithOpts(TLabels labels, std::function<ui64()> supplier, TMetricOpts opts) {
+        return Metric<TLazyRate, EMetricType::RATE>(std::move(labels), std::move(opts), std::move(supplier));
     }
 
     TLazyRate* TMetricRegistry::LazyRate(ILabelsPtr labels, std::function<ui64()> supplier) {
-        return Metric<TLazyRate, EMetricType::RATE>(std::move(labels), std::move(supplier));
+        return LazyRateWithOpts(std::move(labels), std::move(supplier));
+    }
+    TLazyRate* TMetricRegistry::LazyRateWithOpts(ILabelsPtr labels, std::function<ui64()> supplier, TMetricOpts opts) {
+        return Metric<TLazyRate, EMetricType::RATE>(std::move(labels), std::move(opts), std::move(supplier));
     }
 
     THistogram* TMetricRegistry::HistogramCounter(TLabels labels, IHistogramCollectorPtr collector) {
-        return Metric<THistogram, EMetricType::HIST>(std::move(labels), std::move(collector), false);
+        return HistogramCounterWithOpts(std::move(labels), std::move(collector));
+    }
+    THistogram* TMetricRegistry::HistogramCounterWithOpts(TLabels labels, IHistogramCollectorPtr collector, TMetricOpts opts) {
+        return Metric<THistogram, EMetricType::HIST>(std::move(labels), std::move(opts), std::move(collector), false);
     }
 
     THistogram* TMetricRegistry::HistogramCounter(ILabelsPtr labels, IHistogramCollectorPtr collector) {
-        return Metric<THistogram, EMetricType::HIST>(std::move(labels), std::move(collector), false);
+        return HistogramCounterWithOpts(std::move(labels), std::move(collector));
+    }
+    THistogram* TMetricRegistry::HistogramCounterWithOpts(ILabelsPtr labels, IHistogramCollectorPtr collector, TMetricOpts opts) {
+        return Metric<THistogram, EMetricType::HIST>(std::move(labels), std::move(opts), std::move(collector), false);
     }
 
     THistogram* TMetricRegistry::HistogramCounter(TLabels labels, std::function<IHistogramCollectorPtr()> supplier) {
-        return Metric<THistogram, EMetricType::HIST>(std::move(labels), std::move(supplier), false);
+        return HistogramCounterWithOpts(std::move(labels), std::move(supplier));
+    }
+    THistogram* TMetricRegistry::HistogramCounterWithOpts(TLabels labels, std::function<IHistogramCollectorPtr()> supplier, TMetricOpts opts) {
+        return Metric<THistogram, EMetricType::HIST>(std::move(labels), std::move(opts), std::move(supplier), false);
     }
 
     THistogram* TMetricRegistry::HistogramCounter(ILabelsPtr labels, std::function<IHistogramCollectorPtr()> supplier) {
-        return Metric<THistogram, EMetricType::HIST>(std::move(labels), std::move(supplier), false);
+        return HistogramCounterWithOpts(std::move(labels), std::move(supplier));
+    }
+    THistogram* TMetricRegistry::HistogramCounterWithOpts(ILabelsPtr labels, std::function<IHistogramCollectorPtr()> supplier, TMetricOpts opts) {
+        return Metric<THistogram, EMetricType::HIST>(std::move(labels), std::move(opts), std::move(supplier), false);
     }
 
     THistogram* TMetricRegistry::HistogramRate(TLabels labels, IHistogramCollectorPtr collector) {
-        return Metric<THistogram, EMetricType::HIST_RATE>(std::move(labels), std::move(collector), true);
+        return HistogramRateWithOpts(std::move(labels), std::move(collector));
+    }
+    THistogram* TMetricRegistry::HistogramRateWithOpts(TLabels labels, IHistogramCollectorPtr collector, TMetricOpts opts) {
+        return Metric<THistogram, EMetricType::HIST_RATE>(std::move(labels), std::move(opts), std::move(collector), true);
     }
 
     THistogram* TMetricRegistry::HistogramRate(ILabelsPtr labels, IHistogramCollectorPtr collector) {
-        return Metric<THistogram, EMetricType::HIST_RATE>(std::move(labels), std::move(collector), true);
+        return HistogramRateWithOpts(std::move(labels), std::move(collector));
+    }
+    THistogram* TMetricRegistry::HistogramRateWithOpts(ILabelsPtr labels, IHistogramCollectorPtr collector, TMetricOpts opts) {
+        return Metric<THistogram, EMetricType::HIST_RATE>(std::move(labels), std::move(opts), std::move(collector), true);
     }
 
     THistogram* TMetricRegistry::HistogramRate(TLabels labels, std::function<IHistogramCollectorPtr()> supplier) {
-        return Metric<THistogram, EMetricType::HIST_RATE>(std::move(labels), std::move(supplier), true);
+        return HistogramRateWithOpts(std::move(labels), std::move(supplier));
+    }
+    THistogram* TMetricRegistry::HistogramRateWithOpts(TLabels labels, std::function<IHistogramCollectorPtr()> supplier, TMetricOpts opts) {
+        return Metric<THistogram, EMetricType::HIST_RATE>(std::move(labels), std::move(opts), std::move(supplier), true);
     }
 
     THistogram* TMetricRegistry::HistogramRate(ILabelsPtr labels, std::function<IHistogramCollectorPtr()> supplier) {
-        return Metric<THistogram, EMetricType::HIST_RATE>(std::move(labels), std::move(supplier), true);
+        return HistogramRateWithOpts(std::move(labels), std::move(supplier));
+    }
+    THistogram* TMetricRegistry::HistogramRateWithOpts(ILabelsPtr labels, std::function<IHistogramCollectorPtr()> supplier, TMetricOpts opts) {
+        return Metric<THistogram, EMetricType::HIST_RATE>(std::move(labels), std::move(opts), std::move(supplier), true);
     }
 
     void TMetricRegistry::Reset() {
         TWriteGuard g{*Lock_};
-        for (auto& [label, metric] : Metrics_) {
-            switch (metric->Type()) {
-            case EMetricType::GAUGE:
-                static_cast<TGauge*>(metric.Get())->Set(.0);
-                break;
-            case EMetricType::IGAUGE:
-                static_cast<TIntGauge*>(metric.Get())->Set(0);
-                break;
-            case EMetricType::COUNTER:
-                static_cast<TCounter*>(metric.Get())->Reset();
-                break;
-            case EMetricType::RATE:
-                static_cast<TRate*>(metric.Get())->Reset();
-                break;
-            case EMetricType::HIST:
-            case EMetricType::HIST_RATE:
-                static_cast<THistogram*>(metric.Get())->Reset();
-                break;
-            case EMetricType::UNKNOWN:
-            case EMetricType::DSUMMARY:
-            case EMetricType::LOGHIST:
-                break;
-            }
+        for (auto& [label, metricValue] : Metrics_) {
+            metricValue.Metric->Reset();
         }
     }
 
@@ -183,36 +235,6 @@ namespace NMonitoring {
         Metrics_.clear();
     }
 
-    template <typename TMetric, EMetricType type, typename TLabelsType, typename... Args>
-    TMetric* TMetricRegistry::Metric(TLabelsType&& labels, Args&&... args) {
-        {
-            TReadGuard g{*Lock_};
-
-            auto it = Metrics_.find(labels);
-            if (it != Metrics_.end()) {
-                Y_ENSURE(it->second->Type() == type, "cannot create metric " << labels
-                        << " with type " << MetricTypeToStr(type)
-                        << ", because registry already has same metric with type " << MetricTypeToStr(it->second->Type()));
-                return static_cast<TMetric*>(it->second.Get());
-            }
-        }
-
-        {
-            IMetricPtr metric = MakeIntrusive<TMetric>(std::forward<Args>(args)...);
-
-            TWriteGuard g{*Lock_};
-            // decltype(Metrics_)::iterator breaks build on windows
-            THashMap<ILabelsPtr, IMetricPtr>::iterator it;
-            if constexpr (!std::is_convertible_v<TLabelsType, ILabelsPtr>) {
-                it = Metrics_.emplace(new TLabels{std::forward<TLabelsType>(labels)}, std::move(metric)).first;
-            } else {
-                it = Metrics_.emplace(std::forward<TLabelsType>(labels), std::move(metric)).first;
-            }
-
-            return static_cast<TMetric*>(it->second.Get());
-        }
-    }
-
     void TMetricRegistry::RemoveMetric(const ILabels& labels) noexcept {
         TWriteGuard g{*Lock_};
         Metrics_.erase(labels);
@@ -227,7 +249,7 @@ namespace NMonitoring {
             consumer->OnLabelsEnd();
         }
 
-        TVector<std::pair<ILabelsPtr, IMetricPtr>> tmpMetrics;
+        TVector<std::pair<ILabelsPtr, TMetricValue>> tmpMetrics;
 
         {
             TReadGuard g{*Lock_};
@@ -239,25 +261,79 @@ namespace NMonitoring {
 
         for (const auto& it: tmpMetrics) {
             ILabels* labels = it.first.Get();
-            IMetric* metric = it.second.Get();
-            ConsumeMetric(time, consumer, metric, [&]() {
-                ConsumeLabels(consumer, *labels);
-            });
+            IMetric* metric = it.second.Metric.Get();
+            TMetricOpts opts = it.second.Opts;
+            ConsumeMetric(
+                time,
+                consumer,
+                metric,
+                [&]() {
+                    ConsumeLabels(consumer, *labels);
+                },
+                opts
+            );
         }
 
         consumer->OnStreamEnd();
     }
 
     void TMetricRegistry::Append(TInstant time, IMetricConsumer* consumer) const {
-        TReadGuard g{*Lock_};
+        TVector<std::pair<ILabelsPtr, TMetricValue>> tmpMetrics;
+
+        {
+            TReadGuard g{*Lock_};
+            tmpMetrics.reserve(Metrics_.size());
+            for (const auto& it: Metrics_) {
+                tmpMetrics.push_back(it);
+            }
+        }
+
+        for (const auto& it: tmpMetrics) {
+            ILabels* labels = it.first.Get();
+            IMetric* metric = it.second.Metric.Get();
+            TMetricOpts opts = it.second.Opts;
+            ConsumeMetric(
+                time,
+                consumer,
+                metric,
+                [&]() {
+                    ConsumeLabels(consumer, CommonLabels_);
+                    ConsumeLabels(consumer, *labels);
+                },
+                opts
+            );
+        }
+    }
+
+    void TMetricRegistry::Took(TInstant time, IMetricConsumer* consumer) const {
+        consumer->OnStreamBegin();
+
+        TVector<std::pair<ILabelsPtr, TMetricValue>> tmpMetrics;
+
+        {
+            TReadGuard g{*Lock_};
+            tmpMetrics.reserve(Metrics_.size());
+            for (const auto& it: Metrics_) {
+                tmpMetrics.push_back(it);
+            }
+        }
 
-        for (const auto& it: Metrics_) {
+        for (const auto& it: tmpMetrics) {
             ILabels* labels = it.first.Get();
-            IMetric* metric = it.second.Get();
-            ConsumeMetric(time, consumer, metric, [&]() {
-                ConsumeLabels(consumer, CommonLabels_);
-                ConsumeLabels(consumer, *labels);
-            });
+            IMetric* metric = it.second.Metric.Get();
+            TMetricOpts opts = it.second.Opts;
+            ConsumeMetric(
+                time,
+                consumer,
+                metric,
+                [&]() {
+                    ConsumeLabels(consumer, CommonLabels_);
+                    ConsumeLabels(consumer, *labels);
+                },
+                opts
+            );
+            metric->Reset();
         }
+        consumer->OnStreamEnd();
     }
 }
diff --git a/library/cpp/monlib/metrics/metric_registry.h b/library/cpp/monlib/metrics/metric_registry.h
index 7b3a7aab70e..944bee1c6ac 100644
--- a/library/cpp/monlib/metrics/metric_registry.h
+++ b/library/cpp/monlib/metrics/metric_registry.h
@@ -9,35 +9,109 @@
 
 
 namespace NMonitoring {
+
+    struct TMetricOpts {
+        bool MemOnly = false;
+    };
+
     class IMetricFactory {
     public:
         virtual ~IMetricFactory() = default;
 
         virtual IGauge* Gauge(ILabelsPtr labels) = 0;
+        virtual IGauge* GaugeWithOpts(ILabelsPtr labels, TMetricOpts opts = {}) {
+                Y_UNUSED(opts);
+                return Gauge(std::move(labels));
+        }
+
         virtual ILazyGauge* LazyGauge(ILabelsPtr labels, std::function<double()> supplier) = 0;
+        virtual ILazyGauge* LazyGaugeWithOpts(ILabelsPtr labels, std::function<double()> supplier, TMetricOpts opts = {}) {
+                Y_UNUSED(opts);
+                return LazyGauge(std::move(labels), std::move(supplier));
+        }
+
         virtual IIntGauge* IntGauge(ILabelsPtr labels) = 0;
+        virtual IIntGauge* IntGaugeWithOpts(ILabelsPtr labels, TMetricOpts opts = {}) {
+            Y_UNUSED(opts);
+            return IntGauge(std::move(labels));
+        }
         virtual ILazyIntGauge* LazyIntGauge(ILabelsPtr labels, std::function<i64()> supplier) = 0;
+        virtual ILazyIntGauge* LazyIntGaugeWithOpts(ILabelsPtr labels, std::function<i64()> supplier, TMetricOpts opts = {}) {
+            Y_UNUSED(opts);
+            return LazyIntGauge(std::move(labels), std::move(supplier));
+        }
+
         virtual ICounter* Counter(ILabelsPtr labels) = 0;
+        virtual ICounter* CounterWithOpts(ILabelsPtr labels, TMetricOpts opts = {}) {
+            Y_UNUSED(opts);
+            return Counter(std::move(labels));
+        }
+
         virtual ILazyCounter* LazyCounter(ILabelsPtr labels, std::function<ui64()> supplier) = 0;
+        virtual ILazyCounter* LazyCounterWithOpts(ILabelsPtr labels, std::function<ui64()> supplier, TMetricOpts opts = {}) {
+            Y_UNUSED(opts);
+            return LazyCounter(std::move(labels), std::move(supplier));
+        }
 
         virtual IRate* Rate(ILabelsPtr labels) = 0;
+        virtual IRate* RateWithOpts(ILabelsPtr labels, TMetricOpts opts = {}) {
+            Y_UNUSED(opts);
+            return Rate(std::move(labels));
+        }
+
         virtual ILazyRate* LazyRate(ILabelsPtr labels, std::function<ui64()> supplier) = 0;
+        virtual ILazyRate* LazyRateWithOpts(ILabelsPtr labels, std::function<ui64()> supplier, TMetricOpts opts = {}) {
+            Y_UNUSED(opts);
+            return LazyRate(std::move(labels), std::move(supplier));
+        }
 
         virtual IHistogram* HistogramCounter(
                 ILabelsPtr labels,
                 IHistogramCollectorPtr collector) = 0;
+        virtual IHistogram* HistogramCounterWithOpts(
+                ILabelsPtr labels,
+                IHistogramCollectorPtr collector,
+                TMetricOpts opts = {})
+        {
+            Y_UNUSED(opts);
+            return HistogramCounter(std::move(labels), std::move(collector));
+        }
 
         virtual IHistogram* HistogramRate(
                 ILabelsPtr labels,
                 IHistogramCollectorPtr collector) = 0;
+        virtual IHistogram* HistogramRateWithOpts(
+            ILabelsPtr labels,
+            IHistogramCollectorPtr collector,
+            TMetricOpts opts = {})
+        {
+                Y_UNUSED(opts);
+                return HistogramRate(std::move(labels), std::move(collector));
+        }
 
         virtual IHistogram* HistogramCounter(
                 ILabelsPtr labels,
                 std::function<IHistogramCollectorPtr()> makeHistogramCollector) = 0;
+        virtual IHistogram* HistogramCounterWithOpts(
+                ILabelsPtr labels,
+                std::function<IHistogramCollectorPtr()> makeHistogramCollector,
+                TMetricOpts opts = {})
+        {
+                Y_UNUSED(opts);
+                return HistogramCounter(std::move(labels), std::move(makeHistogramCollector));
+        }
 
         virtual IHistogram* HistogramRate(
                 ILabelsPtr labels,
                 std::function<IHistogramCollectorPtr()> makeHistogramCollector) = 0;
+        virtual IHistogram* HistogramRateWithOpts(
+                ILabelsPtr labels,
+                std::function<IHistogramCollectorPtr()> makeHistogramCollector,
+                TMetricOpts opts = {})
+        {
+                Y_UNUSED(opts);
+                return HistogramRate(std::move(labels), std::move(makeHistogramCollector));
+        }
     };
 
     class IMetricSupplier {
@@ -79,29 +153,53 @@ namespace NMonitoring {
         static std::shared_ptr<TMetricRegistry> SharedInstance();
 
         TGauge* Gauge(TLabels labels);
+        TGauge* GaugeWithOpts(TLabels labels, TMetricOpts opts = {});
         TLazyGauge* LazyGauge(TLabels labels, std::function<double()> supplier);
+        TLazyGauge* LazyGaugeWithOpts(TLabels labels, std::function<double()> supplier, TMetricOpts opts = {});
         TIntGauge* IntGauge(TLabels labels);
+        TIntGauge* IntGaugeWithOpts(TLabels labels, TMetricOpts opts = {});
         TLazyIntGauge* LazyIntGauge(TLabels labels, std::function<i64()> supplier);
+        TLazyIntGauge* LazyIntGaugeWithOpts(TLabels labels, std::function<i64()> supplier, TMetricOpts opts = {});
         TCounter* Counter(TLabels labels);
+        TCounter* CounterWithOpts(TLabels labels, TMetricOpts opts = {});
         TLazyCounter* LazyCounter(TLabels labels, std::function<ui64()> supplier);
+        TLazyCounter* LazyCounterWithOpts(TLabels labels, std::function<ui64()> supplier, TMetricOpts opts = {});
         TRate* Rate(TLabels labels);
+        TRate* RateWithOpts(TLabels labels, TMetricOpts opts = {});
         TLazyRate* LazyRate(TLabels labels, std::function<ui64()> supplier);
+        TLazyRate* LazyRateWithOpts(TLabels labels, std::function<ui64()> supplier, TMetricOpts opts = {});
 
         THistogram* HistogramCounter(
                 TLabels labels,
                 IHistogramCollectorPtr collector);
+        THistogram* HistogramCounterWithOpts(
+                TLabels labels,
+                IHistogramCollectorPtr collector,
+                TMetricOpts opts = {});
 
         THistogram* HistogramRate(
                 TLabels labels,
                 IHistogramCollectorPtr collector);
+        THistogram* HistogramRateWithOpts(
+                TLabels labels,
+                IHistogramCollectorPtr collector,
+                TMetricOpts opts = {});
 
         THistogram* HistogramCounter(
                 TLabels labels,
                 std::function<IHistogramCollectorPtr()> makeHistogramCollector);
+        THistogram* HistogramCounterWithOpts(
+                TLabels labels,
+                std::function<IHistogramCollectorPtr()> makeHistogramCollector,
+                TMetricOpts opts = {});
 
         THistogram* HistogramRate(
                 TLabels labels,
                 std::function<IHistogramCollectorPtr()> makeHistogramCollector);
+        THistogram* HistogramRateWithOpts(
+                TLabels labels,
+                std::function<IHistogramCollectorPtr()> makeHistogramCollector,
+                TMetricOpts opts = {});
 
         /**
          * Set all registered metrics to zero
@@ -114,6 +212,7 @@ namespace NMonitoring {
 
         void Accept(TInstant time, IMetricConsumer* consumer) const override;
         void Append(TInstant time, IMetricConsumer* consumer) const override;
+        void Took(TInstant time, IMetricConsumer* consumer) const;
 
         const TLabels& CommonLabels() const noexcept override {
             return CommonLabels_;
@@ -123,36 +222,97 @@ namespace NMonitoring {
 
     private:
         TGauge* Gauge(ILabelsPtr labels) override;
+        TGauge* GaugeWithOpts(ILabelsPtr labels, TMetricOpts opts = {}) override;
         TLazyGauge* LazyGauge(ILabelsPtr labels, std::function<double()> supplier) override;
+        TLazyGauge* LazyGaugeWithOpts(ILabelsPtr labels, std::function<double()> supplier, TMetricOpts opts = {}) override;
         TIntGauge* IntGauge(ILabelsPtr labels) override;
+        TIntGauge* IntGaugeWithOpts(ILabelsPtr labels, TMetricOpts opts = {}) override;
         TLazyIntGauge* LazyIntGauge(ILabelsPtr labels, std::function<i64()> supplier) override;
+        TLazyIntGauge* LazyIntGaugeWithOpts(ILabelsPtr labels, std::function<i64()> supplier, TMetricOpts opts = {}) override;
         TCounter* Counter(ILabelsPtr labels) override;
+        TCounter* CounterWithOpts(ILabelsPtr labels, TMetricOpts opts = {}) override;
         TLazyCounter* LazyCounter(ILabelsPtr labels, std::function<ui64()> supplier) override;
+        TLazyCounter* LazyCounterWithOpts(ILabelsPtr labels, std::function<ui64()> supplier, TMetricOpts opts = {}) override;
         TRate* Rate(ILabelsPtr labels) override;
+        TRate* RateWithOpts(ILabelsPtr labels, TMetricOpts opts = {}) override;
         TLazyRate* LazyRate(ILabelsPtr labels, std::function<ui64()> supplier) override;
+        TLazyRate* LazyRateWithOpts(ILabelsPtr labels, std::function<ui64()> supplier, TMetricOpts opts = {}) override;
 
         THistogram* HistogramCounter(
                 ILabelsPtr labels,
                 IHistogramCollectorPtr collector) override;
+        THistogram* HistogramCounterWithOpts(
+                ILabelsPtr labels,
+                IHistogramCollectorPtr collector,
+                TMetricOpts opts = {}) override;
 
         THistogram* HistogramRate(
                 ILabelsPtr labels,
                 IHistogramCollectorPtr collector) override;
+        THistogram* HistogramRateWithOpts(
+                ILabelsPtr labels,
+                IHistogramCollectorPtr collector,
+                TMetricOpts opts = {}) override;
 
         THistogram* HistogramCounter(
                 ILabelsPtr labels,
                 std::function<IHistogramCollectorPtr()> makeHistogramCollector) override;
+        THistogram* HistogramCounterWithOpts(
+                ILabelsPtr labels,
+                std::function<IHistogramCollectorPtr()> makeHistogramCollector,
+                TMetricOpts opts = {}) override;
 
         THistogram* HistogramRate(
                 ILabelsPtr labels,
                 std::function<IHistogramCollectorPtr()> makeHistogramCollector) override;
+        THistogram* HistogramRateWithOpts(
+                ILabelsPtr labels,
+                std::function<IHistogramCollectorPtr()> makeHistogramCollector,
+                TMetricOpts opts = {}) override;
 
-    private:
-        THolder<TRWMutex> Lock_ = MakeHolder<TRWMutex>();
-        THashMap<ILabelsPtr, IMetricPtr> Metrics_;
+        struct TMetricValue {
+            IMetricPtr Metric;
+            TMetricOpts Opts;
+        };
 
+    protected:
         template <typename TMetric, EMetricType type, typename TLabelsType, typename... Args>
-        TMetric* Metric(TLabelsType&& labels, Args&&... args);
+        TMetric* Metric(TLabelsType&& labels, TMetricOpts&& opts, Args&&... args) {
+            {
+                TReadGuard g{*Lock_};
+
+                auto it = Metrics_.find(labels);
+                if (it != Metrics_.end()) {
+                    Y_ENSURE(it->second.Metric->Type() == type, "cannot create metric " << labels
+                            << " with type " << MetricTypeToStr(type)
+                            << ", because registry already has same metric with type " << MetricTypeToStr(it->second.Metric->Type()));
+                    Y_ENSURE(it->second.Opts.MemOnly == opts.MemOnly,"cannot create metric " << labels
+                            << " with memOnly=" << opts.MemOnly
+                            << ", because registry already has same metric with memOnly=" << it->second.Opts.MemOnly);
+                    return static_cast<TMetric*>(it->second.Metric.Get());
+                }
+            }
+
+            {
+                IMetricPtr metric = MakeIntrusive<TMetric>(std::forward<Args>(args)...);
+
+                TWriteGuard g{*Lock_};
+                // decltype(Metrics_)::iterator breaks build on windows
+                THashMap<ILabelsPtr, TMetricValue>::iterator it;
+                TMetricValue metricValue = {metric, opts};
+                if constexpr (!std::is_convertible_v<TLabelsType, ILabelsPtr>) {
+                    it = Metrics_.emplace(new TLabels{std::forward<TLabelsType>(labels)}, std::move(metricValue)).first;
+                } else {
+                    it = Metrics_.emplace(std::forward<TLabelsType>(labels), std::move(metricValue)).first;
+                }
+
+                return static_cast<TMetric*>(it->second.Metric.Get());
+            }
+        }
+
+    private:
+        THolder<TRWMutex> Lock_ = MakeHolder<TRWMutex>();
+        THashMap<ILabelsPtr, TMetricValue> Metrics_;
 
         TLabels CommonLabels_;
     };
diff --git a/library/cpp/monlib/metrics/metric_registry_ut.cpp b/library/cpp/monlib/metrics/metric_registry_ut.cpp
index 802c423264c..89e6d56146f 100644
--- a/library/cpp/monlib/metrics/metric_registry_ut.cpp
+++ b/library/cpp/monlib/metrics/metric_registry_ut.cpp
@@ -396,4 +396,76 @@ Y_UNIT_TEST_SUITE(TMetricRegistryTest) {
         UNIT_ASSERT(commonLabels[0].GetName() == "common");
         UNIT_ASSERT(commonLabels[0].GetValue() == "label");
     }
+
+    Y_UNIT_TEST(MemOnlyMetric) {
+        TMetricRegistry registry;
+        i64 int_val = 0;
+        double double_val = 0;
+
+        registry.GaugeWithOpts({{"some", "gauge"}}, {true});
+        UNIT_ASSERT_EXCEPTION(registry.Gauge({{"some", "gauge"}}), yexception);
+
+        registry.LazyGaugeWithOpts(
+            {{"some", "lazy_gauge"}},
+            [&double_val](){return double_val;},
+            {true});
+        UNIT_ASSERT_EXCEPTION(
+            registry.LazyGauge(
+                {{"some", "lazy_gauge"}},
+                [&double_val](){return double_val;}),
+            yexception);
+
+        registry.IntGaugeWithOpts({{"some", "int_gauge"}}, {true});
+        UNIT_ASSERT_EXCEPTION(registry.IntGauge({{"some", "int_gauge"}}), yexception);
+
+        registry.LazyIntGaugeWithOpts(
+            {{"some", "lazy_int_gauge"}},
+            [&int_val](){return int_val;},
+            {true});
+        UNIT_ASSERT_EXCEPTION(
+            registry.LazyIntGauge(
+                {{"some", "lazy_int_gauge"}},
+                [&int_val](){return int_val;}),
+            yexception);
+
+        registry.CounterWithOpts({{"some", "counter"}}, {true});
+        UNIT_ASSERT_EXCEPTION(registry.Counter({{"some", "counter"}}), yexception);
+
+        registry.LazyCounterWithOpts({{"some", "lazy_counter"}}, [&int_val](){return int_val;}, {true});
+        UNIT_ASSERT_EXCEPTION(
+            registry.LazyCounter(
+                {{"some", "lazy_counter"}},
+                [&int_val](){return int_val;}),
+            yexception);
+
+        registry.RateWithOpts({{"some", "rate"}}, {true});
+        UNIT_ASSERT_EXCEPTION(registry.Rate({{"some", "rate"}}), yexception);
+
+        registry.LazyRateWithOpts({{"some", "lazy_rate"}}, [&double_val](){return double_val;}, {true});
+        UNIT_ASSERT_EXCEPTION(
+            registry.LazyRate(
+                {{"some", "lazy_rate"}},
+                [&double_val](){return double_val;}),
+            yexception);
+
+        registry.HistogramCounterWithOpts(
+            {{"some", "histogram_counter"}},
+            ExplicitHistogram({1, 5, 15, 20, 25}),
+            {true});
+        UNIT_ASSERT_EXCEPTION(
+            registry.HistogramCounter(
+                {{"some", "histogram_counter"}},
+                ExplicitHistogram({1, 5, 15, 20, 25})),
+                yexception);
+
+        registry.HistogramRateWithOpts(
+            {{"some", "histogram_rate"}},
+            ExponentialHistogram(5, 2),
+            {true});
+        UNIT_ASSERT_EXCEPTION(
+            registry.HistogramRate(
+                {{"some", "histogram_rate"}},
+                ExponentialHistogram(5, 2)),
+                yexception);
+    }
 }
diff --git a/library/cpp/monlib/metrics/metric_sub_registry.h b/library/cpp/monlib/metrics/metric_sub_registry.h
index d1860c00a91..c3481f338fd 100644
--- a/library/cpp/monlib/metrics/metric_sub_registry.h
+++ b/library/cpp/monlib/metrics/metric_sub_registry.h
@@ -33,61 +33,110 @@ class TMetricSubRegistry final: public IMetricRegistry {
         AddCommonLabels(labels.Get());
         return DelegatePtr_->Gauge(std::move(labels));
     }
+    IGauge* GaugeWithOpts(ILabelsPtr labels, TMetricOpts opts = {}) override {
+        AddCommonLabels(labels.Get());
+        return DelegatePtr_->GaugeWithOpts(std::move(labels), std::move(opts));
+    }
 
     ILazyGauge* LazyGauge(ILabelsPtr labels, std::function<double()> supplier) override {
         AddCommonLabels(labels.Get());
         return DelegatePtr_->LazyGauge(std::move(labels), std::move(supplier));
     }
+    ILazyGauge* LazyGaugeWithOpts(ILabelsPtr labels, std::function<double()> supplier, TMetricOpts opts = {}) override {
+        AddCommonLabels(labels.Get());
+        return DelegatePtr_->LazyGaugeWithOpts(std::move(labels), std::move(supplier), std::move(opts));
+    }
 
     IIntGauge* IntGauge(ILabelsPtr labels) override {
         AddCommonLabels(labels.Get());
         return DelegatePtr_->IntGauge(std::move(labels));
     }
+    IIntGauge* IntGaugeWithOpts(ILabelsPtr labels, TMetricOpts opts = {}) override {
+        AddCommonLabels(labels.Get());
+        return DelegatePtr_->IntGaugeWithOpts(std::move(labels), std::move(opts));
+    }
 
     ILazyIntGauge* LazyIntGauge(ILabelsPtr labels, std::function<i64()> supplier) override {
         AddCommonLabels(labels.Get());
         return DelegatePtr_->LazyIntGauge(std::move(labels), std::move(supplier));
     }
+    ILazyIntGauge* LazyIntGaugeWithOpts(ILabelsPtr labels, std::function<i64()> supplier, TMetricOpts opts = {}) override {
+        AddCommonLabels(labels.Get());
+        return DelegatePtr_->LazyIntGaugeWithOpts(std::move(labels), std::move(supplier), std::move(opts));
+    }
 
     ICounter* Counter(ILabelsPtr labels) override {
         AddCommonLabels(labels.Get());
         return DelegatePtr_->Counter(std::move(labels));
     }
+    ICounter* CounterWithOpts(ILabelsPtr labels, TMetricOpts opts = {}) override {
+        AddCommonLabels(labels.Get());
+        return DelegatePtr_->CounterWithOpts(std::move(labels), std::move(opts));
+    }
 
     ILazyCounter* LazyCounter(ILabelsPtr labels, std::function<ui64()> supplier) override {
         AddCommonLabels(labels.Get());
         return DelegatePtr_->LazyCounter(std::move(labels), std::move(supplier));
     }
+    ILazyCounter* LazyCounterWithOpts(ILabelsPtr labels, std::function<ui64()> supplier, TMetricOpts opts = {}) override {
+        AddCommonLabels(labels.Get());
+        return DelegatePtr_->LazyCounterWithOpts(std::move(labels), std::move(supplier), std::move(opts));
+    }
 
     IRate* Rate(ILabelsPtr labels) override {
         AddCommonLabels(labels.Get());
         return DelegatePtr_->Rate(std::move(labels));
     }
 
+    IRate* RateWithOpts(ILabelsPtr labels, TMetricOpts opts = {}) override {
+        AddCommonLabels(labels.Get());
+        return DelegatePtr_->RateWithOpts(std::move(labels), std::move(opts));
+    }
+
     ILazyRate* LazyRate(ILabelsPtr labels, std::function<ui64()> supplier) override {
         AddCommonLabels(labels.Get());
         return DelegatePtr_->LazyRate(std::move(labels), std::move(supplier));
     }
+    ILazyRate* LazyRateWithOpts(ILabelsPtr labels, std::function<ui64()> supplier, TMetricOpts opts = {}) override {
+        AddCommonLabels(labels.Get());
+        return DelegatePtr_->LazyRateWithOpts(std::move(labels), std::move(supplier), std::move(opts));
+    }
 
     IHistogram* HistogramCounter(ILabelsPtr labels, IHistogramCollectorPtr collector) override {
         AddCommonLabels(labels.Get());
         return DelegatePtr_->HistogramCounter(std::move(labels), std::move(collector));
     }
+    IHistogram* HistogramCounterWithOpts(ILabelsPtr labels, IHistogramCollectorPtr collector, TMetricOpts opts = {}) override {
+        AddCommonLabels(labels.Get());
+        return DelegatePtr_->HistogramCounterWithOpts(std::move(labels), std::move(collector), std::move(opts));
+    }
 
     IHistogram* HistogramRate(ILabelsPtr labels, IHistogramCollectorPtr collector) override {
         AddCommonLabels(labels.Get());
         return DelegatePtr_->HistogramRate(std::move(labels), std::move(collector));
     }
+    IHistogram* HistogramRateWithOpts(ILabelsPtr labels, IHistogramCollectorPtr collector, TMetricOpts opts = {}) override {
+        AddCommonLabels(labels.Get());
+        return DelegatePtr_->HistogramRateWithOpts(std::move(labels), std::move(collector), std::move(opts));
+    }
 
     IHistogram* HistogramCounter(ILabelsPtr labels, std::function<IHistogramCollectorPtr()> collector) override {
         AddCommonLabels(labels.Get());
         return DelegatePtr_->HistogramCounter(std::move(labels), std::move(collector));
     }
+    IHistogram* HistogramCounterWithOpts(ILabelsPtr labels, std::function<IHistogramCollectorPtr()> collector, TMetricOpts opts = {}) override {
+        AddCommonLabels(labels.Get());
+        return DelegatePtr_->HistogramCounterWithOpts(std::move(labels), std::move(collector), std::move(opts));
+    }
 
     IHistogram* HistogramRate(ILabelsPtr labels, std::function<IHistogramCollectorPtr()> collector) override {
         AddCommonLabels(labels.Get());
         return DelegatePtr_->HistogramRate(std::move(labels), std::move(collector));
     }
+    IHistogram* HistogramRateWithOpts(ILabelsPtr labels, std::function<IHistogramCollectorPtr()> collector, TMetricOpts opts) override {
+        AddCommonLabels(labels.Get());
+        return DelegatePtr_->HistogramRateWithOpts(std::move(labels), std::move(collector), std::move(opts));
+    }
 
     void Accept(TInstant time, IMetricConsumer* consumer) const override {
         DelegatePtr_->Accept(time, consumer);
diff --git a/library/cpp/monlib/service/format.h b/library/cpp/monlib/service/format.h
index b95f504c05b..edb9fc00526 100644
--- a/library/cpp/monlib/service/format.h
+++ b/library/cpp/monlib/service/format.h
@@ -12,7 +12,7 @@ namespace NMonitoring {
         Y_HAS_MEMBER(second, Second);
     } // namespace NPrivate
 
-    template <typename TRequest>
+    template <typename TRequest, bool UseFastest = false>
     ECompression ParseCompression(const TRequest& req) {
         auto&& headers = req.GetHeaders();
 
@@ -34,10 +34,19 @@ namespace NMonitoring {
         }
 
         NMonitoring::ECompression val{};
+
         if constexpr (isPlainPair) {
-            val = CompressionFromAcceptEncodingHeader(it->second);
+            if constexpr (UseFastest) {
+              val = FastestCompressionFromAcceptEncodingHeader(it->second);
+            } else {
+              val = CompressionFromAcceptEncodingHeader(it->second);
+            }
         } else {
-            val = CompressionFromAcceptEncodingHeader(it->Value());
+            if constexpr (UseFastest) {
+              val = FastestCompressionFromAcceptEncodingHeader(it->Value());
+            } else {
+              val = CompressionFromAcceptEncodingHeader(it->Value());
+            }
         }
 
         return val != NMonitoring::ECompression::UNKNOWN
diff --git a/library/cpp/monlib/service/monservice.h b/library/cpp/monlib/service/monservice.h
index 3116a767654..299b9a48a4f 100644
--- a/library/cpp/monlib/service/monservice.h
+++ b/library/cpp/monlib/service/monservice.h
@@ -45,6 +45,7 @@ namespace NMonitoring {
         explicit TMonService2(const THttpServerOptions& options, TSimpleSharedPtr<IThreadPool> pool, const TString& title = GetProgramName(), THolder<IAuthProvider> auth = nullptr);
 
         ~TMonService2() override {
+            Stop();
         }
 
         const char* GetStartTime() const {
diff --git a/library/cpp/monlib/service/pages/index_mon_page.cpp b/library/cpp/monlib/service/pages/index_mon_page.cpp
index cb8423fe869..1387e350ca4 100644
--- a/library/cpp/monlib/service/pages/index_mon_page.cpp
+++ b/library/cpp/monlib/service/pages/index_mon_page.cpp
@@ -52,6 +52,12 @@ void TIndexMonPage::Output(IMonHttpRequest& request) {
 
 void TIndexMonPage::OutputIndex(IOutputStream& out, bool pathEndsWithSlash) {
     TGuard<TMutex> g(Mtx);
+    if (SortPagesPending) {
+        Pages.sort([](const TMonPagePtr& a, const TMonPagePtr& b) {
+            return AsciiCompareIgnoreCase(a->GetTitle(), b->GetTitle()) < 0;
+        });
+        SortPagesPending = false;
+    }
     for (auto& Page : Pages) {
         IMonPage* page = Page.Get();
         if (page->IsInIndex()) {
@@ -164,9 +170,7 @@ void TIndexMonPage::OutputBody(IMonHttpRequest& req) {
 
 void TIndexMonPage::SortPages() {
     TGuard<TMutex> g(Mtx);
-    Pages.sort([](const TMonPagePtr& a, const TMonPagePtr& b) {
-        return AsciiCompareIgnoreCase(a->GetTitle(), b->GetTitle()) < 0;
-    });
+    SortPagesPending = true;
 }
 
 void TIndexMonPage::ClearPages() {
diff --git a/library/cpp/monlib/service/pages/index_mon_page.h b/library/cpp/monlib/service/pages/index_mon_page.h
index 59e1caf0686..8f034613234 100644
--- a/library/cpp/monlib/service/pages/index_mon_page.h
+++ b/library/cpp/monlib/service/pages/index_mon_page.h
@@ -14,6 +14,7 @@ namespace NMonitoring {
         TPages Pages; // a list of pages to maintain specific order
         using TPagesByPath = THashMap<TString, TPages::iterator>;
         TPagesByPath PagesByPath;
+        bool SortPagesPending = false;
 
         TIndexMonPage(const TString& path, const TString& title)
             : IMonPage(path, title)
diff --git a/library/cpp/monlib/service/pages/mon_page.h b/library/cpp/monlib/service/pages/mon_page.h
index a10d0cdc7e5..dcc021c0584 100644
--- a/library/cpp/monlib/service/pages/mon_page.h
+++ b/library/cpp/monlib/service/pages/mon_page.h
@@ -11,6 +11,7 @@ namespace NMonitoring {
     static const char HTTPOKBIN[] = "HTTP/1.1 200 Ok\r\nContent-Type: application/octet-stream\r\nConnection: Close\r\n\r\n";
     static const char HTTPOKHTML[] = "HTTP/1.1 200 Ok\r\nContent-Type: text/html\r\nConnection: Close\r\n\r\n";
     static const char HTTPOKJSON[] = "HTTP/1.1 200 Ok\r\nContent-Type: application/json\r\nConnection: Close\r\n\r\n";
+    static const char HTTPOKYAML[] = "HTTP/1.1 200 Ok\r\nContent-Type: application/yaml\r\nConnection: Close\r\n\r\n";
     static const char HTTPOKSPACK[] = "HTTP/1.1 200 Ok\r\nContent-Type: application/x-solomon-spack\r\nConnection: Close\r\n\r\n";
     static const char HTTPOKPROMETHEUS[] = "HTTP/1.1 200 Ok\r\nContent-Type: text/plain\r\nConnection: Close\r\n\r\n";
     static const char HTTPOKUNISTAT[] = "HTTP/1.1 200 Ok\r\nContent-Type: text/json\r\nConnection: Close\r\n\r\n";
diff --git a/library/cpp/monlib/service/pages/templates.h b/library/cpp/monlib/service/pages/templates.h
index 3a0b80684d9..342d338a8ef 100644
--- a/library/cpp/monlib/service/pages/templates.h
+++ b/library/cpp/monlib/service/pages/templates.h
@@ -36,6 +36,7 @@
 #define TABLED_ATTRS(...) TAG_ATTRS(TTableD, ##__VA_ARGS__)
 #define TABLEH() TAG(TTableH)
 #define TABLEH_CLASS(cls) TAG_CLASS(TTableH, cls)
+#define TABLEH_ATTRS(...) TAG_ATTRS(TTableH, ##__VA_ARGS__)
 #define FORM() TAG(TFormC)
 #define FORM_CLASS(cls) TAG_CLASS(TFormC, cls)
 #define LABEL() TAG(TLabelC)
diff --git a/library/cpp/openssl/init/init.cpp b/library/cpp/openssl/init/init.cpp
index ae68ef08eaa..b7203e4d9bb 100644
--- a/library/cpp/openssl/init/init.cpp
+++ b/library/cpp/openssl/init/init.cpp
@@ -1,66 +1,10 @@
-#include "init.h"
-
-#include <util/generic/singleton.h>
-#include <util/generic/vector.h>
-#include <util/generic/ptr.h>
-#include <util/generic/buffer.h>
-
-#include <util/system/yassert.h>
-#include <util/system/mutex.h>
-#include <util/system/thread.h>
-
-#include <util/random/entropy.h>
-#include <util/stream/input.h>
-
-#include <openssl/bio.h>
-#include <openssl/ssl.h>
-#include <openssl/err.h>
-#include <openssl/rand.h>
-#include <openssl/conf.h>
 #include <openssl/crypto.h>
 
 namespace {
-    struct TInitSsl {
-        struct TOpensslLocks {
-            inline TOpensslLocks()
-                : Mutexes(CRYPTO_num_locks())
-            {
-                for (auto& mpref : Mutexes) {
-                    mpref.Reset(new TMutex());
-                }
-            }
-
-            inline void LockOP(int mode, int n) {
-                auto& mutex = *Mutexes.at(n);
-
-                if (mode & CRYPTO_LOCK) {
-                    mutex.Acquire();
-                } else {
-                    mutex.Release();
-                }
-            }
-
-            TVector<TAutoPtr<TMutex>> Mutexes;
-        };
-
-        inline TInitSsl() {
-            OPENSSL_init_crypto(OPENSSL_INIT_NO_ATEXIT, nullptr);
-        }
-
-        inline ~TInitSsl() {
-            OPENSSL_cleanup();
-        }
-
-        static void LockingFunction(int mode, int n, const char* /*file*/, int /*line*/) {
-            Singleton<TOpensslLocks>()->LockOP(mode, n);
-        }
-
-        static unsigned long ThreadIdFunction() {
-            return TThread::CurrentThreadId();
-        }
-    };
-}
-
-void InitOpenSSL() {
-    (void)SingletonWithPriority<TInitSsl, 0>();
+    // Initialize OpenSSL as early as possible
+    // in order to prevent any further initializations with different flags.
+    //
+    // Initialize it with OPENSSL_INIT_NO_ATEXIT thus omitting the cleanup routine at process exit
+    // (it looks like it does nothing when openssl is linked statically).
+    [[maybe_unused]] auto _ = OPENSSL_init_crypto(OPENSSL_INIT_ENGINE_ALL_BUILTIN | OPENSSL_INIT_NO_ATEXIT, nullptr);
 }
diff --git a/library/cpp/openssl/init/init.h b/library/cpp/openssl/init/init.h
deleted file mode 100644
index a626b316b3b..00000000000
--- a/library/cpp/openssl/init/init.h
+++ /dev/null
@@ -1,3 +0,0 @@
-#pragma once
-
-void InitOpenSSL();
diff --git a/library/cpp/openssl/io/stream.cpp b/library/cpp/openssl/io/stream.cpp
index 0b4be38c0e3..8bfcdce2ebc 100644
--- a/library/cpp/openssl/io/stream.cpp
+++ b/library/cpp/openssl/io/stream.cpp
@@ -3,8 +3,8 @@
 #include <util/generic/deque.h>
 #include <util/generic/singleton.h>
 #include <util/generic/yexception.h>
+#include <util/system/env.h>
 
-#include <library/cpp/openssl/init/init.h>
 #include <library/cpp/openssl/method/io.h>
 #include <library/cpp/resource/resource.h>
 
@@ -19,12 +19,6 @@ using TOptions = TOpenSslClientIO::TOptions;
 namespace {
     struct TSslIO;
 
-    struct TSslInitOnDemand {
-        inline TSslInitOnDemand() {
-            InitOpenSSL();
-        }
-    };
-
     int GetLastSslError() noexcept {
         return ERR_peek_last_error();
     }
@@ -121,7 +115,7 @@ namespace {
         IOutputStream* Out;
     };
 
-    struct TSslIO: public TSslInitOnDemand, public TOptions {
+    struct TSslIO: public TOptions {
         inline TSslIO(IInputStream* in, IOutputStream* out, const TOptions& opts)
             : TOptions(opts)
             , Io(in, out)
@@ -187,10 +181,9 @@ namespace {
             Y_ENSURE(X509_VERIFY_PARAM_set1_host(param, VerifyCert_->Hostname_.data(), VerifyCert_->Hostname_.size()));
             SSL_set_tlsext_host_name(ssl, VerifyCert_->Hostname_.data()); // TLS extenstion: SNI
 
-            SSL_CTX_set_cert_store(Ctx.Get(), GetBuiltinOpenSslX509Store().Release());
+            SSL_CTX_set_cert_store(Ctx.Get(), GetDefaultOpenSslX509Store().Release());
 
-            Y_ENSURE_EX(1 == SSL_CTX_set_default_verify_paths(Ctx.Get()),
-                        TSslError());
+            // FIXME: This piece seems redundant, but users are unknown.
             // it is OK to ignore result of SSL_CTX_load_verify_locations():
             // Dir "/etc/ssl/certs/" may be missing
             SSL_CTX_load_verify_locations(Ctx.Get(),
@@ -237,7 +230,7 @@ namespace {
         TSslContextPtr Ctx;
         TSslPtr Ssl;
     };
-}
+} // namespace
 
 struct TOpenSslClientIO::TImpl: public TSslIO {
     inline TImpl(IInputStream* in, IOutputStream* out, const TOptions& opts)
@@ -277,6 +270,8 @@ namespace NPrivate {
     }
 }
 
+namespace {
+
 class TBuiltinCerts {
 public:
     TBuiltinCerts() {
@@ -303,9 +298,7 @@ class TBuiltinCerts {
         Y_ENSURE_EX(!Certs.empty(), TSslError());
     }
 
-    TOpenSslX509StorePtr GetX509Store() const {
-        TOpenSslX509StorePtr store(X509_STORE_new());
-
+    void AddCerts(const TOpenSslX509StorePtr& store) const {
         for (const TX509Ptr& c : Certs) {
             if (0 == X509_STORE_add_cert(store.Get(), c.Get())) {
                 int err = GetLastSslError();
@@ -316,14 +309,29 @@ class TBuiltinCerts {
                 }
             }
         }
-
-        return store;
     }
 
 private:
     TDeque<TX509Ptr> Certs;
 };
 
+} // namespace
+
 TOpenSslX509StorePtr GetBuiltinOpenSslX509Store() {
-    return Singleton<TBuiltinCerts>()->GetX509Store();
+    TOpenSslX509StorePtr store(X509_STORE_new());
+    Singleton<TBuiltinCerts>()->AddCerts(store);
+    return store;
+}
+
+TOpenSslX509StorePtr GetDefaultOpenSslX509Store() {
+    TOpenSslX509StorePtr store(X509_STORE_new());
+
+    if (!TryGetEnv("SSL_CERT_FILE") && !TryGetEnv("SSL_CERT_DIR")) {
+        Singleton<TBuiltinCerts>()->AddCerts(store);
+    }
+
+    Y_ENSURE_EX(1 == X509_STORE_set_default_paths(store.Get()),
+        TSslError());
+
+    return store;
 }
diff --git a/library/cpp/openssl/io/stream.h b/library/cpp/openssl/io/stream.h
index 7bca8f80ef8..0b8746051e2 100644
--- a/library/cpp/openssl/io/stream.h
+++ b/library/cpp/openssl/io/stream.h
@@ -47,4 +47,11 @@ namespace NPrivate {
 }
 
 using TOpenSslX509StorePtr = THolder<x509_store_st, NPrivate::TSslDestroy>;
+
 TOpenSslX509StorePtr GetBuiltinOpenSslX509Store();
+
+// Builds default Certificate Authority bundle which includes:
+// - builtin "certs/cacert.pem" when SSL_CERT_FILE and SSL_CERT_DIR both unset
+// - SSL_CERT_FILE when set or /usr/local/ssl/cert.pem when unset
+// - SSL_CERT_DIR when set or /usr/local/ssl/certs when unset
+TOpenSslX509StorePtr GetDefaultOpenSslX509Store();
diff --git a/library/cpp/openssl/io/ut/builtin_ut.cpp b/library/cpp/openssl/io/ut/builtin_ut.cpp
index 987cd084922..954e3214889 100644
--- a/library/cpp/openssl/io/ut/builtin_ut.cpp
+++ b/library/cpp/openssl/io/ut/builtin_ut.cpp
@@ -1,9 +1,44 @@
 #include <library/cpp/openssl/io/stream.h>
+
 #include <library/cpp/testing/unittest/registar.h>
+#include <library/cpp/testing/unittest/gtest.h>
+
+#include <util/system/env.h>
+
+#include <openssl/x509.h>
+
+int GetObjectsCount(const TOpenSslX509StorePtr& store) {
+    return sk_X509_OBJECT_num(X509_STORE_get0_objects(store.Get()));
+}
 
 Y_UNIT_TEST_SUITE(Builtin) {
-    Y_UNIT_TEST(Init) {
+    Y_UNIT_TEST(Builtin) {
         UNIT_ASSERT_NO_EXCEPTION(GetBuiltinOpenSslX509Store());
         UNIT_ASSERT_NO_EXCEPTION(GetBuiltinOpenSslX509Store());
+        EXPECT_GT(GetObjectsCount(GetBuiltinOpenSslX509Store()), 0);
+    }
+    Y_UNIT_TEST(Default) {
+        UNIT_ASSERT_NO_EXCEPTION(GetDefaultOpenSslX509Store());
+        UNIT_ASSERT_NO_EXCEPTION(GetDefaultOpenSslX509Store());
+        EXPECT_GT(GetObjectsCount(GetDefaultOpenSslX509Store()), 0);
+    }
+    Y_UNIT_TEST(OpensslDefaults) {
+#if defined(_win_)
+        UNIT_ASSERT_STRINGS_EQUAL(X509_get_default_cert_file(), "C:\\Program Files\\Common Files\\SSL/cert.pem");
+        UNIT_ASSERT_STRINGS_EQUAL(X509_get_default_cert_dir(), "C:\\Program Files\\Common Files\\SSL/certs");
+#else
+        UNIT_ASSERT_STRINGS_EQUAL(X509_get_default_cert_file(), "/usr/local/ssl/cert.pem");
+        UNIT_ASSERT_STRINGS_EQUAL(X509_get_default_cert_dir(), "/usr/local/ssl/certs");
+#endif
+        UNIT_ASSERT_STRINGS_EQUAL(X509_get_default_cert_file_env(), "SSL_CERT_FILE");
+        UNIT_ASSERT_STRINGS_EQUAL(X509_get_default_cert_dir_env(), "SSL_CERT_DIR");
+    }
+    Y_UNIT_TEST(EnvironmentOptions) {
+        SetEnv("SSL_CERT_FILE", "_non_existing_file_");
+        SetEnv("SSL_CERT_DIR", "_non_existing_dir_");
+        UNIT_ASSERT_NO_EXCEPTION(GetBuiltinOpenSslX509Store());
+        UNIT_ASSERT_NO_EXCEPTION(GetDefaultOpenSslX509Store());
+        EXPECT_GT(GetObjectsCount(GetBuiltinOpenSslX509Store()), 0);
+        EXPECT_EQ(GetObjectsCount(GetDefaultOpenSslX509Store()), 0);
     }
 }
diff --git a/library/cpp/resource/CMakeLists.txt b/library/cpp/resource/CMakeLists.txt
index 13349849ce1..3359da55794 100644
--- a/library/cpp/resource/CMakeLists.txt
+++ b/library/cpp/resource/CMakeLists.txt
@@ -5,6 +5,7 @@ target_link_libraries(resource
     yutil
     blockcodecs-core
     blockcodecs-codecs-zstd
+    absl::flat_hash_map
 )
 
 target_sources(resource
diff --git a/library/cpp/resource/README.md b/library/cpp/resource/README.md
index b1e4961c1fe..b271aacda4f 100644
--- a/library/cpp/resource/README.md
+++ b/library/cpp/resource/README.md
@@ -6,7 +6,7 @@ See ya make documentation, resources section for more details.
 ### Example - adding a resource file into build:
 ```
 LIBRARY()
-OWNER(user1)
+
 RESOURCE(
     path/to/file1 /key/in/program/1
     path/to/file2 /key2
@@ -18,7 +18,7 @@ END()
 ```cpp
 #include <library/cpp/resource/resource.h>
 int main() {
-        Cout << NResource::Find("/key/in/program/1") << Endl;
-        Cout << NResource::Find("/key2") << Endl;
+    Cout << NResource::Find("/key/in/program/1") << Endl;
+    Cout << NResource::Find("/key2") << Endl;
 }
 ```
diff --git a/library/cpp/resource/registry.cpp b/library/cpp/resource/registry.cpp
index e403ba8ede3..00badd0fe31 100644
--- a/library/cpp/resource/registry.cpp
+++ b/library/cpp/resource/registry.cpp
@@ -1,5 +1,8 @@
 #include "registry.h"
 
+#include "resource.h"
+
+#include <absl/container/flat_hash_map.h>
 #include <library/cpp/blockcodecs/core/codecs.h>
 
 #include <util/system/yassert.h>
@@ -20,45 +23,66 @@ namespace {
 
     typedef std::pair<TStringBuf, TStringBuf> TDescriptor;
 
-    struct TStore final: public IStore, public THashMap<TStringBuf, TDescriptor*> {
+    [[noreturn]]
+    void ReportRedefinitionError(const TStringBuf key, const TStringBuf data, const ui64 kk, const TDescriptor& prev) noexcept {
+        const auto& [prevKey, value] = prev;
+        Y_ABORT_UNLESS(key == prevKey, "Internal hash collision:"
+                 " old key: %s,"
+                 " new key: %s,"
+                 " hash: %" PRIx64 ".",
+                 TString{prevKey}.Quote().c_str(),
+                 TString{key}.Quote().c_str(),
+                 kk);
+        size_t vsize = GetCodec()->DecompressedLength(value);
+        size_t dsize = GetCodec()->DecompressedLength(data);
+        if (vsize + dsize < 1000) {
+            Y_ABORT_UNLESS(false, "Redefinition of key %s:\n"
+                     "  old value: %s,\n"
+                     "  new value: %s.",
+                     TString{key}.Quote().c_str(),
+                     Decompress(value).Quote().c_str(),
+                     Decompress(data).Quote().c_str());
+        } else {
+            Y_ABORT_UNLESS(false, "Redefinition of key %s,"
+                     " old size: %zu,"
+                     " new size: %zu.",
+                     TString{key}.Quote().c_str(), vsize, dsize);
+        }
+    }
+
+    struct TStore final: public IStore, public absl::flat_hash_map<ui64, TDescriptor*> {
+        static inline ui64 ToK(TStringBuf k) {
+            return NHashPrivate::ComputeStringHash(k.data(), k.size());
+        }
+
         void Store(const TStringBuf key, const TStringBuf data) override {
-            if (contains(key)) {
-                const TStringBuf value = (*this)[key]->second;
+            auto kk = ToK(key);
+
+            const auto [it, unique] = try_emplace(kk, nullptr);
+            if (!unique) {
+                const auto& [_, value] = *it->second;
                 if (value != data) {
-                    size_t vsize = GetCodec()->DecompressedLength(value);
-                    size_t dsize = GetCodec()->DecompressedLength(data);
-                    if (vsize + dsize < 1000) {
-                        Y_ABORT_UNLESS(false, "Redefinition of key %s:\n"
-                                 "  old value: %s,\n"
-                                 "  new value: %s.",
-                                 TString{key}.Quote().c_str(),
-                                 Decompress(value).Quote().c_str(),
-                                 Decompress(data).Quote().c_str());
-                    } else {
-                        Y_ABORT_UNLESS(false, "Redefinition of key %s,"
-                                 " old size: %zu,"
-                                 " new size: %zu.",
-                                 TString{key}.Quote().c_str(), vsize, dsize);
-                    }
+                    ReportRedefinitionError(key, data, kk, *it->second);
+                    Y_UNREACHABLE();
                 }
             } else {
                 D_.push_back(TDescriptor(key, data));
-                (*this)[key] = &D_.back();
+                it->second = &D_.back();
             }
 
             Y_ABORT_UNLESS(size() == Count(), "size mismatch");
         }
 
         bool Has(const TStringBuf key) const override {
-            return contains(key);
+            return contains(ToK(key));
         }
 
         bool FindExact(const TStringBuf key, TString* out) const override {
-            if (TDescriptor* const* res = FindPtr(key)) {
+            if (auto res = find(ToK(key)); res != end()) {
                 // temporary
                 // https://st.yandex-team.ru/DEVTOOLS-3985
                 try {
-                    *out = Decompress((*res)->second);
+                    *out = Decompress(res->second->second);
                 } catch (const yexception& e) {
                     if (GetEnv("RESOURCE_DECOMPRESS_DIAG")) {
                         Cerr << "Can't decompress resource " << key << Endl << e.what() << Endl;
@@ -73,13 +97,13 @@ namespace {
         }
 
         void FindMatch(const TStringBuf subkey, IMatch& cb) const override {
-            for (const auto& it : *this) {
+            for (const auto& it : D_) {
                 if (it.first.StartsWith(subkey)) {
                     // temporary
                     // https://st.yandex-team.ru/DEVTOOLS-3985
                     try {
                         const TResource res = {
-                            it.first, Decompress(it.second->second)};
+                            it.first, Decompress(it.second)};
                         cb.OnMatch(res);
                     } catch (const yexception& e) {
                         if (GetEnv("RESOURCE_DECOMPRESS_DIAG")) {
@@ -119,3 +143,13 @@ IStore* NResource::CommonStore() {
 NResource::TRegHelper::TRegHelper(const TStringBuf key, const TStringBuf data) {
     CommonStore()->Store(key, data);
 }
+
+int NResource::LightRegisterI(const char* key, const char* data, const char* data_end) {
+    CommonStore()->Store(TStringBuf(key), TStringBuf(data, data_end));
+    return 0;
+
+}
+int NResource::LightRegisterS(const char* key, const char* data, unsigned long data_len) {
+    CommonStore()->Store(TStringBuf(key), TStringBuf(data, data_len));
+    return 0;
+}
diff --git a/library/cpp/resource/registry.h b/library/cpp/resource/registry.h
index d7f687cff8c..1a7b4e19647 100644
--- a/library/cpp/resource/registry.h
+++ b/library/cpp/resource/registry.h
@@ -3,9 +3,10 @@
 #include <util/generic/string.h>
 #include <util/generic/strbuf.h>
 
-#include "resource.h"
-
 namespace NResource {
+    struct TResource;
+
+
     TString Compress(const TStringBuf data);
     TString Decompress(const TStringBuf data);
 
@@ -31,4 +32,7 @@ namespace NResource {
     struct TRegHelper {
         TRegHelper(const TStringBuf key, const TStringBuf data);
     };
+
+    int LightRegisterS(const char* key, const char* data, unsigned long data_len);
+    int LightRegisterI(const char* key, const char* data, const char* data_end);
 }
diff --git a/library/cpp/streams/brotli/CMakeLists.txt b/library/cpp/streams/brotli/CMakeLists.txt
index e6dd2a84eac..8b556e64fa3 100644
--- a/library/cpp/streams/brotli/CMakeLists.txt
+++ b/library/cpp/streams/brotli/CMakeLists.txt
@@ -15,7 +15,6 @@ _ydb_sdk_add_library(streams-brotli)
 target_link_libraries(streams-brotli
   PUBLIC
     yutil
-  PRIVATE
     Brotli::enc
     Brotli::dec
 )
diff --git a/library/cpp/streams/brotli/brotli.cpp b/library/cpp/streams/brotli/brotli.cpp
index aad6e9945e0..1852f7ac9ac 100644
--- a/library/cpp/streams/brotli/brotli.cpp
+++ b/library/cpp/streams/brotli/brotli.cpp
@@ -21,7 +21,10 @@ namespace {
 
 class TBrotliCompress::TImpl {
 public:
-    TImpl(IOutputStream* slave, int quality)
+    TImpl(IOutputStream* slave,
+          int quality,
+          const TBrotliDictionary* dictionary,
+          size_t offset = 0)
         : Slave_(slave)
         , EncoderState_(BrotliEncoderCreateInstance(&TAllocator::Allocate, &TAllocator::Deallocate, nullptr))
     {
@@ -29,19 +32,16 @@ class TBrotliCompress::TImpl {
             ythrow yexception() << "Brotli encoder initialization failed";
         }
 
-        auto res = BrotliEncoderSetParameter(
-            EncoderState_,
-            BROTLI_PARAM_QUALITY,
-            quality);
-
-        if (!res) {
-            BrotliEncoderDestroyInstance(EncoderState_);
-            ythrow yexception() << "Failed to set brotli encoder quality to " << quality;
+        if (dictionary) {
+            BrotliEncoderAttachPreparedDictionary(EncoderState_, dictionary->GetPreparedDictionary());
         }
+
+        SetEncoderParameter(BROTLI_PARAM_QUALITY, quality, "quality");
+        SetEncoderParameter(BROTLI_PARAM_STREAM_OFFSET, offset, "stream offset");
     }
 
     ~TImpl() {
-        BrotliEncoderDestroyInstance(EncoderState_);
+        FreeEncoder();
     }
 
     void Write(const void* buffer, size_t size) {
@@ -62,6 +62,19 @@ class TBrotliCompress::TImpl {
     IOutputStream* Slave_;
     BrotliEncoderState* EncoderState_;
 
+    void SetEncoderParameter(BrotliEncoderParameter parameter,
+                             ui32 value,
+                             TStringBuf parameterName) {
+        if (!BrotliEncoderSetParameter(EncoderState_, parameter, value)) {
+            FreeEncoder();
+            ythrow yexception() << "Failed to set brotli encoder " << parameterName << " to " << value;
+        }
+    }
+
+    void FreeEncoder() {
+        BrotliEncoderDestroyInstance(EncoderState_);
+    }
+
     void DoWrite(const void* buffer, size_t size, BrotliEncoderOperation operation) {
         size_t availableOut = 0;
         ui8* outputBuffer = nullptr;
@@ -91,8 +104,14 @@ class TBrotliCompress::TImpl {
     }
 };
 
-TBrotliCompress::TBrotliCompress(IOutputStream* slave, int quality) {
-    Impl_.Reset(new TImpl(slave, quality));
+TBrotliCompress::TBrotliCompress(IOutputStream* slave,
+                                 int quality,
+                                 const TBrotliDictionary* dictionary,
+                                 size_t offset) {
+    Impl_.Reset(new TImpl(slave,
+                          quality,
+                          dictionary,
+                          offset));
 }
 
 TBrotliCompress::~TBrotliCompress() {
@@ -124,8 +143,10 @@ void TBrotliCompress::DoFinish() {
 
 class TBrotliDecompress::TImpl: public TAdditionalStorage<TImpl> {
 public:
-    TImpl(IInputStream* slave)
+    TImpl(IInputStream* slave,
+          const TBrotliDictionary* dictionary)
         : Slave_(slave)
+        , Dictionary_(dictionary)
     {
         InitDecoder();
     }
@@ -188,6 +209,8 @@ class TBrotliDecompress::TImpl: public TAdditionalStorage<TImpl> {
     IInputStream* Slave_;
     BrotliDecoderState* DecoderState_;
 
+    const TBrotliDictionary* Dictionary_ = nullptr;
+
     bool SubstreamFinished_ = false;
     bool InputExhausted_ = false;
     const ui8* InputBuffer_ = nullptr;
@@ -203,6 +226,13 @@ class TBrotliDecompress::TImpl: public TAdditionalStorage<TImpl> {
 
     void InitDecoder() {
         DecoderState_ = BrotliDecoderCreateInstance(&TAllocator::Allocate, &TAllocator::Deallocate, nullptr);
+        if (Dictionary_) {
+            BrotliDecoderAttachDictionary(
+                DecoderState_,
+                BROTLI_SHARED_DICTIONARY_RAW,
+                Dictionary_->GetSize(),
+                Dictionary_->GetData());
+        }
         if (!DecoderState_) {
             ythrow yexception() << "Brotli decoder initialization failed";
         }
@@ -219,8 +249,10 @@ class TBrotliDecompress::TImpl: public TAdditionalStorage<TImpl> {
     }
 };
 
-TBrotliDecompress::TBrotliDecompress(IInputStream* slave, size_t bufferSize)
-    : Impl_(new (bufferSize) TImpl(slave))
+TBrotliDecompress::TBrotliDecompress(IInputStream* slave,
+                                     size_t bufferSize,
+                                     const TBrotliDictionary* dictionary)
+    : Impl_(new (bufferSize) TImpl(slave, dictionary))
 {
 }
 
diff --git a/library/cpp/streams/brotli/brotli.h b/library/cpp/streams/brotli/brotli.h
index b3af869e29c..ef0c9611acf 100644
--- a/library/cpp/streams/brotli/brotli.h
+++ b/library/cpp/streams/brotli/brotli.h
@@ -1,5 +1,8 @@
 #pragma once
 
+#include "const.h"
+#include "dictionary.h"
+
 #include <util/generic/ptr.h>
 #include <util/stream/input.h>
 #include <util/stream/output.h>
@@ -11,13 +14,16 @@
 
 class TBrotliCompress: public IOutputStream {
 public:
-    static constexpr int BEST_QUALITY = 11;
-
     /**
       @param slave stream to write compressed data to
       @param quality the higher the quality, the slower and better the compression. Range is 0 to 11.
+      @param dictionary custom brotli dictionary
+      @param offset number of bytes already processed by a different encoder instance
     */
-    explicit TBrotliCompress(IOutputStream* slave, int quality = BEST_QUALITY);
+    explicit TBrotliCompress(IOutputStream* slave,
+                             int quality = NBrotli::BEST_BROTLI_QUALITY,
+                             const TBrotliDictionary* dictionary = nullptr,
+                             size_t offset = 0);
     ~TBrotliCompress() override;
 
 private:
@@ -37,8 +43,11 @@ class TBrotliDecompress: public IInputStream {
     /**
       @param slave stream to read compressed data from
       @param bufferSize approximate size of buffer compressed data is read in
+      @param dictionary custom brotli dictionary
     */
-    explicit TBrotliDecompress(IInputStream* slave, size_t bufferSize = 8 * 1024);
+    explicit TBrotliDecompress(IInputStream* slave,
+                               size_t bufferSize = NBrotli::DEFAULT_BROTLI_BUFFER_SIZE,
+                               const TBrotliDictionary* dictionary = nullptr);
     ~TBrotliDecompress() override;
 
 private:
diff --git a/library/cpp/streams/brotli/brotli_ut.cpp b/library/cpp/streams/brotli/brotli_ut.cpp
index aeb2e284dc3..fdf6cb2702e 100644
--- a/library/cpp/streams/brotli/brotli_ut.cpp
+++ b/library/cpp/streams/brotli/brotli_ut.cpp
@@ -5,19 +5,22 @@
 #include <util/random/fast.h>
 
 Y_UNIT_TEST_SUITE(TBrotliTestSuite) {
-    TString Compress(TString data) {
+    TString Compress(const TString& data, TStringBuf dict = "") {
         TString compressed;
         TStringOutput output(compressed);
-        TBrotliCompress compressStream(&output, 11);
+        size_t quality = NBrotli::BEST_BROTLI_QUALITY;
+        TBrotliDictionary dictionary(dict, quality);
+        TBrotliCompress compressStream(&output, quality, &dictionary);
         compressStream.Write(data.data(), data.size());
         compressStream.Finish();
         output.Finish();
         return compressed;
     }
 
-    TString Decompress(TString data) {
+    TString Decompress(const TString& data, TStringBuf dict = "") {
         TStringInput input(data);
-        TBrotliDecompress decompressStream(&input);
+        TBrotliDictionary dictionary(dict);
+        TBrotliDecompress decompressStream(&input, NBrotli::DEFAULT_BROTLI_BUFFER_SIZE, &dictionary);
         return decompressStream.ReadAll();
     }
 
@@ -86,4 +89,28 @@ Y_UNIT_TEST_SUITE(TBrotliTestSuite) {
     Y_UNIT_TEST(TestEmpty) {
         TestCase("");
     }
-}
+
+    Y_UNIT_TEST(TestDictionary) {
+        TString str = "Bond, James Bond";
+        TStringBuf dict = "Bond";
+        UNIT_ASSERT_VALUES_EQUAL(str, Decompress(Compress(str, dict), dict));
+    }
+
+    Y_UNIT_TEST(TestStreamOffset) {
+        TString first = "apple pen";
+        TString second = " pineapple pen";
+
+        TString compressed;
+        TStringOutput out1(compressed);
+        TBrotliCompress stream1(&out1, NBrotli::BEST_BROTLI_QUALITY);
+        stream1.Write(first);
+        stream1.Flush();
+
+        TStringOutput out2(compressed);
+        TBrotliCompress stream2(&out2, NBrotli::BEST_BROTLI_QUALITY, nullptr, first.size());
+        stream2.Write(second);
+        stream2.Finish();
+
+        UNIT_ASSERT_VALUES_EQUAL(first + second, Decompress(compressed));
+    }
+} // Y_UNIT_TEST_SUITE(TBrotliTestSuite)
diff --git a/library/cpp/streams/brotli/const.h b/library/cpp/streams/brotli/const.h
new file mode 100644
index 00000000000..fdcfb632d17
--- /dev/null
+++ b/library/cpp/streams/brotli/const.h
@@ -0,0 +1,10 @@
+#pragma once
+
+#include <stddef.h>
+
+namespace NBrotli {
+
+constexpr int BEST_BROTLI_QUALITY = 11;
+constexpr size_t DEFAULT_BROTLI_BUFFER_SIZE = 8 * 1024;
+
+} // namespace NBrotli
diff --git a/library/cpp/streams/brotli/dictionary.h b/library/cpp/streams/brotli/dictionary.h
new file mode 100644
index 00000000000..301ef840d29
--- /dev/null
+++ b/library/cpp/streams/brotli/dictionary.h
@@ -0,0 +1,54 @@
+#pragma once
+
+#include "const.h"
+
+#include <brotli/encode.h>
+
+#include <util/generic/strbuf.h>
+
+class TBrotliDictionary: public TMoveOnly {
+public:
+    TBrotliDictionary(const ui8* dict, size_t size, int quality = NBrotli::BEST_BROTLI_QUALITY)
+        : Data_(dict)
+        , Size_(size)
+        , PreparedDictionary_(
+              BrotliEncoderPrepareDictionary(
+                  /*type*/ BROTLI_SHARED_DICTIONARY_RAW,
+                  /*size*/ Size_,
+                  /*data*/ Data_,
+                  /*quality*/ quality,
+                  /*alloc_func*/ nullptr,
+                  /*free_func*/ nullptr,
+                  /*opaque*/ nullptr))
+    {
+    }
+
+    explicit TBrotliDictionary(TStringBuf dict, int quality = NBrotli::BEST_BROTLI_QUALITY)
+        : TBrotliDictionary(
+              reinterpret_cast<const ui8*>(dict.data()),
+              dict.size(),
+              quality)
+    {
+    }
+
+    ~TBrotliDictionary() {
+        BrotliEncoderDestroyPreparedDictionary(PreparedDictionary_);
+    }
+
+    BrotliEncoderPreparedDictionary* GetPreparedDictionary() const {
+        return PreparedDictionary_;
+    }
+
+    const ui8* GetData() const {
+        return Data_;
+    }
+
+    size_t GetSize() const {
+        return Size_;
+    }
+
+private:
+    const ui8* Data_ = nullptr;
+    const size_t Size_ = 0;
+    BrotliEncoderPreparedDictionary* PreparedDictionary_ = nullptr;
+};
diff --git a/library/cpp/streams/lzma/lzma_ut.cpp b/library/cpp/streams/lzma/lzma_ut.cpp
index 847e98d1caa..dbcd7d78fac 100644
--- a/library/cpp/streams/lzma/lzma_ut.cpp
+++ b/library/cpp/streams/lzma/lzma_ut.cpp
@@ -10,7 +10,7 @@ class TStrokaByOneByte: public IZeroCopyInput {
 public:
     TStrokaByOneByte(const TString& s)
         : Data(s)
-        , Pos(s.data())
+        , Pos(Data.data())
     {
     }
 
diff --git a/library/cpp/string_utils/quote/CMakeLists.txt b/library/cpp/string_utils/quote/CMakeLists.txt
index 79aafb2e319..8507073378c 100644
--- a/library/cpp/string_utils/quote/CMakeLists.txt
+++ b/library/cpp/string_utils/quote/CMakeLists.txt
@@ -1,7 +1,7 @@
 if (YDB_SDK_TESTS)
   add_ydb_test(NAME string_utils-quote-ut
     SOURCES
-      quote_ut.cpp
+      ut/quote_ut.cpp
     LINK_LIBRARIES
       string_utils-quote
       cpp-testing-unittest_main
diff --git a/library/cpp/string_utils/quote/quote.cpp b/library/cpp/string_utils/quote/quote.cpp
index 6a117c424af..91e31da1102 100644
--- a/library/cpp/string_utils/quote/quote.cpp
+++ b/library/cpp/string_utils/quote/quote.cpp
@@ -62,10 +62,6 @@ namespace {
     };
 }
 
-static inline char d2x(unsigned x) {
-    return (char)((x < 10) ? ('0' + x) : ('A' + x - 10));
-}
-
 static inline const char* FixZero(const char* s) noexcept {
     return s ? s : "";
 }
@@ -101,22 +97,65 @@ static const bool chars_to_url_escape[256] = {
     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, //F
 };
 
+static const char d2x[16] = {
+    '0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'
+};
+
+template <class It1>
+static inline void EscapeHelper(It1& to, unsigned char c, const bool* escape_map) {
+    if (!escape_map[c]) {
+        *to++ = (c == ' ') ? '+' : c;
+    } else {
+        *to++ = '%';
+        *to++ = d2x[c >> 4];
+        *to++ = d2x[c & 0xF];
+    }
+}
+
 template <class It1, class It2, class It3>
 static inline It1 Escape(It1 to, It2 from, It3 end, const bool* escape_map = chars_to_url_escape) {
     while (from != end) {
-        if (escape_map[(unsigned char)*from]) {
-            *to++ = '%';
-            *to++ = d2x((unsigned char)*from >> 4);
-            *to++ = d2x((unsigned char)*from & 0xF);
+        EscapeHelper(to, *from++, escape_map);
+    }
+
+    *to = 0;
+
+    return to;
+}
+
+static inline char* Escape(char* to, const char* from, const char* end, const bool* escape_map = chars_to_url_escape) {
+    constexpr size_t BLOCK = 16;
+
+    while (from + BLOCK <= end) {
+        uint32_t escape_count = 0;
+        for (size_t i = 0; i < BLOCK; ++i) {
+            escape_count |= escape_map[(unsigned char)from[i]];
+        }
+
+        if (escape_count == 0) {
+            unsigned char src[BLOCK];
+            for (size_t i = 0; i < BLOCK; ++i) {
+                src[i] = from[i];
+            }
+            for (size_t i = 0; i < BLOCK; ++i) {
+                unsigned char c = src[i];
+                to[i] = (c == ' ') ? '+' : c;
+            }
+            to += BLOCK;
         } else {
-            *to++ = (*from == ' ' ? '+' : *from);
+            for (size_t i = 0; i < BLOCK; ++i) {
+                unsigned char c = from[i];
+                EscapeHelper(to, c, escape_map);
+            }
         }
+        from += BLOCK;
+    }
 
-        ++from;
+    while (from != end) {
+        EscapeHelper(to, *from++, escape_map);
     }
 
     *to = 0;
-
     return to;
 }
 
@@ -274,20 +313,18 @@ TString UrlUnescapeRet(const TStringBuf from) {
     return to;
 }
 
-char* UrlEscape(char* to, const char* from, bool forceEscape) {
-    from = FixZero(from);
-
-    while (*from) {
+char* UrlEscape(char* to, TStringBuf src, bool forceEscape) {
+    for (auto from = src.begin(); from != src.end(); ++from) {
         const bool escapePercent = (*from == '%') &&
-                                   (forceEscape || !((*(from + 1) && IsAsciiHex(*(from + 1)) && *(from + 2) && IsAsciiHex(*(from + 2)))));
+                                   (forceEscape || !((std::next(from) != src.end() && IsAsciiHex(*(std::next(from)))
+                                   && std::next(from, 2) != src.end() && IsAsciiHex(*(std::next(from, 2))))));
 
         if (escapePercent || (unsigned char)*from <= ' ' || (unsigned char)*from > '~') {
             *to++ = '%';
-            *to++ = d2x((unsigned char)*from >> 4);
-            *to++ = d2x((unsigned char)*from & 0xF);
+            *to++ = d2x[(unsigned char)*from >> 4];
+            *to++ = d2x[(unsigned char)*from & 0xF];
         } else
             *to++ = *from;
-        ++from;
     }
 
     *to = 0;
@@ -298,12 +335,12 @@ char* UrlEscape(char* to, const char* from, bool forceEscape) {
 void UrlEscape(TString& url, bool forceEscape) {
     TTempBuf tempBuf(CgiEscapeBufLen(url.size()));
     char* to = tempBuf.Data();
-    url.AssignNoAlias(to, UrlEscape(to, url.data(), forceEscape));
+    url.AssignNoAlias(to, UrlEscape(to, url, forceEscape));
 }
 
 TString UrlEscapeRet(const TStringBuf from, bool forceEscape) {
     TString to;
     to.ReserveAndResize(CgiEscapeBufLen(from.size()));
-    to.resize(UrlEscape(to.begin(), from.begin(), forceEscape) - to.data());
+    to.resize(UrlEscape(to.begin(), from, forceEscape) - to.data());
     return to;
 }
diff --git a/library/cpp/string_utils/quote/quote.h b/library/cpp/string_utils/quote/quote.h
index 3b7221154eb..d99c08dfb39 100644
--- a/library/cpp/string_utils/quote/quote.h
+++ b/library/cpp/string_utils/quote/quote.h
@@ -51,7 +51,7 @@ void Quote(TString& url, const char* safe = "/");
 // escapes only '%' not followed by two hex-digits or if forceEscape set to ture,
 // and chars outside [32, 126] range.
 // Can't handle '\0'-chars in TString.
-char* UrlEscape(char* to, const char* from, bool forceEscape = false);
+char* UrlEscape(char* to, TStringBuf from, bool forceEscape = false);
 void UrlEscape(TString& url, bool forceEscape = false);
 TString UrlEscapeRet(const TStringBuf from, bool forceEscape = false);
 
diff --git a/library/cpp/string_utils/quote/quote_ut.cpp b/library/cpp/string_utils/quote/ut/quote_ut.cpp
similarity index 99%
rename from library/cpp/string_utils/quote/quote_ut.cpp
rename to library/cpp/string_utils/quote/ut/quote_ut.cpp
index 9d6f56ffbb0..b0773ebe996 100644
--- a/library/cpp/string_utils/quote/quote_ut.cpp
+++ b/library/cpp/string_utils/quote/ut/quote_ut.cpp
@@ -1,4 +1,4 @@
-#include "quote.h"
+#include <library/cpp/string_utils/quote/quote.h>
 
 #include <library/cpp/testing/unittest/registar.h>
 
diff --git a/library/cpp/string_utils/url/url.cpp b/library/cpp/string_utils/url/url.cpp
index c850afa5a73..7d7d7dbd90b 100644
--- a/library/cpp/string_utils/url/url.cpp
+++ b/library/cpp/string_utils/url/url.cpp
@@ -71,6 +71,40 @@ namespace NUrl {
         return {host, path};
     }
 
+    bool HasLowerHost(const TStringBuf url) {
+        for (size_t n = 0; n < url.length(); ++n) {
+            if (url[n] == '/')
+                break;
+            if (isupper(url[n]))
+                return false;
+        }
+        return true;
+    }
+
+    TStringBuf CutHttpWwwPrefixes(const TStringBuf url Y_LIFETIME_BOUND) {
+        TStringBuf urlCut = CutWWWPrefix(CutHttpPrefix(url));
+        if (!urlCut.empty() && urlCut.back() == '/')
+            urlCut = urlCut.substr(0, urlCut.length() - 1);
+        return urlCut;
+    }
+
+    TString MakeLowerHost(const TStringBuf url, size_t shift) {
+        TString urlFixed(url);
+        for (char *c = urlFixed.begin() + shift; *c && (*c != '/'); ++c) {
+            *c = tolower(*c);
+        }
+
+        return urlFixed;
+    }
+
+    TString MakeNormalized(const TStringBuf url) {
+        TStringBuf urlCut = CutHttpWwwPrefixes(url);
+        if (HasLowerHost(urlCut)) {
+            return ToString(urlCut);
+        }
+        return MakeLowerHost(urlCut);
+    }
+
 } // namespace NUrl
 
 size_t GetHttpPrefixSize(const char* url, bool ignorehttps) noexcept {
@@ -89,11 +123,11 @@ size_t GetHttpPrefixSize(const TWtringBuf url, bool ignorehttps) noexcept {
     return GetHttpPrefixSizeImpl<wchar16>(url.data(), TKnownSize(url.size()), ignorehttps);
 }
 
-TStringBuf CutHttpPrefix(const TStringBuf url, bool ignorehttps) noexcept {
+TStringBuf CutHttpPrefix(const TStringBuf url Y_LIFETIME_BOUND, bool ignorehttps) noexcept {
     return CutHttpPrefixImpl(url, ignorehttps);
 }
 
-TWtringBuf CutHttpPrefix(const TWtringBuf url, bool ignorehttps) noexcept {
+TWtringBuf CutHttpPrefix(const TWtringBuf url Y_LIFETIME_BOUND, bool ignorehttps) noexcept {
     return CutHttpPrefixImpl(url, ignorehttps);
 }
 
@@ -119,11 +153,11 @@ size_t GetSchemePrefixSize(const TStringBuf url) noexcept {
     return n + 3 - url.begin();
 }
 
-TStringBuf GetSchemePrefix(const TStringBuf url) noexcept {
+TStringBuf GetSchemePrefix(const TStringBuf url Y_LIFETIME_BOUND) noexcept {
     return url.Head(GetSchemePrefixSize(url));
 }
 
-TStringBuf CutSchemePrefix(const TStringBuf url) noexcept {
+TStringBuf CutSchemePrefix(const TStringBuf url Y_LIFETIME_BOUND) noexcept {
     return url.Tail(GetSchemePrefixSize(url));
 }
 
@@ -150,15 +184,15 @@ static inline TStringBuf GetHostAndPortImpl(const TStringBuf url) {
     return urlNoScheme;
 }
 
-TStringBuf GetHost(const TStringBuf url) noexcept {
+TStringBuf GetHost(const TStringBuf url Y_LIFETIME_BOUND) noexcept {
     return GetHostAndPortImpl<false>(url);
 }
 
-TStringBuf GetHostAndPort(const TStringBuf url) noexcept {
+TStringBuf GetHostAndPort(const TStringBuf url Y_LIFETIME_BOUND) noexcept {
     return GetHostAndPortImpl<true>(url);
 }
 
-TStringBuf GetSchemeHost(const TStringBuf url, bool trimHttp) noexcept {
+TStringBuf GetSchemeHost(const TStringBuf url Y_LIFETIME_BOUND, bool trimHttp) noexcept {
     const size_t schemeSize = GetSchemePrefixSize(url);
     const TStringBuf scheme = url.Head(schemeSize);
 
@@ -173,7 +207,7 @@ TStringBuf GetSchemeHost(const TStringBuf url, bool trimHttp) noexcept {
     }
 }
 
-TStringBuf GetSchemeHostAndPort(const TStringBuf url, bool trimHttp, bool trimDefaultPort) noexcept {
+TStringBuf GetSchemeHostAndPort(const TStringBuf url Y_LIFETIME_BOUND, bool trimHttp, bool trimDefaultPort) noexcept {
     const size_t schemeSize = GetSchemePrefixSize(url);
     const TStringBuf scheme = url.Head(schemeSize);
 
@@ -254,11 +288,11 @@ void GetSchemeHostAndPort(const TStringBuf url, TStringBuf& scheme, TStringBuf&
     Y_ENSURE(isOk, "cannot parse port number from URL: " << url);
 }
 
-TStringBuf GetOnlyHost(const TStringBuf url) noexcept {
+TStringBuf GetOnlyHost(const TStringBuf url Y_LIFETIME_BOUND) noexcept {
     return GetHost(CutSchemePrefix(url));
 }
 
-TStringBuf GetPathAndQuery(const TStringBuf url, bool trimFragment) noexcept {
+TStringBuf GetPathAndQuery(const TStringBuf url Y_LIFETIME_BOUND, bool trimFragment) noexcept {
     const size_t off = url.find('/', GetHttpPrefixSize(url));
     TStringBuf hostUnused, path;
     if (!url.TrySplitAt(off, hostUnused, path))
@@ -268,7 +302,7 @@ TStringBuf GetPathAndQuery(const TStringBuf url, bool trimFragment) noexcept {
 }
 
 // this strange creature returns 2nd level domain, possibly with port
-TStringBuf GetDomain(const TStringBuf host) noexcept {
+TStringBuf GetDomain(const TStringBuf host Y_LIFETIME_BOUND) noexcept {
     const char* c = !host ? host.data() : host.end() - 1;
     for (bool wasPoint = false; c != host.data(); --c) {
         if (*c == '.') {
@@ -282,7 +316,7 @@ TStringBuf GetDomain(const TStringBuf host) noexcept {
     return TStringBuf(c, host.end());
 }
 
-TStringBuf GetParentDomain(const TStringBuf host, size_t level) noexcept {
+TStringBuf GetParentDomain(const TStringBuf host Y_LIFETIME_BOUND, size_t level) noexcept {
     size_t pos = host.size();
     for (size_t i = 0; i < level; ++i) {
         pos = host.rfind('.', pos);
@@ -292,17 +326,17 @@ TStringBuf GetParentDomain(const TStringBuf host, size_t level) noexcept {
     return host.SubStr(pos + 1);
 }
 
-TStringBuf GetZone(const TStringBuf host) noexcept {
+TStringBuf GetZone(const TStringBuf host Y_LIFETIME_BOUND) noexcept {
     return GetParentDomain(host, 1);
 }
 
-TStringBuf CutWWWPrefix(const TStringBuf url) noexcept {
+TStringBuf CutWWWPrefix(const TStringBuf url Y_LIFETIME_BOUND) noexcept {
     if (url.size() >= 4 && url[3] == '.' && !strnicmp(url.data(), "www", 3))
         return url.substr(4);
     return url;
 }
 
-TStringBuf CutWWWNumberedPrefix(const TStringBuf url) noexcept {
+TStringBuf CutWWWNumberedPrefix(const TStringBuf url Y_LIFETIME_BOUND) noexcept {
     auto it = url.begin();
 
     StripRangeBegin(it, url.end(), [](auto& it){ return *it == 'w' || *it == 'W'; });
@@ -322,7 +356,7 @@ TStringBuf CutWWWNumberedPrefix(const TStringBuf url) noexcept {
     return url;
 }
 
-TStringBuf CutMPrefix(const TStringBuf url) noexcept {
+TStringBuf CutMPrefix(const TStringBuf url Y_LIFETIME_BOUND) noexcept {
     if (url.size() >= 2 && url[1] == '.' && (url[0] == 'm' || url[0] == 'M')) {
         return url.substr(2);
     }
@@ -407,20 +441,20 @@ size_t NormalizeHostName(char* dest, const TStringBuf source, size_t dest_size,
     return len;
 }
 
-TStringBuf RemoveFinalSlash(TStringBuf str) noexcept {
+TStringBuf RemoveFinalSlash(TStringBuf str Y_LIFETIME_BOUND) noexcept {
     if (str.EndsWith('/')) {
         str.Chop(1);
     }
     return str;
 }
 
-TStringBuf CutUrlPrefixes(TStringBuf url) noexcept {
+TStringBuf CutUrlPrefixes(TStringBuf url Y_LIFETIME_BOUND) noexcept {
     url = CutSchemePrefix(url);
     url = CutWWWPrefix(url);
     return url;
 }
 
-bool DoesUrlPathStartWithToken(TStringBuf url, const TStringBuf& token) noexcept {
+bool DoesUrlPathStartWithToken(TStringBuf url, const TStringBuf token) noexcept {
     url = CutSchemePrefix(url);
     const TStringBuf noHostSuffix = url.After('/');
     if (noHostSuffix == url) {
diff --git a/library/cpp/string_utils/url/url.h b/library/cpp/string_utils/url/url.h
index 68fa23d64c8..5e707756c3b 100644
--- a/library/cpp/string_utils/url/url.h
+++ b/library/cpp/string_utils/url/url.h
@@ -19,7 +19,12 @@ namespace NUrl {
     };
 
     Y_PURE_FUNCTION
-    TSplitUrlToHostAndPathResult SplitUrlToHostAndPath(const TStringBuf url);
+    TSplitUrlToHostAndPathResult SplitUrlToHostAndPath(const TStringBuf url Y_LIFETIME_BOUND);
+
+    bool HasLowerHost(const TStringBuf url);
+    TStringBuf CutHttpWwwPrefixes(const TStringBuf url Y_LIFETIME_BOUND);
+    TString MakeLowerHost(const TStringBuf url, size_t shift = 0);
+    TString MakeNormalized(const TStringBuf url);
 
 } // namespace NUrl
 
@@ -40,7 +45,7 @@ Y_PURE_FUNCTION
 size_t GetSchemePrefixSize(const TStringBuf url) noexcept;
 
 Y_PURE_FUNCTION
-TStringBuf GetSchemePrefix(const TStringBuf url) noexcept;
+TStringBuf GetSchemePrefix(const TStringBuf url Y_LIFETIME_BOUND) noexcept;
 
 //! removes protocol prefixes 'http://' and 'https://' from given URL
 //! @note if URL has no prefix or some other prefix the function does nothing
@@ -48,13 +53,13 @@ TStringBuf GetSchemePrefix(const TStringBuf url) noexcept;
 //! @param ignorehttps if true, leaves https://
 //! @return a new URL without protocol prefix
 Y_PURE_FUNCTION
-TStringBuf CutHttpPrefix(const TStringBuf url, bool ignorehttps = false) noexcept;
+TStringBuf CutHttpPrefix(const TStringBuf url Y_LIFETIME_BOUND, bool ignorehttps = false) noexcept;
 
 Y_PURE_FUNCTION
-TWtringBuf CutHttpPrefix(const TWtringBuf url, bool ignorehttps = false) noexcept;
+TWtringBuf CutHttpPrefix(const TWtringBuf url Y_LIFETIME_BOUND, bool ignorehttps = false) noexcept;
 
 Y_PURE_FUNCTION
-TStringBuf CutSchemePrefix(const TStringBuf url) noexcept;
+TStringBuf CutSchemePrefix(const TStringBuf url Y_LIFETIME_BOUND) noexcept;
 
 //! adds specified scheme prefix if URL has no scheme
 //! @note if URL has scheme prefix already the function returns unchanged URL
@@ -64,16 +69,16 @@ TString AddSchemePrefix(const TString& url, const TStringBuf scheme);
 TString AddSchemePrefix(const TString& url);
 
 Y_PURE_FUNCTION
-TStringBuf GetHost(const TStringBuf url) noexcept;
+TStringBuf GetHost(const TStringBuf url Y_LIFETIME_BOUND) noexcept;
 
 Y_PURE_FUNCTION
-TStringBuf GetHostAndPort(const TStringBuf url) noexcept;
+TStringBuf GetHostAndPort(const TStringBuf url Y_LIFETIME_BOUND) noexcept;
 
 Y_PURE_FUNCTION
-TStringBuf GetSchemeHost(const TStringBuf url, bool trimHttp = true) noexcept;
+TStringBuf GetSchemeHost(const TStringBuf url Y_LIFETIME_BOUND, bool trimHttp = true) noexcept;
 
 Y_PURE_FUNCTION
-TStringBuf GetSchemeHostAndPort(const TStringBuf url, bool trimHttp = true, bool trimDefaultPort = true) noexcept;
+TStringBuf GetSchemeHostAndPort(const TStringBuf url Y_LIFETIME_BOUND, bool trimHttp = true, bool trimDefaultPort = true) noexcept;
 
 /**
  * Splits URL to host and path
@@ -127,26 +132,26 @@ bool TryGetSchemeHostAndPort(const TStringBuf url, TStringBuf& scheme, TStringBu
 void GetSchemeHostAndPort(const TStringBuf url, TStringBuf& scheme, TStringBuf& host, ui16& port);
 
 Y_PURE_FUNCTION
-TStringBuf GetPathAndQuery(const TStringBuf url, bool trimFragment = true) noexcept;
+TStringBuf GetPathAndQuery(const TStringBuf url Y_LIFETIME_BOUND, bool trimFragment = true) noexcept;
 /**
  * Extracts host from url and cuts http(https) protocol prefix and port if any.
  * @param[in] url   any URL
  * @return          host without port and http(https) prefix.
  */
 Y_PURE_FUNCTION
-TStringBuf GetOnlyHost(const TStringBuf url) noexcept;
+TStringBuf GetOnlyHost(const TStringBuf url Y_LIFETIME_BOUND) noexcept;
 
 Y_PURE_FUNCTION
-TStringBuf GetParentDomain(const TStringBuf host, size_t level) noexcept; // ("www.ya.ru", 2) -> "ya.ru"
+TStringBuf GetParentDomain(const TStringBuf host Y_LIFETIME_BOUND, size_t level) noexcept; // ("www.ya.ru", 2) -> "ya.ru"
 
 Y_PURE_FUNCTION
-TStringBuf GetZone(const TStringBuf host) noexcept;
+TStringBuf GetZone(const TStringBuf host Y_LIFETIME_BOUND) noexcept;
 
 Y_PURE_FUNCTION
-TStringBuf CutWWWPrefix(const TStringBuf url) noexcept;
+TStringBuf CutWWWPrefix(const TStringBuf url Y_LIFETIME_BOUND) noexcept;
 
 Y_PURE_FUNCTION
-TStringBuf CutWWWNumberedPrefix(const TStringBuf url) noexcept;
+TStringBuf CutWWWNumberedPrefix(const TStringBuf url Y_LIFETIME_BOUND) noexcept;
 
 /**
  * Cuts 'm.' prefix from url if and only if the url starts with it
@@ -157,17 +162,16 @@ TStringBuf CutWWWNumberedPrefix(const TStringBuf url) noexcept;
  * @return          url without 'm.' or 'M.' prefix.
  */
 Y_PURE_FUNCTION
-TStringBuf CutMPrefix(const TStringBuf url) noexcept;
+TStringBuf CutMPrefix(const TStringBuf url Y_LIFETIME_BOUND) noexcept;
 
 Y_PURE_FUNCTION
-TStringBuf GetDomain(const TStringBuf host) noexcept; // should not be used
+TStringBuf GetDomain(const TStringBuf host Y_LIFETIME_BOUND) noexcept; // should not be used
 
 size_t NormalizeUrlName(char* dest, const TStringBuf source, size_t dest_size);
 size_t NormalizeHostName(char* dest, const TStringBuf source, size_t dest_size, ui16 defport = 80);
 
 Y_PURE_FUNCTION
-TStringBuf RemoveFinalSlash(TStringBuf str) noexcept;
-
-TStringBuf CutUrlPrefixes(TStringBuf url) noexcept;
-bool DoesUrlPathStartWithToken(TStringBuf url, const TStringBuf& token) noexcept;
+TStringBuf RemoveFinalSlash(TStringBuf str Y_LIFETIME_BOUND) noexcept;
 
+TStringBuf CutUrlPrefixes(TStringBuf url Y_LIFETIME_BOUND) noexcept;
+bool DoesUrlPathStartWithToken(TStringBuf url, const TStringBuf token) noexcept;
diff --git a/library/cpp/svnversion/test/main.cpp b/library/cpp/svnversion/test/main.cpp
index 830686d5b3d..632c8d3915b 100644
--- a/library/cpp/svnversion/test/main.cpp
+++ b/library/cpp/svnversion/test/main.cpp
@@ -8,6 +8,7 @@
 int main() {
     Cout << "GetProgramSvnVersion(): " << GetProgramSvnVersion() << Endl;
     Cout << "GetCustomVersion(): " << GetCustomVersion() << Endl;
+    Cout << "GetReleaseVersion(): " << GetReleaseVersion() << Endl;
     Cout << "PrintProgramSvnVersion(): " << Endl; PrintProgramSvnVersion();
     Cout << "GetArcadiaSourcePath(): " << GetArcadiaSourcePath() << Endl;
     Cout << "GetArcadiaSourceUrl(): " << GetArcadiaSourceUrl() << Endl;
diff --git a/library/cpp/testing/common/env.cpp b/library/cpp/testing/common/env.cpp
index bf5eb34c782..4ef0e169ccc 100644
--- a/library/cpp/testing/common/env.cpp
+++ b/library/cpp/testing/common/env.cpp
@@ -41,27 +41,7 @@ TString BinaryPath(TStringBuf path) {
 }
 
 TString GetArcadiaTestsData() {
-    TString atdRoot = NPrivate::GetTestEnv().ArcadiaTestsDataDir;
-    if (atdRoot) {
-        return atdRoot;
-    }
-
-    TString path = NPrivate::GetCwd();
-    const char pathsep = GetDirectorySeparator();
-    while (!path.empty()) {
-        TString dataDir = path + "/arcadia_tests_data";
-        if (IsDir(dataDir)) {
-            return dataDir;
-        }
-
-        size_t pos = path.find_last_of(pathsep);
-        if (pos == TString::npos) {
-            pos = 0;
-        }
-        path.erase(pos);
-    }
-
-    return {};
+    return ArcadiaSourceRoot() + "/atd_ro_snapshot";
 }
 
 TString GetWorkPath() {
@@ -161,7 +141,6 @@ namespace NPrivate {
 
     void TTestEnv::ReInitialize() {
         IsRunningFromTest = false;
-        ArcadiaTestsDataDir = "";
         SourceRoot = "";
         BuildRoot = "";
         WorkPath = "";
@@ -191,11 +170,6 @@ namespace NPrivate {
                 BuildRoot = value->GetStringSafe("");
             }
 
-            value = context.GetValueByPath("runtime.atd_root");
-            if (value) {
-                ArcadiaTestsDataDir = value->GetStringSafe("");
-            }
-
             value = context.GetValueByPath("runtime.work_path");
             if (value) {
                 WorkPath = value->GetStringSafe("");
@@ -250,7 +224,12 @@ namespace NPrivate {
                     while (file.ReadLine(ljson) > 0) {
                         NJson::ReadJsonTree(ljson, &envVar);
                         for (const auto& entry : envVar.GetMap()) {
-                            SetEnv(entry.first, entry.second.GetStringSafe(""));
+                            auto value = entry.second;
+                            if (value.GetType() == NJson::JSON_NULL) {
+                                UnsetEnv(entry.first);
+                            } else {
+                                SetEnv(entry.first, value.GetStringSafe(""));
+                            }
                         }
                     }
                 }
@@ -269,10 +248,6 @@ namespace NPrivate {
             BuildRoot = GetEnv("ARCADIA_BUILD_ROOT");
         }
 
-        if (!ArcadiaTestsDataDir) {
-            ArcadiaTestsDataDir = GetEnv("ARCADIA_TESTS_DATA_DIR");
-        }
-
         if (!WorkPath) {
             WorkPath = GetEnv("TEST_WORK_PATH");
         }
diff --git a/library/cpp/testing/common/env.h b/library/cpp/testing/common/env.h
index 6cd840442f8..f9a5aff5d33 100644
--- a/library/cpp/testing/common/env.h
+++ b/library/cpp/testing/common/env.h
@@ -69,7 +69,6 @@ namespace NPrivate {
         void AddTestParam(TStringBuf name, TStringBuf value);
 
         bool IsRunningFromTest;
-        TString ArcadiaTestsDataDir;
         TString SourceRoot;
         TString BuildRoot;
         TString WorkPath;
diff --git a/library/cpp/testing/common/network.cpp b/library/cpp/testing/common/network.cpp
index 9f018f69b72..dbc80715fde 100644
--- a/library/cpp/testing/common/network.cpp
+++ b/library/cpp/testing/common/network.cpp
@@ -2,6 +2,7 @@
 
 #include <util/folder/dirut.h>
 #include <util/folder/path.h>
+#include <util/generic/noncopyable.h>
 #include <util/generic/singleton.h>
 #include <util/generic/utility.h>
 #include <util/generic/vector.h>
@@ -15,6 +16,7 @@
 #include <util/system/error.h>
 #include <util/system/file_lock.h>
 #include <util/system/fs.h>
+#include <util/system/sysstat.h>
 
 #ifdef _darwin_
 #include <sys/types.h>
@@ -29,7 +31,7 @@ namespace {
         }                                                                 \
     } while (false)
 
-    class TPortGuard : public NTesting::IPort {
+    class TPortGuard : public NTesting::IPort, TNonCopyable {
     public:
         TPortGuard(ui16 port, THolder<TFileLock> lock)
             : Lock_(std::move(lock))
@@ -38,7 +40,16 @@ namespace {
         }
 
         ~TPortGuard() override {
-            Y_VERIFY_SYSERROR(NFs::Remove(Lock_->GetName()));
+            try {
+                if (!NFs::Remove(Lock_->GetName())) {
+                    // Deletion may fail if the current user does not have
+                    // write permission to the PORT_SYNC_PATH directory.
+                    // At least let's release the lock file.
+                    Lock_->Release();
+                }
+            } catch (const TSystemError& e) {
+                Y_ABORT("Failed to unlock port %d, error=%d", Port_, e.Status());
+            }
         }
 
         ui16 Get() override {
@@ -107,6 +118,7 @@ namespace {
             }
             Y_ABORT_UNLESS(SyncDir_.IsDefined());
             NFs::MakeDirectoryRecursive(SyncDir_);
+            Chmod(SyncDir_.c_str(), NFs::FP_COMMON_FILE); // override umask
 
             Ranges_ = GetPortRanges();
             TotalCount_ = 0;
diff --git a/library/cpp/testing/common/ut/env_ut.cpp b/library/cpp/testing/common/ut/env_ut.cpp
index fe4946a65f3..4b67d05efb4 100644
--- a/library/cpp/testing/common/ut/env_ut.cpp
+++ b/library/cpp/testing/common/ut/env_ut.cpp
@@ -45,24 +45,6 @@ TEST(Runtime, BinaryPath) {
     EXPECT_TRUE(TFsPath(BinaryPath("library/cpp/testing/common/ut")).Exists());
 }
 
-TEST(Runtime, GetArcadiaTestsData) {
-    NTesting::TScopedEnvironment contextGuard("YA_TEST_CONTEXT_FILE", ""); // remove context filename
-    {
-        auto tmpDir = ::GetSystemTempDir();
-        NTesting::TScopedEnvironment guard("ARCADIA_TESTS_DATA_DIR", tmpDir);
-        Singleton<NPrivate::TTestEnv>()->ReInitialize();
-        EXPECT_EQ(tmpDir, GetArcadiaTestsData());
-    }
-    {
-        NTesting::TScopedEnvironment guard("ARCADIA_TESTS_DATA_DIR", "");
-        Singleton<NPrivate::TTestEnv>()->ReInitialize();
-        auto path = GetArcadiaTestsData();
-        // it is not error if path is empty
-        const bool ok = (path.empty() || GetBaseName(path) == "arcadia_tests_data");
-        EXPECT_TRUE(ok);
-    }
-}
-
 TEST(Runtime, GetWorkPath) {
     NTesting::TScopedEnvironment contextGuard("YA_TEST_CONTEXT_FILE", ""); // remove context filename
     {
diff --git a/library/cpp/testing/common/ut/network_ut.cpp b/library/cpp/testing/common/ut/network_ut.cpp
index 2016e26b092..22cedf87ae9 100644
--- a/library/cpp/testing/common/ut/network_ut.cpp
+++ b/library/cpp/testing/common/ut/network_ut.cpp
@@ -1,20 +1,38 @@
+#include <library/cpp/testing/common/env.h>
 #include <library/cpp/testing/common/network.h>
 #include <library/cpp/testing/common/scope.h>
+#include <library/cpp/testing/gtest/gtest.h>
 
 #include <util/generic/hash_set.h>
 
 #include <util/folder/dirut.h>
 #include <util/folder/path.h>
 #include <util/folder/tempdir.h>
+#include <util/generic/scope.h>
 #include <util/network/sock.h>
+#include <util/system/file.h>
 #include <util/system/fs.h>
+#include <util/system/sysstat.h>
 
-#include <library/cpp/testing/gtest/gtest.h>
+class NetworkTestBase: public ::testing::Test {
+protected:
+    void SetUp() override {
+        TmpDir.ConstructInPlace();
+    }
+
+    void TearDown() override {
+        TmpDir.Clear();
+    }
+
+public:
+    TMaybe<TTempDir> TmpDir;
+};
 
-static TTempDir TmpDir;
+class NetworkTest: public NetworkTestBase {};
+class FreePortTest: public NetworkTestBase {};
 
-TEST(NetworkTest, FreePort) {
-    NTesting::TScopedEnvironment envGuard("PORT_SYNC_PATH", TmpDir.Name());
+TEST_F(NetworkTest, FreePort) {
+    NTesting::TScopedEnvironment envGuard("PORT_SYNC_PATH", TmpDir->Name());
     NTesting::InitPortManagerFromEnv();
     TVector<NTesting::TPortHolder> ports(Reserve(100));
 
@@ -24,7 +42,7 @@ TEST(NetworkTest, FreePort) {
 
     THashSet<ui16> uniqPorts;
     for (auto& port : ports) {
-        const TString guardPath = TmpDir.Path() / ToString(static_cast<ui16>(port));
+        const TString guardPath = TmpDir->Path() / ToString(static_cast<ui16>(port));
         EXPECT_TRUE(NFs::Exists(guardPath));
         EXPECT_TRUE(uniqPorts.emplace(port).second);
 
@@ -35,16 +53,16 @@ TEST(NetworkTest, FreePort) {
     }
     ports.clear();
     for (ui16 port : uniqPorts) {
-        const TString guardPath = TmpDir.Path() / ToString(port);
+        const TString guardPath = TmpDir->Path() / ToString(port);
         EXPECT_FALSE(NFs::Exists(guardPath));
     }
 }
 
-TEST(NetworkTest, FreePortWithinRanges) {
+TEST_F(NetworkTest, FreePortWithinRanges) {
     NTesting::TScopedEnvironment envGuard{{
-            {"PORT_SYNC_PATH", TmpDir.Name()},
-            {"VALID_PORT_RANGE", "3456:7654"},
-        }};
+        {"PORT_SYNC_PATH", TmpDir->Name()},
+        {"VALID_PORT_RANGE", "3456:7654"},
+    }};
     NTesting::InitPortManagerFromEnv();
 
     for (size_t i = 0; i < 100; ++i) {
@@ -55,11 +73,11 @@ TEST(NetworkTest, FreePortWithinRanges) {
     }
 }
 
-TEST(NetworkTest, GetPortRandom) {
+TEST_F(NetworkTest, GetPortRandom) {
     NTesting::TScopedEnvironment envGuard{{
-            {"PORT_SYNC_PATH", TmpDir.Name()},
-            {"NO_RANDOM_PORTS", ""},
-        }};
+        {"PORT_SYNC_PATH", TmpDir->Name()},
+        {"NO_RANDOM_PORTS", ""},
+    }};
     NTesting::InitPortManagerFromEnv();
 
     ui16 testPort = 80; // value just must be outside the assignable range
@@ -70,11 +88,11 @@ TEST(NetworkTest, GetPortRandom) {
     }
 }
 
-TEST(NetworkTest, GetPortNonRandom) {
+TEST_F(NetworkTest, GetPortNonRandom) {
     NTesting::TScopedEnvironment envGuard{{
-            {"PORT_SYNC_PATH", TmpDir.Name()},
-            {"NO_RANDOM_PORTS", "1"},
-        }};
+        {"PORT_SYNC_PATH", TmpDir->Name()},
+        {"NO_RANDOM_PORTS", "1"},
+    }};
     NTesting::InitPortManagerFromEnv();
 
     TVector<ui16> ports(Reserve(100)); // keep integers, we don't need the ports to remain allocated
@@ -91,9 +109,36 @@ TEST(NetworkTest, GetPortNonRandom) {
     }
 }
 
+TEST_F(NetworkTest, Permissions) {
+    constexpr ui16 loPort = 3456;
+    constexpr ui16 hiPort = 7654;
+    NTesting::TScopedEnvironment envGuard{{
+        {"PORT_SYNC_PATH", TmpDir->Name()},
+        {"VALID_PORT_RANGE", ToString(loPort) + ":" + ToString(hiPort)},
+    }};
+    NTesting::InitPortManagerFromEnv();
+    TVector<NTesting::TPortHolder> ports(Reserve(100));
+    for (ui64 port = loPort; port <= hiPort; ++port) {
+        const TString guardPath = TmpDir->Path() / ToString(static_cast<ui16>(port));
+        TFile f{guardPath, OpenAlways | RdOnly};
+        ASSERT_TRUE(f.IsOpen());
+        ASSERT_TRUE(Chmod(f.GetName().c_str(), 0444) != -1);
+    }
+    Y_DEFER {
+        Chmod(TmpDir->Path().c_str(), NFs::FP_COMMON_FILE);
+    };
+    ASSERT_TRUE(Chmod(TmpDir->Path().c_str(), 0555) != -1) << errno << " " << strerror(errno); // Lock dir
+    for (size_t i = 0; i < 100; ++i) {
+        NTesting::TPortHolder p;
+        EXPECT_NO_THROW(p = NTesting::GetFreePort());
+        ui16 port = p;
+        ASSERT_GE(port, 3456u);
+        ASSERT_LE(port, 7654u);
+    }
+}
 
-TEST(FreePortTest, FreePortsRange) {
-    NTesting::TScopedEnvironment envGuard("PORT_SYNC_PATH", TmpDir.Name());
+TEST_F(FreePortTest, FreePortsRange) {
+    NTesting::TScopedEnvironment envGuard("PORT_SYNC_PATH", TmpDir->Name());
     NTesting::InitPortManagerFromEnv();
 
     for (ui16 i = 2; i < 10; ++i) {
diff --git a/library/cpp/testing/hook/yt_initialize_hook.h b/library/cpp/testing/hook/yt_initialize_hook.h
new file mode 100644
index 00000000000..646015c1d61
--- /dev/null
+++ b/library/cpp/testing/hook/yt_initialize_hook.h
@@ -0,0 +1,6 @@
+#pragma once
+
+// Since we need to call NYT::Initialize immediately on starting the program, we separate it from other BEFORE_INIT hooks.
+// This weak function is overriden in C++ client (see yt/cpp/mapreduce/tests/yt_initialize_hook/yt_hook.cpp).
+__attribute__((weak)) void InitializeYt(int, char**) {
+}
diff --git a/library/cpp/testing/unittest/gtest.h b/library/cpp/testing/unittest/gtest.h
index a59ea48fddb..6bda57334dc 100644
--- a/library/cpp/testing/unittest/gtest.h
+++ b/library/cpp/testing/unittest/gtest.h
@@ -33,6 +33,8 @@ namespace NTesting {
         inline TTest* _This() noexcept {
             return this;
         }
+
+        virtual ~TTest() = default;
     };
 }
 
diff --git a/library/cpp/testing/unittest/registar.cpp b/library/cpp/testing/unittest/registar.cpp
index 675d1f60030..e915eccd3c8 100644
--- a/library/cpp/testing/unittest/registar.cpp
+++ b/library/cpp/testing/unittest/registar.cpp
@@ -3,9 +3,8 @@
 #include <library/cpp/diff/diff.h>
 #include <library/cpp/colorizer/colors.h>
 
-#include <util/generic/bt_exception.h>
+#include <util/generic/yexception.h>
 #include <util/random/fast.h>
-#include <util/string/printf.h>
 #include <util/system/backtrace.h>
 #include <util/system/guard.h>
 #include <util/system/tls.h>
@@ -134,8 +133,8 @@ struct TTraceDiffFormatter {
     }
 };
 
-TString NUnitTest::GetFormatTag(const char* name) {
-    return Sprintf("[[%s]]", name);
+TString NUnitTest::GetFormatTag(TStringBuf name) {
+    return TString::Join("[[", name, "]]");
 }
 
 TString NUnitTest::GetResetTag() {
@@ -156,7 +155,7 @@ TString NUnitTest::ColoredDiff(TStringBuf s1, TStringBuf s2, const TString& deli
 }
 
 static TString MakeTestName(const NUnitTest::ITestSuiteProcessor::TTest& test) {
-    return TStringBuilder() << test.unit->name << "::" << test.name;
+    return TString::Join(test.unit->name, "::", test.name);
 }
 
 static size_t CountTests(const TMap<TString, size_t>& testErrors, bool succeeded) {
@@ -335,6 +334,11 @@ bool NUnitTest::TTestBase::CheckAccessTest(const char* test) {
     return Processor()->CheckAccessTest(Name(), test);
 }
 
+bool NUnitTest::TTestBase::CheckAccessTest(const char* test, const char* file, int line) {
+    return Processor()->CheckAccessTest(Name(), test, file, line);
+
+}
+
 void NUnitTest::TTestBase::BeforeTest(const char* func) {
     const NUnitTest::ITestSuiteProcessor::TUnit unit = {Name()};
     const NUnitTest::ITestSuiteProcessor::TTest test = {&unit, func};
diff --git a/library/cpp/testing/unittest/registar.h b/library/cpp/testing/unittest/registar.h
index 54b9b0364c0..600ac815f03 100644
--- a/library/cpp/testing/unittest/registar.h
+++ b/library/cpp/testing/unittest/registar.h
@@ -2,7 +2,7 @@
 
 #include <library/cpp/dbg_output/dump.h>
 
-#include <util/generic/bt_exception.h>
+#include <util/generic/yexception.h>
 #include <util/generic/hash.h>
 #include <util/generic/intrlist.h>
 #include <util/generic/map.h>
@@ -12,6 +12,7 @@
 #include <util/generic/typetraits.h>
 #include <util/generic/vector.h>
 #include <util/generic/yexception.h>
+#include <util/generic/serialized_enum.h>
 
 #include <util/string/builder.h>
 #include <util/string/cast.h>
@@ -27,6 +28,8 @@
 #include <cmath>
 #include <cstdio>
 #include <functional>
+#include <tuple>
+#include <utility>
 
 extern bool CheckExceptionMessage(const char*, TString&);
 
@@ -42,7 +45,7 @@ namespace NUnitTest {
 
     extern bool ShouldColorizeDiff;
     TString ColoredDiff(TStringBuf s1, TStringBuf s2, const TString& delims = TString(), bool reverse = false);
-    TString GetFormatTag(const char* name);
+    TString GetFormatTag(TStringBuf name);
     TString GetResetTag();
 
     // Raise error handler
@@ -135,6 +138,14 @@ namespace NUnitTest {
         // Should execute a test whitin suite?
         virtual bool CheckAccessTest(TString /*suite*/, const char* /*name*/);
 
+        // Should execute a test within suite? (with file and line info)
+        virtual bool CheckAccessTest(TString suite, const char* name, const char* file, int line) {
+            // Default implementation ignores file and line, calls the old version
+            Y_UNUSED(file);
+            Y_UNUSED(line);
+            return CheckAccessTest(suite, name);
+        }
+
         virtual void Run(std::function<void()> f, const TString& /*suite*/, const char* /*name*/, bool /*forceFork*/);
 
         // This process is forked for current test
@@ -219,6 +230,8 @@ namespace NUnitTest {
     protected:
         bool CheckAccessTest(const char* test);
 
+        bool CheckAccessTest(const char* test, const char* file, int line);
+
         void BeforeTest(const char* func);
 
         void Finish(const char* func, TTestContext* context);
@@ -482,6 +495,7 @@ public:                       \
 //bool
 #define UNIT_ASSERT_C(A, C)                                                                             \
     do {                                                                                                \
+        static_assert(!std::is_array_v<std::remove_cvref_t<decltype(A)>>, "An array type always evaluates to true in a condition; this is likely an error in the condition expression."); \
         if (!(A)) {                                                                                     \
             UNIT_FAIL_IMPL("assertion failed", Sprintf("(%s) %s", #A, (::TStringBuilder() << C).data())); \
         }                                                                                               \
@@ -714,6 +728,7 @@ public:                       \
 //values
 #define UNIT_ASSERT_VALUES_EQUAL_IMPL(A, B, C, EQflag, EQstr, NEQstr)                                                                  \
     do {                                                                                                                               \
+        /* NOLINTBEGIN(bugprone-reserved-identifier, readability-identifier-naming) */                                                 \
         TString _as;                                                                                                                   \
         TString _bs;                                                                                                                   \
         TString _asInd;                                                                                                                \
@@ -727,6 +742,7 @@ public:                       \
             }                                                                                                                          \
             UNIT_FAIL_IMPL("assertion failed", failMsg);                                                                               \
         }                                                                                                                              \
+        /* NOLINTEND(bugprone-reserved-identifier, readability-identifier-naming) */                                                   \
     } while (false)
 
 #define UNIT_ASSERT_VALUES_EQUAL_C(A, B, C) \
@@ -809,14 +825,21 @@ public:                       \
         // Consider using SetUp()/TearDown() methods instead
 
         inline TBaseTestCase()
-            : TBaseTestCase(nullptr, nullptr, false)
+            : TBaseTestCase(nullptr, nullptr, false, nullptr, 0)
         {
         }
 
         inline TBaseTestCase(const char* name, std::function<void(TTestContext&)> body, bool forceFork)
+            : TBaseTestCase(name, std::move(body), forceFork, nullptr, 0)
+        {
+        }
+
+        inline TBaseTestCase(const char* name, std::function<void(TTestContext&)> body, bool forceFork, const char* file, int line)
             : Name_(name)
             , Body_(std::move(body))
             , ForceFork_(forceFork)
+            , File_(file)
+            , Line_(line)
         {
         }
 
@@ -844,6 +867,8 @@ public:                       \
         const char* Name_;
         std::function<void(TTestContext&)> Body_;
         bool ForceFork_;
+        const char* File_;
+        int Line_;
     };
 
     using TBaseFixture = TBaseTestCase;
@@ -919,6 +944,42 @@ public:                       \
         bool Failed_ = false;
     };
 
+    template <class... Es>
+    TString BuildParamTestName(const char* base, const Es&... es) {
+        TString s = base;
+        ((s += "-", s += ToString(es)), ...);
+        return s;
+    }
+
+    template <class F>
+    void ForEachProductRanges(F&& f) {
+        std::invoke(std::forward<F>(f));
+    }
+
+    template <class F, class FirstRange, class... RestRanges>
+    void ForEachProductRanges(F&& f, const FirstRange& first, const RestRanges&... rest) {
+        for (auto&& x : first) {
+            auto bound = std::bind_front(std::forward<F>(f), x);
+            ForEachProductRanges(std::move(bound), rest...);
+        }
+    }
+
+    template <class... Enums, class F>
+    void ForEachEnums(F&& f) {
+        ForEachProductRanges(std::forward<F>(f), GetEnumAllValues<Enums>()...);
+    }
+
+    template <class Tuple, size_t... I>
+    TString BuildParamTestNameFromTupleImpl(const char* base, const Tuple& t, std::index_sequence<I...>) {
+        return BuildParamTestName(base, std::get<I>(t)...);
+    }
+
+    template <class Tuple>
+    TString BuildParamTestNameFromTuple(const char* base, const Tuple& t) {
+        return BuildParamTestNameFromTupleImpl(
+            base, t, std::make_index_sequence<std::tuple_size_v<Tuple>>{});
+    }
+
 #define UNIT_TEST_SUITE_REGISTRATION(T) \
     static const ::NUnitTest::TTestBaseFactory<T> Y_GENERATE_UNIQUE_ID(UTREG_);
 
@@ -945,9 +1006,10 @@ public:                       \
             }                                                                                                           \
                                                                                                                         \
             static void AddTest(const char* name,                                                                       \
-                const std::function<void(NUnitTest::TTestContext&)>& body, bool forceFork)                              \
+                const std::function<void(NUnitTest::TTestContext&)>& body, bool forceFork,                              \
+                const char* file = nullptr, int line = 0)                                                               \
             {                                                                                                           \
-                Tests().emplace_back([=]{ return MakeHolder<NUnitTest::TBaseTestCase>(name, body, forceFork); });       \
+                Tests().emplace_back([=]{ return MakeHolder<NUnitTest::TBaseTestCase>(name, body, forceFork, file, line); }); \
             }                                                                                                           \
                                                                                                                         \
             static void AddTest(TTestCaseFactory testCaseFactory) {                                                     \
@@ -959,7 +1021,7 @@ public:                       \
                 this->GlobalSuiteSetUp();                                                                               \
                 for (TTests::iterator it = Tests().begin(), ie = Tests().end(); it != ie; ++it) {                       \
                     const auto i = (*it)();                                                                             \
-                    if (!this->CheckAccessTest(i->Name_)) {                                                             \
+                    if (!this->CheckAccessTest(i->Name_, i->File_, i->Line_)) {                                         \
                         continue;                                                                                       \
                     }                                                                                                   \
                     NUnitTest::TTestContext context(this->TTestBase::Processor());                                      \
@@ -1014,6 +1076,8 @@ public:                       \
         {                                                   \
             Name_ = #N;                                     \
             ForceFork_ = FF;                                \
+            File_ = __FILE__;                               \
+            Line_ = __LINE__;                               \
         }                                                   \
         static THolder<NUnitTest::TBaseTestCase> Create() { \
             return ::MakeHolder<TTestCase##N>();            \
@@ -1031,9 +1095,70 @@ public:                       \
     Y_UNIT_TEST_IMPL_REGISTER(N, FF, F) \
     void TTestCase##N::Execute_(NUnitTest::TTestContext& ut_context Y_DECLARE_UNUSED)
 
-#define Y_UNIT_TEST(N) Y_UNIT_TEST_IMPL(N, false, TCurrentTestCase)
-#define Y_UNIT_TEST_F(N, F) Y_UNIT_TEST_IMPL(N, false, F)
-#define SIMPLE_UNIT_FORKED_TEST(N) Y_UNIT_TEST_IMPL(N, true, TCurrentTestCase)
+#define Y_UNIT_TEST_ENUM_IMPL(N, FF, F, ...)                                                                               \
+    struct TTestCase##N : public F {                                                                                         \
+        using Types = std::tuple<__VA_ARGS__>;                                                                               \
+        Types Args;                                                                                                          \
+        TString ParametrizedTestName;                                                                                        \
+        explicit TTestCase##N(Types args)                                                                                    \
+            : Args(std::move(args))                                                                                          \
+            , ParametrizedTestName(::NUnitTest::BuildParamTestNameFromTuple(#N, Args))                                       \
+       {                                                                                                                    \
+            Name_ = ParametrizedTestName.c_str();                                                                            \
+            ForceFork_ = FF;                                                                                                 \
+            File_ = nullptr;                                                                                                 \
+            Line_ = 0;                                                                                                       \
+        }                                                                                                                    \
+        static THolder<NUnitTest::TBaseTestCase> Create(Types args) {                                                        \
+            return ::MakeHolder<TTestCase##N>(std::move(args));                                                              \
+        }                                                                                                                    \
+        void Execute_(NUnitTest::TTestContext&) override;                                                                     \
+        template <size_t I>                                                                                                  \
+        decltype(auto) Arg() const {                                                                                         \
+            return std::get<I>(Args);                                                                                        \
+        }                                                                                                                    \
+    };                                                                                                                       \
+    struct TTestRegistration##N {                                                                                            \
+        TTestRegistration##N() {                                                                                             \
+            ::NUnitTest::ForEachEnums<__VA_ARGS__>([&](auto... items) {                                                      \
+                TCurrentTest::AddTest([=] {                                                                                 \
+                    return TTestCase##N::Create(typename TTestCase##N::Types(items...));                                   \
+                });                                                                                                          \
+            });                                                                                                              \
+        }                                                                                                                    \
+    };                                                                                                                       \
+    static const TTestRegistration##N testRegistration##N;                                                                     \
+    void TTestCase##N::Execute_(NUnitTest::TTestContext& ut_context Y_DECLARE_UNUSED)
+
+#define Y_UNIT_TEST_ENUM_IMPL_LINE(N, FF, F, ...) \
+    Y_UNIT_TEST_ENUM_IMPL(N, FF, F, __VA_ARGS__)
+
+#define Y_UNIT_TEST(N, ...) \
+    Y_UNIT_TEST_DISPATCH_##__VA_OPT__(ENUMS)(N __VA_OPT__(,) __VA_ARGS__)
+
+#define Y_UNIT_TEST_DISPATCH_(N) \
+    Y_UNIT_TEST_IMPL(N, false, TCurrentTestCase)
+
+#define Y_UNIT_TEST_DISPATCH_ENUMS(N, ...) \
+    Y_UNIT_TEST_ENUM_IMPL_LINE(N, false, TCurrentTestCase, __VA_ARGS__)
+
+#define Y_UNIT_TEST_F(N, F, ...) \
+    Y_UNIT_TEST_F_DISPATCH_##__VA_OPT__(ENUMS)(N, F __VA_OPT__(,) __VA_ARGS__)
+
+#define Y_UNIT_TEST_F_DISPATCH_(N, F) \
+    Y_UNIT_TEST_IMPL(N, false, F)
+
+#define Y_UNIT_TEST_F_DISPATCH_ENUMS(N, F, ...) \
+    Y_UNIT_TEST_ENUM_IMPL_LINE(N, false, F, __VA_ARGS__)
+
+#define SIMPLE_UNIT_FORKED_TEST(N, ...) \
+    SIMPLE_UNIT_FORKED_TEST_DISPATCH_##__VA_OPT__(ENUMS)(N __VA_OPT__(,) __VA_ARGS__)
+
+#define SIMPLE_UNIT_FORKED_TEST_DISPATCH_(N) \
+    Y_UNIT_TEST_IMPL(N, true, TCurrentTestCase)
+
+#define SIMPLE_UNIT_FORKED_TEST_DISPATCH_ENUMS(N, ...) \
+    Y_UNIT_TEST_ENUM_IMPL_LINE(N, true, TCurrentTestCase, __VA_ARGS__)
 
 #define Y_UNIT_TEST_SUITE_IMPLEMENTATION(N) \
     namespace NTestSuite##N
diff --git a/library/cpp/testing/unittest/utmain.cpp b/library/cpp/testing/unittest/utmain.cpp
index 6ecfc3a64f3..63c2875fbae 100644
--- a/library/cpp/testing/unittest/utmain.cpp
+++ b/library/cpp/testing/unittest/utmain.cpp
@@ -5,10 +5,12 @@
 
 #include <library/cpp/colorizer/colors.h>
 
+#include <library/cpp/json/json_writer.h>
 #include <library/cpp/json/writer/json.h>
 #include <library/cpp/json/writer/json_value.h>
 #include <library/cpp/testing/common/env.h>
 #include <library/cpp/testing/hook/hook.h>
+#include <library/cpp/testing/hook/yt_initialize_hook.h>
 
 #include <util/datetime/base.h>
 
@@ -601,9 +603,10 @@ const char* const TColoredProcessor::ForkCorrectExitMsg = "--END--";
 
 class TEnumeratingProcessor: public ITestSuiteProcessor {
 public:
-    TEnumeratingProcessor(bool verbose, IOutputStream& stream) noexcept
+    TEnumeratingProcessor(bool verbose, IOutputStream& stream, bool isFileOutput = false) noexcept
         : Verbose_(verbose)
         , Stream_(stream)
+        , IsFileOutput_(isFileOutput)
     {
     }
 
@@ -624,9 +627,31 @@ class TEnumeratingProcessor: public ITestSuiteProcessor {
         return false;
     }
 
+    bool CheckAccessTest(TString suite, const char* name, const char* file, int line) override {
+        if (Verbose_) {
+            // If we processing output to file (list-path), we would use JSON, else old plain text format
+            if (IsFileOutput_) {
+                NJson::TJsonValue testObj;
+                testObj["test_suite_name"] = suite;
+                testObj["name"] = name;
+                testObj["file"] = file ? file : "";
+                testObj["line"] = line;
+                testObj["nodeid"] = suite + "::" + name;
+                NJson::WriteJson(&Stream_, &testObj);
+                Stream_.Write("\n");
+            } else {
+                Stream_ << suite << "::" << name << "\n";
+            }
+        } else {
+            Stream_ << suite << "::" << name << "\n";
+        }
+        return false;
+    }
+
 private:
     bool Verbose_;
     IOutputStream& Stream_;
+    bool IsFileOutput_;
 };
 
 #ifdef _win_
@@ -662,8 +687,8 @@ class TWinEnvironment {
 static const TWinEnvironment Instance;
 #endif // _win_
 
-static int DoList(bool verbose, IOutputStream& stream) {
-    TEnumeratingProcessor eproc(verbose, stream);
+static int DoList(bool verbose, IOutputStream& stream, bool isFileOutput = false) {
+    TEnumeratingProcessor eproc(verbose, stream, isFileOutput);
     TTestFactory::Instance().SetProcessor(&eproc);
     TTestFactory::Instance().Execute();
     return 0;
@@ -709,6 +734,8 @@ int NUnitTest::RunMain(int argc, char** argv) {
         Y_ABORT_UNLESS(!sigaction(SIGUSR2, &sa, nullptr));
     }
 #endif
+    InitializeYt(argc, argv);
+
     NTesting::THook::CallBeforeInit();
     InitNetworkSubSystem();
     Singleton<::NPrivate::TTestEnv>();
@@ -848,7 +875,7 @@ int NUnitTest::RunMain(int argc, char** argv) {
             }
         }
         if (listTests != DONT_LIST) {
-            return DoList(listTests == LIST_VERBOSE, *listStream);
+            return DoList(listTests == LIST_VERBOSE, *listStream, listFile.Get() != nullptr);
         }
 
         if (!hasJUnitProcessor) {
diff --git a/library/cpp/threading/cancellation/README.md b/library/cpp/threading/cancellation/README.md
new file mode 100644
index 00000000000..8fb8ea616c1
--- /dev/null
+++ b/library/cpp/threading/cancellation/README.md
@@ -0,0 +1,112 @@
+The Cancellation library
+========================
+
+Intro
+-----
+
+This small library provides primitives for implementation of a cooperative cancellation of long running or asynchronous operations.
+The design has been copied from the well-known CancellationTokenSource/CancellationToken classes of the .NET Framework
+
+To use the library include `cancellation_token.h`.
+
+Examples
+--------
+
+1. Simple check for cancellation
+
+    ```c++
+    void LongRunningOperation(TCancellationToken token) {
+        ...
+        if (token.IsCancellationRequested()) {
+            return;
+        }
+        ...
+    }
+
+    TCancellationTokenSource source;
+    TThread thread([token = source.Token()]() { LongRunningOperation(std::move(token)); });
+    thread.Start();
+    ...
+    source.Cancel();
+    thread.Join();
+    ```
+
+2. Exit via an exception
+
+    ```c++
+    void LongRunningOperation(TCancellationToken token) {
+        try {
+            for (;;) {
+                ...
+                token.ThrowIfCancellationRequested();
+                ...
+            }
+        } catch (TOperationCancelledException const&) {
+            return;
+        } catch (...) {
+            Y_ABORT("Never should be there")
+        }
+    }
+
+    TCancellationTokenSource source;
+    TThread thread([token = source.Token()]() { LongRunningOperation(std::move(token)); });
+    thread.Start();
+    ...
+    source.Cancel();
+    thread.Join();
+    ```
+
+3. Periodic poll with cancellation
+
+    ```c++
+    void LongRunningOperation(TCancellationToken token) {
+        while (!token.Wait(PollInterval)) {
+            ...
+        }
+    }
+
+    TCancellationTokenSource source;
+    TThread thread([token = source.Token()]() { LongRunningOperation(std::move(token)); });
+    thread.Start();
+    ...
+    source.Cancel();
+    thread.Join();
+    ```
+
+4. Waiting on the future
+
+    ```c++
+    TFuture<void> InnerOperation();
+    TFuture<void> OuterOperation(TCancellationToken token) {
+        return WaitAny(FirstOperation(), token.Future())
+                    .Apply([token = std::move(token)](auto&&) {
+                        token.ThrowIfCancellationRequested();
+                    });
+    }
+
+    TCancellationTokenSource source;
+    auto future = OuterOperation();
+    ...
+    source.Cancel()
+    ...
+    try {
+        auto value = future.ExtractValueSync();
+    } catch (TOperationCancelledException const&) {
+        // cancelled
+    }
+    ```
+
+5. Using default token when no cancellation needed
+
+    ```c++
+    void LongRunningOperation(TCancellationToken token) {
+        ...
+        if (token.IsCancellationRequested()) {
+            return;
+        }
+        ...
+    }
+
+    // We do not want to cancel the operation. So, there is no need to create a cancellation token source
+    LongRunningOperation(TCancellationToken::Default);
+    ```
diff --git a/library/cpp/threading/cancellation/cancellation_token.cpp b/library/cpp/threading/cancellation/cancellation_token.cpp
new file mode 100644
index 00000000000..1a0a19f690f
--- /dev/null
+++ b/library/cpp/threading/cancellation/cancellation_token.cpp
@@ -0,0 +1 @@
+#include "cancellation_token.h"
diff --git a/library/cpp/threading/cancellation/cancellation_token.h b/library/cpp/threading/cancellation/cancellation_token.h
new file mode 100644
index 00000000000..2c1626bc3b2
--- /dev/null
+++ b/library/cpp/threading/cancellation/cancellation_token.h
@@ -0,0 +1,137 @@
+#pragma once
+
+#include "operation_cancelled_exception.h"
+
+#include <library/cpp/threading/future/future.h>
+
+#include <util/generic/ptr.h>
+#include <util/generic/singleton.h>
+
+namespace NThreading {
+
+class TCancellationTokenSource;
+
+//! A cancellation token could be passed to an async or long running operation to perform a cooperative operation cancel
+class TCancellationToken {
+private:
+    TFuture<void> Future_;
+    TInstant Deadline_ = TInstant::Max();
+
+public:
+    TCancellationToken() = delete;
+    TCancellationToken(const TCancellationToken&) noexcept = default;
+    TCancellationToken(TCancellationToken&&) noexcept = default;
+    TCancellationToken& operator = (const TCancellationToken&) noexcept = default;
+    TCancellationToken& operator = (TCancellationToken&&) noexcept = default;
+
+    //! Shows whether a cancellation has been requested
+    bool IsCancellationRequested() const {
+        return Future_.HasValue();
+    }
+
+    //! Shows whether a cancellation has been requested
+    bool IsDeadlineReached() const {
+        return TInstant::Now() > Deadline_;
+    }
+
+    //! Throws the TOperationCancelledException if a cancellation has been requested
+    void ThrowIfCancellationRequested() const {
+        if (IsCancellationRequested()) {
+            ythrow TOperationCancelledException();
+        }
+    }
+
+    //! Throws the TOperationCancelledException if the Deadline_ has been reached
+    void ThrowIfDeadlineReached() const {
+        if (IsDeadlineReached()) {
+            ythrow TOperationCancelledException();
+        }
+    }
+
+    //! Throws the TOperationCancelledException if a cancellation has been requested
+    // or reached the Deadline_
+    void ThrowIfTokenCancelled() const {
+        ThrowIfCancellationRequested();
+        ThrowIfDeadlineReached();
+    }
+
+    //! Waits for a cancellation
+    bool Wait(TDuration duration) const {
+        return Future_.Wait(duration);
+    }
+
+    bool Wait(TInstant deadline) const {
+        return Future_.Wait(deadline);
+    }
+
+    void Wait() const {
+        return Future_.Wait();
+    }
+
+    //! Returns a future that could be used for waiting for a cancellation
+    TFuture<void> const& Future() const noexcept {
+        return Future_;
+    }
+
+    //! The default cancellation token that cannot be cancelled
+    static TCancellationToken const& Default() {
+        struct TCache {
+            TPromise<void> Promise{NewPromise()};
+            TCancellationToken Token{Promise.GetFuture()};
+        };
+        return SingletonWithPriority<TCache, 0>()->Token;
+    }
+
+    void SetDeadline(TInstant deadline) {
+        Deadline_ = deadline;
+    }
+
+    TInstant GetDeadline() const {
+        return Deadline_;
+    }
+
+private:
+    TCancellationToken(TFuture<void> future)
+        : Future_(std::move(future))
+    {
+    }
+
+private:
+    friend class TCancellationTokenSource;
+
+    Y_DECLARE_SINGLETON_FRIEND();
+};
+
+//! A cancellation token source produces cancellation tokens to be passed to cancellable operations
+class TCancellationTokenSource {
+private:
+    TPromise<void> Promise;
+
+public:
+    TCancellationTokenSource()
+        : Promise(NewPromise())
+    {
+    }
+
+    TCancellationTokenSource(TCancellationTokenSource const&) = delete;
+    TCancellationTokenSource(TCancellationTokenSource&&) = delete;
+    TCancellationTokenSource& operator=(TCancellationTokenSource const&) = delete;
+    TCancellationTokenSource& operator=(TCancellationTokenSource&&) = delete;
+
+    //! Shows whether a cancellation has been requested
+    bool IsCancellationRequested() const noexcept {
+        return Promise.HasValue();
+    }
+
+    //! Produces a cancellation token
+    TCancellationToken Token() const {
+        return TCancellationToken(Promise.GetFuture());
+    }
+
+    //! Propagates a cancel request to all produced tokens
+    void Cancel() noexcept {
+        Promise.TrySetValue();
+    }
+};
+
+}
diff --git a/library/cpp/threading/cancellation/ut.cpp b/library/cpp/threading/cancellation/ut.cpp
new file mode 100644
index 00000000000..c744795a081
--- /dev/null
+++ b/library/cpp/threading/cancellation/ut.cpp
@@ -0,0 +1,56 @@
+#include "cancellation_token.h"
+
+#include <library/cpp/testing/unittest/registar.h>
+
+using namespace NThreading;
+
+Y_UNIT_TEST_SUITE(Cancellation) {
+    Y_UNIT_TEST(IsCancellationRequested) {
+        TCancellationTokenSource source;
+        auto const token = source.Token();
+        UNIT_ASSERT(!source.IsCancellationRequested());
+        UNIT_ASSERT(!token.IsCancellationRequested());
+        source.Cancel();
+        UNIT_ASSERT(source.IsCancellationRequested());
+        UNIT_ASSERT(token.IsCancellationRequested());
+    }
+
+    Y_UNIT_TEST(ThrowIfCancellationRequested) {
+        TCancellationTokenSource source;
+        auto const token = source.Token();
+        UNIT_ASSERT_NO_EXCEPTION(token.ThrowIfCancellationRequested());
+        source.Cancel();
+        UNIT_ASSERT_EXCEPTION(token.ThrowIfCancellationRequested(), TOperationCancelledException);
+    }
+
+    Y_UNIT_TEST(Wait) {
+        TCancellationTokenSource source;
+        auto const token = source.Token();
+        UNIT_ASSERT(!token.Wait(TDuration::MilliSeconds(10)));
+        source.Cancel();
+        UNIT_ASSERT(token.Wait(TDuration::MilliSeconds(10)));
+    }
+
+    Y_UNIT_TEST(Future) {
+        TCancellationTokenSource source;
+        auto const future = source.Token().Future();
+        UNIT_ASSERT(!future.HasValue());
+        UNIT_ASSERT(!future.HasException());
+        source.Cancel();
+        UNIT_ASSERT(future.HasValue());
+    }
+
+    Y_UNIT_TEST(Default) {
+        auto const& token = TCancellationToken::Default();
+        UNIT_ASSERT(!token.IsCancellationRequested());
+    }
+
+    Y_UNIT_TEST(ThrowIfDeadlineReached) {
+        TCancellationTokenSource source;
+        auto token = source.Token();
+        UNIT_ASSERT_NO_EXCEPTION(token.ThrowIfCancellationRequested());
+        token.SetDeadline(TInstant::Now() - TDuration::Minutes(1));
+        UNIT_ASSERT_NO_EXCEPTION(token.ThrowIfCancellationRequested());
+        UNIT_ASSERT_EXCEPTION(token.ThrowIfDeadlineReached(), TOperationCancelledException);
+    }
+}
diff --git a/library/cpp/threading/chunk_queue/queue.h b/library/cpp/threading/chunk_queue/queue.h
index feee776b872..7cb4be4b4ef 100644
--- a/library/cpp/threading/chunk_queue/queue.h
+++ b/library/cpp/threading/chunk_queue/queue.h
@@ -1,29 +1,28 @@
 #pragma once
 
+#include <library/cpp/deprecated/atomic/atomic.h> // AtomicGet
+
 #include <util/datetime/base.h>
 #include <util/generic/noncopyable.h>
 #include <util/generic/ptr.h>
 #include <util/generic/typetraits.h>
-#include <util/generic/vector.h>
 #include <util/generic/ylimits.h>
-#include <library/cpp/deprecated/atomic/atomic.h>
 #include <util/system/guard.h>
 #include <util/system/spinlock.h>
 #include <util/system/yassert.h>
 
-#include <type_traits>
-#include <utility>
+#include <atomic>
 
 namespace NThreading {
-////////////////////////////////////////////////////////////////////////////////
-// Platform helpers
+    ////////////////////////////////////////////////////////////////////////////////
+    // Platform helpers
 
 #if !defined(PLATFORM_CACHE_LINE)
-#define PLATFORM_CACHE_LINE 64
+    #define PLATFORM_CACHE_LINE 64
 #endif
 
 #if !defined(PLATFORM_PAGE_SIZE)
-#define PLATFORM_PAGE_SIZE 4 * 1024
+    #define PLATFORM_PAGE_SIZE 4 * 1024
 #endif
 
     template <typename T, size_t PadSize = PLATFORM_CACHE_LINE>
@@ -35,7 +34,7 @@ namespace NThreading {
             Y_UNUSED(Pad);
         }
 
-        template<typename... Args>
+        template <typename... Args>
         TPadded(Args&&... args)
             : T(std::forward<Args>(args)...)
         {
@@ -87,7 +86,7 @@ namespace NThreading {
             TPodTypeHelper<T>,
             TNonPodTypeHelper<T>>;
 
-    }
+    } // namespace NImpl
 
     ////////////////////////////////////////////////////////////////////////////////
     // One producer/one consumer chunked queue.
@@ -240,7 +239,7 @@ namespace NThreading {
         };
 
         struct TQueueType: public TOneOneQueue<TEntry, ChunkSize> {
-            TAtomic WriteLock = 0;
+            TSpinLock WriteLock;
 
             using TOneOneQueue<TEntry, ChunkSize>::PrepareWrite;
             using TOneOneQueue<TEntry, ChunkSize>::CompleteWrite;
@@ -250,11 +249,7 @@ namespace NThreading {
         };
 
     private:
-        union {
-            TAtomic WriteTag = 0;
-            char Pad[PLATFORM_CACHE_LINE];
-        };
-
+        TPadded<std::atomic<ui64>> WriteTag{1};
         TQueueType Queues[Concurrency];
 
     public:
@@ -291,22 +286,26 @@ namespace NThreading {
         ui64 NextTag() {
             // TODO: can we avoid synchronization here? it costs 1.5x performance penalty
             // return GetCycleCount();
-            return AtomicIncrement(WriteTag);
+            return WriteTag.fetch_add(1, std::memory_order_relaxed);
         }
 
         template <typename TT>
         bool TryEnqueue(TT&& value, ui64 tag) {
             for (size_t i = 0; i < Concurrency; ++i) {
                 TQueueType& queue = Queues[i];
-                if (AtomicTryAndTryLock(&queue.WriteLock)) {
-                    TEntry* entry = queue.PrepareWrite();
-                    Y_ASSERT(entry);
-                    TTypeHelper::Write(&entry->Value, std::forward<TT>(value));
-                    entry->Tag = tag;
-                    queue.CompleteWrite();
-                    AtomicUnlock(&queue.WriteLock);
-                    return true;
+                if (queue.WriteLock.IsLocked()) {
+                    continue;
+                }
+                TTryGuard guard{queue.WriteLock};
+                if (!guard) {
+                    continue;
                 }
+                TEntry* entry = queue.PrepareWrite();
+                Y_ASSERT(entry);
+                TTypeHelper::Write(&entry->Value, std::forward<TT>(value));
+                entry->Tag = tag;
+                queue.CompleteWrite();
+                return true;
             }
             return false;
         }
@@ -383,7 +382,7 @@ namespace NThreading {
     template <typename T, size_t Concurrency = 4, size_t ChunkSize = PLATFORM_PAGE_SIZE>
     class TRelaxedManyOneQueue: private TNonCopyable {
         struct TQueueType: public TOneOneQueue<T, ChunkSize> {
-            TAtomic WriteLock = 0;
+            TSpinLock WriteLock;
         };
 
     private:
@@ -429,11 +428,15 @@ namespace NThreading {
             size_t writePos = GetCycleCount();
             for (size_t i = 0; i < Concurrency; ++i) {
                 TQueueType& queue = Queues[writePos++ % Concurrency];
-                if (AtomicTryAndTryLock(&queue.WriteLock)) {
-                    queue.Enqueue(std::forward<TT>(value));
-                    AtomicUnlock(&queue.WriteLock);
-                    return true;
+                if (queue.WriteLock.IsLocked()) {
+                    continue;
+                }
+                TTryGuard guard{queue.WriteLock};
+                if (!guard) {
+                    continue;
                 }
+                queue.Enqueue(std::forward<TT>(value));
+                return true;
             }
             return false;
         }
@@ -446,14 +449,8 @@ namespace NThreading {
     template <typename T, size_t Concurrency = 4, size_t ChunkSize = PLATFORM_PAGE_SIZE>
     class TRelaxedManyManyQueue: private TNonCopyable {
         struct TQueueType: public TOneOneQueue<T, ChunkSize> {
-            union {
-                TAtomic WriteLock = 0;
-                char Pad1[PLATFORM_CACHE_LINE];
-            };
-            union {
-                TAtomic ReadLock = 0;
-                char Pad2[PLATFORM_CACHE_LINE];
-            };
+            TPadded<TSpinLock> WriteLock;
+            TPadded<TSpinLock> ReadLock;
         };
 
     private:
@@ -473,12 +470,15 @@ namespace NThreading {
             size_t readPos = GetCycleCount();
             for (size_t i = 0; i < Concurrency; ++i) {
                 TQueueType& queue = Queues[readPos++ % Concurrency];
-                if (AtomicTryAndTryLock(&queue.ReadLock)) {
-                    bool dequeued = queue.Dequeue(value);
-                    AtomicUnlock(&queue.ReadLock);
-                    if (dequeued) {
-                        return true;
-                    }
+                if (queue.ReadLock.IsLocked()) {
+                    continue;
+                }
+                TTryGuard guard{queue.ReadLock};
+                if (!guard) {
+                    continue;
+                }
+                if (queue.Dequeue(value)) {
+                    return true;
                 }
             }
             return false;
@@ -487,12 +487,15 @@ namespace NThreading {
         bool IsEmpty() {
             for (size_t i = 0; i < Concurrency; ++i) {
                 TQueueType& queue = Queues[i];
-                if (AtomicTryAndTryLock(&queue.ReadLock)) {
-                    bool empty = queue.IsEmpty();
-                    AtomicUnlock(&queue.ReadLock);
-                    if (!empty) {
-                        return false;
-                    }
+                if (queue.ReadLock.IsLocked()) {
+                    continue;
+                }
+                TTryGuard guard{queue.ReadLock};
+                if (!guard) {
+                    continue;
+                }
+                if (!queue.IsEmpty()) {
+                    return false;
                 }
             }
             return true;
@@ -504,11 +507,15 @@ namespace NThreading {
             size_t writePos = GetCycleCount();
             for (size_t i = 0; i < Concurrency; ++i) {
                 TQueueType& queue = Queues[writePos++ % Concurrency];
-                if (AtomicTryAndTryLock(&queue.WriteLock)) {
-                    queue.Enqueue(std::forward<TT>(value));
-                    AtomicUnlock(&queue.WriteLock);
-                    return true;
+                if (queue.WriteLock.IsLocked()) {
+                    continue;
+                }
+                TTryGuard guard{queue.WriteLock};
+                if (!guard) {
+                    continue;
                 }
+                queue.Enqueue(std::forward<TT>(value));
+                return true;
             }
             return false;
         }
@@ -526,18 +533,18 @@ namespace NThreading {
         using TItem = TAutoPtr<T>;
 
         ~TAutoQueueBase() {
-            TAutoPtr<T> value;
+            TItem value;
             while (Dequeue(value)) {
                 // do nothing
             }
         }
 
-        void Enqueue(TAutoPtr<T> value) {
+        void Enqueue(TItem value) {
             Impl.Enqueue(value.Get());
             Y_UNUSED(value.Release());
         }
 
-        bool Dequeue(TAutoPtr<T>& value) {
+        bool Dequeue(TItem& value) {
             T* ptr = nullptr;
             if (Impl.Dequeue(ptr)) {
                 value.Reset(ptr);
@@ -565,4 +572,4 @@ namespace NThreading {
 
     template <typename T, size_t Concurrency = 4, size_t ChunkSize = PLATFORM_PAGE_SIZE>
     using TAutoRelaxedManyManyQueue = TAutoQueueBase<T, TRelaxedManyManyQueue<T*, Concurrency, ChunkSize>>;
-}
+} // namespace NThreading
diff --git a/library/cpp/threading/equeue/equeue.cpp b/library/cpp/threading/equeue/equeue.cpp
index 54a848e912a..bc0b6fc8144 100644
--- a/library/cpp/threading/equeue/equeue.cpp
+++ b/library/cpp/threading/equeue/equeue.cpp
@@ -6,12 +6,12 @@ TElasticQueue::TElasticQueue(THolder<IThreadPool> slaveQueue)
 }
 
 size_t TElasticQueue::ObjectCount() const {
-    return (size_t)AtomicGet(ObjectCount_);
+    return ObjectCount_.load();
 }
 
 bool TElasticQueue::TryIncCounter() {
-    if ((size_t)AtomicIncrement(GuardCount_) > MaxQueueSize_) {
-        AtomicDecrement(GuardCount_);
+    if (++GuardCount_ > CurrentMaxQueueSize_) {
+        --GuardCount_;
         return false;
     }
 
@@ -26,12 +26,12 @@ class TElasticQueue::TDecrementingWrapper: TNonCopyable, public IObjectInQueue {
         : RealObject_(realObject)
         , Queue_(queue)
     {
-        AtomicIncrement(Queue_->ObjectCount_);
+        ++Queue_->ObjectCount_;
     }
 
     ~TDecrementingWrapper() override {
-        AtomicDecrement(Queue_->ObjectCount_);
-        AtomicDecrement(Queue_->GuardCount_);
+        --Queue_->ObjectCount_;
+        --Queue_->GuardCount_;
     }
 private:
     void Process(void *tsr) override {
@@ -54,7 +54,7 @@ bool TElasticQueue::Add(IObjectInQueue* obj) {
     try {
         wrapper.Reset(new TDecrementingWrapper(obj, this));
     } catch (...) {
-        AtomicDecrement(GuardCount_);
+        --GuardCount_;
         throw;
     }
 
@@ -68,6 +68,7 @@ bool TElasticQueue::Add(IObjectInQueue* obj) {
 
 void TElasticQueue::Start(size_t threadCount, size_t maxQueueSize) {
     MaxQueueSize_ = maxQueueSize;
+    CurrentMaxQueueSize_ = maxQueueSize;
     SlaveQueue_->Start(threadCount, maxQueueSize);
 }
 
diff --git a/library/cpp/threading/equeue/equeue.h b/library/cpp/threading/equeue/equeue.h
index c61b9f7b857..a76271c27ea 100644
--- a/library/cpp/threading/equeue/equeue.h
+++ b/library/cpp/threading/equeue/equeue.h
@@ -1,9 +1,10 @@
 #pragma once
 
 #include <util/thread/pool.h>
-#include <library/cpp/deprecated/atomic/atomic.h>
 #include <util/generic/ptr.h>
 
+#include <atomic>
+
 //actual queue limit will be (maxQueueSize - numBusyThreads) or 0
 class TElasticQueue: public IThreadPool {
 public:
@@ -16,13 +17,20 @@ class TElasticQueue: public IThreadPool {
     void Stop() noexcept override;
 
     size_t ObjectCount() const;
+
+    void SetCurrentMaxQueueSize(size_t v) {
+        Y_ENSURE(v <= MaxQueueSize_);
+        CurrentMaxQueueSize_ = v;
+    }
 private:
     class TDecrementingWrapper;
 
     bool TryIncCounter();
 private:
     THolder<IThreadPool> SlaveQueue_;
+
     size_t MaxQueueSize_ = 0;
-    TAtomic ObjectCount_ = 0;
-    TAtomic GuardCount_ = 0;
+    std::atomic<size_t> CurrentMaxQueueSize_ = 0;
+    std::atomic<size_t> ObjectCount_ = 0;
+    std::atomic<size_t> GuardCount_ = 0;
 };
diff --git a/library/cpp/threading/equeue/equeue_ut.cpp b/library/cpp/threading/equeue/equeue_ut.cpp
index 47b1029a2f9..615d3d877d5 100644
--- a/library/cpp/threading/equeue/equeue_ut.cpp
+++ b/library/cpp/threading/equeue/equeue_ut.cpp
@@ -44,10 +44,10 @@ Y_UNIT_TEST_SUITE(TElasticQueueTest) {
             Processed = Scheduled = Discarded = Total = 0;
         }
 
-        TAtomic Processed;
-        TAtomic Scheduled;
-        TAtomic Discarded;
-        TAtomic Total;
+        std::atomic<size_t> Processed;
+        std::atomic<size_t> Scheduled;
+        std::atomic<size_t> Discarded;
+        std::atomic<size_t> Total;
     };
     static TCounters Counters;
 
@@ -61,7 +61,7 @@ Y_UNIT_TEST_SUITE(TElasticQueueTest) {
         struct TWaitJob: public IObjectInQueue {
             void Process(void*) override {
                 WaitEvent.Wait();
-                AtomicIncrement(Counters.Processed);
+                ++Counters.Processed;
             }
         } job;
 
@@ -87,7 +87,26 @@ Y_UNIT_TEST_SUITE(TElasticQueueTest) {
 
         UNIT_ASSERT_VALUES_EQUAL(0u, TEnv<T>::Queue->ObjectCount());
         UNIT_ASSERT_VALUES_EQUAL(0u, TEnv<T>::Queue->Size());
-        UNIT_ASSERT_VALUES_EQUAL((size_t)Counters.Processed, enqueued);
+        UNIT_ASSERT_VALUES_EQUAL(Counters.Processed.load(), enqueued);
+
+        Counters.Reset();
+
+        enqueued = 0;
+        {
+            TLocalSetup setup;
+            TEnv<T>::Queue->SetCurrentMaxQueueSize(MaxQueueSize / 2);
+
+            while (TEnv<T>::Queue->Add(&job) && enqueued < MaxQueueSize + 100) {
+                ++enqueued;
+            }
+
+            UNIT_ASSERT_VALUES_EQUAL(enqueued, MaxQueueSize / 2);
+            UNIT_ASSERT_VALUES_EQUAL(enqueued, TEnv<T>::Queue->ObjectCount());
+        }
+
+        UNIT_ASSERT_VALUES_EQUAL(0u, TEnv<T>::Queue->ObjectCount());
+        UNIT_ASSERT_VALUES_EQUAL(0u, TEnv<T>::Queue->Size());
+        UNIT_ASSERT_VALUES_EQUAL(Counters.Processed.load(), enqueued);
     }
 
     Y_UNIT_TEST(FillTest) {
@@ -101,25 +120,25 @@ Y_UNIT_TEST_SUITE(TElasticQueueTest) {
 //concurrent test -- send many jobs from different threads
     struct TJob: public IObjectInQueue {
         void Process(void*) override {
-            AtomicIncrement(Counters.Processed);
+            ++Counters.Processed;
         }
     };
     static TJob Job;
 
     template <typename T>
     static bool TryAdd() {
-        AtomicIncrement(Counters.Total);
+        ++Counters.Total;
         if (TEnv<T>::Queue->Add(&Job)) {
-            AtomicIncrement(Counters.Scheduled);
+            ++Counters.Scheduled;
             return true;
         } else {
-            AtomicIncrement(Counters.Discarded);
+            ++Counters.Discarded;
             return false;
         }
     }
 
     const size_t N = 100000;
-    static size_t TryCounter;
+    static std::atomic<size_t> TryCounter;
 
     template <typename T>
     void ConcurrentTest() {
@@ -128,7 +147,7 @@ Y_UNIT_TEST_SUITE(TElasticQueueTest) {
 
         struct TSender: public IThreadFactory::IThreadAble {
             void DoExecute() override {
-                while ((size_t)AtomicIncrement(TryCounter) <= N) {
+                while (++TryCounter <= N) {
                     if (!TryAdd<T>()) {
                         Sleep(TDuration::MicroSeconds(50));
                     }
@@ -149,9 +168,9 @@ Y_UNIT_TEST_SUITE(TElasticQueueTest) {
             }
         }
 
-        UNIT_ASSERT_VALUES_EQUAL((size_t)Counters.Total, N);
-        UNIT_ASSERT_VALUES_EQUAL(Counters.Processed, Counters.Scheduled);
-        UNIT_ASSERT_VALUES_EQUAL(Counters.Total, Counters.Scheduled + Counters.Discarded);
+        UNIT_ASSERT_VALUES_EQUAL(Counters.Total.load(), N);
+        UNIT_ASSERT_VALUES_EQUAL(Counters.Processed.load(), Counters.Scheduled.load());
+        UNIT_ASSERT_VALUES_EQUAL(Counters.Total.load(), Counters.Scheduled.load() + Counters.Discarded.load());
     }
 
     Y_UNIT_TEST(ConcurrentTest) {
diff --git a/library/cpp/threading/equeue/fast/equeue.h b/library/cpp/threading/equeue/fast/equeue.h
index 0a3ba47184d..0463507a55b 100644
--- a/library/cpp/threading/equeue/fast/equeue.h
+++ b/library/cpp/threading/equeue/fast/equeue.h
@@ -5,6 +5,7 @@
 #include <util/datetime/base.h>
 #include <util/thread/lfqueue.h>
 #include <util/system/thread.h>
+#include <util/generic/bitops.h>
 #include <util/generic/vector.h>
 #include <util/generic/scope.h>
 #include <util/stream/str.h>
@@ -33,6 +34,8 @@ class TFastElasticQueue
 
         Queue_.Reset(new NThreading::TBoundedQueue<IObjectInQueue*>(FastClp2(maxQueueSize + threadCount))); //threadCount is for stop events
         MaxQueueSize_ = maxQueueSize;
+        CurrentMaxQueueSize_ = maxQueueSize;
+        ActiveThreadCount_ = threadCount;
 
         try {
             for (size_t i = 0; i < threadCount; ++i) {
@@ -47,8 +50,8 @@ class TFastElasticQueue
     }
 
     size_t ObjectCount() const {
-        //GuardCount_ can be temporary incremented above real object count in queue
-        return Min(GuardCount_.load(), MaxQueueSize_);
+        //May return extra +1 for real object count if near CurrentMaxQueueSize_
+        return GuardCount_.load();
     }
 
     bool Add(IObjectInQueue* obj) override Y_WARN_UNUSED_RESULT {
@@ -56,7 +59,7 @@ class TFastElasticQueue
             return false;
         }
 
-        if (GuardCount_.fetch_add(1) >= MaxQueueSize_) {
+        if (GuardCount_.fetch_add(1) >= CurrentMaxQueueSize_) {
             GuardCount_.fetch_sub(1);
             return false;
         }
@@ -65,7 +68,7 @@ class TFastElasticQueue
 
         if (!Queue_->Enqueue(obj)) {
             //Simultaneous Dequeue calls can return not in exact fifo order of items,
-            //so there can be GuardCount_ < MaxQueueSize_ but Enqueue will fail because of
+            //so there can be GuardCount_ < CurrentMaxQueueSize_ but Enqueue will fail because of
             //the oldest enqueued item is not actually dequeued and ring buffer can't proceed.
             GuardCount_.fetch_sub(1);
             QueueSize_.fetch_sub(1);
@@ -103,10 +106,15 @@ class TFastElasticQueue
 
     void DoExecute() override {
         TThread::SetCurrentThreadName(Params.ThreadName_.c_str());
+        const size_t thisThreadId = ThreadCount_++;
 
         while (true) {
             IObjectInQueue* job = nullptr;
 
+            while (thisThreadId >= ActiveThreadCount_ && !Stopped_) {
+                Sleep(TDuration::Seconds(1));
+            }
+
             Event_.Await([&]() {
                 return Queue_->Dequeue(job);
             });
@@ -136,9 +144,22 @@ class TFastElasticQueue
             }
         }
     }
+
+    void SetCurrentMaxQueueSize(size_t v) {
+        Y_ENSURE(v <= MaxQueueSize_);
+        CurrentMaxQueueSize_ = v;
+    }
+
+    void SetActiveThreadCount(size_t v) {
+        Y_ENSURE(v <= ThreadCount_);
+        ActiveThreadCount_ = v;
+    }
 private:
     std::atomic<bool> Stopped_ = false;
     size_t MaxQueueSize_ = 0;
+    std::atomic<size_t> CurrentMaxQueueSize_ = 0;
+    std::atomic<size_t> ThreadCount_ = 0;
+    std::atomic<size_t> ActiveThreadCount_ = 0;
 
     alignas(64) std::atomic<size_t> GuardCount_ = 0;
     alignas(64) std::atomic<size_t> QueueSize_ = 0;
diff --git a/library/cpp/threading/future/core/coroutine_traits.h b/library/cpp/threading/future/core/coroutine_traits.h
index cdd3eeeff3e..e519dd681f6 100644
--- a/library/cpp/threading/future/core/coroutine_traits.h
+++ b/library/cpp/threading/future/core/coroutine_traits.h
@@ -3,51 +3,106 @@
 #include <library/cpp/threading/future/future.h>
 
 #include <coroutine>
+#include <utility>
 
 template <typename... Args>
 struct std::coroutine_traits<NThreading::TFuture<void>, Args...> {
     struct promise_type {
 
-        NThreading::TFuture<void> get_return_object() {
-            return Promise_.GetFuture();
+        NThreading::TFuture<void> get_return_object() noexcept {
+            return NThreading::TFuture<void>(State_);
         }
 
-        std::suspend_never initial_suspend() { return {}; }
-        std::suspend_never final_suspend() noexcept { return {}; }
+        struct TFinalSuspend {
+            bool await_ready() noexcept { return false; }
+            void await_resume() noexcept { /* never called */ }
+            void await_suspend(std::coroutine_handle<promise_type> self) noexcept {
+                auto state = std::move(self.promise().State_);
+                // We must destroy the coroutine before running callbacks
+                // This will make sure argument copies are destroyed before the caller is resumed
+                self.destroy();
+                state->RunCallbacks();
+            }
+        };
+
+        std::suspend_never initial_suspend() noexcept { return {}; }
+        TFinalSuspend final_suspend() noexcept { return {}; }
 
         void unhandled_exception() {
-            Promise_.SetException(std::current_exception());
+            bool success = State_->TrySetException(std::current_exception(), /* deferCallbacks */ true);
+            Y_ASSERT(success && "value already set");
         }
 
         void return_void() {
-            Promise_.SetValue();
+            bool success = State_->TrySetValue(/* deferCallbacks */ true);
+            Y_ASSERT(success && "value already set");
         }
 
     private:
-        NThreading::TPromise<void> Promise_ = NThreading::NewPromise();
+        TIntrusivePtr<NThreading::NImpl::TFutureState<void>> State_{new NThreading::NImpl::TFutureState<void>()};
     };
 };
 
 template <typename T, typename... Args>
 struct std::coroutine_traits<NThreading::TFuture<T>, Args...> {
     struct promise_type {
-        NThreading::TFuture<T> get_return_object() {
-            return Promise_.GetFuture();
+
+        static_assert(
+            !std::derived_from<T, std::exception>,
+            "TFuture<std::exception can not be used in coroutines"
+        );
+
+        NThreading::TFuture<T> get_return_object() noexcept {
+            return NThreading::TFuture<T>(State_);
         }
 
-        std::suspend_never initial_suspend() { return {}; }
-        std::suspend_never final_suspend() noexcept { return {}; }
+        struct TFinalSuspend {
+            bool await_ready() noexcept { return false; }
+            void await_resume() noexcept { /* never called */ }
+            void await_suspend(std::coroutine_handle<promise_type> self) noexcept {
+                auto state = std::move(self.promise().State_);
+                // We must destroy the coroutine before running callbacks
+                // This will make sure argument copies are destroyed before the caller is resumed
+                self.destroy();
+                state->RunCallbacks();
+            }
+        };
+
+        std::suspend_never initial_suspend() noexcept { return {}; }
+        TFinalSuspend final_suspend() noexcept { return {}; }
 
         void unhandled_exception() {
-            Promise_.SetException(std::current_exception());
+            bool success = State_->TrySetException(std::current_exception(), /* deferCallbacks */ true);
+            Y_ASSERT(success && "value already set");
         }
 
+        template <typename E>
+        requires std::derived_from<std::remove_cvref_t<E>, std::exception>
+        void return_value(E&& err) {
+            // Allow co_return std::exception instances in order to avoid stack unwinding
+            bool success = State_->TrySetException(
+                std::make_exception_ptr(std::forward<E>(err)),
+                /* deferCallbacks */ true
+            );
+            Y_ASSERT(success && "value already set");
+        }
+
+        // Allow only rvalues to be returned to prevent accidental slicing if used this way:
+        // } catch (const std::exception& ex) {
+        //      co_return ex;
+        // }
+        // (rethrow exception to preserve actual exception type)
+        template <typename E>
+        requires std::derived_from<std::remove_cvref_t<E>, std::exception>
+        void return_value(E& err) = delete;
+
         void return_value(auto&& val) {
-            Promise_.SetValue(std::forward<decltype(val)>(val));
+            bool success = State_->TrySetValue(std::forward<decltype(val)>(val), /* deferCallbacks */ true);
+            Y_ASSERT(success && "value already set");
         }
 
     private:
-        NThreading::TPromise<T> Promise_ = NThreading::NewPromise<T>();
+        TIntrusivePtr<NThreading::NImpl::TFutureState<T>> State_{new NThreading::NImpl::TFutureState<T>()};
     };
 };
 
@@ -61,7 +116,6 @@ namespace NThreading {
             : Future{future}
         {
         }
-
         TFutureAwaitable(NThreading::TFuture<T>&& future) noexcept
             : Future{std::move(future)}
         {
@@ -98,23 +152,19 @@ namespace NThreading {
     template <typename T>
     using TExtractingFutureAwaitable = TFutureAwaitable<T, true>;
 
-} // namespace NThreading
-
-template <typename T>
-auto operator co_await(const NThreading::TFuture<T>& future) noexcept {
-    return NThreading::TFutureAwaitable{future};
-}
-
-template <typename T>
-auto operator co_await(NThreading::TFuture<T>&& future) noexcept {
-    // Not TExtractongFutureAwaitable, because TFuture works like std::shared_future.
-    // auto value = co_await GetCachedFuture();
-    // If GetCachedFuture stores a future in some cache and returns its copies,
-    // then subsequent uses of co_await will return a moved-from value.
-    return NThreading::TFutureAwaitable{std::move(future)};
-}
+    template <typename T>
+    auto operator co_await(const NThreading::TFuture<T>& future) noexcept {
+        return NThreading::TFutureAwaitable{future};
+    }
 
-namespace NThreading {
+    template <typename T>
+    auto operator co_await(NThreading::TFuture<T>&& future) noexcept {
+        // Not TExtractongFutureAwaitable, because TFuture works like std::shared_future.
+        // auto value = co_await GetCachedFuture();
+        // If GetCachedFuture stores a future in some cache and returns its copies,
+        // then subsequent uses of co_await will return a moved-from value.
+        return NThreading::TFutureAwaitable{std::move(future)};
+    }
 
     template <typename T>
     auto AsAwaitable(const NThreading::TFuture<T>& fut) noexcept {
diff --git a/library/cpp/threading/future/core/future-inl.h b/library/cpp/threading/future/core/future-inl.h
index 1ce1cbd4e21..a9dc10eaecd 100644
--- a/library/cpp/threading/future/core/future-inl.h
+++ b/library/cpp/threading/future/core/future-inl.h
@@ -140,9 +140,8 @@ namespace NThreading {
             }
 
             template <typename TT>
-            bool TrySetValue(TT&& value) {
+            bool TrySetValue(TT&& value, bool deferCallbacks = false) {
                 TSystemEvent* readyEvent = nullptr;
-                TCallbackList<T> callbacks;
 
                 with_lock (StateLock) {
                     TAtomicBase state = AtomicGet(State);
@@ -153,7 +152,6 @@ namespace NThreading {
                     new (&Value) T(std::forward<TT>(value));
 
                     readyEvent = ReadyEvent.Get();
-                    callbacks = std::move(Callbacks);
 
                     AtomicSet(State, ValueSet);
                 }
@@ -162,11 +160,8 @@ namespace NThreading {
                     readyEvent->Signal();
                 }
 
-                if (callbacks) {
-                    TFuture<T> temp(this);
-                    for (auto& callback : callbacks) {
-                        callback(temp);
-                    }
+                if (!deferCallbacks) {
+                    RunCallbacks();
                 }
 
                 return true;
@@ -179,9 +174,8 @@ namespace NThreading {
                 }
             }
 
-            bool TrySetException(std::exception_ptr e) {
+            bool TrySetException(std::exception_ptr e, bool deferCallbacks = false) {
                 TSystemEvent* readyEvent;
-                TCallbackList<T> callbacks;
 
                 with_lock (StateLock) {
                     TAtomicBase state = AtomicGet(State);
@@ -192,7 +186,6 @@ namespace NThreading {
                     Exception = std::move(e);
 
                     readyEvent = ReadyEvent.Get();
-                    callbacks = std::move(Callbacks);
 
                     AtomicSet(State, ExceptionSet);
                 }
@@ -201,14 +194,22 @@ namespace NThreading {
                     readyEvent->Signal();
                 }
 
-                if (callbacks) {
+                if (!deferCallbacks) {
+                    RunCallbacks();
+                }
+
+                return true;
+            }
+
+            void RunCallbacks() {
+                Y_ASSERT(AtomicGet(State) != NotReady);
+                if (!Callbacks.empty()) {
+                    TCallbackList<T> callbacks = std::move(Callbacks);
                     TFuture<T> temp(this);
                     for (auto& callback : callbacks) {
                         callback(temp);
                     }
                 }
-
-                return true;
             }
 
             template <typename F>
@@ -331,9 +332,8 @@ namespace NThreading {
                 }
             }
 
-            bool TrySetValue() {
+            bool TrySetValue(bool deferCallbacks = false) {
                 TSystemEvent* readyEvent = nullptr;
-                TCallbackList<void> callbacks;
 
                 with_lock (StateLock) {
                     TAtomicBase state = AtomicGet(State);
@@ -342,7 +342,6 @@ namespace NThreading {
                     }
 
                     readyEvent = ReadyEvent.Get();
-                    callbacks = std::move(Callbacks);
 
                     AtomicSet(State, ValueSet);
                 }
@@ -351,11 +350,8 @@ namespace NThreading {
                     readyEvent->Signal();
                 }
 
-                if (callbacks) {
-                    TFuture<void> temp(this);
-                    for (auto& callback : callbacks) {
-                        callback(temp);
-                    }
+                if (!deferCallbacks) {
+                    RunCallbacks();
                 }
 
                 return true;
@@ -368,9 +364,8 @@ namespace NThreading {
                 }
             }
 
-            bool TrySetException(std::exception_ptr e) {
+            bool TrySetException(std::exception_ptr e, bool deferCallbacks = false) {
                 TSystemEvent* readyEvent = nullptr;
-                TCallbackList<void> callbacks;
 
                 with_lock (StateLock) {
                     TAtomicBase state = AtomicGet(State);
@@ -381,7 +376,6 @@ namespace NThreading {
                     Exception = std::move(e);
 
                     readyEvent = ReadyEvent.Get();
-                    callbacks = std::move(Callbacks);
 
                     AtomicSet(State, ExceptionSet);
                 }
@@ -390,14 +384,22 @@ namespace NThreading {
                     readyEvent->Signal();
                 }
 
-                if (callbacks) {
+                if (!deferCallbacks) {
+                    RunCallbacks();
+                }
+
+                return true;
+            }
+
+            void RunCallbacks() {
+                Y_ASSERT(AtomicGet(State) != NotReady);
+                if (!Callbacks.empty()) {
+                    TCallbackList<void> callbacks = std::move(Callbacks);
                     TFuture<void> temp(this);
                     for (auto& callback : callbacks) {
                         callback(temp);
                     }
                 }
-
-                return true;
             }
 
             template <typename F>
@@ -968,10 +970,6 @@ namespace NThreading {
         return {new NImpl::TFutureState<T>()};
     }
 
-    inline TPromise<void> NewPromise() {
-        return {new NImpl::TFutureState<void>()};
-    }
-
     template <typename T>
     inline TFuture<T> MakeFuture(const T& value) {
         return {new NImpl::TFutureState<T>(value)};
@@ -1002,7 +1000,8 @@ namespace NThreading {
         return {new NImpl::TFutureState<T>(std::move(exception), NImpl::TError::Error)};
     }
 
-    inline TFuture<void> MakeFuture() {
+    template<>
+    inline TFuture<void> MakeFuture<void>() {
         struct TCache {
             TFuture<void> Instance{new NImpl::TFutureState<void>(true)};
         };
diff --git a/library/cpp/threading/future/core/future.h b/library/cpp/threading/future/core/future.h
index 1e76a04d3f1..74d47580e50 100644
--- a/library/cpp/threading/future/core/future.h
+++ b/library/cpp/threading/future/core/future.h
@@ -19,20 +19,18 @@ namespace NThreading {
     struct TFutureException: public yexception {};
 
     // creates unset promise
-    template <typename T>
+    template <typename T = void>
     TPromise<T> NewPromise();
-    TPromise<void> NewPromise();
 
     // creates preset future
     template <typename T>
     TFuture<T> MakeFuture(const T& value);
     template <typename T>
     TFuture<std::remove_reference_t<T>> MakeFuture(T&& value);
-    template <typename T>
+    template <typename T = void>
     TFuture<T> MakeFuture();
     template <typename T>
     TFuture<T> MakeErrorFuture(std::exception_ptr exception);
-    TFuture<void> MakeFuture();
 
     ////////////////////////////////////////////////////////////////////////////////
 
diff --git a/library/cpp/threading/future/future_ut.cpp b/library/cpp/threading/future/future_ut.cpp
index ceb07cae934..857a29bec6b 100644
--- a/library/cpp/threading/future/future_ut.cpp
+++ b/library/cpp/threading/future/future_ut.cpp
@@ -86,6 +86,9 @@ namespace {
             promise = NewPromise();
             UNIT_ASSERT(!promise.HasValue());
 
+            promise = NewPromise<void>();
+            UNIT_ASSERT(!promise.HasValue());
+
             TFuture<void> future;
             UNIT_ASSERT(!future.HasValue());
 
@@ -120,6 +123,9 @@ namespace {
 
             future = MakeFuture();
             UNIT_ASSERT(future.HasValue());
+
+            future = MakeFuture<void>();
+            UNIT_ASSERT(future.HasValue());
         }
 
         struct TTestCallback {
diff --git a/library/cpp/threading/future/ut_gtest/coroutine_traits_adl_ut.cpp b/library/cpp/threading/future/ut_gtest/coroutine_traits_adl_ut.cpp
new file mode 100644
index 00000000000..317dcb73c03
--- /dev/null
+++ b/library/cpp/threading/future/ut_gtest/coroutine_traits_adl_ut.cpp
@@ -0,0 +1,24 @@
+#include "simple_task.h"
+
+#include <library/cpp/testing/gtest/gtest.h>
+#include <library/cpp/testing/gtest_extensions/gtest_extensions.h>
+#include <library/cpp/threading/future/future.h>
+#include <library/cpp/threading/future/core/coroutine_traits.h>
+
+TEST(TestFutureTraits, ArgumentDependentLookup) {
+    TVector<TString> result;
+    NThreading::TPromise<void> promise = NThreading::NewPromise<void>();
+    NThreading::TFuture<void> future = promise.GetFuture();
+
+    NSimpleTestTask::RunAwaitable(result, std::move(future));
+
+    promise.SetValue();
+
+    EXPECT_THAT(
+        result,
+        ::testing::ContainerEq(
+            TVector<TString>({
+                "before co_await",
+                "after co_await",
+            })));
+}
diff --git a/library/cpp/threading/future/ut_gtest/simple_task.h b/library/cpp/threading/future/ut_gtest/simple_task.h
new file mode 100644
index 00000000000..8291de2dba0
--- /dev/null
+++ b/library/cpp/threading/future/ut_gtest/simple_task.h
@@ -0,0 +1,47 @@
+#pragma once
+
+#include <util/generic/string.h>
+#include <util/generic/vector.h>
+
+#include <coroutine>
+#include <utility>
+
+// Note: this namespace must be separate from NThreading and global namespace
+namespace NSimpleTestTask {
+
+    /**
+     * The simplest possible coroutine type for testing
+     */
+    struct TSimpleTask {
+        struct promise_type {
+            TSimpleTask get_return_object() noexcept {
+                return {};
+            }
+            std::suspend_never initial_suspend() noexcept {
+                return {};
+            }
+            std::suspend_never final_suspend() noexcept {
+                return {};
+            }
+            void unhandled_exception() {
+                throw;
+            }
+            void return_void() noexcept {
+            }
+        };
+    };
+
+    /**
+     * This coroutine awaits a generic awaitable
+     *
+     * When operator co_await for awaitables is not defined before this header
+     * is included it will be searched using argument dependent lookup.
+     */
+    template <class TAwaitable>
+    TSimpleTask RunAwaitable(TVector<TString>& result, TAwaitable&& awaitable) {
+        result.push_back("before co_await");
+        co_await std::forward<TAwaitable>(awaitable);
+        result.push_back("after co_await");
+    }
+
+} // namespace NSimpleTestTask
diff --git a/library/cpp/uri/common.h b/library/cpp/uri/common.h
index 23be2571fc5..5a74d4da5e4 100644
--- a/library/cpp/uri/common.h
+++ b/library/cpp/uri/common.h
@@ -366,7 +366,9 @@ namespace NUri {
             NewFeaturesRecommended = 0 | FeatureSchemeKnown | FeatureRemoteOnly | FeatureToLower | FeatureCheckHost | FeatureConvertHostIDN | FeatureFragmentToHashBang | FeatureEncodeSpace | FeatureEncodeCntrl | FeatureEncodeExtendedASCII | FeatureUpperEncoded | FeatureDecodeUnreserved | FeaturePathOperation | FeaturePathStripRootParent,
 
             // FeaturesRobot is deprecated, use NewFeaturesRecommended: ROBOTQUALITY-718
-            FeaturesRobot = FeaturesRecommended
+            FeaturesRobot = NewFeaturesRecommended,
+
+            FeaturesDefaultOrSchemeKnown = 0 | FeaturesDefault | FeatureSchemeKnown
         };
     };
 
diff --git a/library/cpp/uri/uri_ut.cpp b/library/cpp/uri/uri_ut.cpp
index 1198140ce92..fe15c7f9f9c 100644
--- a/library/cpp/uri/uri_ut.cpp
+++ b/library/cpp/uri/uri_ut.cpp
@@ -794,7 +794,7 @@ namespace NUri {
 
         Y_UNIT_TEST(test_NonRfcUrls) {
             TUri url;
-            const long flags = TFeature::FeaturesRobot;
+            const ui64 flags = TFeature::FeaturesRobot;
             for (size_t i = 0;; ++i) {
                 const TStringBuf& buf = NonRfcUrls[i];
                 if (!buf.IsInited())
@@ -809,7 +809,7 @@ namespace NUri {
 
         Y_UNIT_TEST(test_CheckParseException) {
             TUri url;
-            const long flags = TFeature::FeaturesRobot | TFeature::FeaturesEncode;
+            const ui64 flags = TFeature::FeaturesRobot | TFeature::FeaturesEncode;
             for (size_t i = 0;; ++i) {
                 const TStringBuf& buf = CheckParseException[i];
                 if (!buf.IsInited())
@@ -840,7 +840,7 @@ namespace NUri {
                 uri.Parse("http://srv.net:80/print", TFeature::FeaturesRecommended);
                 TString s = uri.PrintS(TUri::FlagPort);
                 Cdbg << uri.PrintS() << ',' << uri.PrintS(TUri::FlagPort) << Endl;
-                UNIT_ASSERT(s.Empty());
+                UNIT_ASSERT(s.empty());
             }
         }
 
diff --git a/library/cpp/yson/varint.cpp b/library/cpp/yson/varint.cpp
index deed1fdbd6f..ff451990f9a 100644
--- a/library/cpp/yson/varint.cpp
+++ b/library/cpp/yson/varint.cpp
@@ -3,6 +3,7 @@
 #include "zigzag.h"
 
 #include <util/generic/yexception.h>
+#include <util/generic/ylimits.h>
 
 namespace NYson {
     ////////////////////////////////////////////////////////////////////////////////
diff --git a/library/cpp/yt/CMakeLists.txt b/library/cpp/yt/CMakeLists.txt
index 12640b3c377..de7d4c795fc 100644
--- a/library/cpp/yt/CMakeLists.txt
+++ b/library/cpp/yt/CMakeLists.txt
@@ -71,9 +71,11 @@ target_link_libraries(yt-memory
     yt-assert
     yt-misc
     yt-malloc
+    yt-system
 )
 target_sources(yt-memory
   PRIVATE
+    memory/allocation_tags_hooks.cpp
     memory/blob.cpp
     memory/chunked_input_stream.cpp
     memory/chunked_memory_allocator.cpp
@@ -81,10 +83,13 @@ target_sources(yt-memory
     memory/chunked_memory_pool_output.cpp
     memory/chunked_output_stream.cpp
     memory/memory_tag.cpp
+    memory/new.cpp
+    memory/poison.cpp
     memory/ref.cpp
     memory/ref_tracked.cpp
     memory/safe_memory_reader.cpp
     memory/shared_range.cpp
+    memory/simple_memory_usage_tracker.cpp
 )
 if (NOT WIN32 AND CMAKE_CXX_COMPILER_ID STREQUAL "Clang")
   target_compile_options(yt-memory PRIVATE
@@ -109,21 +114,34 @@ target_sources(yt-misc
   PRIVATE
     misc/guid.cpp
     misc/source_location.cpp
-    misc/thread_name.cpp
-    misc/variant.cpp
 )
 _ydb_sdk_install_targets(TARGETS yt-misc)
 
 
-_ydb_sdk_add_library(yt-small_containers INTERFACE)
-target_link_libraries(yt-small_containers 
+_ydb_sdk_add_library(yt-system)
+target_link_libraries(yt-system
+  PUBLIC
+    yutil
+    yt-exception
+    yt-misc
+)
+target_sources(yt-system
+  PRIVATE
+    system/exit.cpp
+    system/thread_name.cpp
+)
+_ydb_sdk_install_targets(TARGETS yt-system)
+
+
+_ydb_sdk_add_library(yt-compact_containers INTERFACE)
+target_link_libraries(yt-compact_containers
   INTERFACE
     yutil
     yt-assert
     yt-malloc
     yt-misc
 )
-_ydb_sdk_install_targets(TARGETS yt-small_containers)
+_ydb_sdk_install_targets(TARGETS yt-compact_containers)
 
 
 _ydb_sdk_add_library(yt-string)
@@ -138,15 +156,18 @@ target_link_libraries(yt-string
     yt-assert
     yt-exception
     yt-misc
-    yt-small_containers
+    yt-compact_containers
     yt-containers
 )
 target_sources(yt-string
   PRIVATE
     string/enum.cpp
+    string/format_string.cpp
     string/guid.cpp
     string/string.cpp
     string/format.cpp
+    string/string_builder.cpp
+    string/stream.cpp
 )
 _ydb_sdk_install_targets(TARGETS yt-string)
 
@@ -172,6 +193,7 @@ _ydb_sdk_add_library(yt-yson_string)
 target_link_libraries(yt-yson_string
   PUBLIC
     yutil
+    containers-cow_string
     yt-exception
     yt-string
     yt-memory
diff --git a/library/cpp/yt/assert/assert.cpp b/library/cpp/yt/assert/assert.cpp
index 095357cdfa8..2329a5118db 100644
--- a/library/cpp/yt/assert/assert.cpp
+++ b/library/cpp/yt/assert/assert.cpp
@@ -10,6 +10,7 @@ namespace NYT::NDetail {
 Y_WEAK void AssertTrapImpl(
     TStringBuf trapType,
     TStringBuf expr,
+    TStringBuf description,
     TStringBuf file,
     int line,
     TStringBuf function)
@@ -20,8 +21,10 @@ Y_WEAK void AssertTrapImpl(
         line,
         function.data(),
         expr.data(),
-        "%s",
-        trapType.data());
+        "%s: %.*s",
+        trapType.data(),
+        static_cast<int>(std::min<ui64>(description.length(), std::numeric_limits<int>::max())),
+        description.data());
 }
 
 ////////////////////////////////////////////////////////////////////////////////
diff --git a/library/cpp/yt/assert/assert.h b/library/cpp/yt/assert/assert.h
index 7a9e761a3a9..6430f136ffc 100644
--- a/library/cpp/yt/assert/assert.h
+++ b/library/cpp/yt/assert/assert.h
@@ -15,6 +15,7 @@ namespace NDetail {
 void AssertTrapImpl(
     TStringBuf trapType,
     TStringBuf expr,
+    TStringBuf description,
     TStringBuf file,
     int line,
     TStringBuf function);
@@ -27,48 +28,80 @@ void AssertTrapImpl(
     #define YT_BUILTIN_TRAP()  std::terminate()
 #endif
 
-#define YT_ASSERT_TRAP(trapType, expr) \
-    ::NYT::NDetail::AssertTrapImpl(TStringBuf(trapType), TStringBuf(expr), __SOURCE_FILE_IMPL__.As<TStringBuf>(), __LINE__, TStringBuf(__FUNCTION__)); \
-    Y_UNREACHABLE() \
+#define YT_ASSERT_TRAP_IMPL(trapType, expr, description) \
+    ::NYT::NDetail::AssertTrapImpl(                      \
+        TStringBuf(trapType),                            \
+        TStringBuf(expr),                                \
+        TStringBuf(description),                         \
+        __SOURCE_FILE_IMPL__.As<TStringBuf>(),           \
+        __LINE__,                                        \
+        TStringBuf(__FUNCTION__));                       \
+    Y_UNREACHABLE()
 
+#define YT_ASSERT_TRAP_IMPL_EXTRA_ARG(trapType, expr, description, _) YT_ASSERT_TRAP_IMPL(trapType, expr, description)
+
+#define YT_ASSERT_TRAP(trapType, expr, ...) \
+    YT_ASSERT_TRAP_IMPL##__VA_OPT__(_EXTRA_ARG)(trapType, expr,  __VA_OPT__(__VA_ARGS__,) "")
+
+//! If |expr| is evaluated to false, abnormally terminates the current process in debug mode.
+//! Does nothing in release mode.
+//! Accepts an optional string argument that will be printed in error with #expr.
 #ifdef NDEBUG
-    #define YT_ASSERT(expr) \
+    #define YT_ASSERT(expr, ...) \
         do { \
             if (false) { \
                 (void) (expr); \
+                __VA_OPT__((void)(__VA_ARGS__)); \
             } \
         } while (false)
 #else
-    #define YT_ASSERT(expr) \
+    #define YT_ASSERT(expr, ...) \
         do { \
             if (Y_UNLIKELY(!(expr))) { \
-                YT_ASSERT_TRAP("YT_ASSERT", #expr); \
+                YT_ASSERT_TRAP("YT_ASSERT", #expr __VA_OPT__(, __VA_ARGS__)); \
             } \
         } while (false)
 #endif
 
 //! Same as |YT_ASSERT| but evaluates and checks the expression in both release and debug mode.
-#define YT_VERIFY(expr) \
+//! Accepts an optional string argument that will be printed in error message with #expr.
+#define YT_VERIFY(expr, ...) \
     do { \
         if (Y_UNLIKELY(!(expr))) { \
-            YT_ASSERT_TRAP("YT_VERIFY", #expr); \
+            YT_ASSERT_TRAP("YT_VERIFY", #expr __VA_OPT__(, __VA_ARGS__)); \
         } \
     } while (false)
 
+//! Behaves as |YT_ASSERT| in debug mode and as |Y_ASSUME| in release.
+#ifdef NDEBUG
+    #define YT_ASSUME(expr) Y_ASSUME(expr)
+#else
+    #define YT_ASSUME(expr) YT_ASSERT(expr)
+#endif
+
+//! Behaves as |YT_ASSERT(false)| in debug mode and as |Y_UNREACHABLE| in release.
+#ifdef NDEBUG
+    #define YT_UNREACHABLE() Y_UNREACHABLE()
+#else
+    #define YT_UNREACHABLE() YT_ASSERT(false)
+#endif
+
 //! Fatal error code marker. Abnormally terminates the current process.
+//! Accepts an optional string argument that will be printed in error message.
 #ifdef YT_COMPILING_UDF
-    #define YT_ABORT() __YT_BUILTIN_ABORT()
+    #define YT_ABORT(...) __YT_BUILTIN_ABORT()
 #else
-    #define YT_ABORT() \
+    #define YT_ABORT(...) \
         do { \
-            YT_ASSERT_TRAP("YT_ABORT", ""); \
+            YT_ASSERT_TRAP("YT_ABORT", "" __VA_OPT__(, __VA_ARGS__)); \
         } while (false)
 #endif
 
 //! Unimplemented code marker. Abnormally terminates the current process.
-#define YT_UNIMPLEMENTED() \
+//! Accepts an optional string argument that will be printed in error message.
+#define YT_UNIMPLEMENTED(...) \
     do { \
-        YT_ASSERT_TRAP("YT_UNIMPLEMENTED", ""); \
+        YT_ASSERT_TRAP("YT_UNIMPLEMENTED", "" __VA_OPT__(, __VA_ARGS__)); \
     } while (false)
 
 ////////////////////////////////////////////////////////////////////////////////
diff --git a/library/cpp/yt/coding/bit_io-inl.h b/library/cpp/yt/coding/bit_io-inl.h
new file mode 100644
index 00000000000..89d69be6251
--- /dev/null
+++ b/library/cpp/yt/coding/bit_io-inl.h
@@ -0,0 +1,69 @@
+#ifndef BIT_IO_INL_H_
+#error "Direct inclusion of this file is not allowed, include bit_io.h"
+// For the sake of sane code completion.
+#include "bit_io.h"
+#endif
+
+#include <util/system/compiler.h>
+#include <util/system/unaligned_mem.h>
+
+namespace NYT {
+
+////////////////////////////////////////////////////////////////////////////////
+
+inline TBitWriter::TBitWriter(char* ptr)
+    : Ptr_(ptr)
+{ }
+
+Y_FORCE_INLINE void TBitWriter::WriteBits(ui32 value, int width)
+{
+    // Flush a whole 32-bit word at once (a single unaligned store) instead of
+    // looping over individual bytes with a data-dependent trip count.
+    Accumulator_ = (Accumulator_ << width) | value;
+    BitCount_ += width;
+    if (BitCount_ >= 32) {
+        BitCount_ -= 32;
+        ui32 word = __builtin_bswap32(static_cast<ui32>(Accumulator_ >> BitCount_));
+        WriteUnaligned<ui32>(Ptr_, word);
+        Ptr_ += sizeof(word);
+    }
+}
+
+inline char* TBitWriter::Finish()
+{
+    while (BitCount_ >= 8) {
+        BitCount_ -= 8;
+        *Ptr_++ = static_cast<char>((Accumulator_ >> BitCount_) & 0xff);
+    }
+    if (BitCount_ > 0) {
+        *Ptr_++ = static_cast<char>((Accumulator_ << (8 - BitCount_)) & 0xff);
+        BitCount_ = 0;
+    }
+    Accumulator_ = 0;
+    return Ptr_;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+inline TBitReader::TBitReader(const char* ptr)
+    : Ptr_(reinterpret_cast<const ui8*>(ptr))
+{ }
+
+Y_FORCE_INLINE ui32 TBitReader::ReadBits(int width)
+{
+    while (BitCount_ < width) {
+        Accumulator_ = (Accumulator_ << 8) | *Ptr_++;
+        BitCount_ += 8;
+    }
+    BitCount_ -= width;
+    return static_cast<ui32>((Accumulator_ >> BitCount_) & ((1ull << width) - 1));
+}
+
+inline const char* TBitReader::Finish()
+{
+    return reinterpret_cast<const char*>(Ptr_);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace NYT
diff --git a/library/cpp/yt/coding/bit_io.h b/library/cpp/yt/coding/bit_io.h
new file mode 100644
index 00000000000..18900d69f85
--- /dev/null
+++ b/library/cpp/yt/coding/bit_io.h
@@ -0,0 +1,63 @@
+#pragma once
+
+#include <util/system/types.h>
+
+namespace NYT {
+
+////////////////////////////////////////////////////////////////////////////////
+
+//! MSB-first bit writer over a caller-owned buffer.
+/*!
+ *  Bits are flushed to the buffer in 4-byte chunks, so the buffer must have room
+ *  for up to 3 bytes beyond the last logically-written byte before #Finish is
+ *  called.
+ */
+class TBitWriter
+{
+public:
+    explicit TBitWriter(char* ptr);
+
+    //! Appends the #width low bits of #value. Requires 0 <= #width <= 32 and
+    //! #value < 2^#width (for #width == 32 any value is accepted).
+    void WriteBits(ui32 value, int width);
+
+    //! Pads the last partial byte with zero low bits and returns the
+    //! one-past-end pointer.
+    char* Finish();
+
+private:
+    char* Ptr_;
+    ui64 Accumulator_ = 0;
+    int BitCount_ = 0;
+};
+
+//! MSB-first bit reader.
+/*!
+ *  Reads bits written by #TBitWriter. Assumes up to 8 bytes past the logical end
+ *  of the stream are safe to read.
+ */
+class TBitReader
+{
+public:
+    explicit TBitReader(const char* ptr);
+
+    //! Reads and returns #width bits (0 <= #width <= 32).
+    ui32 ReadBits(int width);
+
+    //! Returns the one-past-end pointer; the (< 8) buffered sub-byte bits, which
+    //! are the writer's zero padding, are dropped.
+    const char* Finish();
+
+private:
+    const ui8* Ptr_;
+    ui64 Accumulator_ = 0;
+    int BitCount_ = 0;
+};
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace NYT
+
+#define BIT_IO_INL_H_
+#include "bit_io-inl.h"
+#undef BIT_IO_INL_H_
diff --git a/library/cpp/yt/coding/interpolative-inl.h b/library/cpp/yt/coding/interpolative-inl.h
new file mode 100644
index 00000000000..5eadfdd483e
--- /dev/null
+++ b/library/cpp/yt/coding/interpolative-inl.h
@@ -0,0 +1,182 @@
+#ifndef INTERPOLATIVE_INL_H_
+#error "Direct inclusion of this file is not allowed, include interpolative.h"
+// For the sake of sane code completion.
+#include "interpolative.h"
+#endif
+
+#include "bit_io.h"
+
+#include <library/cpp/yt/assert/assert.h>
+
+#include <library/cpp/yt/memory/range.h>
+
+#include <util/system/compiler.h>
+
+#include <array>
+#include <bit>
+#include <concepts>
+
+namespace NYT {
+
+////////////////////////////////////////////////////////////////////////////////
+
+namespace NInterpolativeCodingDetail {
+
+// Truncated-binary (minimal) code for a value in [0, rangeSize): the first
+// Cutoff values take LowWidth bits, the rest one more.
+struct TTruncatedBinaryParams
+{
+    int LowWidth;   // floor(log2(rangeSize))
+    ui32 Cutoff;    // 2^(LowWidth + 1) - rangeSize
+};
+
+Y_FORCE_INLINE TTruncatedBinaryParams GetTruncatedBinaryParams(ui32 rangeSize)
+{
+    int lowWidth = std::bit_width(rangeSize) - 1;
+    ui32 cutoff = (2u << lowWidth) - rangeSize;
+    return {lowWidth, cutoff};
+}
+
+// Writes #value in [0, #rangeSize) with the entropy-optimal integer code for a
+// uniform value. rangeSize == 1 yields lowWidth 0 / cutoff 1 and emits a
+// zero-width code (a no-op), so the singleton case needs no branch.
+Y_FORCE_INLINE void WriteTruncatedBinary(TBitWriter* writer, ui32 value, ui32 rangeSize)
+{
+    auto [lowWidth, cutoff] = GetTruncatedBinaryParams(rangeSize);
+    // Branchless: the (value >= cutoff) predicate would mispredict on nearly
+    // every element, so fold it into the emitted codeword and width instead.
+    ui32 isLong = value >= cutoff ? 1 : 0;
+    writer->WriteBits(value + (cutoff & (0u - isLong)), lowWidth + static_cast<int>(isLong));
+}
+
+Y_FORCE_INLINE ui32 ReadTruncatedBinary(TBitReader* reader, ui32 rangeSize)
+{
+    auto [lowWidth, cutoff] = GetTruncatedBinaryParams(rangeSize);
+    ui32 high = reader->ReadBits(lowWidth);
+    if (high < cutoff) {
+        return high;
+    }
+    ui32 low = reader->ReadBits(1);
+    return ((high << 1) | low) - cutoff;
+}
+
+// A subrange [BeginIndex, EndIndex) of the value array together with the
+// inclusive value bounds [Lo, Hi] that its elements must fall in. The median
+// values[m] is the only array element touched per node, which matters because
+// the traversal walks a large sequence in a cache-unfriendly tree order.
+struct TInterpolativeFrame
+{
+    int BeginIndex;
+    int EndIndex;
+    ui32 Lo;
+    ui32 Hi;
+};
+
+} // namespace NInterpolativeCodingDetail
+
+////////////////////////////////////////////////////////////////////////////////
+
+inline size_t GetInterpolativeMaxByteSize(int count, ui32 lo, ui32 hi)
+{
+    // Each element is coded in at most ceil(log2(hi - lo + 1)) bits; the trailing
+    // word covers the writer's 4-byte flush store.
+    int maxBitWidth = std::bit_width(hi - lo);
+    return (static_cast<size_t>(count) * maxBitWidth + 7) / 8 + sizeof(ui32);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+// Both traversals descend the left child in place and stack only the (non-empty)
+// right child, so the stack sees ~count/2 pushes instead of ~count. Left-first
+// order matches between encoder and decoder.
+template <std::unsigned_integral T>
+void InterpolativeEncode(TBitWriter* writer, TRange<T> values, ui32 lo, ui32 hi)
+{
+    using namespace NInterpolativeCodingDetail;
+
+    int count = std::ssize(values);
+    if (count == 0) {
+        return;
+    }
+
+    // Right children stack up along the leftmost path => depth <= ceil(log2(count)).
+    std::array<TInterpolativeFrame, 48> stack;
+    int top = 0;
+    int beginIndex = 0;
+    int endIndex = count;
+    ui32 l = lo;
+    ui32 h = hi;
+    for (;;) {
+        // beginIndex is invariant while descending left; only endIndex/l/h change.
+        while (beginIndex < endIndex) {
+            int half = (endIndex - beginIndex) / 2;
+            int m = beginIndex + half;
+            // The next descent step reads values[beginIndex + half/2]; prefetch it
+            // to hide the cache-scattered tree walk on large sequences.
+            Y_PREFETCH_READ(values.data() + beginIndex + (half >> 1), 0);
+            ui32 value = static_cast<ui32>(values[m]);
+            // rangeSize = (upperBound - lowerBound + 1) simplifies to this;
+            // lowerBound = l + half.
+            ui32 rangeSize = (h - l) - static_cast<ui32>(endIndex - beginIndex) + 2;
+            WriteTruncatedBinary(writer, value - l - static_cast<ui32>(half), rangeSize);
+            if (m + 1 < endIndex) {
+                YT_ASSERT(top < std::ssize(stack));
+                stack[top++] = {m + 1, endIndex, value + 1, h};
+            }
+            endIndex = m;
+            h = value - 1;
+        }
+        if (top == 0) {
+            break;
+        }
+        auto f = stack[--top];
+        beginIndex = f.BeginIndex;
+        endIndex = f.EndIndex;
+        l = f.Lo;
+        h = f.Hi;
+    }
+}
+
+template <std::unsigned_integral T>
+void InterpolativeDecode(TBitReader* reader, TMutableRange<T> values, ui32 lo, ui32 hi)
+{
+    using namespace NInterpolativeCodingDetail;
+
+    int count = std::ssize(values);
+    if (count == 0) {
+        return;
+    }
+
+    std::array<TInterpolativeFrame, 48> stack;
+    int top = 0;
+    int beginIndex = 0;
+    int endIndex = count;
+    ui32 l = lo;
+    ui32 h = hi;
+    for (;;) {
+        while (beginIndex < endIndex) {
+            int half = (endIndex - beginIndex) / 2;
+            int m = beginIndex + half;
+            ui32 rangeSize = (h - l) - static_cast<ui32>(endIndex - beginIndex) + 2;
+            ui32 value = l + static_cast<ui32>(half) + ReadTruncatedBinary(reader, rangeSize);
+            values[m] = static_cast<T>(value);
+            if (m + 1 < endIndex) {
+                stack[top++] = {m + 1, endIndex, value + 1, h};
+            }
+            endIndex = m;
+            h = value - 1;
+        }
+        if (top == 0) {
+            break;
+        }
+        auto f = stack[--top];
+        beginIndex = f.BeginIndex;
+        endIndex = f.EndIndex;
+        l = f.Lo;
+        h = f.Hi;
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace NYT
diff --git a/library/cpp/yt/coding/interpolative.h b/library/cpp/yt/coding/interpolative.h
new file mode 100644
index 00000000000..88e415e754c
--- /dev/null
+++ b/library/cpp/yt/coding/interpolative.h
@@ -0,0 +1,52 @@
+#pragma once
+
+#include "bit_io.h"
+
+#include <library/cpp/yt/memory/range.h>
+
+#include <util/system/types.h>
+
+#include <concepts>
+
+namespace NYT {
+
+////////////////////////////////////////////////////////////////////////////////
+//
+// Binary interpolative coding for a sorted, strictly increasing sequence of
+// integers drawn from a known range [lo, hi]. The value domain is 32-bit: lo, hi
+// and hence every value fit in ui32, independent of the element type T (which is
+// merely the container's width).
+//
+// It recursively encodes the median element within the range implied by its
+// position and its already-coded neighbors, so clustered sequences compress far
+// below a flat log2 per element and no per-element headers are needed. Each
+// element is stored with a truncated-binary (minimal) code, which spends the
+// fractional part of log2(range) instead of rounding every element up to a whole
+// bit.
+//
+// The bit stream is MSB-first (see bit_io.h).
+//
+////////////////////////////////////////////////////////////////////////////////
+
+//! Encodes #values, which must be strictly increasing and all within [#lo, #hi],
+//! with binary interpolative coding. An empty range emits nothing; the length is
+//! not stored and must be conveyed out of band (e.g. as a varint prefix).
+template <std::unsigned_integral T>
+void InterpolativeEncode(TBitWriter* writer, TRange<T> values, ui32 lo, ui32 hi);
+
+//! Decodes a sequence written by #InterpolativeEncode into #values, whose size
+//! must equal the encoded element count. #lo and #hi must match the encoder.
+template <std::unsigned_integral T>
+void InterpolativeDecode(TBitReader* reader, TMutableRange<T> values, ui32 lo, ui32 hi);
+
+//! An upper bound on the buffer size #InterpolativeEncode needs to encode #count
+//! values over [#lo, #hi], including the slack the writer requires.
+size_t GetInterpolativeMaxByteSize(int count, ui32 lo, ui32 hi);
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace NYT
+
+#define INTERPOLATIVE_INL_H_
+#include "interpolative-inl.h"
+#undef INTERPOLATIVE_INL_H_
diff --git a/library/cpp/yt/coding/unittests/bit_io_ut.cpp b/library/cpp/yt/coding/unittests/bit_io_ut.cpp
new file mode 100644
index 00000000000..5d61b166f0a
--- /dev/null
+++ b/library/cpp/yt/coding/unittests/bit_io_ut.cpp
@@ -0,0 +1,69 @@
+#include <library/cpp/testing/gtest/gtest.h>
+
+#include <library/cpp/yt/coding/bit_io.h>
+
+#include <utility>
+#include <vector>
+
+namespace NYT {
+namespace {
+
+////////////////////////////////////////////////////////////////////////////////
+
+TEST(TBitIOTest, RoundTrip)
+{
+    std::vector<std::pair<ui32, int>> items = {
+        {0, 0}, {1, 1}, {0, 1}, {5, 3}, {0, 8}, {255, 8}, {12345, 14},
+        {0, 32}, {0xffffffffu, 32}, {0x12345, 17}, {7, 3}, {1u << 30, 31},
+    };
+    std::vector<char> buffer(256, 0);
+
+    TBitWriter writer(buffer.data());
+    for (auto [value, width] : items) {
+        writer.WriteBits(value, width);
+    }
+    writer.Finish();
+
+    TBitReader reader(buffer.data());
+    for (auto [value, width] : items) {
+        EXPECT_EQ(reader.ReadBits(width), value) << "width=" << width;
+    }
+}
+
+TEST(TBitIOTest, ZeroWidthIsNoop)
+{
+    std::vector<char> buffer(16, 0);
+    TBitWriter writer(buffer.data());
+    writer.WriteBits(0, 0);
+    writer.WriteBits(1, 1);
+    writer.WriteBits(0, 0);
+    char* end = writer.Finish();
+    EXPECT_EQ(end - buffer.data(), 1);  // a single bit occupies one byte
+
+    TBitReader reader(buffer.data());
+    EXPECT_EQ(reader.ReadBits(0), 0u);
+    EXPECT_EQ(reader.ReadBits(1), 1u);
+    EXPECT_EQ(reader.ReadBits(0), 0u);
+}
+
+TEST(TBitIOTest, FlushBoundary)
+{
+    // Many 17-bit writes repeatedly cross the internal 32-bit flush boundary.
+    constexpr int Count = 1000;
+    std::vector<char> buffer(Count * 3 + 16, 0);
+    TBitWriter writer(buffer.data());
+    for (int i = 0; i < Count; ++i) {
+        writer.WriteBits(static_cast<ui32>(i) & 0x1ffff, 17);
+    }
+    writer.Finish();
+
+    TBitReader reader(buffer.data());
+    for (int i = 0; i < Count; ++i) {
+        EXPECT_EQ(reader.ReadBits(17), static_cast<ui32>(i) & 0x1ffff) << "i=" << i;
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace
+} // namespace NYT
diff --git a/library/cpp/yt/coding/unittests/interpolative_ut.cpp b/library/cpp/yt/coding/unittests/interpolative_ut.cpp
new file mode 100644
index 00000000000..a63b12f6eac
--- /dev/null
+++ b/library/cpp/yt/coding/unittests/interpolative_ut.cpp
@@ -0,0 +1,221 @@
+#include <library/cpp/testing/gtest/gtest.h>
+
+#include <library/cpp/yt/coding/interpolative.h>
+#include <library/cpp/yt/coding/varint.h>
+
+#include <algorithm>
+#include <bit>
+#include <numeric>
+#include <random>
+#include <set>
+#include <vector>
+
+namespace NYT {
+namespace {
+
+////////////////////////////////////////////////////////////////////////////////
+// Truncated binary
+
+TEST(TTruncatedBinaryTest, Exhaustive)
+{
+    for (ui32 rangeSize = 1; rangeSize <= 2050; ++rangeSize) {
+        for (ui32 value = 0; value < rangeSize; ++value) {
+            std::vector<char> buffer(16, 0);
+            TBitWriter writer(buffer.data());
+            NInterpolativeCodingDetail::WriteTruncatedBinary(&writer, value, rangeSize);
+            writer.Finish();
+
+            TBitReader reader(buffer.data());
+            EXPECT_EQ(NInterpolativeCodingDetail::ReadTruncatedBinary(&reader, rangeSize), value)
+                << "rangeSize=" << rangeSize << " value=" << value;
+        }
+    }
+}
+
+TEST(TTruncatedBinaryTest, MinimalLength)
+{
+    // Every codeword is floor(log2(rangeSize)) or ceil(log2(rangeSize)) bits.
+    for (ui32 rangeSize = 1; rangeSize <= 1000; ++rangeSize) {
+        int lowWidth = std::bit_width(rangeSize) - 1;
+        for (ui32 value = 0; value < rangeSize; ++value) {
+            std::vector<char> buffer(16, 0);
+            TBitWriter writer(buffer.data());
+            NInterpolativeCodingDetail::WriteTruncatedBinary(&writer, value, rangeSize);
+            char* end = writer.Finish();
+
+            TBitReader reader(buffer.data());
+            NInterpolativeCodingDetail::ReadTruncatedBinary(&reader, rangeSize);
+            const char* readEnd = reader.Finish();
+            i64 bytes = end - buffer.data();
+            // Read must consume no more bytes than were written.
+            EXPECT_LE(readEnd - buffer.data(), bytes);
+            EXPECT_LE(bytes, (lowWidth + 1 + 7) / 8 + 1);
+        }
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Interpolative coding
+
+template <class T>
+std::vector<char> Encode(const std::vector<T>& values, ui32 lo, ui32 hi)
+{
+    std::vector<char> buffer(values.size() * sizeof(ui32) + 16, 0);
+    TBitWriter writer(buffer.data());
+    InterpolativeEncode(&writer, TRange(values), lo, hi);
+    char* end = writer.Finish();
+    buffer.resize(end - buffer.data());
+    return buffer;
+}
+
+template <class T>
+std::vector<T> Decode(std::vector<char> buffer, int count, ui32 lo, ui32 hi)
+{
+    buffer.resize(buffer.size() + 8, 0);  // reader may over-read up to 8 bytes
+    std::vector<T> values(count);
+    TBitReader reader(buffer.data());
+    InterpolativeDecode(&reader, TMutableRange(values), lo, hi);
+    return values;
+}
+
+template <class T>
+void ExpectRoundTrip(const std::vector<T>& values, ui32 lo, ui32 hi)
+{
+    auto decoded = Decode<T>(Encode(values, lo, hi), std::ssize(values), lo, hi);
+    EXPECT_EQ(decoded, values);
+}
+
+TEST(TInterpolativeCodingTest, Empty)
+{
+    ExpectRoundTrip<ui32>({}, 0, 100);
+}
+
+TEST(TInterpolativeCodingTest, Single)
+{
+    ExpectRoundTrip<ui32>({0}, 0, 0);
+    ExpectRoundTrip<ui32>({42}, 0, 100);
+    ExpectRoundTrip<ui32>({100}, 0, 100);
+}
+
+TEST(TInterpolativeCodingTest, SmallCases)
+{
+    ExpectRoundTrip<ui32>({3, 7}, 0, 10);
+    ExpectRoundTrip<ui32>({0, 1, 2}, 0, 2);          // full, zero bits
+    ExpectRoundTrip<ui32>({0, 5, 10}, 0, 10);        // boundaries present
+    ExpectRoundTrip<ui32>({1, 2, 3, 4, 5}, 0, 6);
+}
+
+TEST(TInterpolativeCodingTest, FullRange)
+{
+    // Every value present => every range collapses to a singleton (zero bits).
+    std::vector<ui32> values(500);
+    std::iota(values.begin(), values.end(), 7);
+    auto encoded = Encode(values, 7, 506);
+    EXPECT_TRUE(encoded.empty());
+    EXPECT_EQ(Decode<ui32>(encoded, 500, 7, 506), values);
+}
+
+TEST(TInterpolativeCodingTest, RandomRoundTrip)
+{
+    std::mt19937 rng(12345);
+    for (int iteration = 0; iteration < 500; ++iteration) {
+        ui32 universe = 1 + rng() % 200'000;
+        int count = std::min<ui32>(universe, 1 + rng() % 2000);
+        std::set<ui32> unique;
+        std::uniform_int_distribution<ui32> dist(0, universe - 1);
+        while (std::ssize(unique) < count) {
+            unique.insert(dist(rng));
+        }
+        std::vector<ui32> values(unique.begin(), unique.end());
+        ExpectRoundTrip<ui32>(values, 0, universe - 1);
+    }
+}
+
+TEST(TInterpolativeCodingTest, NonZeroLowerBound)
+{
+    std::mt19937 rng(999);
+    for (int iteration = 0; iteration < 200; ++iteration) {
+        ui32 lo = rng() % 100'000;
+        ui32 span = 1 + rng() % 100'000;
+        ui32 hi = lo + span;
+        int count = std::min<ui32>(span + 1, 1 + rng() % 500);
+        std::set<ui32> unique;
+        std::uniform_int_distribution<ui32> dist(lo, hi);
+        while (std::ssize(unique) < count) {
+            unique.insert(dist(rng));
+        }
+        std::vector<ui32> values(unique.begin(), unique.end());
+        ExpectRoundTrip<ui32>(values, lo, hi);
+    }
+}
+
+TEST(TInterpolativeCodingTest, Ui64Values)
+{
+    std::vector<ui64> values = {0, 1, 100, 1000, 50'000, 200'000};
+    ExpectRoundTrip<ui64>(values, 0, 200'000);
+}
+
+TEST(TInterpolativeCodingTest, MaxByteSize)
+{
+    std::mt19937 rng(555);
+    for (int iteration = 0; iteration < 300; ++iteration) {
+        ui32 universe = 1 + rng() % 200'000;
+        int count = std::min<ui32>(universe, 1 + rng() % 1000);
+        std::set<ui32> unique;
+        std::uniform_int_distribution<ui32> dist(0, universe - 1);
+        while (std::ssize(unique) < count) {
+            unique.insert(dist(rng));
+        }
+        std::vector<ui32> values(unique.begin(), unique.end());
+
+        size_t bound = GetInterpolativeMaxByteSize(count, 0, universe - 1);
+        std::vector<char> buffer(bound, 0);
+        TBitWriter writer(buffer.data());
+        InterpolativeEncode(&writer, TRange(values), 0, universe - 1);
+        EXPECT_LE(static_cast<size_t>(writer.Finish() - buffer.data()), bound);
+    }
+}
+
+TEST(TInterpolativeCodingTest, MultipleListsInOneBuffer)
+{
+    // Mirrors real usage: each list is prefixed with a varint length and is
+    // byte-aligned, so lists can be concatenated and read back in sequence.
+    std::mt19937 rng(7);
+    ui32 hi = 199999;
+    std::vector<std::vector<ui32>> lists;
+    for (int listIndex = 0; listIndex < 50; ++listIndex) {
+        int count = 1 + rng() % 300;
+        std::set<ui32> unique;
+        std::uniform_int_distribution<ui32> dist(0, hi);
+        while (std::ssize(unique) < count) {
+            unique.insert(dist(rng));
+        }
+        lists.emplace_back(unique.begin(), unique.end());
+    }
+
+    std::vector<char> buffer(200'000, 0);
+    char* ptr = buffer.data();
+    for (const auto& list : lists) {
+        ptr += WriteVarUint32(ptr, static_cast<ui32>(list.size()));
+        TBitWriter writer(ptr);
+        InterpolativeEncode(&writer, TRange(list), 0, hi);
+        ptr = writer.Finish();
+    }
+
+    const char* readPtr = buffer.data();
+    for (const auto& list : lists) {
+        ui32 count;
+        readPtr += ReadVarUint32(readPtr, &count);
+        ASSERT_EQ(count, list.size());
+        std::vector<ui32> decoded(count);
+        TBitReader reader(readPtr);
+        InterpolativeDecode(&reader, TMutableRange(decoded), 0, hi);
+        readPtr = reader.Finish();
+        EXPECT_EQ(decoded, list);
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace
+} // namespace NYT
diff --git a/library/cpp/yt/coding/unittests/varint_ut.cpp b/library/cpp/yt/coding/unittests/varint_ut.cpp
index ed83ab5c92b..3cd695cc1ef 100644
--- a/library/cpp/yt/coding/unittests/varint_ut.cpp
+++ b/library/cpp/yt/coding/unittests/varint_ut.cpp
@@ -15,13 +15,14 @@ using ::testing::Values;
 
 ////////////////////////////////////////////////////////////////////////////////
 
-class TWriteVarIntTest: public ::testing::TestWithParam<std::tuple<ui64, TString> >
+class TWriteVarIntTest
+    : public ::testing::TestWithParam<std::tuple<ui64, std::string>>
 { };
 
 TEST_P(TWriteVarIntTest, Serialization)
 {
     ui64 value = std::get<0>(GetParam());
-    TString rightAnswer = std::get<1>(GetParam());
+    std::string rightAnswer = std::get<1>(GetParam());
 
     TStringStream outputStream;
     WriteVarUint64(&outputStream, value);
@@ -30,13 +31,13 @@ TEST_P(TWriteVarIntTest, Serialization)
 
 ////////////////////////////////////////////////////////////////////////////////
 
-class TReadVarIntTest: public ::testing::TestWithParam<std::tuple<ui64, TString> >
+class TReadVarIntTest: public ::testing::TestWithParam<std::tuple<ui64, std::string> >
 { };
 
 TEST_P(TReadVarIntTest, Serialization)
 {
     ui64 rightAnswer = std::get<0>(GetParam());
-    TString input = std::get<1>(GetParam());
+    auto input = TString(std::get<1>(GetParam()));
 
     TStringInput inputStream(input);
     ui64 value;
@@ -56,34 +57,34 @@ TEST(TReadVarIntTest, Overflow)
 
 auto ValuesForVarIntTests = Values(
     // Simple cases.
-    std::make_tuple(0x0ull,                TString("\x00", 1)),
-    std::make_tuple(0x1ull,                TString("\x01", 1)),
-    std::make_tuple(0x2ull,                TString("\x02", 1)),
-    std::make_tuple(0x3ull,                TString("\x03", 1)),
-    std::make_tuple(0x4ull,                TString("\x04", 1)),
+    std::make_tuple(0x0ull,                std::string("\x00", 1)),
+    std::make_tuple(0x1ull,                std::string("\x01", 1)),
+    std::make_tuple(0x2ull,                std::string("\x02", 1)),
+    std::make_tuple(0x3ull,                std::string("\x03", 1)),
+    std::make_tuple(0x4ull,                std::string("\x04", 1)),
 
     // The following "magic numbers" are critical points for varint encoding.
-    std::make_tuple((1ull << 7) - 1,       TString("\x7f", 1)),
-    std::make_tuple((1ull << 7),           TString("\x80\x01", 2)),
-    std::make_tuple((1ull << 14) - 1,      TString("\xff\x7f", 2)),
-    std::make_tuple((1ull << 14),          TString("\x80\x80\x01", 3)),
-    std::make_tuple((1ull << 21) - 1,      TString("\xff\xff\x7f", 3)),
-    std::make_tuple((1ull << 21),          TString("\x80\x80\x80\x01", 4)),
-    std::make_tuple((1ull << 28) - 1,      TString("\xff\xff\xff\x7f", 4)),
-    std::make_tuple((1ull << 28),          TString("\x80\x80\x80\x80\x01", 5)),
-    std::make_tuple((1ull << 35) - 1,      TString("\xff\xff\xff\xff\x7f", 5)),
-    std::make_tuple((1ull << 35),          TString("\x80\x80\x80\x80\x80\x01", 6)),
-    std::make_tuple((1ull << 42) - 1,      TString("\xff\xff\xff\xff\xff\x7f", 6)),
-    std::make_tuple((1ull << 42),          TString("\x80\x80\x80\x80\x80\x80\x01", 7)),
-    std::make_tuple((1ull << 49) - 1,      TString("\xff\xff\xff\xff\xff\xff\x7f", 7)),
-    std::make_tuple((1ull << 49),          TString("\x80\x80\x80\x80\x80\x80\x80\x01", 8)),
-    std::make_tuple((1ull << 56) - 1,      TString("\xff\xff\xff\xff\xff\xff\xff\x7f", 8)),
-    std::make_tuple((1ull << 56),          TString("\x80\x80\x80\x80\x80\x80\x80\x80\x01", 9)),
-    std::make_tuple((1ull << 63) - 1,      TString("\xff\xff\xff\xff\xff\xff\xff\xff\x7f", 9)),
-    std::make_tuple((1ull << 63),          TString("\x80\x80\x80\x80\x80\x80\x80\x80\x80\x01", 10)),
+    std::make_tuple((1ull << 7) - 1,       std::string("\x7f", 1)),
+    std::make_tuple((1ull << 7),           std::string("\x80\x01", 2)),
+    std::make_tuple((1ull << 14) - 1,      std::string("\xff\x7f", 2)),
+    std::make_tuple((1ull << 14),          std::string("\x80\x80\x01", 3)),
+    std::make_tuple((1ull << 21) - 1,      std::string("\xff\xff\x7f", 3)),
+    std::make_tuple((1ull << 21),          std::string("\x80\x80\x80\x01", 4)),
+    std::make_tuple((1ull << 28) - 1,      std::string("\xff\xff\xff\x7f", 4)),
+    std::make_tuple((1ull << 28),          std::string("\x80\x80\x80\x80\x01", 5)),
+    std::make_tuple((1ull << 35) - 1,      std::string("\xff\xff\xff\xff\x7f", 5)),
+    std::make_tuple((1ull << 35),          std::string("\x80\x80\x80\x80\x80\x01", 6)),
+    std::make_tuple((1ull << 42) - 1,      std::string("\xff\xff\xff\xff\xff\x7f", 6)),
+    std::make_tuple((1ull << 42),          std::string("\x80\x80\x80\x80\x80\x80\x01", 7)),
+    std::make_tuple((1ull << 49) - 1,      std::string("\xff\xff\xff\xff\xff\xff\x7f", 7)),
+    std::make_tuple((1ull << 49),          std::string("\x80\x80\x80\x80\x80\x80\x80\x01", 8)),
+    std::make_tuple((1ull << 56) - 1,      std::string("\xff\xff\xff\xff\xff\xff\xff\x7f", 8)),
+    std::make_tuple((1ull << 56),          std::string("\x80\x80\x80\x80\x80\x80\x80\x80\x01", 9)),
+    std::make_tuple((1ull << 63) - 1,      std::string("\xff\xff\xff\xff\xff\xff\xff\xff\x7f", 9)),
+    std::make_tuple((1ull << 63),          std::string("\x80\x80\x80\x80\x80\x80\x80\x80\x80\x01", 10)),
 
     // Boundary case.
-    std::make_tuple(static_cast<ui64>(-1), TString("\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01", 10))
+    std::make_tuple(static_cast<ui64>(-1), std::string("\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01", 10))
 );
 
 INSTANTIATE_TEST_SUITE_P(ValueParametrized, TWriteVarIntTest,
@@ -112,6 +113,25 @@ TEST(TVarInt32Test, RandomValues)
 
 ////////////////////////////////////////////////////////////////////////////////
 
+TEST(TVarUint32Test, BoundaryValues)
+{
+    // UINT32_MAX encoded as a 5-byte varint: should succeed.
+    const char maxBytes[] = "\xff\xff\xff\xff\x0f";
+    ui32 value = 0;
+    EXPECT_EQ(5, ReadVarUint32(maxBytes, &value));
+    EXPECT_EQ(std::numeric_limits<ui32>::max(), value);
+
+    // 2^32 encoded as a 5-byte varint: should throw.
+    const char overflowBytes[] = "\x80\x80\x80\x80\x10";
+    EXPECT_THROW(ReadVarUint32(overflowBytes, &value), TSimpleException);
+
+    // Max 5-byte varint (2^35 - 1): should throw.
+    const char maxFiveByteBytes[] = "\xff\xff\xff\xff\x7f";
+    EXPECT_THROW(ReadVarUint32(maxFiveByteBytes, &value), TSimpleException);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
 TEST(TVarInt64Test, RandomValues)
 {
     srand(100500); // Set seed
diff --git a/library/cpp/yt/coding/varint-inl.h b/library/cpp/yt/coding/varint-inl.h
index ed0bfc508ce..6b74dd035cf 100644
--- a/library/cpp/yt/coding/varint-inl.h
+++ b/library/cpp/yt/coding/varint-inl.h
@@ -60,38 +60,45 @@ T ReadVarUintKnownSize(const char* buffer)
 
 } // namespace NDetail
 
-#define XX(type, size) \
-    if (static_cast<ui8>(input[size - 1]) < 0x80) { \
+#define READ_VARUINT_STEP(type, size, bound) \
+    if (static_cast<ui8>(input[size - 1]) < (bound)) { \
         *value = NYT::NDetail::ReadVarUintKnownSize<type, size>(input); \
         return size; \
     }
 
+#define READ_VARUINT_STEP7(type, size) \
+    READ_VARUINT_STEP(type, size, 0x80)
+
 Y_FORCE_INLINE int ReadVarUint32(const char* input, ui32* value)
 {
-    XX(ui64, 1)
-    XX(ui64, 2)
-    XX(ui64, 3)
-    XX(ui64, 4)
-    XX(ui64, 5)
+    READ_VARUINT_STEP7(ui64, 1)
+    READ_VARUINT_STEP7(ui64, 2)
+    READ_VARUINT_STEP7(ui64, 3)
+    READ_VARUINT_STEP7(ui64, 4)
+    // A varuint32 fits in at most 5 bytes: bytes 1-4 carry 7 bits each (28 bits),
+    // byte 5 carries the remaining 4 bits, so it must be below 0x10 = 2^4.
+    // Using READ_VARUINT_STEP7 here would silently accept 33-35 bit values.
+    READ_VARUINT_STEP(ui64, 5, 0x10)
     throw TSimpleException("Value is too big for varuint32");
 }
 
 Y_FORCE_INLINE int ReadVarUint64(const char* input, ui64* value)
 {
-    XX(ui64, 1)
-    XX(ui64, 2)
-    XX(ui64, 3)
-    XX(ui64, 4)
-    XX(ui64, 5)
-    XX(ui64, 6)
-    XX(ui64, 7)
-    XX(ui64, 8)
-    XX(ui64, 9)
-    XX(ui64, 10)
+    READ_VARUINT_STEP7(ui64, 1)
+    READ_VARUINT_STEP7(ui64, 2)
+    READ_VARUINT_STEP7(ui64, 3)
+    READ_VARUINT_STEP7(ui64, 4)
+    READ_VARUINT_STEP7(ui64, 5)
+    READ_VARUINT_STEP7(ui64, 6)
+    READ_VARUINT_STEP7(ui64, 7)
+    READ_VARUINT_STEP7(ui64, 8)
+    READ_VARUINT_STEP7(ui64, 9)
+    READ_VARUINT_STEP7(ui64, 10)
     throw TSimpleException("Value is too big for varuint64");
 }
 
-#undef XX
+#undef READ_VARUINT_STEP7
+#undef READ_VARUINT_STEP
 
 ////////////////////////////////////////////////////////////////////////////////
 
diff --git a/library/cpp/yt/coding/zig_zag-inl.h b/library/cpp/yt/coding/zig_zag-inl.h
index c611f7e1d46..9df9a2cc5f4 100644
--- a/library/cpp/yt/coding/zig_zag-inl.h
+++ b/library/cpp/yt/coding/zig_zag-inl.h
@@ -3,7 +3,6 @@
 // For the sake of sane code completion.
 #include "zig_zag.h"
 #endif
-#undef ZIG_ZAG_INL_H_
 
 namespace NYT {
 
diff --git a/library/cpp/yt/compact_containers/compact_flat_map-inl.h b/library/cpp/yt/compact_containers/compact_flat_map-inl.h
new file mode 100644
index 00000000000..87cb9841436
--- /dev/null
+++ b/library/cpp/yt/compact_containers/compact_flat_map-inl.h
@@ -0,0 +1,241 @@
+#ifndef COMPACT_FLAT_MAP_INL_H_
+#error "Direct inclusion of this file is not allowed, include compact_flat_map.h"
+// For the sake of sane code completion.
+#include "compact_flat_map.h"
+#endif
+
+namespace NYT {
+
+///////////////////////////////////////////////////////////////////////////////
+
+template <class TKey, class TValue, size_t N, class TKeyCompare>
+template <class TInputIterator>
+TCompactFlatMap<TKey, TValue, N, TKeyCompare>::TCompactFlatMap(TInputIterator begin, TInputIterator end)
+{
+    insert(begin, end);
+}
+
+template <class TKey, class TValue, size_t N, class TKeyCompare>
+TCompactFlatMap<TKey, TValue, N, TKeyCompare>::TCompactFlatMap(std::initializer_list<value_type> values)
+    : TCompactFlatMap<TKey, TValue, N, TKeyCompare>(values.begin(), values.end())
+{ }
+
+template <class TKey, class TValue, size_t N, class TKeyCompare>
+typename TCompactFlatMap<TKey, TValue, N, TKeyCompare>::iterator TCompactFlatMap<TKey, TValue, N, TKeyCompare>::begin()
+{
+    return Storage_.begin();
+}
+
+template <class TKey, class TValue, size_t N, class TKeyCompare>
+typename TCompactFlatMap<TKey, TValue, N, TKeyCompare>::const_iterator TCompactFlatMap<TKey, TValue, N, TKeyCompare>::begin() const
+{
+    return Storage_.begin();
+}
+
+template <class TKey, class TValue, size_t N, class TKeyCompare>
+typename TCompactFlatMap<TKey, TValue, N, TKeyCompare>::const_iterator TCompactFlatMap<TKey, TValue, N, TKeyCompare>::cbegin() const
+{
+    return Storage_.begin();
+}
+
+template <class TKey, class TValue, size_t N, class TKeyCompare>
+typename TCompactFlatMap<TKey, TValue, N, TKeyCompare>::iterator TCompactFlatMap<TKey, TValue, N, TKeyCompare>::end()
+{
+    return Storage_.end();
+}
+
+template <class TKey, class TValue, size_t N, class TKeyCompare>
+typename TCompactFlatMap<TKey, TValue, N, TKeyCompare>::const_iterator TCompactFlatMap<TKey, TValue, N, TKeyCompare>::end() const
+{
+    return Storage_.end();
+}
+
+template <class TKey, class TValue, size_t N, class TKeyCompare>
+typename TCompactFlatMap<TKey, TValue, N, TKeyCompare>::const_iterator TCompactFlatMap<TKey, TValue, N, TKeyCompare>::cend() const
+{
+    return Storage_.end();
+}
+
+template <class TKey, class TValue, size_t N, class TKeyCompare>
+void TCompactFlatMap<TKey, TValue, N, TKeyCompare>::reserve(size_type n)
+{
+    Storage_.reserve(n);
+}
+
+template <class TKey, class TValue, size_t N, class TKeyCompare>
+typename TCompactFlatMap<TKey, TValue, N, TKeyCompare>::size_type TCompactFlatMap<TKey, TValue, N, TKeyCompare>::size() const
+{
+    return Storage_.size();
+}
+
+template <class TKey, class TValue, size_t N, class TKeyCompare>
+int TCompactFlatMap<TKey, TValue, N, TKeyCompare>::ssize() const
+{
+    return static_cast<int>(Storage_.size());
+}
+
+template <class TKey, class TValue, size_t N, class TKeyCompare>
+bool TCompactFlatMap<TKey, TValue, N, TKeyCompare>::empty() const
+{
+    return Storage_.empty();
+}
+
+template <class TKey, class TValue, size_t N, class TKeyCompare>
+void TCompactFlatMap<TKey, TValue, N, TKeyCompare>::clear()
+{
+    Storage_.clear();
+}
+
+template <class TKey, class TValue, size_t N, class TKeyCompare>
+void TCompactFlatMap<TKey, TValue, N, TKeyCompare>::shrink_to_small()
+{
+    Storage_.shrink_to_small();
+}
+
+template <class TKey, class TValue, size_t N, class TKeyCompare>
+template <NDetail::CComparisonAllowed<TKey, TKeyCompare> TOtherKey>
+typename TCompactFlatMap<TKey, TValue, N, TKeyCompare>::iterator TCompactFlatMap<TKey, TValue, N, TKeyCompare>::find(const TOtherKey& k)
+{
+    auto [rangeBegin, rangeEnd] = equal_range(k);
+    return rangeBegin == rangeEnd ? end() : rangeBegin;
+}
+
+template <class TKey, class TValue, size_t N, class TKeyCompare>
+template <NDetail::CComparisonAllowed<TKey, TKeyCompare> TOtherKey>
+typename TCompactFlatMap<TKey, TValue, N, TKeyCompare>::const_iterator TCompactFlatMap<TKey, TValue, N, TKeyCompare>::find(const TOtherKey& k) const
+{
+    auto [rangeBegin, rangeEnd] = equal_range(k);
+    return rangeBegin == rangeEnd ? end() : rangeBegin;
+}
+
+template <class TKey, class TValue, size_t N, class TKeyCompare>
+template <NDetail::CComparisonAllowed<TKey, TKeyCompare> TOtherKey>
+bool TCompactFlatMap<TKey, TValue, N, TKeyCompare>::contains(const TOtherKey& k) const
+{
+    return find(k) != end();
+}
+
+template <class TKey, class TValue, size_t N, class TKeyCompare>
+auto TCompactFlatMap<TKey, TValue, N, TKeyCompare>::insert(const value_type& value) -> std::pair<iterator, bool>
+{
+    return DoInsert(value);
+}
+
+template <class TKey, class TValue, size_t N, class TKeyCompare>
+auto TCompactFlatMap<TKey, TValue, N, TKeyCompare>::insert(value_type&& value) -> std::pair<iterator, bool>
+{
+    return DoInsert(std::move(value));
+}
+
+template <class TKey, class TValue, size_t N, class TKeyCompare>
+template <class TArg>
+auto TCompactFlatMap<TKey, TValue, N, TKeyCompare>::DoInsert(TArg&& value) -> std::pair<iterator, bool>
+{
+    auto [rangeBegin, rangeEnd] = equal_range(value.first);
+    if (rangeBegin != rangeEnd) {
+        return {rangeBegin, false};
+    } else {
+        auto it = Storage_.insert(rangeBegin, std::forward<TArg>(value));
+        return {it, true};
+    }
+}
+
+template <class TKey, class TValue, size_t N, class TKeyCompare>
+template <class TInputIterator>
+void TCompactFlatMap<TKey, TValue, N, TKeyCompare>::insert(TInputIterator begin, TInputIterator end)
+{
+    for (auto it = begin; it != end; ++it) {
+        insert(*it);
+    }
+}
+
+template <class TKey, class TValue, size_t N, class TKeyCompare>
+template <class... TArgs>
+auto TCompactFlatMap<TKey, TValue, N, TKeyCompare>::emplace(TArgs&&... args) -> std::pair<iterator, bool>
+{
+    return insert(value_type(std::forward<TArgs>(args)...));
+}
+
+template <class TKey, class TValue, size_t N, class TKeyCompare>
+TValue& TCompactFlatMap<TKey, TValue, N, TKeyCompare>::operator[](const TKey& k)
+{
+    auto [it, inserted] = insert({k, TValue()});
+    return it->second;
+}
+
+template <class TKey, class TValue, size_t N, class TKeyCompare>
+void TCompactFlatMap<TKey, TValue, N, TKeyCompare>::erase(const TKey& k)
+{
+    auto [rangeBegin, rangeEnd] = equal_range(k);
+    erase(rangeBegin, rangeEnd);
+}
+
+template <class TKey, class TValue, size_t N, class TKeyCompare>
+void TCompactFlatMap<TKey, TValue, N, TKeyCompare>::erase(iterator pos)
+{
+    Storage_.erase(pos);
+
+    // Try to keep the storage inline. This is why erase doesn't return an iterator.
+    Storage_.shrink_to_small();
+}
+
+template <class TKey, class TValue, size_t N, class TKeyCompare>
+void TCompactFlatMap<TKey, TValue, N, TKeyCompare>::erase(iterator b, iterator e)
+{
+    Storage_.erase(b, e);
+
+    // Try to keep the storage inline. This is why erase doesn't return an iterator.
+    Storage_.shrink_to_small();
+}
+
+template <class TKey, class TValue, size_t N, class TKeyCompare>
+template <NDetail::CComparisonAllowed<TKey, TKeyCompare> TOtherKey>
+std::pair<typename TCompactFlatMap<TKey, TValue, N, TKeyCompare>::iterator, typename TCompactFlatMap<TKey, TValue, N, TKeyCompare>::iterator>
+TCompactFlatMap<TKey, TValue, N, TKeyCompare>::equal_range(const TOtherKey& k)
+{
+    auto result = std::ranges::equal_range(Storage_, k, TKeyCompare{}, &value_type::first);
+    YT_ASSERT(result.size() <= 1);
+    return result;
+}
+
+template <class TKey, class TValue, size_t N, class TKeyCompare>
+template <NDetail::CComparisonAllowed<TKey, TKeyCompare> TOtherKey>
+std::pair<typename TCompactFlatMap<TKey, TValue, N, TKeyCompare>::const_iterator, typename TCompactFlatMap<TKey, TValue, N, TKeyCompare>::const_iterator>
+TCompactFlatMap<TKey, TValue, N, TKeyCompare>::equal_range(const TOtherKey& k) const
+{
+    auto result = std::ranges::equal_range(Storage_, k, TKeyCompare{}, &value_type::first);
+    YT_ASSERT(result.size() <= 1);
+    return result;
+}
+
+template <class TKey, class TValue, size_t N, class TKeyCompare>
+template <NDetail::CComparisonAllowed<TKey, TKeyCompare> TOtherKey>
+typename TCompactFlatMap<TKey, TValue, N, TKeyCompare>::const_iterator TCompactFlatMap<TKey, TValue, N, TKeyCompare>::lower_bound(const TOtherKey& k) const
+{
+    return std::ranges::lower_bound(Storage_, k, TKeyCompare{}, &value_type::first);
+}
+
+template <class TKey, class TValue, size_t N, class TKeyCompare>
+template <NDetail::CComparisonAllowed<TKey, TKeyCompare> TOtherKey>
+typename TCompactFlatMap<TKey, TValue, N, TKeyCompare>::iterator TCompactFlatMap<TKey, TValue, N, TKeyCompare>::lower_bound(const TOtherKey& k)
+{
+    return std::ranges::lower_bound(Storage_, k, TKeyCompare{}, &value_type::first);
+}
+
+template <class TKey, class TValue, size_t N, class TKeyCompare>
+template <NDetail::CComparisonAllowed<TKey, TKeyCompare> TOtherKey>
+typename TCompactFlatMap<TKey, TValue, N, TKeyCompare>::const_iterator TCompactFlatMap<TKey, TValue, N, TKeyCompare>::upper_bound(const TOtherKey& k) const
+{
+    return std::ranges::upper_bound(Storage_, k, TKeyCompare{}, &value_type::first);
+}
+
+template <class TKey, class TValue, size_t N, class TKeyCompare>
+template <NDetail::CComparisonAllowed<TKey, TKeyCompare> TOtherKey>
+typename TCompactFlatMap<TKey, TValue, N, TKeyCompare>::iterator TCompactFlatMap<TKey, TValue, N, TKeyCompare>::upper_bound(const TOtherKey& k)
+{
+    return std::ranges::upper_bound(Storage_, k, TKeyCompare{}, &value_type::first);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace NYT
diff --git a/library/cpp/yt/small_containers/compact_flat_map.h b/library/cpp/yt/compact_containers/compact_flat_map.h
similarity index 55%
rename from library/cpp/yt/small_containers/compact_flat_map.h
rename to library/cpp/yt/compact_containers/compact_flat_map.h
index b598a34731c..b6c8adad93c 100644
--- a/library/cpp/yt/small_containers/compact_flat_map.h
+++ b/library/cpp/yt/compact_containers/compact_flat_map.h
@@ -2,10 +2,26 @@
 
 #include "compact_vector.h"
 
+#include <functional>
+
 namespace NYT {
 
 ///////////////////////////////////////////////////////////////////////////////
 
+namespace NDetail {
+
+template <typename T>
+concept CHasIsTransparentFlag = requires {
+    typename T::is_transparent;
+};
+
+template <typename T, typename U, typename TCompare>
+concept CComparisonAllowed = std::same_as<T, U> || CHasIsTransparentFlag<TCompare>;
+
+} // namespace NDetail
+
+///////////////////////////////////////////////////////////////////////////////
+
 //! A flat map implementation over TCompactVector that tries to keep data inline.
 /*!
  *  Similarly to SmallSet, this is implemented via binary search over a sorted
@@ -21,32 +37,20 @@ namespace NYT {
  *  Because of the latter, one should be very careful with iterators: virtually
  *  any call to insert or erase may potentially invalidate all iterators.
  */
-template <class K, class V, size_t N>
+template <class TKey, class TValue, size_t N, class TKeyCompare = std::ranges::less>
 class TCompactFlatMap
 {
 public:
-    // NB: can't make this pair<const K, V> as TCompactVector requires its type
+    // NB: can't make this pair<const TKey, TValue> as TCompactTValueector requires its type
     // parameter to be copy-assignable.
-    using value_type = std::pair<K, V>;
-    using key_type = K;
-    using mapped_type = V;
+    using value_type = std::pair<TKey, TValue>;
+    using key_type = TKey;
+    using mapped_type = TValue;
+    using key_compare = TKeyCompare;
 
 private:
     using TStorage = TCompactVector<value_type, N>;
 
-    struct TKeyComparer
-    {
-        bool operator()(const K& lhs, const value_type& rhs)
-        {
-            return lhs < rhs.first;
-        }
-
-        bool operator()(const value_type& lhs, const K& rhs)
-        {
-            return lhs.first < rhs;
-        }
-    };
-
 public:
     using iterator = typename TStorage::iterator;
     using const_iterator = typename TStorage::const_iterator;
@@ -59,8 +63,7 @@ class TCompactFlatMap
 
     TCompactFlatMap(std::initializer_list<value_type> values);
 
-    bool operator==(const TCompactFlatMap& rhs) const;
-    bool operator!=(const TCompactFlatMap& rhs) const;
+    bool operator==(const TCompactFlatMap& rhs) const = default;
 
     iterator begin();
     const_iterator begin() const;
@@ -80,17 +83,26 @@ class TCompactFlatMap
 
     void shrink_to_small();
 
-    iterator find(const K& k);
-    const_iterator find(const K& k) const;
-
-    iterator lower_bound(const K& k);
-    const_iterator lower_bound(const K& k) const;
-    iterator upper_bound(const K& k);
-    const_iterator upper_bound(const K& k) const;
-    std::pair<iterator, iterator> equal_range(const K& k);
-    std::pair<const_iterator, const_iterator> equal_range(const K& k) const;
-
-    bool contains(const K& k) const;
+    template <NDetail::CComparisonAllowed<TKey, TKeyCompare> TOtherKey>
+    iterator find(const TOtherKey& k);
+    template <NDetail::CComparisonAllowed<TKey, TKeyCompare> TOtherKey>
+    const_iterator find(const TOtherKey& k) const;
+
+    template <NDetail::CComparisonAllowed<TKey, TKeyCompare> TOtherKey>
+    iterator lower_bound(const TOtherKey& k);
+    template <NDetail::CComparisonAllowed<TKey, TKeyCompare> TOtherKey>
+    const_iterator lower_bound(const TOtherKey& k) const;
+    template <NDetail::CComparisonAllowed<TKey, TKeyCompare> TOtherKey>
+    iterator upper_bound(const TOtherKey& k);
+    template <NDetail::CComparisonAllowed<TKey, TKeyCompare> TOtherKey>
+    const_iterator upper_bound(const TOtherKey& k) const;
+    template <NDetail::CComparisonAllowed<TKey, TKeyCompare> TOtherKey>
+    std::pair<iterator, iterator> equal_range(const TOtherKey& k);
+    template <NDetail::CComparisonAllowed<TKey, TKeyCompare> TOtherKey>
+    std::pair<const_iterator, const_iterator> equal_range(const TOtherKey& k) const;
+
+    template <NDetail::CComparisonAllowed<TKey, TKeyCompare> TOtherKey>
+    bool contains(const TOtherKey& k) const;
 
     std::pair<iterator, bool> insert(const value_type& value);
     std::pair<iterator, bool> insert(value_type&& value);
@@ -101,9 +113,9 @@ class TCompactFlatMap
     template <class... TArgs>
     std::pair<iterator, bool> emplace(TArgs&&... args);
 
-    V& operator[](const K& k);
+    TValue& operator[](const TKey& k);
 
-    void erase(const K& k);
+    void erase(const TKey& k);
     void erase(iterator pos);
     void erase(iterator b, iterator e);
 
@@ -111,7 +123,7 @@ class TCompactFlatMap
     TStorage Storage_;
 
     template <class TArg>
-    std::pair<iterator, bool> do_insert(TArg&& value);
+    std::pair<iterator, bool> DoInsert(TArg&& value);
 };
 
 ////////////////////////////////////////////////////////////////////////////////
diff --git a/library/cpp/yt/compact_containers/compact_flat_set-inl.h b/library/cpp/yt/compact_containers/compact_flat_set-inl.h
new file mode 100644
index 00000000000..07f7d5fae10
--- /dev/null
+++ b/library/cpp/yt/compact_containers/compact_flat_set-inl.h
@@ -0,0 +1,251 @@
+#ifndef COMPACT_FLAT_SET_INL_H_
+#error "Direct inclusion of this file is not allowed, include compact_flat_set.h"
+// For the sake of sane code completion.
+#include "compact_flat_set.h"
+#endif
+
+namespace NYT {
+
+///////////////////////////////////////////////////////////////////////////////
+
+template <class TValue, size_t N>
+template <class TInputIterator>
+TCompactFlatSet<TValue, N>::TCompactFlatSet(TInputIterator begin, TInputIterator end)
+{
+    insert(begin, end);
+}
+
+template <class TValue, size_t N>
+TCompactFlatSet<TValue, N>::TCompactFlatSet(std::initializer_list<TValue> values)
+    : TCompactFlatSet<TValue, N>(values.begin(), values.end())
+{ }
+
+template <class TValue, size_t N>
+typename TCompactFlatSet<TValue, N>::iterator TCompactFlatSet<TValue, N>::begin()
+{
+    return Storage_.begin();
+}
+
+template <class TValue, size_t N>
+typename TCompactFlatSet<TValue, N>::const_iterator TCompactFlatSet<TValue, N>::begin() const
+{
+    return Storage_.begin();
+}
+
+template <class TValue, size_t N>
+typename TCompactFlatSet<TValue, N>::const_iterator TCompactFlatSet<TValue, N>::cbegin() const
+{
+    return Storage_.begin();
+}
+
+template <class TValue, size_t N>
+typename TCompactFlatSet<TValue, N>::iterator TCompactFlatSet<TValue, N>::end()
+{
+    return Storage_.end();
+}
+
+template <class TValue, size_t N>
+typename TCompactFlatSet<TValue, N>::const_iterator TCompactFlatSet<TValue, N>::end() const
+{
+    return Storage_.end();
+}
+
+template <class TValue, size_t N>
+typename TCompactFlatSet<TValue, N>::const_iterator TCompactFlatSet<TValue, N>::cend() const
+{
+    return Storage_.end();
+}
+
+template <class TValue, size_t N>
+typename TCompactFlatSet<TValue, N>::reverse_iterator TCompactFlatSet<TValue, N>::rbegin()
+{
+    return Storage_.rbegin();
+}
+
+template <class TValue, size_t N>
+typename TCompactFlatSet<TValue, N>::const_reverse_iterator TCompactFlatSet<TValue, N>::rbegin() const
+{
+    return Storage_.rbegin();
+}
+
+template <class TValue, size_t N>
+typename TCompactFlatSet<TValue, N>::reverse_iterator TCompactFlatSet<TValue, N>::rend()
+{
+    return Storage_.rend();
+}
+
+template <class TValue, size_t N>
+typename TCompactFlatSet<TValue, N>::const_reverse_iterator TCompactFlatSet<TValue, N>::rend() const
+{
+    return Storage_.rend();
+}
+
+template <class TValue, size_t N>
+void TCompactFlatSet<TValue, N>::reserve(size_type size)
+{
+    Storage_.reserve(size);
+}
+
+template <class TValue, size_t N>
+typename TCompactFlatSet<TValue, N>::size_type TCompactFlatSet<TValue, N>::size() const
+{
+    return Storage_.size();
+}
+
+template <class TValue, size_t N>
+int TCompactFlatSet<TValue, N>::ssize() const
+{
+    return static_cast<int>(Storage_.size());
+}
+
+template <class TValue, size_t N>
+bool TCompactFlatSet<TValue, N>::empty() const
+{
+    return Storage_.empty();
+}
+
+template <class TValue, size_t N>
+void TCompactFlatSet<TValue, N>::clear()
+{
+    Storage_.clear();
+}
+
+template <class TValue, size_t N>
+void TCompactFlatSet<TValue, N>::shrink_to_small()
+{
+    Storage_.shrink_to_small();
+}
+
+template <class TValue, size_t N>
+typename TCompactFlatSet<TValue, N>::iterator TCompactFlatSet<TValue, N>::find(const TValue& value)
+{
+    auto [rangeBegin, rangeEnd] = equal_range(value);
+    return rangeBegin == rangeEnd ? end() : rangeBegin;
+}
+
+template <class TValue, size_t N>
+typename TCompactFlatSet<TValue, N>::const_iterator TCompactFlatSet<TValue, N>::find(const TValue& value) const
+{
+    auto [rangeBegin, rangeEnd] = equal_range(value);
+    return rangeBegin == rangeEnd ? end() : rangeBegin;
+}
+
+template <class TValue, size_t N>
+typename TCompactFlatSet<TValue, N>::size_type TCompactFlatSet<TValue, N>::count(const TValue& value) const
+{
+    auto [rangeBegin, rangeEnd] = equal_range(value);
+    return rangeEnd - rangeBegin;
+}
+
+
+template <class TValue, size_t N>
+typename TCompactFlatSet<TValue, N>::const_iterator TCompactFlatSet<TValue, N>::lower_bound(const TValue& value) const
+{
+    return std::ranges::lower_bound(Storage_, value);
+}
+
+template <class TValue, size_t N>
+typename TCompactFlatSet<TValue, N>::iterator TCompactFlatSet<TValue, N>::lower_bound(const TValue& value)
+{
+    return std::ranges::lower_bound(Storage_, value);
+}
+
+template <class TValue, size_t N>
+typename TCompactFlatSet<TValue, N>::const_iterator TCompactFlatSet<TValue, N>::upper_bound(const TValue& value) const
+{
+    return std::ranges::upper_bound(Storage_, value);
+}
+
+template <class TValue, size_t N>
+typename TCompactFlatSet<TValue, N>::iterator TCompactFlatSet<TValue, N>::upper_bound(const TValue& value)
+{
+    return std::ranges::upper_bound(Storage_, value);
+}
+
+template <class TValue, size_t N>
+std::pair<typename TCompactFlatSet<TValue, N>::iterator, typename TCompactFlatSet<TValue, N>::iterator>
+TCompactFlatSet<TValue, N>::equal_range(const TValue& value)
+{
+    auto result = std::ranges::equal_range(Storage_.begin(), Storage_.end(), value);
+    YT_ASSERT(result.size() <= 1);
+    return result;
+}
+
+template <class TValue, size_t N>
+std::pair<typename TCompactFlatSet<TValue, N>::const_iterator, typename TCompactFlatSet<TValue, N>::const_iterator>
+TCompactFlatSet<TValue, N>::equal_range(const TValue& value) const
+{
+    auto result = std::ranges::equal_range(Storage_.begin(), Storage_.end(), value);
+    YT_ASSERT(result.size() <= 1);
+    return result;
+}
+
+template <class TValue, size_t N>
+bool TCompactFlatSet<TValue, N>::contains(const TValue& value) const
+{
+    return find(value) != end();
+}
+
+template <class TValue, size_t N>
+auto TCompactFlatSet<TValue, N>::insert(const TValue& value) -> std::pair<iterator, bool>
+{
+    return DoInsert(value);
+}
+
+template <class TValue, size_t N>
+auto TCompactFlatSet<TValue, N>::insert(TValue&& value) -> std::pair<iterator, bool>
+{
+    return DoInsert(std::move(value));
+}
+
+template <class TValue, size_t N>
+template <class TInputIterator>
+void TCompactFlatSet<TValue, N>::insert(TInputIterator begin, TInputIterator end)
+{
+    for (auto it = begin; it != end; ++it) {
+        insert(*it);
+    }
+}
+
+template <class TValue, size_t N>
+bool TCompactFlatSet<TValue, N>::erase(const TValue& value)
+{
+    auto [rangeBegin, rangeEnd] = equal_range(value);
+    erase(rangeBegin, rangeEnd);
+    return rangeBegin != rangeEnd;
+}
+
+template <class TValue, size_t N>
+void TCompactFlatSet<TValue, N>::erase(iterator pos)
+{
+    Storage_.erase(pos);
+
+    // Try to keep the storage inline. This is why erase doesn't return an iterator.
+    Storage_.shrink_to_small();
+}
+
+template <class TValue, size_t N>
+void TCompactFlatSet<TValue, N>::erase(iterator begin, iterator end)
+{
+    Storage_.erase(begin, end);
+
+    // Try to keep the storage inline. This is why erase doesn't return an iterator.
+    Storage_.shrink_to_small();
+}
+
+template <class TValue, size_t N>
+template <class TArg>
+auto TCompactFlatSet<TValue, N>::DoInsert(TArg&& value) -> std::pair<iterator, bool>
+{
+    auto [rangeBegin, rangeEnd] = equal_range(value);
+    if (rangeBegin != rangeEnd) {
+        return {rangeBegin, false};
+    } else {
+        auto it = Storage_.insert(rangeBegin, std::forward<TArg>(value));
+        return {it, true};
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace NYT
diff --git a/library/cpp/yt/compact_containers/compact_flat_set.h b/library/cpp/yt/compact_containers/compact_flat_set.h
new file mode 100644
index 00000000000..26463d94f00
--- /dev/null
+++ b/library/cpp/yt/compact_containers/compact_flat_set.h
@@ -0,0 +1,111 @@
+#pragma once
+
+#include "compact_vector.h"
+
+namespace NYT {
+
+///////////////////////////////////////////////////////////////////////////////
+
+//! A flat set implementation over TCompactVector that tries to keep data inline.
+/*!
+ *  Similarly to TCompactSet, this is implemented via binary search over a sorted
+ *  vector. Unlike TCompactSet, however, this one never falls back to std::map (or
+ *  set) for larger sizes. This means that the flat set is only useful
+ *    - at small sizes, when there's absolutely no chance of it getting big, or
+ *    - when it's filled once and is then only read from.
+ *
+ *  In return, the flat set provides
+ *    - a smaller size overhead and
+ *    - a guarantee that if data fits into inline storage, it goes there.
+ *
+ *  Because of the latter, one should be very careful with iterators: virtually
+ *  any call to insert or erase may potentially invalidate all iterators.
+ */
+template <class TValue, size_t N>
+class TCompactFlatSet
+{
+private:
+    using TStorage = TCompactVector<TValue, N>;
+
+public:
+    using iterator = typename TStorage::iterator;
+    using const_iterator = typename TStorage::const_iterator;
+
+    using const_reverse_iterator = typename TStorage::const_reverse_iterator;
+    using reverse_iterator = typename TStorage::reverse_iterator;
+
+    using size_type = std::size_t;
+    using key_type = TValue;
+    using value_type = TValue;
+
+    TCompactFlatSet() = default;
+
+    template <class TInputIterator>
+    TCompactFlatSet(TInputIterator begin, TInputIterator end);
+
+    TCompactFlatSet(std::initializer_list<TValue> values);
+
+    bool operator==(const TCompactFlatSet& rhs) const = default;
+
+    iterator begin();
+    const_iterator begin() const;
+    const_iterator cbegin() const;
+
+    iterator end();
+    const_iterator end() const;
+    const_iterator cend() const;
+
+    reverse_iterator rbegin();
+    const_reverse_iterator rbegin() const;
+
+    reverse_iterator rend();
+    const_reverse_iterator rend() const;
+
+    void reserve(size_type size);
+
+    size_type size() const;
+    int ssize() const;
+
+    [[nodiscard]] bool empty() const;
+    void clear();
+
+    void shrink_to_small();
+
+    iterator find(const TValue& value);
+    const_iterator find(const TValue& value) const;
+
+    size_type count(const TValue& value) const;
+
+    iterator lower_bound(const TValue& value);
+    const_iterator lower_bound(const TValue& value) const;
+    iterator upper_bound(const TValue& value);
+    const_iterator upper_bound(const TValue& value) const;
+    std::pair<iterator, iterator> equal_range(const TValue& value);
+    std::pair<const_iterator, const_iterator> equal_range(const TValue& value) const;
+
+    bool contains(const TValue& value) const;
+
+    std::pair<iterator, bool> insert(const TValue& value);
+    std::pair<iterator, bool> insert(TValue&& value);
+
+    template <class TInputIterator>
+    void insert(TInputIterator begin, TInputIterator end);
+
+    bool erase(const TValue& value);
+    void erase(iterator pos);
+    void erase(iterator begin, iterator end);
+
+private:
+    TStorage Storage_;
+
+    template <class TArg>
+    std::pair<iterator, bool> DoInsert(TArg&& value);
+};
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace NYT
+
+#define COMPACT_FLAT_SET_INL_H_
+#include "compact_flat_set-inl.h"
+#undef COMPACT_FLAT_SET_INL_H_
diff --git a/library/cpp/yt/small_containers/compact_heap-inl.h b/library/cpp/yt/compact_containers/compact_heap-inl.h
similarity index 100%
rename from library/cpp/yt/small_containers/compact_heap-inl.h
rename to library/cpp/yt/compact_containers/compact_heap-inl.h
diff --git a/library/cpp/yt/small_containers/compact_heap.h b/library/cpp/yt/compact_containers/compact_heap.h
similarity index 100%
rename from library/cpp/yt/small_containers/compact_heap.h
rename to library/cpp/yt/compact_containers/compact_heap.h
diff --git a/library/cpp/yt/small_containers/compact_queue-inl.h b/library/cpp/yt/compact_containers/compact_queue-inl.h
similarity index 100%
rename from library/cpp/yt/small_containers/compact_queue-inl.h
rename to library/cpp/yt/compact_containers/compact_queue-inl.h
diff --git a/library/cpp/yt/small_containers/compact_queue.h b/library/cpp/yt/compact_containers/compact_queue.h
similarity index 100%
rename from library/cpp/yt/small_containers/compact_queue.h
rename to library/cpp/yt/compact_containers/compact_queue.h
diff --git a/library/cpp/yt/small_containers/compact_set-inl.h b/library/cpp/yt/compact_containers/compact_set-inl.h
similarity index 86%
rename from library/cpp/yt/small_containers/compact_set-inl.h
rename to library/cpp/yt/compact_containers/compact_set-inl.h
index e93d11f126f..048dfa696ab 100644
--- a/library/cpp/yt/small_containers/compact_set-inl.h
+++ b/library/cpp/yt/compact_containers/compact_set-inl.h
@@ -35,7 +35,7 @@ class TCompactSet<T, N, C, A>::const_iterator
     { }
 
     template <typename TOther>
-    void ConstructFrom(TOther&& rhs)
+    void ConstructFrom(TOther&& rhs) noexcept
     {
         YT_ASSERT(Small == rhs.Small);
 
@@ -47,7 +47,7 @@ class TCompactSet<T, N, C, A>::const_iterator
     }
 
     template <typename TOther>
-    const_iterator& AssignFrom(TOther&& rhs)
+    const_iterator& AssignFrom(TOther&& rhs) noexcept
     {
         if (this == &rhs) {
             return *this;
@@ -102,7 +102,7 @@ class TCompactSet<T, N, C, A>::const_iterator
         ConstructFrom(rhs);
     }
 
-    const_iterator(const_iterator&& rhs)
+    const_iterator(const_iterator&& rhs) noexcept
         : Small(rhs.Small)
     {
         ConstructFrom(std::move(rhs));
@@ -122,7 +122,7 @@ class TCompactSet<T, N, C, A>::const_iterator
         return AssignFrom(rhs);
     }
 
-    const_iterator& operator=(const_iterator&& rhs)
+    const_iterator& operator=(const_iterator&& rhs) noexcept
     {
         return AssignFrom(std::move(rhs));
     }
@@ -207,6 +207,34 @@ TCompactSet<T, N, C, A>::TCompactSet(const A& allocator)
     : Set_(allocator)
 { }
 
+template <typename T, size_t N,  typename C, typename A>
+template <typename TIterator>
+TCompactSet<T, N, C, A>::TCompactSet(TIterator first, TIterator last)
+{
+    insert(first, last);
+}
+
+template <typename T, size_t N,  typename C, typename A>
+TCompactSet<T, N, C, A>::TCompactSet(std::initializer_list<key_type> values)
+{
+    insert(values.begin(), values.end());
+}
+
+template <typename T, size_t N,  typename C, typename A>
+bool TCompactSet<T, N, C, A>::operator==(const TCompactSet& rhs) const
+{
+    if (size() != rhs.size()) {
+        return false;
+    }
+
+    for (const auto& value : *this) {
+        if (!rhs.contains(value)) {
+            return false;
+        }
+    }
+    return true;
+}
+
 template <typename T, size_t N,  typename C, typename A>
 bool TCompactSet<T, N, C, A>::empty() const
 {
@@ -216,19 +244,19 @@ bool TCompactSet<T, N, C, A>::empty() const
 template <typename T, size_t N,  typename C, typename A>
 typename TCompactSet<T, N, C, A>::size_type TCompactSet<T, N, C, A>::size() const
 {
-    return is_small() ? Vector_.size() : Set_.size();
+    return IsSmall() ? Vector_.size() : Set_.size();
 }
 
 template <typename T, size_t N,  typename C, typename A>
 const T& TCompactSet<T, N, C, A>::front() const
 {
-    return is_small() ? Vector_.front() : *Set_.begin();
+    return IsSmall() ? Vector_.front() : *Set_.begin();
 }
 
 template <typename T, size_t N,  typename C, typename A>
 typename TCompactSet<T, N, C, A>::size_type TCompactSet<T, N, C, A>::count(const T& v) const
 {
-    if (is_small()) {
+    if (IsSmall()) {
         return std::binary_search(Vector_.begin(), Vector_.end(), v, C()) ? 1 : 0;
     } else {
         return Set_.count(v);
@@ -244,7 +272,7 @@ bool TCompactSet<T, N, C, A>::contains(const T& v) const
 template <typename T, size_t N,  typename C, typename A>
 std::pair<typename TCompactSet<T, N, C, A>::const_iterator, bool> TCompactSet<T, N, C, A>::insert(const T& v)
 {
-    if (!is_small()) {
+    if (!IsSmall()) {
         auto [it, inserted] = Set_.insert(v);
         return {const_iterator(std::move(it)), inserted};
     }
@@ -279,7 +307,7 @@ void TCompactSet<T, N, C, A>::insert(TIter i, TIter e)
 template <typename T, size_t N,  typename C, typename A>
 bool TCompactSet<T, N, C, A>::erase(const T& v)
 {
-    if (!is_small()) {
+    if (!IsSmall()) {
         return Set_.erase(v);
     }
 
@@ -302,7 +330,7 @@ void TCompactSet<T, N, C, A>::clear()
 template <typename T, size_t N,  typename C, typename A>
 typename TCompactSet<T, N, C, A>::const_iterator TCompactSet<T, N, C, A>::begin() const
 {
-    return is_small() ? const_iterator(Vector_.begin()) : const_iterator(Set_.begin());
+    return IsSmall() ? const_iterator(Vector_.begin()) : const_iterator(Set_.begin());
 }
 
 template <typename T, size_t N,  typename C, typename A>
@@ -314,7 +342,7 @@ typename TCompactSet<T, N, C, A>::const_iterator TCompactSet<T, N, C, A>::cbegin
 template <typename T, size_t N,  typename C, typename A>
 typename TCompactSet<T, N, C, A>::const_iterator TCompactSet<T, N, C, A>::end() const
 {
-    return is_small() ? const_iterator(Vector_.end()) : const_iterator(Set_.end());
+    return IsSmall() ? const_iterator(Vector_.end()) : const_iterator(Set_.end());
 }
 
 template <typename T, size_t N,  typename C, typename A>
@@ -324,7 +352,7 @@ typename TCompactSet<T, N, C, A>::const_iterator TCompactSet<T, N, C, A>::cend()
 }
 
 template <typename T, size_t N,  typename C, typename A>
-bool TCompactSet<T, N, C, A>::is_small() const
+bool TCompactSet<T, N, C, A>::IsSmall() const
 {
     return Set_.empty();
 }
diff --git a/library/cpp/yt/small_containers/compact_set.h b/library/cpp/yt/compact_containers/compact_set.h
similarity index 82%
rename from library/cpp/yt/small_containers/compact_set.h
rename to library/cpp/yt/compact_containers/compact_set.h
index ca5e3c6efd7..ce89bfb66ae 100644
--- a/library/cpp/yt/small_containers/compact_set.h
+++ b/library/cpp/yt/compact_containers/compact_set.h
@@ -41,26 +41,33 @@ class TCompactSet
     class const_iterator;
     using size_type = std::size_t;
     using key_type = T;
+    using value_type = T;
 
     TCompactSet() = default;
     TCompactSet(const A& allocator);
 
+    template <class TIterator>
+    TCompactSet(TIterator first, TIterator last);
+    TCompactSet(std::initializer_list<key_type> values);
+
+    bool operator==(const TCompactSet& rhs) const;
+
     [[nodiscard]] bool empty() const;
 
     size_type size() const;
 
     const T& front() const;
 
-    size_type count(const T& v) const;
+    size_type count(const T& value) const;
 
-    bool contains(const T& v) const;
+    bool contains(const T& value) const;
 
-    std::pair<const_iterator, bool> insert(const T& v);
+    std::pair<const_iterator, bool> insert(const T& value);
 
     template <typename TIter>
-    void insert(TIter i, TIter e);
+    void insert(TIter first, TIter last);
 
-    bool erase(const T& v);
+    bool erase(const T& value);
 
     void clear();
 
@@ -80,7 +87,7 @@ class TCompactSet
     using TSetConstIterator = typename std::set<T, C, A>::const_iterator;
     using TVectorConstIterator = typename TCompactVector<T, N>::const_iterator;
 
-    bool is_small() const;
+    bool IsSmall() const;
 };
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -90,4 +97,3 @@ class TCompactSet
 #define COMPACT_SET_INL_H_
 #include "compact_set-inl.h"
 #undef COMPACT_SET_INL_H_
-
diff --git a/library/cpp/yt/small_containers/compact_vector-inl.h b/library/cpp/yt/compact_containers/compact_vector-inl.h
similarity index 99%
rename from library/cpp/yt/small_containers/compact_vector-inl.h
rename to library/cpp/yt/compact_containers/compact_vector-inl.h
index 3bb9576d3ea..1070e6b1c91 100644
--- a/library/cpp/yt/small_containers/compact_vector-inl.h
+++ b/library/cpp/yt/compact_containers/compact_vector-inl.h
@@ -3,7 +3,6 @@
 // For the sake of sane code completion.
 #include "compact_vector.h"
 #endif
-#undef COMPACT_VECTOR_INL_H_
 
 #include <library/cpp/yt/assert/assert.h>
 
@@ -73,7 +72,8 @@ class TCompactVectorReallocationPtrAdjuster<TVector, std::nullptr_t>
 ////////////////////////////////////////////////////////////////////////////////
 
 template <class T, size_t N>
-TCompactVector<T, N>::TCompactVector() noexcept
+constexpr TCompactVector<T, N>::TCompactVector() noexcept
+    : InlineMeta_{}
 {
     InlineMeta_.SizePlusOne = 1;
 }
@@ -595,7 +595,7 @@ auto TCompactVector<T, N>::operator=(const TCompactVector<T, OtherN>& other) ->
 }
 
 template <class T, size_t N>
-auto TCompactVector<T, N>::operator=(TCompactVector&& other) -> TCompactVector&
+auto TCompactVector<T, N>::operator=(TCompactVector&& other) noexcept -> TCompactVector&
 {
     assign(std::move(other));
     return *this;
diff --git a/library/cpp/yt/small_containers/compact_vector.h b/library/cpp/yt/compact_containers/compact_vector.h
similarity index 98%
rename from library/cpp/yt/small_containers/compact_vector.h
rename to library/cpp/yt/compact_containers/compact_vector.h
index 23a0ac3fd01..77311c89f9e 100644
--- a/library/cpp/yt/small_containers/compact_vector.h
+++ b/library/cpp/yt/compact_containers/compact_vector.h
@@ -56,7 +56,7 @@ class TCompactVector
     using pointer = T*;
     using const_pointer = const T*;
 
-    TCompactVector() noexcept;
+    constexpr TCompactVector() noexcept;
     TCompactVector(const TCompactVector& other);
     template <size_t OtherN>
     TCompactVector(const TCompactVector<T, OtherN>& other);
@@ -69,7 +69,7 @@ class TCompactVector
     TCompactVector(TIterator first, TIterator last);
     TCompactVector(std::initializer_list<T> list);
 
-     ~TCompactVector();
+    ~TCompactVector();
 
     [[nodiscard]] bool empty() const;
 
@@ -132,7 +132,7 @@ class TCompactVector
     TCompactVector& operator=(const TCompactVector& other);
     template <size_t OtherN>
     TCompactVector& operator=(const TCompactVector<T, OtherN>& other);
-    TCompactVector& operator=(TCompactVector&& other);
+    TCompactVector& operator=(TCompactVector&& other) noexcept;
     template <size_t OtherN>
     TCompactVector& operator=(TCompactVector<T, OtherN>&& other);
     TCompactVector& operator=(std::initializer_list<T> list);
diff --git a/library/cpp/yt/small_containers/unittests/compact_flat_map_ut.cpp b/library/cpp/yt/compact_containers/unittests/compact_flat_map_ut.cpp
similarity index 99%
rename from library/cpp/yt/small_containers/unittests/compact_flat_map_ut.cpp
rename to library/cpp/yt/compact_containers/unittests/compact_flat_map_ut.cpp
index c4b3508652e..9683d2a267f 100644
--- a/library/cpp/yt/small_containers/unittests/compact_flat_map_ut.cpp
+++ b/library/cpp/yt/compact_containers/unittests/compact_flat_map_ut.cpp
@@ -1,4 +1,4 @@
-#include <library/cpp/yt/small_containers/compact_flat_map.h>
+#include <library/cpp/yt/compact_containers/compact_flat_map.h>
 
 #include <library/cpp/testing/gtest/gtest.h>
 
diff --git a/library/cpp/yt/compact_containers/unittests/compact_flat_set_ut.cpp b/library/cpp/yt/compact_containers/unittests/compact_flat_set_ut.cpp
new file mode 100644
index 00000000000..25149017bd9
--- /dev/null
+++ b/library/cpp/yt/compact_containers/unittests/compact_flat_set_ut.cpp
@@ -0,0 +1,333 @@
+//===- llvm/unittest/ADT/SmallSetTest.cpp ---------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+//
+// CompactFlatSet unit tests.
+//
+//===----------------------------------------------------------------------===//
+
+#include <library/cpp/testing/gtest/gtest.h>
+
+#include <library/cpp/yt/compact_containers/compact_flat_set.h>
+
+#include <string>
+
+namespace NYT {
+namespace {
+
+////////////////////////////////////////////////////////////////////////////////
+
+TEST(TCompactFlatSetTest, Insert)
+{
+    TCompactFlatSet<int, 4> s1;
+
+    for (int i = 0; i < 4; i++)
+        s1.insert(i);
+
+    for (int i = 0; i < 4; i++)
+        s1.insert(i);
+
+    EXPECT_EQ(4u, s1.size());
+
+    for (int i = 0; i < 4; i++)
+        EXPECT_EQ(1u, s1.count(i));
+
+    EXPECT_EQ(0u, s1.count(4));
+}
+
+TEST(TCompactFlatSetTest, Grow)
+{
+    TCompactFlatSet<int, 4> s1;
+
+    for (int i = 0; i < 8; i++)
+        s1.insert(i);
+
+    EXPECT_EQ(8u, s1.size());
+
+    for (int i = 0; i < 8; i++)
+        EXPECT_EQ(1u, s1.count(i));
+
+    EXPECT_EQ(0u, s1.count(8));
+}
+
+TEST(TCompactFlatSetTest, Erase)
+{
+    TCompactFlatSet<int, 4> s1;
+
+    for (int i = 0; i < 8; i++)
+        s1.insert(i);
+
+    EXPECT_EQ(8u, s1.size());
+
+    // Remove elements one by one and check if all other elements are still there.
+    for (int i = 0; i < 8; i++) {
+        EXPECT_EQ(1u, s1.count(i));
+        EXPECT_TRUE(s1.erase(i));
+        EXPECT_EQ(0u, s1.count(i));
+        EXPECT_EQ(8u - i - 1, s1.size());
+        for (int j = i + 1; j < 8; j++)
+            EXPECT_EQ(1u, s1.count(j));
+    }
+
+    EXPECT_EQ(0u, s1.count(8));
+}
+
+TEST(TCompactFlatSetTest, IteratorInt)
+{
+    TCompactFlatSet<int, 4> s1;
+
+    // Test the 'small' case.
+    for (int i = 0; i < 3; i++)
+        s1.insert(i);
+
+    std::vector<int> V(s1.begin(), s1.end());
+    // Make sure the elements are in the expected order.
+    std::sort(V.begin(), V.end());
+    for (int i = 0; i < 3; i++)
+        EXPECT_EQ(i, V[i]);
+
+    // Test the 'big' case by adding a few more elements to switch to std::set
+    // internally.
+    for (int i = 3; i < 6; i++)
+        s1.insert(i);
+
+    V.assign(s1.begin(), s1.end());
+    // Make sure the elements are in the expected order.
+    std::sort(V.begin(), V.end());
+    for (int i = 0; i < 6; i++)
+        EXPECT_EQ(i, V[i]);
+}
+
+TEST(TCompactFlatSetTest, IteratorString)
+{
+    // Test CompactSetIterator for TCompactFlatSet with a type with non-trivial
+    // ctors/dtors.
+    TCompactFlatSet<std::string, 2> s1;
+
+    s1.insert("str 1");
+    s1.insert("str 2");
+    s1.insert("str 1");
+
+    std::vector<std::string> V(s1.begin(), s1.end());
+    std::sort(V.begin(), V.end());
+    EXPECT_EQ(2u, s1.size());
+    EXPECT_EQ("str 1", V[0]);
+    EXPECT_EQ("str 2", V[1]);
+
+    s1.insert("str 4");
+    s1.insert("str 0");
+    s1.insert("str 4");
+
+    V.assign(s1.begin(), s1.end());
+    // Make sure the elements are in the expected order.
+    std::sort(V.begin(), V.end());
+    EXPECT_EQ(4u, s1.size());
+    EXPECT_EQ("str 0", V[0]);
+    EXPECT_EQ("str 1", V[1]);
+    EXPECT_EQ("str 2", V[2]);
+    EXPECT_EQ("str 4", V[3]);
+}
+
+TEST(TCompactFlatSetTest, IteratorIncMoveCopy)
+{
+    // Test CompactSetIterator for TCompactFlatSet with a type with non-trivial
+    // ctors/dtors.
+    TCompactFlatSet<std::string, 2> s1;
+
+    s1.insert("str 1");
+    s1.insert("str 2");
+
+    auto Iter = s1.begin();
+    EXPECT_EQ("str 1", *Iter);
+    ++Iter;
+    EXPECT_EQ("str 2", *Iter);
+
+    s1.insert("str 4");
+    s1.insert("str 0");
+    auto Iter2 = s1.begin();
+    Iter = std::move(Iter2);
+    EXPECT_EQ("str 0", *Iter);
+}
+
+// These test weren't taken from llvm.
+
+TEST(TCompactFlatSetTest, Empty)
+{
+    TCompactFlatSet<int, 10> v;
+    EXPECT_TRUE(v.empty());
+
+    auto data = {1, 2, 3, 4, 5};
+
+    v.insert(data.begin(), data.end()); // not crossing size threshold
+    v.erase(4);
+    v.erase(2);
+    v.erase(3);
+    v.erase(5);
+    v.erase(1);
+    EXPECT_TRUE(v.empty());
+
+    auto data2 = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+    v.insert(data2.begin(), data2.end()); // crossing size threshold
+    v.erase(7);
+    v.erase(3);
+    v.erase(1);
+    v.erase(10);
+    v.erase(9);
+    v.erase(0);
+    v.erase(2);
+    v.erase(6);
+    v.erase(4);
+    v.erase(5);
+    v.erase(8);
+    EXPECT_TRUE(v.empty());
+}
+
+TEST(TCompactFlatSetTest, InsertRange)
+{
+    TCompactFlatSet<int, 10> v;
+
+    auto data = {10, 9, 3, 4, 1, 5, 6, 8};
+
+    v.insert(data.begin(), data.end());
+
+    std::vector<int> buf(v.begin(), v.end());
+    std::vector<int> expected{1, 3, 4, 5, 6, 8, 9, 10};
+    EXPECT_EQ(expected, buf);
+
+    auto data2 = {7, 1, 2, 0};
+    v.insert(data2.begin(), data2.end());
+    buf.assign(v.begin(), v.end());
+    expected = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+    EXPECT_EQ(expected, buf);
+}
+
+TEST(TCompactFlatSetTest, GrowShrink)
+{
+    TCompactFlatSet<int, 10> s;
+    for (int i = 0; i < 10; ++i) {
+        s.insert(i);
+    }
+    for (int i = 0; i < 4; ++i) {
+        s.erase(i);
+    }
+
+    EXPECT_EQ(s.ssize(), 6);
+
+    // Must not crash or trigger asan.
+}
+
+TEST(TCompactFlatSetTest, GrowShrinkGrow)
+{
+    TCompactFlatSet<int, 10> s;
+    for (int i = 0; i < 10; ++i) {
+        s.insert(i);
+    }
+    for (int i = 0; i < 4; ++i) {
+        s.erase(i);
+    }
+
+    EXPECT_EQ(s.ssize(), 6);
+
+    for (int i = 10; i < 20; ++i) {
+        s.insert(i);
+    }
+
+    EXPECT_EQ(s.ssize(), 16);
+
+    // Must not crash or trigger asan.
+}
+
+TEST(TCompactFlatSetTest, LowerBound)
+{
+    TCompactFlatSet<int, 2> s;
+    EXPECT_EQ(s.lower_bound(42), s.end());
+
+    s.insert(42);
+    EXPECT_EQ(*s.lower_bound(41), 42);
+    EXPECT_EQ(*s.lower_bound(42), 42);
+
+    s.insert(43);
+
+    // Grows here.
+    s.insert(44);
+    EXPECT_EQ(*s.lower_bound(41), 42);
+    EXPECT_EQ(s.lower_bound(45), s.end());
+}
+
+TEST(TCompactFlatSetTest, UpperBound)
+{
+    TCompactFlatSet<int, 2> s;
+    EXPECT_EQ(s.upper_bound(41), s.end());
+
+    s.insert(42);
+    EXPECT_EQ(*s.upper_bound(41), 42);
+    EXPECT_EQ(s.upper_bound(42), s.end());
+
+    s.insert(43);
+
+    // Grows here.
+    s.insert(44);
+
+    EXPECT_EQ(*s.upper_bound(41), 42);
+    EXPECT_EQ(*s.upper_bound(42), 43);
+    EXPECT_EQ(s.upper_bound(44), s.end());
+}
+
+TEST(TCompactFlatSetTest, EqualRange)
+{
+    TCompactFlatSet<int, 2> s;
+    EXPECT_EQ(s.equal_range(41), std::pair(s.end(), s.end()));
+
+    s.insert(42);
+    EXPECT_EQ(s.equal_range(41), std::pair(s.begin(), s.begin()));
+    EXPECT_EQ(s.equal_range(42), std::pair(s.begin(), s.end()));
+    EXPECT_EQ(s.equal_range(43), std::pair(s.end(), s.end()));
+
+    s.insert(43);
+    s.insert(44);
+
+    auto it = s.begin();
+    EXPECT_EQ(s.equal_range(41), std::pair(it, it));
+    EXPECT_EQ(s.equal_range(42), std::pair(it, std::next(it)));
+    ++it;
+    EXPECT_EQ(s.equal_range(43), std::pair(it, std::next(it)));
+    ++it;
+    EXPECT_EQ(s.equal_range(44), std::pair(it, std::next(it)));
+    EXPECT_EQ(s.equal_range(45), std::pair(s.end(), s.end()));
+}
+
+TEST(TCompactFlatSetTest, ForEach)
+{
+    TCompactFlatSet<int, 2> s;
+    for (int i = 10; i > 0; --i) {
+        s.insert(i);
+    }
+
+    {
+        std::vector<int> buf;
+        for (auto it = s.begin(); it != s.end(); ++it) {
+            buf.push_back(*it);
+        }
+        std::vector<int> expected{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+        EXPECT_EQ(expected, buf);
+    }
+
+    {
+        std::vector<int> buf;
+        for (auto rit = s.rbegin(); rit != s.rend(); ++rit) {
+            buf.push_back(*rit);
+        }
+        std::vector<int> expected{10, 9, 8, 7, 6, 5, 4, 3, 2, 1};
+        EXPECT_EQ(expected, buf);
+
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace
+} // namespace NYT
diff --git a/library/cpp/yt/small_containers/unittests/compact_heap_ut.cpp b/library/cpp/yt/compact_containers/unittests/compact_heap_ut.cpp
similarity index 97%
rename from library/cpp/yt/small_containers/unittests/compact_heap_ut.cpp
rename to library/cpp/yt/compact_containers/unittests/compact_heap_ut.cpp
index 259c576e87c..4cd66443563 100644
--- a/library/cpp/yt/small_containers/unittests/compact_heap_ut.cpp
+++ b/library/cpp/yt/compact_containers/unittests/compact_heap_ut.cpp
@@ -1,4 +1,4 @@
-#include <library/cpp/yt/small_containers/compact_heap.h>
+#include <library/cpp/yt/compact_containers/compact_heap.h>
 
 #include <library/cpp/testing/gtest/gtest.h>
 
diff --git a/library/cpp/yt/small_containers/unittests/compact_queue_ut.cpp b/library/cpp/yt/compact_containers/unittests/compact_queue_ut.cpp
similarity index 97%
rename from library/cpp/yt/small_containers/unittests/compact_queue_ut.cpp
rename to library/cpp/yt/compact_containers/unittests/compact_queue_ut.cpp
index acea1c5c714..463d4ec4970 100644
--- a/library/cpp/yt/small_containers/unittests/compact_queue_ut.cpp
+++ b/library/cpp/yt/compact_containers/unittests/compact_queue_ut.cpp
@@ -1,4 +1,4 @@
-#include <library/cpp/yt/small_containers/compact_queue.h>
+#include <library/cpp/yt/compact_containers/compact_queue.h>
 
 #include <library/cpp/testing/gtest/gtest.h>
 
diff --git a/library/cpp/yt/small_containers/unittests/compact_set_ut.cpp b/library/cpp/yt/compact_containers/unittests/compact_set_ut.cpp
similarity index 98%
rename from library/cpp/yt/small_containers/unittests/compact_set_ut.cpp
rename to library/cpp/yt/compact_containers/unittests/compact_set_ut.cpp
index 17b96a21954..203a6f75f58 100644
--- a/library/cpp/yt/small_containers/unittests/compact_set_ut.cpp
+++ b/library/cpp/yt/compact_containers/unittests/compact_set_ut.cpp
@@ -10,7 +10,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include <library/cpp/yt/small_containers/compact_set.h>
+#include <library/cpp/yt/compact_containers/compact_set.h>
 
 #include <library/cpp/testing/gtest/gtest.h>
 
diff --git a/library/cpp/yt/small_containers/unittests/compact_vector_ut.cpp b/library/cpp/yt/compact_containers/unittests/compact_vector_ut.cpp
similarity index 97%
rename from library/cpp/yt/small_containers/unittests/compact_vector_ut.cpp
rename to library/cpp/yt/compact_containers/unittests/compact_vector_ut.cpp
index 715de64dfb9..ecc0a745d4a 100644
--- a/library/cpp/yt/small_containers/unittests/compact_vector_ut.cpp
+++ b/library/cpp/yt/compact_containers/unittests/compact_vector_ut.cpp
@@ -12,7 +12,7 @@
 //
 //===----------------------------------------------------------------------===//
 
-#include <library/cpp/yt/small_containers/compact_vector.h>
+#include <library/cpp/yt/compact_containers/compact_vector.h>
 
 #include <library/cpp/testing/gtest/gtest.h>
 
@@ -58,7 +58,7 @@ class Constructable {
     ++numCopyConstructorCalls;
   }
 
-  Constructable(Constructable && src) : constructed(true) {
+  Constructable(Constructable && src) noexcept : constructed(true) {
     value = src.value;
     ++numConstructorCalls;
     ++numMoveConstructorCalls;
@@ -78,7 +78,7 @@ class Constructable {
     return *this;
   }
 
-  Constructable & operator=(Constructable && src) {
+  Constructable & operator=(Constructable && src) noexcept {
     EXPECT_TRUE(constructed);
     value = src.value;
     ++numAssignmentCalls;
@@ -143,8 +143,8 @@ int Constructable::numMoveAssignmentCalls;
 
 struct NonCopyable {
   NonCopyable() {}
-  NonCopyable(NonCopyable &&) {}
-  NonCopyable &operator=(NonCopyable &&) { return *this; }
+  NonCopyable(NonCopyable &&) noexcept {}
+  NonCopyable &operator=(NonCopyable &&) noexcept { return *this; }
 private:
   NonCopyable(const NonCopyable &) = delete;
   NonCopyable &operator=(const NonCopyable &) = delete;
@@ -273,7 +273,7 @@ TYPED_TEST(CompactVectorTest, InsertEnd)
 {
     SCOPED_TRACE("InsertEnd");
 
-    TCompactVector<TString, 5> vector;
+    TCompactVector<std::string, 5> vector;
     for (int index = 0; index < 10; ++index) {
         vector.insert(vector.end(), ToString(index));
     }
@@ -286,7 +286,7 @@ TYPED_TEST(CompactVectorTest, ShrinkToSmall)
 {
     SCOPED_TRACE("ShrinkToSmall");
 
-    TCompactVector<TString, 5> vector;
+    TCompactVector<std::string, 5> vector;
     for (int index = 0; index < 10; ++index) {
         vector.shrink_to_small();
         vector.push_back(ToString(index));
@@ -789,10 +789,10 @@ struct MovedFrom {
   bool hasValue;
   MovedFrom() : hasValue(true) {
   }
-  MovedFrom(MovedFrom&& m) : hasValue(m.hasValue) {
+  MovedFrom(MovedFrom&& m) noexcept : hasValue(m.hasValue) {
     m.hasValue = false;
   }
-  MovedFrom &operator=(MovedFrom&& m) {
+  MovedFrom &operator=(MovedFrom&& m) noexcept {
     hasValue = m.hasValue;
     m.hasValue = false;
     return *this;
@@ -817,7 +817,7 @@ enum EmplaceableArgState {
 template <int I> struct EmplaceableArg {
   EmplaceableArgState State;
   EmplaceableArg() : State(EAS_Defaulted) {}
-  EmplaceableArg(EmplaceableArg &&X)
+  EmplaceableArg(EmplaceableArg &&X) noexcept
       : State(X.State == EAS_Arg ? EAS_RValue : EAS_Failure) {}
   EmplaceableArg(EmplaceableArg &X)
       : State(X.State == EAS_Arg ? EAS_LValue : EAS_Failure) {}
@@ -859,8 +859,8 @@ struct Emplaceable {
         A2(std::forward<A2Ty>(A2)), A3(std::forward<A3Ty>(A3)),
         State(ES_Emplaced) {}
 
-  Emplaceable(Emplaceable &&) : State(ES_Moved) {}
-  Emplaceable &operator=(Emplaceable &&) {
+  Emplaceable(Emplaceable &&) noexcept : State(ES_Moved) {}
+  Emplaceable &operator=(Emplaceable &&) noexcept {
     State = ES_Moved;
     return *this;
   }
@@ -1061,8 +1061,8 @@ TEST(CompactVectorTest, InitializerList) {
 }
 
 TEST(CompactVectorTest, AssignToShorter) {
-  TCompactVector<TString, 4> lhs;
-  TCompactVector<TString, 4> rhs;
+  TCompactVector<std::string, 4> lhs;
+  TCompactVector<std::string, 4> rhs;
   rhs.emplace_back("foo");
   lhs = rhs;
   EXPECT_EQ(1U, lhs.size());
@@ -1070,10 +1070,10 @@ TEST(CompactVectorTest, AssignToShorter) {
 }
 
 TEST(CompactVectorTest, AssignToLonger) {
-  TCompactVector<TString, 4> lhs;
+  TCompactVector<std::string, 4> lhs;
   lhs.emplace_back("bar");
   lhs.emplace_back("baz");
-  TCompactVector<TString, 4> rhs;
+  TCompactVector<std::string, 4> rhs;
   rhs.emplace_back("foo");
   lhs = rhs;
   EXPECT_EQ(1U, lhs.size());
diff --git a/library/cpp/yt/containers/default_map-inl.h b/library/cpp/yt/containers/default_map-inl.h
new file mode 100644
index 00000000000..95e29623e0e
--- /dev/null
+++ b/library/cpp/yt/containers/default_map-inl.h
@@ -0,0 +1,58 @@
+#ifndef DEFAULT_MAP_INL_H_
+#error "Direct inclusion of this file is not allowed, include default_map.h"
+// For the sake of sane code completion.
+#include "default_map.h"
+#endif
+
+#include <utility>
+
+namespace NYT {
+
+////////////////////////////////////////////////////////////////////////////////
+
+template <class T>
+TDefaultMap<T>::TDefaultMap(mapped_type defaultValue)
+    : DefaultValue_(std::move(defaultValue))
+{ }
+
+template <class T>
+template <class K>
+typename TDefaultMap<T>::mapped_type& TDefaultMap<T>::operator[](const K& key)
+{
+    if (auto it = T::find(key); it != T::end()) {
+        return it->second;
+    }
+    return T::insert({key, DefaultValue_}).first->second;
+}
+
+template <class T>
+template <class K>
+const typename TDefaultMap<T>::mapped_type& TDefaultMap<T>::GetOrDefault(const K& key) const
+{
+    auto it = T::find(key);
+    return it == T::end() ? DefaultValue_ : it->second;
+}
+
+template <class T>
+T& TDefaultMap<T>::AsUnderlying() noexcept
+{
+    return static_cast<T&>(*this);
+}
+
+template <class T>
+const T& TDefaultMap<T>::AsUnderlying() const noexcept
+{
+    return static_cast<const T&>(*this);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+template <class T>
+void FormatValue(TStringBuilderBase* builder, const TDefaultMap<T>& map, TStringBuf format)
+{
+    FormatValue(builder, static_cast<const T&>(map), format);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace NYT
diff --git a/library/cpp/yt/containers/default_map.h b/library/cpp/yt/containers/default_map.h
new file mode 100644
index 00000000000..f40551a9dd3
--- /dev/null
+++ b/library/cpp/yt/containers/default_map.h
@@ -0,0 +1,64 @@
+#pragma once
+
+#include <library/cpp/yt/misc/property.h>
+
+#include <library/cpp/yt/string/string_builder.h>
+
+namespace NYT {
+
+////////////////////////////////////////////////////////////////////////////////
+
+template <class T>
+class TDefaultMap
+    : public T
+{
+public:
+    using TUnderlying = T;
+    using mapped_type = typename T::mapped_type;
+
+    DEFINE_BYREF_RO_PROPERTY(mapped_type, DefaultValue);
+
+    TDefaultMap() = default;
+
+    explicit TDefaultMap(mapped_type defaultValue);
+
+    template <class K>
+    mapped_type& operator[](const K& key);
+
+    template <class K>
+    const mapped_type& GetOrDefault(const K& key) const;
+
+    T& AsUnderlying() noexcept;
+    const T& AsUnderlying() const noexcept;
+
+    // NB: There are no Save()/Load() since it can be easiliy (de)serialized
+    // manually. Moreover, it's easy to forget write compats when replacing
+    // THashTable to this one since Save()/Load() works out of the box.
+};
+
+////////////////////////////////////////////////////////////////////////////////
+
+template <class T>
+void FormatValue(TStringBuilderBase* builder, const TDefaultMap<T>& map, TStringBuf format);
+
+////////////////////////////////////////////////////////////////////////////////
+
+template <class T>
+struct TIsDefaultMap
+{
+    static constexpr bool Value = false;
+};
+
+template <class T>
+struct TIsDefaultMap<TDefaultMap<T>>
+{
+    static constexpr bool Value = true;
+};
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace NYT
+
+#define DEFAULT_MAP_INL_H_
+#include "default_map-inl.h"
+#undef DEFAULT_MAP_INL_H_
diff --git a/library/cpp/yt/containers/enum_indexed_array-inl.h b/library/cpp/yt/containers/enum_indexed_array-inl.h
index edda891683e..92181c69bf8 100644
--- a/library/cpp/yt/containers/enum_indexed_array-inl.h
+++ b/library/cpp/yt/containers/enum_indexed_array-inl.h
@@ -12,7 +12,7 @@ namespace NYT {
 ////////////////////////////////////////////////////////////////////////////////
 
 template <class E, class T, E Min, E Max>
-TEnumIndexedArray<E, T, Min, Max>::TEnumIndexedArray(std::initializer_list<std::pair<E, T>> elements)
+constexpr TEnumIndexedArray<E, T, Min, Max>::TEnumIndexedArray(std::initializer_list<std::pair<E, T>> elements)
 {
     for (const auto& [index, value] : elements) {
         (*this)[index] = value;
@@ -20,38 +20,38 @@ TEnumIndexedArray<E, T, Min, Max>::TEnumIndexedArray(std::initializer_list<std::
 }
 
 template <class E, class T, E Min, E Max>
-T& TEnumIndexedArray<E, T, Min, Max>::operator[] (E index)
+constexpr T& TEnumIndexedArray<E, T, Min, Max>::operator[] (E index)
 {
     YT_ASSERT(IsValidIndex(index));
     return Items_[ToUnderlying(index) - ToUnderlying(Min)];
 }
 
 template <class E, class T, E Min, E Max>
-const T& TEnumIndexedArray<E, T, Min, Max>::operator[] (E index) const
+constexpr const T& TEnumIndexedArray<E, T, Min, Max>::operator[] (E index) const
 {
     return const_cast<TEnumIndexedArray&>(*this)[index];
 }
 
 template <class E, class T, E Min, E Max>
-T* TEnumIndexedArray<E, T, Min, Max>::begin()
+constexpr T* TEnumIndexedArray<E, T, Min, Max>::begin()
 {
     return Items_.data();
 }
 
 template <class E, class T, E Min, E Max>
-const T* TEnumIndexedArray<E, T, Min, Max>::begin() const
+constexpr const T* TEnumIndexedArray<E, T, Min, Max>::begin() const
 {
     return Items_.data();
 }
 
 template <class E, class T, E Min, E Max>
-T* TEnumIndexedArray<E, T, Min, Max>::end()
+constexpr T* TEnumIndexedArray<E, T, Min, Max>::end()
 {
     return begin() + Size;
 }
 
 template <class E, class T, E Min, E Max>
-const T* TEnumIndexedArray<E, T, Min, Max>::end() const
+constexpr const T* TEnumIndexedArray<E, T, Min, Max>::end() const
 {
     return begin() + Size;
 }
@@ -63,7 +63,7 @@ constexpr size_t TEnumIndexedArray<E, T, Min, Max>::size() const
 }
 
 template <class E, class T, E Min, E Max>
-bool TEnumIndexedArray<E, T, Min, Max>::IsValidIndex(E index)
+constexpr bool TEnumIndexedArray<E, T, Min, Max>::IsValidIndex(E index)
 {
     return index >= Min && index <= Max;
 }
diff --git a/library/cpp/yt/containers/enum_indexed_array.h b/library/cpp/yt/containers/enum_indexed_array.h
index bae6a75237a..4a164791c0c 100644
--- a/library/cpp/yt/containers/enum_indexed_array.h
+++ b/library/cpp/yt/containers/enum_indexed_array.h
@@ -29,7 +29,7 @@ class TEnumIndexedArray
     using TValue = T;
 
     constexpr TEnumIndexedArray() = default;
-    TEnumIndexedArray(std::initializer_list<std::pair<E, T>> elements);
+    constexpr TEnumIndexedArray(std::initializer_list<std::pair<E, T>> elements);
 
     constexpr TEnumIndexedArray(const TEnumIndexedArray&) = default;
     constexpr TEnumIndexedArray(TEnumIndexedArray&&) = default;
@@ -37,18 +37,20 @@ class TEnumIndexedArray
     constexpr TEnumIndexedArray& operator=(const TEnumIndexedArray&) = default;
     constexpr TEnumIndexedArray& operator=(TEnumIndexedArray&&) = default;
 
-    T& operator[] (E index);
-    const T& operator[] (E index) const;
+    constexpr bool operator==(const TEnumIndexedArray&) const = default;
+
+    constexpr T& operator[] (E index);
+    constexpr const T& operator[] (E index) const;
 
     // STL interop.
-    T* begin();
-    const T* begin() const;
-    T* end();
-    const T* end() const;
+    constexpr T* begin();
+    constexpr const T* begin() const;
+    constexpr T* end();
+    constexpr const T* end() const;
 
     constexpr size_t size() const;
 
-    static bool IsValidIndex(E index);
+    static constexpr bool IsValidIndex(E index);
 
 private:
     static constexpr size_t Size = static_cast<size_t>(Max) - static_cast<size_t>(Min) + 1;
diff --git a/library/cpp/yt/containers/expiring_set-inl.h b/library/cpp/yt/containers/expiring_set-inl.h
new file mode 100644
index 00000000000..5bc000395c2
--- /dev/null
+++ b/library/cpp/yt/containers/expiring_set-inl.h
@@ -0,0 +1,88 @@
+#ifndef EXPIRING_SET_INL_H_
+#error "Direct inclusion of this file is not allowed, include expiring_set.h"
+// For the sake of sane code completion.
+#include "expiring_set.h"
+#endif
+
+namespace NYT {
+
+////////////////////////////////////////////////////////////////////////////////
+
+template <class TItem, class THash, class TEqual>
+void TExpiringSet<TItem, THash, TEqual>::SetTtl(TDuration ttl)
+{
+    Ttl_ = ttl;
+}
+
+template <class TItem, class THash, class TEqual>
+void TExpiringSet<TItem, THash, TEqual>::Insert(TInstant now, const TItem& item)
+{
+    Expire(now);
+    auto deadline = now + Ttl_;
+    ItemToDeadline_[item] = deadline;
+    ExpirationQueue_.push(TItemPack{.Items = {item}, .Deadline = deadline});
+}
+
+template <class TItem, class THash, class TEqual>
+template <class TItems>
+void TExpiringSet<TItem, THash, TEqual>::InsertMany(TInstant now, const TItems& items)
+{
+    Expire(now);
+    auto deadline = now + Ttl_;
+    for (const auto& item : items) {
+        ItemToDeadline_[item] = deadline;
+    }
+    ExpirationQueue_.push(TItemPack{.Items = {items.begin(), items.end()}, .Deadline = deadline});
+}
+
+template <class TItem, class THash, class TEqual>
+void TExpiringSet<TItem, THash, TEqual>::Remove(const TItem& item)
+{
+    ItemToDeadline_.erase(item);
+}
+
+template <class TItem, class THash, class TEqual>
+void TExpiringSet<TItem, THash, TEqual>::Expire(TInstant now)
+{
+    while (!ExpirationQueue_.empty() && ExpirationQueue_.top().Deadline <= now) {
+        for (const auto& item : ExpirationQueue_.top().Items) {
+            if (auto it = ItemToDeadline_.find(item); it != ItemToDeadline_.end()) {
+                if (it->second <= now) {
+                    ItemToDeadline_.erase(it);
+                }
+            }
+        }
+        ExpirationQueue_.pop();
+    }
+}
+
+template <class TItem, class THash, class TEqual>
+void TExpiringSet<TItem, THash, TEqual>::Clear()
+{
+    ItemToDeadline_ = {};
+    ExpirationQueue_ = {};
+}
+
+template <class TItem, class THash, class TEqual>
+template <class TItemLike>
+bool TExpiringSet<TItem, THash, TEqual>::Contains(const TItemLike& item) const
+{
+    return ItemToDeadline_.contains(item);
+}
+
+template <class TItem, class THash, class TEqual>
+int TExpiringSet<TItem, THash, TEqual>::GetSize() const
+{
+    return std::ssize(ItemToDeadline_);
+}
+
+template <class TItem, class THash, class TEqual>
+bool TExpiringSet<TItem, THash, TEqual>::TItemPack::operator<(const TItemPack& other) const
+{
+    // Reversed ordering for the priority queue.
+    return Deadline > other.Deadline;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace NYT
diff --git a/library/cpp/yt/containers/expiring_set.h b/library/cpp/yt/containers/expiring_set.h
new file mode 100644
index 00000000000..44e9d7e07d4
--- /dev/null
+++ b/library/cpp/yt/containers/expiring_set.h
@@ -0,0 +1,56 @@
+#pragma once
+
+#include <util/generic/hash.h>
+
+#include <util/datetime/base.h>
+
+#include <queue>
+
+namespace NYT {
+
+////////////////////////////////////////////////////////////////////////////////
+
+//! Maintains a set of items that expire after a certain time.
+template <class TItem, class THash = THash<TItem>, class TEqual = TEqualTo<TItem>>
+class TExpiringSet
+{
+public:
+    void SetTtl(TDuration ttl);
+
+    void Insert(TInstant now, const TItem& item);
+    template <class TItems>
+    void InsertMany(TInstant now, const TItems& items);
+
+    void Remove(const TItem& item);
+
+    void Expire(TInstant now);
+
+    void Clear();
+
+    template <class TItemLike>
+    bool Contains(const TItemLike& item) const;
+
+    int GetSize() const;
+
+private:
+    TDuration Ttl_;
+
+    struct TItemPack
+    {
+        std::vector<TItem> Items;
+        TInstant Deadline;
+
+        bool operator<(const TItemPack& other) const;
+    };
+
+    THashMap<TItem, TInstant, THash, TEqual> ItemToDeadline_;
+    std::priority_queue<TItemPack> ExpirationQueue_;
+};
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace NYT
+
+#define EXPIRING_SET_INL_H_
+#include "expiring_set-inl.h"
+#undef EXPIRING_SET_INL_H_
diff --git a/library/cpp/yt/containers/non_empty-inl.h b/library/cpp/yt/containers/non_empty-inl.h
new file mode 100644
index 00000000000..eacafea3095
--- /dev/null
+++ b/library/cpp/yt/containers/non_empty-inl.h
@@ -0,0 +1,193 @@
+#ifndef NON_EMPTY_INL_H_
+#error "Direct inclusion of this file is not allowed, include non_empty.h"
+// For the sake of sane code completion.
+#include "non_empty.h"
+#endif
+
+#include <library/cpp/yt/assert/assert.h>
+
+namespace NYT {
+
+////////////////////////////////////////////////////////////////////////////////
+
+template <class TContainer>
+TNonEmpty<TContainer>::TNonEmpty(TContainer underlying)
+    : Underlying_(std::move(underlying))
+{
+    YT_ASSERT(!Underlying_.empty());
+}
+
+template <class TContainer>
+template <class TIterator>
+TNonEmpty<TContainer>::TNonEmpty(TIterator first, TIterator last)
+    : TNonEmpty(TContainer(first, last))
+{ }
+
+template <class TContainer>
+TNonEmpty<TContainer>::TNonEmpty(std::initializer_list<value_type> values)
+    : TNonEmpty(TContainer(values))
+{ }
+
+template <class TContainer>
+typename TContainer::size_type TNonEmpty<TContainer>::size() const
+{
+    return Underlying_.size();
+}
+
+template <class TContainer>
+void TNonEmpty<TContainer>::resize(size_type size)
+{
+    YT_ASSERT(size > 0);
+    Underlying_.resize(size);
+}
+
+template <class TContainer>
+void TNonEmpty<TContainer>::resize(size_type size, const value_type& value)
+{
+    YT_ASSERT(size > 0);
+    Underlying_.resize(size, value);
+}
+
+template <class TContainer>
+typename TContainer::iterator TNonEmpty<TContainer>::begin()
+{
+    return Underlying_.begin();
+}
+
+template <class TContainer>
+typename TContainer::const_iterator TNonEmpty<TContainer>::begin() const
+{
+    return Underlying_.begin();
+}
+
+template <class TContainer>
+typename TContainer::iterator TNonEmpty<TContainer>::end()
+{
+    return Underlying_.end();
+}
+
+template <class TContainer>
+typename TContainer::const_iterator TNonEmpty<TContainer>::end() const
+{
+    return Underlying_.end();
+}
+
+template <class TContainer>
+typename TContainer::reverse_iterator TNonEmpty<TContainer>::rbegin()
+{
+    return Underlying_.rbegin();
+}
+
+template <class TContainer>
+typename TContainer::const_reverse_iterator TNonEmpty<TContainer>::rbegin() const
+{
+    return Underlying_.rbegin();
+}
+
+template <class TContainer>
+typename TContainer::reverse_iterator TNonEmpty<TContainer>::rend()
+{
+    return Underlying_.rend();
+}
+
+template <class TContainer>
+typename TContainer::const_reverse_iterator TNonEmpty<TContainer>::rend() const
+{
+    return Underlying_.rend();
+}
+
+template <class TContainer>
+typename TContainer::pointer TNonEmpty<TContainer>::data()
+{
+    return Underlying_.data();
+}
+
+template <class TContainer>
+typename TContainer::const_pointer TNonEmpty<TContainer>::data() const
+{
+    return Underlying_.data();
+}
+
+template <class TContainer>
+typename TContainer::reference TNonEmpty<TContainer>::operator[](size_type index)
+{
+    return Underlying_[index];
+}
+
+template <class TContainer>
+typename TContainer::const_reference TNonEmpty<TContainer>::operator[](size_type index) const
+{
+    return Underlying_[index];
+}
+
+template <class TContainer>
+typename TContainer::reference TNonEmpty<TContainer>::front()
+{
+    return Underlying_.front();
+}
+
+template <class TContainer>
+typename TContainer::const_reference TNonEmpty<TContainer>::front() const
+{
+    return Underlying_.front();
+}
+
+template <class TContainer>
+typename TContainer::reference TNonEmpty<TContainer>::back()
+{
+    return Underlying_.back();
+}
+
+template <class TContainer>
+typename TContainer::const_reference TNonEmpty<TContainer>::back() const
+{
+    return Underlying_.back();
+}
+
+template <class TContainer>
+void TNonEmpty<TContainer>::push_back(const value_type& value)
+{
+    Underlying_.push_back(value);
+}
+
+template <class TContainer>
+void TNonEmpty<TContainer>::push_back(value_type&& value)
+{
+    Underlying_.push_back(std::move(value));
+}
+
+template <class TContainer>
+template <class... TArgs>
+typename TContainer::reference TNonEmpty<TContainer>::emplace_back(TArgs&&... args)
+{
+    return Underlying_.emplace_back(std::forward<TArgs>(args)...);
+}
+
+template <class TContainer>
+void TNonEmpty<TContainer>::pop_back()
+{
+    YT_ASSERT(Underlying_.size() > 1);
+    Underlying_.pop_back();
+}
+
+template <class TContainer>
+const TContainer& TNonEmpty<TContainer>::Get() const
+{
+    return Underlying_;
+}
+
+template <class TContainer>
+TNonEmpty<TContainer>::operator const TContainer&() const
+{
+    return Underlying_;
+}
+
+template <class TContainer>
+void FormatValue(TStringBuilderBase* builder, const TNonEmpty<TContainer>& nonempty, TStringBuf spec)
+{
+    FormatValue(builder, nonempty.Get(), spec);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace NYT
diff --git a/library/cpp/yt/containers/non_empty.h b/library/cpp/yt/containers/non_empty.h
new file mode 100644
index 00000000000..f0cec6ce884
--- /dev/null
+++ b/library/cpp/yt/containers/non_empty.h
@@ -0,0 +1,91 @@
+#pragma once
+
+#include <library/cpp/yt/string/string_builder.h>
+
+#include <util/system/compiler.h>
+
+#include <initializer_list>
+
+namespace NYT {
+
+////////////////////////////////////////////////////////////////////////////////
+
+template <class TContainer>
+class TNonEmpty
+{
+public:
+    using TUnderlying = TContainer;
+
+    using size_type = typename TUnderlying::size_type;
+    using difference_type = typename TUnderlying::difference_type;
+
+    using value_type = typename TUnderlying::value_type;
+
+    using iterator = typename TUnderlying::iterator;
+    using const_iterator = typename TUnderlying::const_iterator;
+
+    using const_reverse_iterator = typename TUnderlying::const_reverse_iterator;
+    using reverse_iterator = typename TUnderlying::reverse_iterator;
+
+    using reference = typename TUnderlying::reference;
+    using const_reference = typename TUnderlying::const_reference;
+
+    using pointer = typename TUnderlying::pointer;
+    using const_pointer = typename TUnderlying::const_pointer;
+
+    explicit TNonEmpty(TContainer underlying);
+    template <class TIterator>
+    TNonEmpty(TIterator first, TIterator last);
+    TNonEmpty(std::initializer_list<value_type> values);
+
+    size_type size() const;
+
+    void resize(size_type size);
+    void resize(size_type size, const value_type& value);
+
+    iterator begin();
+    const_iterator begin() const;
+    iterator end();
+    const_iterator end() const;
+
+    reverse_iterator rbegin();
+    const_reverse_iterator rbegin() const;
+    reverse_iterator rend();
+    const_reverse_iterator rend() const;
+
+    pointer data();
+    const_pointer data() const;
+
+    reference operator[](size_type index);
+    const_reference operator[](size_type index) const;
+
+    reference front();
+    const_reference front() const;
+    reference back();
+    const_reference back() const;
+
+    void push_back(const value_type& value);
+    void push_back(value_type&& value);
+
+    template <class... TArgs>
+    reference emplace_back(TArgs&&... args);
+
+    void pop_back();
+
+    const TContainer& Get() const Y_LIFETIME_BOUND;
+    operator const TContainer&() const Y_LIFETIME_BOUND;
+
+private:
+    TContainer Underlying_;
+};
+
+template <class TContainer>
+void FormatValue(TStringBuilderBase* builder, const TNonEmpty<TContainer>& nonempty, TStringBuf spec);
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace NYT
+
+#define NON_EMPTY_INL_H_
+#include "non_empty-inl.h"
+#undef NON_EMPTY_INL_H_
diff --git a/library/cpp/yt/containers/ordered_hash_map-inl.h b/library/cpp/yt/containers/ordered_hash_map-inl.h
new file mode 100644
index 00000000000..75c1b0a1599
--- /dev/null
+++ b/library/cpp/yt/containers/ordered_hash_map-inl.h
@@ -0,0 +1,153 @@
+#ifndef ORDERED_HASH_MAP_INL_H_
+#error "Direct inclusion of this file is not allowed, include ordered_hash_map.h"
+// For the sake of sane code completion.
+#include "ordered_hash_map.h"
+#endif
+
+#include <library/cpp/yt/assert/assert.h>
+
+namespace NYT {
+
+////////////////////////////////////////////////////////////////////////////////
+
+template <class TKey, class TValue, class THashFunction, class TEqualFunction>
+std::pair<const TKey, TValue>& TOrderedHashMap<TKey, TValue, THashFunction, TEqualFunction>::TSelectPair::operator()(TItem& item) const
+{
+    return item;
+}
+
+template <class TKey, class TValue, class THashFunction, class TEqualFunction>
+const std::pair<const TKey, TValue>& TOrderedHashMap<TKey, TValue, THashFunction, TEqualFunction>::TSelectPair::operator()(const TItem& item) const
+{
+    return item;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+template <class TKey, class TValue, class THashFunction, class TEqualFunction>
+TOrderedHashMap<TKey, TValue, THashFunction, TEqualFunction>::TOrderedHashMap(const TOrderedHashMap& other)
+{
+    *this = other;
+}
+
+template <class TKey, class TValue, class THashFunction, class TEqualFunction>
+auto TOrderedHashMap<TKey, TValue, THashFunction, TEqualFunction>::operator=(const TOrderedHashMap& other) -> TOrderedHashMap&
+{
+    if (this == &other) {
+        return *this;
+    }
+    clear();
+    Table_.reserve(other.size());
+    for (const auto& item : other) {
+        emplace(item.first, item.second);
+    }
+    return *this;
+}
+
+template <class TKey, class TValue, class THashFunction, class TEqualFunction>
+template <class... TArgs>
+auto TOrderedHashMap<TKey, TValue, THashFunction, TEqualFunction>::emplace(TArgs&&... args) -> std::pair<iterator, bool>
+{
+    auto [it, success] = Table_.emplace_unique(std::forward<TArgs>(args)...);
+    if (success) {
+        List_.PushBack(&*it);
+    }
+    return {MakeMappedIterator(TListIterator(&*it), TSelectPair{}), success};
+}
+
+template <class TKey, class TValue, class THashFunction, class TEqualFunction>
+template <class TOtherKey>
+auto TOrderedHashMap<TKey, TValue, THashFunction, TEqualFunction>::find(const TOtherKey& key) -> iterator
+{
+    auto it = Table_.find(key);
+    if (it == Table_.end()) {
+        return MakeMappedIterator(List_.end(), TSelectPair{});
+    }
+    return MakeMappedIterator(TListIterator(&*it), TSelectPair{});
+}
+
+template <class TKey, class TValue, class THashFunction, class TEqualFunction>
+template <class TOtherKey>
+auto TOrderedHashMap<TKey, TValue, THashFunction, TEqualFunction>::find(const TOtherKey& key) const -> const_iterator
+{
+    auto it = Table_.find(key);
+    if (it == Table_.end()) {
+        return MakeMappedIterator(List_.end(), TSelectPair{});
+    }
+    return MakeMappedIterator(TListConstIterator(&*it), TSelectPair{});
+}
+
+template <class TKey, class TValue, class THashFunction, class TEqualFunction>
+template <class TOtherKey>
+bool TOrderedHashMap<TKey, TValue, THashFunction, TEqualFunction>::contains(const TOtherKey& key) const
+{
+    return Table_.find(key) != Table_.end();
+}
+
+template <class TKey, class TValue, class THashFunction, class TEqualFunction>
+template <class TOtherKey>
+TValue& TOrderedHashMap<TKey, TValue, THashFunction, TEqualFunction>::operator[](const TOtherKey& key)
+{
+    typename TTable::insert_ctx ctx = nullptr;
+    auto it = Table_.find_i(key, ctx);
+    if (it != Table_.end()) {
+        return it->second;
+    }
+    it = Table_.emplace_direct(ctx, std::piecewise_construct, std::forward_as_tuple(key), std::forward_as_tuple());
+    List_.PushBack(&*it);
+    return it->second;
+}
+
+template <class TKey, class TValue, class THashFunction, class TEqualFunction>
+template <class TOtherKey>
+size_t TOrderedHashMap<TKey, TValue, THashFunction, TEqualFunction>::erase(const TOtherKey& key)
+{
+    return Table_.erase_one(key);
+}
+
+template <class TKey, class TValue, class THashFunction, class TEqualFunction>
+void TOrderedHashMap<TKey, TValue, THashFunction, TEqualFunction>::erase(iterator it)
+{
+    erase(it->first);
+}
+
+template <class TKey, class TValue, class THashFunction, class TEqualFunction>
+auto TOrderedHashMap<TKey, TValue, THashFunction, TEqualFunction>::begin() -> iterator
+{
+    return MakeMappedIterator(List_.begin(), TSelectPair{});
+}
+
+template <class TKey, class TValue, class THashFunction, class TEqualFunction>
+auto TOrderedHashMap<TKey, TValue, THashFunction, TEqualFunction>::end() -> iterator
+{
+    return MakeMappedIterator(List_.end(), TSelectPair{});
+}
+
+template <class TKey, class TValue, class THashFunction, class TEqualFunction>
+auto TOrderedHashMap<TKey, TValue, THashFunction, TEqualFunction>::begin() const -> const_iterator
+{
+    return MakeMappedIterator(List_.begin(), TSelectPair{});
+}
+
+template <class TKey, class TValue, class THashFunction, class TEqualFunction>
+auto TOrderedHashMap<TKey, TValue, THashFunction, TEqualFunction>::end() const -> const_iterator
+{
+    return MakeMappedIterator(List_.end(), TSelectPair{});
+}
+
+template <class TKey, class TValue, class THashFunction, class TEqualFunction>
+size_t TOrderedHashMap<TKey, TValue, THashFunction, TEqualFunction>::size() const
+{
+    return Table_.size();
+}
+
+template <class TKey, class TValue, class THashFunction, class TEqualFunction>
+void TOrderedHashMap<TKey, TValue, THashFunction, TEqualFunction>::clear()
+{
+    Table_.clear();
+    YT_ASSERT(List_.begin() == List_.end());
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace NYT
diff --git a/library/cpp/yt/containers/ordered_hash_map.h b/library/cpp/yt/containers/ordered_hash_map.h
new file mode 100644
index 00000000000..50b41e8c20c
--- /dev/null
+++ b/library/cpp/yt/containers/ordered_hash_map.h
@@ -0,0 +1,94 @@
+#pragma once
+
+#include <library/cpp/iterator/mapped.h>
+
+#include <util/generic/hash_table.h>
+#include <util/generic/intrlist.h>
+
+namespace NYT {
+
+////////////////////////////////////////////////////////////////////////////////
+
+//! A hash map where the iteration order is the insertion order.
+template <
+    class TKey,
+    class TValue,
+    class THashFunction = THash<TKey>,
+    class TEqualFunction = TEqualTo<TKey>
+>
+class TOrderedHashMap
+{
+private:
+    struct TItem
+        : public std::pair<const TKey, TValue>
+        , public TIntrusiveListItem<TItem>
+    {
+        using std::pair<const TKey, TValue>::pair;
+    };
+
+    struct TSelectPair
+    {
+        std::pair<const TKey, TValue>& operator()(TItem& item) const;
+        const std::pair<const TKey, TValue>& operator()(const TItem& item) const;
+    };
+
+    using TList = TIntrusiveList<TItem>;
+    using TListIterator = TList::iterator;
+    using TListConstIterator = TList::const_iterator;
+
+public:
+    using iterator = TMappedIterator<TListIterator, TSelectPair>;
+    using const_iterator = TMappedIterator<TListConstIterator, TSelectPair>;
+
+public:
+    TOrderedHashMap() = default;
+    TOrderedHashMap(const TOrderedHashMap& other);
+    TOrderedHashMap(TOrderedHashMap&& other) = default;
+
+    TOrderedHashMap& operator=(const TOrderedHashMap& other);
+    TOrderedHashMap& operator=(TOrderedHashMap&& other) = default;
+
+    template <typename... TArgs>
+    std::pair<iterator, bool> emplace(TArgs&&... args);
+
+    template <class TOtherKey>
+    iterator find(const TOtherKey& key);
+
+    template <class TOtherKey>
+    const_iterator find(const TOtherKey& key) const;
+
+    template <class TOtherKey>
+    bool contains(const TOtherKey& key) const;
+
+    template <class TOtherKey>
+    TValue& operator[](const TOtherKey& key);
+
+    template <class TOtherKey>
+    size_t erase(const TOtherKey& key);
+    void erase(iterator it);
+
+    iterator begin();
+    iterator end();
+
+    const_iterator begin() const;
+    const_iterator end() const;
+
+    size_t size() const;
+
+    void clear();
+
+private:
+    using TTable = THashTable<TItem, TKey, THashFunction, TSelect1st, TEqualFunction, std::allocator<TKey>>;
+
+private:
+    TList List_;
+    TTable Table_;
+};
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace NYT
+
+#define ORDERED_HASH_MAP_INL_H_
+#include "ordered_hash_map-inl.h"
+#undef ORDERED_HASH_MAP_INL_H_
diff --git a/library/cpp/yt/containers/ring_queue.h b/library/cpp/yt/containers/ring_queue.h
new file mode 100644
index 00000000000..c3be1fa5844
--- /dev/null
+++ b/library/cpp/yt/containers/ring_queue.h
@@ -0,0 +1,382 @@
+#pragma once
+
+#include <library/cpp/yt/assert/assert.h>
+
+#include <library/cpp/yt/string/format.h>
+
+#include <cstring>
+#include <memory>
+#include <type_traits>
+#include <utility>
+
+namespace NYT {
+
+////////////////////////////////////////////////////////////////////////////////
+
+//! A simple and high-performant drop-in replacement for |std::queue|.
+/*!
+ *  Things to keep in mind:
+ *  - Capacity is doubled each time it is exhausted and is never shrunk back.
+ *  - Iteration is supported but iterator movements involve calling |move_forward| and |move_backward|.
+ *  - |T| must be nothrow move constructable.
+ */
+template <class T, class TAllocator = std::allocator<T>>
+class TRingQueue
+{
+public:
+    using value_type = T;
+    using reference = T&;
+    using const_reference = const T&;
+    using pointer = T*;
+    using const_pointer = const T*;
+    using size_type = size_t;
+
+    static_assert(std::is_nothrow_move_constructible<T>::value, "T must be nothrow move constructable.");
+
+    class TIterator
+    {
+    public:
+        TIterator() = default;
+        TIterator(const TIterator&) = default;
+
+        const T& operator*() const
+        {
+            return *Ptr_;
+        }
+
+        T& operator*()
+        {
+            return *Ptr_;
+        }
+
+        const T* operator->() const
+        {
+            return Ptr_;
+        }
+
+        T* operator->()
+        {
+            return Ptr_;
+        }
+
+        bool operator==(TIterator other) const
+        {
+            return Ptr_ == other.Ptr_;
+        }
+
+        TIterator& operator=(TIterator other)
+        {
+            Ptr_ = other.Ptr_;
+            return *this;
+        }
+
+    private:
+        friend class TRingQueue<T, TAllocator>;
+
+        explicit TIterator(T* ptr)
+            : Ptr_(ptr)
+        { }
+
+        T* Ptr_;
+    };
+
+    TRingQueue()
+        : TRingQueue(TAllocator())
+    { }
+
+    explicit TRingQueue(const TAllocator& allocator)
+        : Allocator_(allocator)
+    {
+        Capacity_ = InitialCapacity;
+        Begin_ = Allocator_.allocate(Capacity_);
+        End_ = Begin_ + Capacity_;
+
+        Size_ = 0;
+        Head_ = Tail_ = Begin_;
+    }
+
+    TRingQueue(TRingQueue&& other) noexcept
+        : Allocator_(std::move(other.Allocator_))
+    {
+        Capacity_ = other.Capacity_;
+        Begin_ = other.Begin_;
+        End_ = other.End_;
+
+        Size_ = other.Size_;
+        Head_ = other.Head_;
+        Tail_ = other.Tail_;
+
+        other.Capacity_ = other.Size_ = 0;
+        other.Begin_ = other.End_ = other.Head_ = other.Tail_ = nullptr;
+    }
+
+    TRingQueue(const TRingQueue& other) = delete;
+
+    ~TRingQueue()
+    {
+        DestroyElements();
+        if (Begin_) {
+            Allocator_.deallocate(Begin_, Capacity_);
+        }
+    }
+
+    T& front()
+    {
+        return *Head_;
+    }
+
+    const T& front() const
+    {
+        return *Head_;
+    }
+
+    T& back()
+    {
+        if (Tail_ == Begin_) {
+            return *(End_ - 1);
+        } else {
+            return *(Tail_ - 1);
+        }
+    }
+
+    const T& back() const
+    {
+        if (Tail_ == Begin_) {
+            return *(End_ - 1);
+        } else {
+            return *(Tail_ - 1);
+        }
+    }
+
+    // For performance reasons iterators do not provide their own operator++ and operator--.
+    // move_forward and move_backward are provided instead.
+    TIterator begin()
+    {
+        return TIterator(Head_);
+    }
+
+    TIterator end()
+    {
+        return TIterator(Tail_);
+    }
+
+    void move_forward(TIterator& it) const
+    {
+        ++it.Ptr_;
+        if (it.Ptr_ == End_) {
+            it.Ptr_ = Begin_;
+        }
+    }
+
+    void move_backward(TIterator& it) const
+    {
+        if (it.Ptr_ == Begin_) {
+            it.Ptr_ = End_ - 1;
+        } else {
+            --it.Ptr_;
+        }
+    }
+
+    T& operator[](size_t index)
+    {
+        YT_ASSERT(index < size());
+        auto headToEnd = static_cast<size_t>(End_ - Head_);
+        return index < headToEnd
+            ? Head_[index]
+            : Begin_[index - headToEnd];
+    }
+
+    const T& operator[](size_t index) const
+    {
+        return const_cast<TRingQueue*>(this)->operator[](index);
+    }
+
+    size_t size() const
+    {
+        return Size_;
+    }
+
+    bool empty() const
+    {
+        return Size_ == 0;
+    }
+
+    void push(const T& value)
+    {
+        BeforePush();
+        new(Tail_) T(value);
+        AfterPush();
+    }
+
+    void push(T&& value)
+    {
+        BeforePush();
+        new(Tail_) T(std::move(value));
+        AfterPush();
+    }
+
+    template <class... TArgs>
+    T& emplace(TArgs&&... args)
+    {
+        BeforePush();
+        auto* ptr = Tail_;
+        new (ptr) T(std::forward<TArgs>(args)...);
+        AfterPush();
+        return *ptr;
+    }
+
+    void pop()
+    {
+        YT_ASSERT(Size_ > 0);
+        Head_->T::~T();
+        ++Head_;
+        if (Head_ == End_) {
+            Head_ = Begin_;
+        }
+        --Size_;
+    }
+
+    void clear()
+    {
+        DestroyElements();
+        Size_ = 0;
+        Head_ = Tail_ = Begin_;
+    }
+
+private:
+    TAllocator Allocator_;
+
+    size_t Capacity_;
+    T* Begin_;
+    T* End_;
+
+    size_t Size_;
+    T* Head_;
+    T* Tail_;
+
+    static const size_t InitialCapacity = 16;
+
+    void DestroyElements()
+    {
+        if (Head_ <= Tail_) {
+            DestroyRange(Head_, Tail_);
+        } else {
+            DestroyRange(Head_, End_);
+            DestroyRange(Begin_, Tail_);
+        }
+    }
+
+    static void DestroyRange(T* begin, T* end)
+    {
+        if (!std::is_trivially_destructible<T>::value) {
+            for (auto* current = begin; current != end; ++current) {
+                current->T::~T();
+            }
+        }
+    }
+
+    static void MoveRange(T* begin, T* end, T* result)
+    {
+        if (std::is_trivially_move_constructible<T>::value) {
+            ::memcpy(result, begin, sizeof(T) * (end - begin));
+        } else {
+            for (auto* current = begin; current != end; ++current) {
+                new(result++) T(std::move(*current));
+                current->T::~T();
+            }
+        }
+    }
+
+    void BeforePush() noexcept
+    {
+        // NB: Avoid filling Items_ completely and collapsing Head_ with Tail_.
+        if (Size_ == Capacity_ - 1) {
+            auto newCapacity = Capacity_ * 2;
+            auto* newBegin = Allocator_.allocate(newCapacity);
+
+            if (Head_ <= Tail_) {
+                MoveRange(Head_, Tail_, newBegin);
+            } else {
+                MoveRange(Head_, End_, newBegin);
+                MoveRange(Begin_, Tail_, newBegin + (End_ - Head_));
+            }
+
+            Allocator_.deallocate(Begin_, Capacity_);
+
+            Capacity_ = newCapacity;
+            Begin_ = newBegin;
+            End_ = Begin_ + newCapacity;
+
+            Head_ = Begin_;
+            Tail_ = Head_ + Size_;
+        }
+    }
+
+    void AfterPush()
+    {
+        if (++Tail_ == End_) {
+            Tail_ = Begin_;
+        }
+        ++Size_;
+    }
+};
+
+////////////////////////////////////////////////////////////////////////////////
+
+template <class T, class TAllocator = std::allocator<T>>
+class TRingQueueIterableWrapper
+{
+public:
+    using TContainer = TRingQueue<T, TAllocator>;
+    using TBaseIterator = typename TContainer::TIterator;
+
+    class TIterator
+        : public TBaseIterator
+    {
+    public:
+        TIterator(TBaseIterator baseIterator, TContainer& container)
+            : TBaseIterator(std::move(baseIterator))
+            , Container_(container)
+        { }
+
+        void operator++()
+        {
+            Container_.move_forward(*this);
+        }
+
+    private:
+        TRingQueue<T, TAllocator>& Container_;
+    };
+
+    TIterator begin() const
+    {
+        auto& container = const_cast<TContainer&>(Container_);
+        return TIterator(container.begin(), container);
+    }
+
+    TIterator end() const
+    {
+        auto& container = const_cast<TContainer&>(Container_);
+        return TIterator(container.end(), container);
+    }
+
+    TRingQueueIterableWrapper(TContainer& container)
+        : Container_(container)
+    { }
+
+    using value_type = typename TContainer::value_type;
+
+private:
+    TContainer& Container_;
+};
+
+namespace NDetail {
+
+template <class T, class Allocator>
+constexpr bool CKnownRange<TRingQueueIterableWrapper<T, Allocator>> = true;
+
+} // namespace NDetail
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace NYT
diff --git a/library/cpp/yt/containers/sentinel_optional-inl.h b/library/cpp/yt/containers/sentinel_optional-inl.h
new file mode 100644
index 00000000000..a5676afa7f3
--- /dev/null
+++ b/library/cpp/yt/containers/sentinel_optional-inl.h
@@ -0,0 +1,118 @@
+#ifndef SENTINEL_OPTIONAL_INL_H_
+#error "Direct inclusion of this file is not allowed, include sentinel_optional.h"
+// For the sake of sane code completion.
+#include "sentinel_optional.h"
+#endif
+
+#include <library/cpp/yt/assert/assert.h>
+
+namespace NYT {
+
+////////////////////////////////////////////////////////////////////////////////
+
+template <class T, class TSentinel>
+constexpr TSentinelOptional<T, TSentinel>::TSentinelOptional(std::nullopt_t) noexcept
+    : Value_(TSentinel::Sentinel)
+{ }
+
+template <class T, class TSentinel>
+constexpr TSentinelOptional<T, TSentinel>::TSentinelOptional(T value) noexcept
+    : Value_(value)
+{ }
+
+template <class T, class TSentinel>
+constexpr TSentinelOptional<T, TSentinel>::TSentinelOptional(std::optional<T> opt) noexcept
+    : Value_(opt ? *opt : TSentinel::Sentinel)
+{ }
+
+template <class T, class TSentinel>
+constexpr TSentinelOptional<T, TSentinel>& TSentinelOptional<T, TSentinel>::operator=(std::nullopt_t) noexcept
+{
+    Value_ = TSentinel::Sentinel;
+    return *this;
+}
+
+template <class T, class TSentinel>
+constexpr TSentinelOptional<T, TSentinel>& TSentinelOptional<T, TSentinel>::operator=(T value) noexcept
+{
+    Value_ = value;
+    return *this;
+}
+
+template <class T, class TSentinel>
+constexpr bool TSentinelOptional<T, TSentinel>::has_value() const noexcept
+{
+    return Value_ != TSentinel::Sentinel;
+}
+
+template <class T, class TSentinel>
+constexpr TSentinelOptional<T, TSentinel>::operator bool() const noexcept
+{
+    return has_value();
+}
+
+template <class T, class TSentinel>
+constexpr T& TSentinelOptional<T, TSentinel>::operator*() noexcept
+{
+    return Value_;
+}
+
+template <class T, class TSentinel>
+constexpr const T& TSentinelOptional<T, TSentinel>::operator*() const noexcept
+{
+    return Value_;
+}
+
+template <class T, class TSentinel>
+constexpr T* TSentinelOptional<T, TSentinel>::operator->() noexcept
+{
+    return &Value_;
+}
+
+template <class T, class TSentinel>
+constexpr const T* TSentinelOptional<T, TSentinel>::operator->() const noexcept
+{
+    return &Value_;
+}
+
+template <class T, class TSentinel>
+T& TSentinelOptional<T, TSentinel>::value() noexcept
+{
+    YT_ASSERT(has_value());
+    return Value_;
+}
+
+template <class T, class TSentinel>
+const T& TSentinelOptional<T, TSentinel>::value() const noexcept
+{
+    YT_ASSERT(has_value());
+    return Value_;
+}
+
+template <class T, class TSentinel>
+constexpr T TSentinelOptional<T, TSentinel>::value_or(T default_value) const noexcept
+{
+    return has_value() ? Value_ : default_value;
+}
+
+template <class T, class TSentinel>
+constexpr void TSentinelOptional<T, TSentinel>::reset() noexcept
+{
+    Value_ = TSentinel::Sentinel;
+}
+
+template <class T, class TSentinel>
+constexpr TSentinelOptional<T, TSentinel>::operator std::optional<T>() const noexcept
+{
+    return has_value() ? std::optional<T>(Value_) : std::nullopt;
+}
+
+template <class T, class TSentinel>
+constexpr bool TSentinelOptional<T, TSentinel>::operator==(std::nullopt_t) const noexcept
+{
+    return !has_value();
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace NYT
diff --git a/library/cpp/yt/containers/sentinel_optional.h b/library/cpp/yt/containers/sentinel_optional.h
new file mode 100644
index 00000000000..6178327e29f
--- /dev/null
+++ b/library/cpp/yt/containers/sentinel_optional.h
@@ -0,0 +1,128 @@
+#pragma once
+
+#include <optional>
+
+namespace NYT {
+
+////////////////////////////////////////////////////////////////////////////////
+
+//! Convenience sentinel traits for structural types (integers, enums, pointers).
+/*!
+ *  Usage: |TSentinelOptional<int, TValueSentinel<-1>>|
+ */
+template <auto V>
+struct TValueSentinel
+{
+    static constexpr auto Sentinel = V;
+};
+
+////////////////////////////////////////////////////////////////////////////////
+
+//! A compact alternative to |std::optional<T>| that uses a sentinel value
+//! to represent the null state rather than an additional boolean field.
+/*!
+ *  The null state is represented by |TSentinel::Sentinel| of type |T|.
+ *  The stored representation is exactly one |T|, so:
+ *    sizeof(TSentinelOptional<T, TSentinel>) == sizeof(T)
+ *    alignof(TSentinelOptional<T, TSentinel>) == alignof(T)
+ *
+ *  Whenever |T| is trivially copyable the class is also trivially copyable,
+ *  which guarantees that |std::atomic<TSentinelOptional<T, TSentinel>>| is lock-free
+ *  if and only if |std::atomic<T>| is lock-free.
+ *
+ *  The interface is a drop-in replacement for |std::optional<T>|.
+ *
+ *  |TSentinel| must provide a |static constexpr T Sentinel| member.
+ *  For structural types, use |TValueSentinel<V>| as a convenience.
+ */
+template <class T, class TSentinel>
+class TSentinelOptional
+{
+public:
+    using value_type = T;
+
+    //! Constructs a null optional (stores the sentinel value).
+    constexpr TSentinelOptional() = default;
+
+    //! Constructs a null optional.
+    constexpr TSentinelOptional(std::nullopt_t) noexcept;
+
+    //! Constructs an optional holding |value|.
+    /*!
+     *  \note The behavior is undefined if |value == TSentinel::Sentinel|.
+     */
+    constexpr TSentinelOptional(T value) noexcept;
+
+    //! Converts from |std::optional<T>|; nullopt maps to the null state.
+    constexpr TSentinelOptional(std::optional<T> opt) noexcept;
+
+    constexpr TSentinelOptional(const TSentinelOptional&) = default;
+    constexpr TSentinelOptional(TSentinelOptional&&) = default;
+
+    constexpr TSentinelOptional& operator=(const TSentinelOptional&) = default;
+    constexpr TSentinelOptional& operator=(TSentinelOptional&&) = default;
+
+    //! Resets to null.
+    constexpr TSentinelOptional& operator=(std::nullopt_t) noexcept;
+
+    //! Assigns |value|.
+    /*!
+     *  \note The behavior is undefined if |value == TSentinel::Sentinel|.
+     */
+    constexpr TSentinelOptional& operator=(T value) noexcept;
+
+    //! Returns |true| iff the optional holds a value (i.e., the stored value differs from the sentinel).
+    [[nodiscard]] constexpr bool has_value() const noexcept;
+
+    //! Returns |true| iff the optional holds a value.
+    constexpr explicit operator bool() const noexcept;
+
+    //! Returns a reference to the held value; behavior is undefined if null.
+    constexpr T& operator*() noexcept;
+    constexpr const T& operator*() const noexcept;
+
+    //! Returns a pointer to the held value; behavior is undefined if null.
+    constexpr T* operator->() noexcept;
+    constexpr const T* operator->() const noexcept;
+
+    //! Returns a reference to the held value; aborts if null.
+    T& value() noexcept;
+    const T& value() const noexcept;
+
+    //! Returns the held value if present, otherwise |default_value|.
+    constexpr T value_or(T default_value) const noexcept;
+
+    //! Resets to null (equivalent to assigning |std::nullopt|).
+    constexpr void reset() noexcept;
+
+    //! Converts to |std::optional<T>|; the null state maps to nullopt.
+    constexpr operator std::optional<T>() const noexcept;
+
+    constexpr bool operator==(const TSentinelOptional& other) const = default;
+    [[nodiscard]] constexpr bool operator==(std::nullopt_t) const noexcept;
+
+private:
+    T Value_ = TSentinel::Sentinel;
+};
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace NYT
+
+//! Defines a type alias for |TSentinelOptional<type, ...>| with an inline sentinel struct.
+/*!
+ *  Example:
+ *    YT_DEFINE_SENTINEL_OPTIONAL(TInstantOpt, TInstant, TInstant::Zero());
+ */
+#define YT_DEFINE_SENTINEL_OPTIONAL(name, type, sentinel_value)  \
+    struct name##Sentinel                                        \
+    {                                                            \
+        static constexpr auto Sentinel = (sentinel_value);       \
+    };                                                           \
+    using name = ::NYT::TSentinelOptional<type, name##Sentinel>
+
+////////////////////////////////////////////////////////////////////////////////
+
+#define SENTINEL_OPTIONAL_INL_H_
+#include "sentinel_optional-inl.h"
+#undef SENTINEL_OPTIONAL_INL_H_
diff --git a/library/cpp/yt/containers/slot_map-inl.h b/library/cpp/yt/containers/slot_map-inl.h
new file mode 100644
index 00000000000..931678e3c40
--- /dev/null
+++ b/library/cpp/yt/containers/slot_map-inl.h
@@ -0,0 +1,96 @@
+#ifndef SLOT_MAP_INL_H_
+#error "Direct inclusion of this file is not allowed, include slot_map.h"
+// For the sake of sane code completion.
+#include "slot_map.h"
+#endif
+
+#include <library/cpp/yt/assert/assert.h>
+
+#include <iterator>
+#include <utility>
+
+namespace NYT {
+
+////////////////////////////////////////////////////////////////////////////////
+
+template <class T>
+bool TDefaultSlotMapTraits::IsEmpty(const T& value) const
+{
+    return !static_cast<bool>(value);
+}
+
+template <class T>
+T TDefaultSlotMapTraits::MakeEmpty() const
+{
+    return T();
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+template <class T, template <class> class TVector, class TTraits>
+constexpr TSlotMap<T, TVector, TTraits>::TSlotMap(TTraits traits)
+    : Traits_(std::move(traits))
+{ }
+
+template <class T, template <class> class TVector, class TTraits>
+TSlotMapIndex TSlotMap<T, TVector, TTraits>::Insert(T value)
+{
+    YT_VERIFY(!Traits_.IsEmpty(value));
+
+    if (!FreeList_.empty()) {
+        auto index = FreeList_.back();
+        FreeList_.pop_back();
+        auto& slot = Slots_[index.Underlying()];
+        YT_ASSERT(Traits_.IsEmpty(slot));
+        slot = std::move(value);
+        return index;
+    }
+
+    auto index = TSlotMapIndex(std::ssize(Slots_));
+    Slots_.push_back(std::move(value));
+    return index;
+}
+
+template <class T, template <class> class TVector, class TTraits>
+T TSlotMap<T, TVector, TTraits>::Extract(TSlotMapIndex index)
+{
+    auto rawIndex = index.Underlying();
+    YT_ASSERT(rawIndex < std::ssize(Slots_));
+
+    auto& slot = Slots_[rawIndex];
+    YT_ASSERT(!Traits_.IsEmpty(slot));
+
+    auto value = std::move(slot);
+    slot = Traits_.template MakeEmpty<T>();
+    FreeList_.push_back(index);
+    return value;
+}
+
+template <class T, template <class> class TVector, class TTraits>
+template <class F>
+void TSlotMap<T, TVector, TTraits>::ExtractAll(F&& func)
+{
+    for (auto& slot : Slots_) {
+        if (!Traits_.IsEmpty(slot)) {
+            func(std::move(slot));
+        }
+    }
+    Slots_.clear();
+    FreeList_.clear();
+}
+
+template <class T, template <class> class TVector, class TTraits>
+bool TSlotMap<T, TVector, TTraits>::IsEmpty() const
+{
+    return Slots_.size() == FreeList_.size();
+}
+
+template <class T, template <class> class TVector, class TTraits>
+int TSlotMap<T, TVector, TTraits>::GetSize() const
+{
+    return std::ssize(Slots_) - std::ssize(FreeList_);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace NYT
diff --git a/library/cpp/yt/containers/slot_map.h b/library/cpp/yt/containers/slot_map.h
new file mode 100644
index 00000000000..f506c0cb42d
--- /dev/null
+++ b/library/cpp/yt/containers/slot_map.h
@@ -0,0 +1,77 @@
+#pragma once
+
+#include <library/cpp/yt/misc/strong_typedef.h>
+
+#include <vector>
+
+namespace NYT {
+
+////////////////////////////////////////////////////////////////////////////////
+
+//! A stable handle into a #TSlotMap; remains valid until the value is extracted.
+YT_DEFINE_STRONG_TYPEDEF(TSlotMapIndex, ui32);
+
+//! A sentinel that never refers to a live slot.
+constexpr auto InvalidSlotMapIndex = TSlotMapIndex(-1);
+
+////////////////////////////////////////////////////////////////////////////////
+
+//! Defines the tombstone marking free slots: a value-initialized |T| convertible
+//! to |false| (empty callback, null pointer). Provide a custom traits object for
+//! types lacking a null state.
+struct TDefaultSlotMapTraits
+{
+    template <class T>
+    bool IsEmpty(const T& value) const;
+
+    template <class T>
+    T MakeEmpty() const;
+};
+
+////////////////////////////////////////////////////////////////////////////////
+
+//! Maps stable indices to values, recycling freed slots via a free list.
+/*!
+ *  Values live in a dense vector; each #Insert returns an index valid until the
+ *  value is extracted. Freed slots hold a tombstone (see #TDefaultSlotMapTraits).
+ *  Inserted values must be non-empty. Not thread-safe.
+ */
+template <
+    class T,
+    template <class> class TVector = std::vector,
+    class TTraits = TDefaultSlotMapTraits>
+class TSlotMap
+{
+public:
+    explicit constexpr TSlotMap(TTraits traits = {});
+
+    //! Inserts a non-empty #value; returns its stable index.
+    TSlotMapIndex Insert(T value);
+
+    //! Extracts and returns the value at #index, freeing the slot.
+    /*!
+     *  #index must refer to a live slot (as returned by a prior #Insert and not
+     *  yet extracted).
+     */
+    T Extract(TSlotMapIndex index);
+
+    //! Moves each live value into #func, then clears the map.
+    template <class F>
+    void ExtractAll(F&& func);
+
+    bool IsEmpty() const;
+    int GetSize() const;
+
+private:
+    Y_NO_UNIQUE_ADDRESS TTraits Traits_;
+    TVector<T> Slots_;
+    TVector<TSlotMapIndex> FreeList_;
+};
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace NYT
+
+#define SLOT_MAP_INL_H_
+#include "slot_map-inl.h"
+#undef SLOT_MAP_INL_H_
diff --git a/library/cpp/yt/containers/static_ring_queue-inl.h b/library/cpp/yt/containers/static_ring_queue-inl.h
new file mode 100644
index 00000000000..3d4f553ab80
--- /dev/null
+++ b/library/cpp/yt/containers/static_ring_queue-inl.h
@@ -0,0 +1,69 @@
+#ifndef STATIC_RING_QUEUE_INL_H_
+#error "Direct inclusion of this file is not allowed, include static_ring_queue.h"
+// For the sake of sane code completion.
+#include "static_ring_queue.h"
+#endif
+
+#include <library/cpp/yt/assert/assert.h>
+
+#include <util/system/types.h>
+
+#include <algorithm>
+#include <iterator>
+
+namespace NYT {
+
+////////////////////////////////////////////////////////////////////////////////
+
+template <class T, size_t Capacity>
+void TStaticRingQueue<T, Capacity>::Append(const T* begin, const T* end)
+{
+    // Determine input tail.
+    if (std::distance(begin, end) > static_cast<i64>(Capacity)) {
+        begin = end - Capacity;
+    }
+
+    size_t appendSize = std::distance(begin, end);
+
+    if (Size_ > Capacity - appendSize) {
+        Size_ = Capacity;
+    } else {
+        Size_ += appendSize;
+    }
+
+    EndOffset_ += appendSize;
+    if (EndOffset_ >= Capacity) {
+        EndOffset_ -= Capacity;
+        YT_VERIFY(EndOffset_ < Capacity);
+    }
+
+    size_t tailSize = std::min<size_t>(EndOffset_, appendSize);
+
+    std::copy(end - tailSize, end, Buffer_ + EndOffset_ - tailSize);
+    end -= tailSize;
+    std::copy(begin, end, Buffer_ + Capacity - (end - begin));
+}
+
+template <class T, size_t Capacity>
+void TStaticRingQueue<T, Capacity>::CopyTailTo(size_t copySize, T* begin) const
+{
+    YT_VERIFY(copySize <= Size_);
+
+    if (copySize > EndOffset_) {
+        size_t tailSize = copySize - EndOffset_;
+        std::copy(Buffer_ + Capacity - tailSize, Buffer_ + Capacity, begin);
+        std::copy(Buffer_, Buffer_ + EndOffset_, begin + tailSize);
+    } else {
+        std::copy(Buffer_ + EndOffset_ - copySize, Buffer_ + EndOffset_, begin);
+    }
+}
+
+template <class T, size_t Capacity>
+size_t TStaticRingQueue<T, Capacity>::Size() const
+{
+    return Size_;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace NYT
diff --git a/library/cpp/yt/containers/static_ring_queue.h b/library/cpp/yt/containers/static_ring_queue.h
new file mode 100644
index 00000000000..acb5c09c4e7
--- /dev/null
+++ b/library/cpp/yt/containers/static_ring_queue.h
@@ -0,0 +1,29 @@
+#pragma once
+
+#include <cstddef>
+
+namespace NYT {
+
+////////////////////////////////////////////////////////////////////////////////
+
+template <class T, size_t Capacity>
+class TStaticRingQueue
+{
+public:
+    void Append(const T* begin, const T* end);
+    void CopyTailTo(size_t copySize, T* begin) const;
+    size_t Size() const;
+
+private:
+    T Buffer_[Capacity];
+    size_t EndOffset_ = 0;
+    size_t Size_ = 0;
+};
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace NYT
+
+#define STATIC_RING_QUEUE_INL_H_
+#include "static_ring_queue-inl.h"
+#undef STATIC_RING_QUEUE_INL_H_
diff --git a/library/cpp/yt/containers/unittests/default_map_ut.cpp b/library/cpp/yt/containers/unittests/default_map_ut.cpp
new file mode 100644
index 00000000000..029fdb041c2
--- /dev/null
+++ b/library/cpp/yt/containers/unittests/default_map_ut.cpp
@@ -0,0 +1,27 @@
+#include <library/cpp/yt/containers/default_map.h>
+
+#include <library/cpp/testing/gtest/gtest.h>
+
+#include <util/generic/hash_table.h>
+
+namespace NYT {
+namespace {
+
+////////////////////////////////////////////////////////////////////////////////
+
+TEST(TDefaultMapTest, Common)
+{
+    TDefaultMap<THashMap<int, std::string>> defaultMap("Hello");
+    EXPECT_EQ(defaultMap[1], "Hello");
+    defaultMap[1].append(", World");
+    EXPECT_EQ(defaultMap[1], "Hello, World");
+    defaultMap.insert({2, "abc"});
+    EXPECT_EQ(defaultMap[2], "abc");
+    EXPECT_EQ(defaultMap.find(3), defaultMap.end());
+    EXPECT_EQ(defaultMap.GetOrDefault(7), "Hello");
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace
+} // namespace NYT
diff --git a/library/cpp/yt/containers/unittests/expiring_set_ut.cpp b/library/cpp/yt/containers/unittests/expiring_set_ut.cpp
new file mode 100644
index 00000000000..96e09d64164
--- /dev/null
+++ b/library/cpp/yt/containers/unittests/expiring_set_ut.cpp
@@ -0,0 +1,132 @@
+#include <library/cpp/yt/containers/expiring_set.h>
+
+#include <library/cpp/testing/gtest/gtest.h>
+
+namespace NYT {
+namespace {
+
+////////////////////////////////////////////////////////////////////////////////
+
+TInstant operator""_ts(unsigned long long seconds)
+{
+    return TInstant::Zero() + TDuration::Seconds(seconds);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+TEST(TExpiringSetTest, Empty)
+{
+    TExpiringSet<int> set;
+    EXPECT_EQ(set.GetSize(), 0);
+}
+
+TEST(TExpiringSetTest, ExpireSingle)
+{
+    TExpiringSet<int> set;
+    set.SetTtl(TDuration::Seconds(2));
+
+    set.Insert(0_ts, 1);
+    EXPECT_EQ(set.GetSize(), 1);
+
+    set.Expire(1_ts);
+    EXPECT_EQ(set.GetSize(), 1);
+
+    set.Expire(2_ts);
+    EXPECT_EQ(set.GetSize(), 0);
+}
+
+TEST(TExpiringSetTest, ExpireBatch)
+{
+    TExpiringSet<int> set;
+    set.SetTtl(TDuration::Seconds(2));
+
+    set.InsertMany(0_ts, std::vector<int>{1, 2, 3});
+    EXPECT_EQ(set.GetSize(), 3);
+
+    set.Expire(1_ts);
+    EXPECT_EQ(set.GetSize(), 3);
+
+    set.Expire(2_ts);
+    EXPECT_EQ(set.GetSize(), 0);
+}
+
+TEST(TExpiringSetTest, Reinsert)
+{
+    TExpiringSet<int> set;
+    set.SetTtl(TDuration::Seconds(2));
+
+    set.Insert(0_ts, 1);
+    EXPECT_EQ(set.GetSize(), 1);
+
+    set.Insert(1_ts, 1);
+    EXPECT_EQ(set.GetSize(), 1);
+
+    set.Expire(2_ts);
+    EXPECT_EQ(set.GetSize(), 1);
+
+    set.Expire(3_ts);
+    EXPECT_EQ(set.GetSize(), 0);
+}
+
+TEST(TExpiringSetTest, Contains)
+{
+    TExpiringSet<int> set;
+    set.SetTtl(TDuration::Seconds(1));
+
+    EXPECT_FALSE(set.Contains(1));
+
+    set.Insert(0_ts, 1);
+    EXPECT_TRUE(set.Contains(1));
+
+    set.Expire(1_ts);
+    EXPECT_FALSE(set.Contains(1));
+}
+
+TEST(TExpiringSetTest, Clear)
+{
+    TExpiringSet<int> set;
+    set.SetTtl(TDuration::Seconds(1));
+
+    set.Insert(0_ts, 1);
+    EXPECT_EQ(set.GetSize(), 1);
+    EXPECT_TRUE(set.Contains(1));
+
+    set.Clear();
+    EXPECT_EQ(set.GetSize(), 0);
+    EXPECT_FALSE(set.Contains(1));
+}
+
+TEST(TExpiringSetTest, RemoveBeforeExpire)
+{
+    TExpiringSet<int> set;
+    set.SetTtl(TDuration::Seconds(1));
+
+    set.Insert(0_ts, 1);
+    EXPECT_EQ(set.GetSize(), 1);
+    EXPECT_TRUE(set.Contains(1));
+
+    set.Remove(1);
+    EXPECT_EQ(set.GetSize(), 0);
+    EXPECT_FALSE(set.Contains(1));
+}
+
+TEST(TExpiringSetTest, RemoveAfterExpire)
+{
+    TExpiringSet<int> set;
+    set.SetTtl(TDuration::Seconds(1));
+
+    set.Insert(0_ts, 1);
+    set.Expire(2_ts);
+
+    EXPECT_EQ(set.GetSize(), 0);
+    EXPECT_FALSE(set.Contains(1));
+
+    set.Remove(1);
+    EXPECT_EQ(set.GetSize(), 0);
+    EXPECT_FALSE(set.Contains(1));
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace
+} // namespace NYT
diff --git a/library/cpp/yt/containers/unittests/non_empty_ut.cpp b/library/cpp/yt/containers/unittests/non_empty_ut.cpp
new file mode 100644
index 00000000000..a4dde36d047
--- /dev/null
+++ b/library/cpp/yt/containers/unittests/non_empty_ut.cpp
@@ -0,0 +1,109 @@
+#include <library/cpp/testing/gtest/gtest.h>
+
+#include <library/cpp/yt/containers/non_empty.h>
+
+#include <vector>
+#include <string>
+
+namespace NYT {
+namespace {
+
+////////////////////////////////////////////////////////////////////////////////
+
+TEST(TNonEmptyTest, ConstructFromNonEmptyVector)
+{
+    std::vector<int> vec = {1, 2, 3};
+    TNonEmpty<std::vector<int>> nonEmpty(vec);
+
+    EXPECT_EQ(nonEmpty.size(), 3u);
+    EXPECT_EQ(nonEmpty[0], 1);
+    EXPECT_EQ(nonEmpty[1], 2);
+    EXPECT_EQ(nonEmpty[2], 3);
+}
+
+TEST(TNonEmptyTest, ConstructFromEmptyVectorThrows)
+{
+#ifdef NDEBUG
+    GTEST_SKIP() << "Assertions are disabled in release build";
+#endif
+
+    std::vector<int> vec;
+    EXPECT_DEATH(
+        { TNonEmpty<std::vector<int>> nonEmpty(vec); },
+        ".*"
+    );
+}
+
+TEST(TNonEmptyTest, FrontAndBack)
+{
+    TNonEmpty<std::vector<int>> nonEmpty = {10, 20, 30};
+
+    EXPECT_EQ(nonEmpty.front(), 10);
+    EXPECT_EQ(nonEmpty.back(), 30);
+
+    nonEmpty.front() = 100;
+    nonEmpty.back() = 300;
+
+    EXPECT_EQ(nonEmpty[0], 100);
+    EXPECT_EQ(nonEmpty[2], 300);
+}
+
+TEST(TNonEmptyTest, PushBackAndEmplaceBack)
+{
+    TNonEmpty<std::vector<std::string>> nonEmpty = {"hello"};
+
+    nonEmpty.push_back("world");
+    EXPECT_EQ(nonEmpty.size(), 2u);
+    EXPECT_EQ(nonEmpty[1], "world");
+
+    nonEmpty.emplace_back("test");
+    EXPECT_EQ(nonEmpty.size(), 3u);
+    EXPECT_EQ(nonEmpty[2], "test");
+}
+
+TEST(TNonEmptyTest, PopBackMaintainsNonEmpty)
+{
+    TNonEmpty<std::vector<int>> nonEmpty = {1, 2, 3};
+
+    nonEmpty.pop_back();
+    EXPECT_EQ(nonEmpty.size(), 2u);
+
+    nonEmpty.pop_back();
+    EXPECT_EQ(nonEmpty.size(), 1u);
+
+#ifdef NDEBUG
+    GTEST_SKIP() << "Assertions are disabled in release build";
+#endif
+
+    // Cannot pop the last element
+    EXPECT_DEATH(
+        { nonEmpty.pop_back(); },
+        ".*"
+    );
+}
+
+TEST(TNonEmptyTest, ResizeWithAssertion)
+{
+    TNonEmpty<std::vector<int>> nonEmpty = {1, 2, 3};
+
+    nonEmpty.resize(5);
+    EXPECT_EQ(nonEmpty.size(), 5u);
+
+    nonEmpty.resize(2, 99);
+    EXPECT_EQ(nonEmpty.size(), 2u);
+
+#ifdef NDEBUG
+    GTEST_SKIP() << "Assertions are disabled in release build";
+#endif
+
+    // Cannot resize to 0
+    EXPECT_DEATH(
+        { nonEmpty.resize(0); },
+        ".*"
+    );
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace
+} // namespace NYT
diff --git a/library/cpp/yt/containers/unittests/ordered_hash_map_ut.cpp b/library/cpp/yt/containers/unittests/ordered_hash_map_ut.cpp
new file mode 100644
index 00000000000..aeebc5bed5a
--- /dev/null
+++ b/library/cpp/yt/containers/unittests/ordered_hash_map_ut.cpp
@@ -0,0 +1,149 @@
+#include <library/cpp/yt/containers/ordered_hash_map.h>
+
+#include <library/cpp/testing/gtest/gtest.h>
+
+#include <random>
+
+namespace NYT {
+namespace {
+
+////////////////////////////////////////////////////////////////////////////////
+
+struct TInt
+{
+    std::vector<int> Data;
+
+    explicit TInt(int value = 0)
+        : Data(1, value)
+    { }
+
+    operator int () const
+    {
+        return Data[0];
+    }
+};
+
+TInt operator""_i(unsigned long long n)
+{
+    return TInt(n);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+TEST(TOrderedHashMapTest, Trivial)
+{
+    TOrderedHashMap<TInt, TInt> map;
+
+    {
+        auto [it, success] =  map.emplace(1_i, 10_i);
+        EXPECT_TRUE(success);
+        EXPECT_EQ(1_i, it->first);
+        EXPECT_EQ(10_i, it->second);
+    }
+
+    {
+        auto [it, success] =  map.emplace(1_i, 20_i);
+        EXPECT_FALSE(success);
+        EXPECT_EQ(1_i, it->first);
+        EXPECT_EQ(10_i, it->second);
+    }
+
+    {
+        auto it = map.find(2_i);
+        EXPECT_EQ(map.end(), it);
+    }
+
+    {
+        auto it = map.find(1_i);
+        EXPECT_EQ(map.begin(), it);
+        EXPECT_EQ(1_i, it->first);
+        EXPECT_EQ(10_i, it->second);
+    }
+
+    {
+        auto result = map.erase(1_i);
+        EXPECT_TRUE(result);
+        EXPECT_EQ(map.end(), map.find(1_i));
+    }
+
+    {
+        map.emplace(2_i, 20_i);
+        auto it = map.find(2_i);
+        EXPECT_EQ(20_i, it->second);
+        map.erase(it);
+        EXPECT_EQ(map.end(), map.find(2_i));
+    }
+}
+
+TEST(TOrderedHashMapTest, Order)
+{
+    std::vector<std::pair<TInt, TInt>> elements;
+    TOrderedHashMap<TInt, TInt> map;
+    int n = 100;
+
+    for (int i = 0; i < n; ++i) {
+        elements.emplace_back(TInt(i * 13 % (n + 1)), TInt(i * 10));
+        map.emplace(elements.back().first, elements.back().second);
+    }
+
+    auto check = [&] {
+        ASSERT_EQ(elements.size(), map.size());
+
+        auto vecIt = elements.begin();
+        auto mapIt = map.begin();
+        while (vecIt != elements.end() && mapIt != map.end()) {
+            ASSERT_EQ(vecIt->first, mapIt->first);
+            ASSERT_EQ(vecIt->second, mapIt->second);
+            ++vecIt;
+            ++mapIt;
+        }
+        ASSERT_EQ(vecIt, elements.end());
+        ASSERT_EQ(mapIt, map.end());
+    };
+
+    check();
+
+    // Now remove part of elements and repeat check.
+    std::vector<std::pair<TInt, TInt>> keptElements;
+    for (int i = 0; i < n; ++i) {
+        if (i % 3 == 1) {
+            keptElements.push_back(elements[i]);
+            continue;
+        }
+        map.erase(elements[i].first);
+    }
+    elements = std::move(keptElements);
+
+    check();
+}
+
+
+TEST(TOrderedHashMapTest, Misc)
+{
+    TOrderedHashMap<TInt, TInt> map;
+
+    // operator[].
+    map[1_i] = 10_i;
+    EXPECT_EQ(map[1_i], 10_i);
+    EXPECT_EQ(map.begin()->second, 10_i);
+    map[1_i] = 20_i;
+    EXPECT_EQ(map.begin()->second, 20_i);
+    map.begin()->second = 30_i;
+    EXPECT_EQ(map[1_i], 30_i);
+
+    // size().
+    EXPECT_EQ(map.size(), 1u);
+
+    // contains().
+    EXPECT_TRUE(map.contains(1_i));
+    EXPECT_FALSE(map.contains(2_i));
+
+    // clear().
+    map.clear();
+    EXPECT_EQ(map.size(), 0u);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace
+} // namespace NYT
diff --git a/library/cpp/yt/containers/unittests/ring_queue_ut.cpp b/library/cpp/yt/containers/unittests/ring_queue_ut.cpp
new file mode 100644
index 00000000000..a425773650d
--- /dev/null
+++ b/library/cpp/yt/containers/unittests/ring_queue_ut.cpp
@@ -0,0 +1,134 @@
+#include <library/cpp/yt/containers/ring_queue.h>
+
+#include <library/cpp/testing/gtest/gtest.h>
+
+#include <library/cpp/yt/memory/new.h>
+#include <library/cpp/yt/memory/ref_counted.h>
+
+#include <cstdlib>
+#include <deque>
+#include <iterator>
+
+namespace NYT {
+namespace {
+
+////////////////////////////////////////////////////////////////////////////////
+
+TEST(TRingQueueTest, PodRandomOperations)
+{
+    TRingQueue<int> queue;
+    EXPECT_EQ(0, std::ssize(queue));
+    EXPECT_TRUE(queue.empty());
+    EXPECT_EQ(queue.begin(), queue.end());
+
+    const int N = 100000;
+    // We perform same sequence of operations on this deque.
+    std::deque<int> deque;
+
+    for (int i = 0; i < N; ++i) {
+        EXPECT_EQ(queue.size(), deque.size());
+        EXPECT_EQ(queue.empty(), deque.empty());
+        if (!queue.empty()) {
+            EXPECT_EQ(queue.back(), deque.back());
+            EXPECT_EQ(queue.front(), deque.front());
+        }
+
+        int r = rand() % 100;
+        if (r == 0) {
+            queue.clear();
+            deque.clear();
+            EXPECT_EQ(0, std::ssize(queue));
+            EXPECT_TRUE(queue.empty());
+            EXPECT_EQ(queue.begin(), queue.end());
+        } else if (r < 10) {
+            auto queueIterator = queue.begin();
+            auto dequeIterator = deque.begin();
+            while (dequeIterator != deque.end()) {
+                EXPECT_NE(queueIterator, queue.end());
+                EXPECT_EQ(*queueIterator, *dequeIterator);
+                queue.move_forward(queueIterator);
+                ++dequeIterator;
+            }
+            EXPECT_EQ(queueIterator, queue.end());
+        } else if (r < 55 && !queue.empty()) {
+            queue.pop();
+            deque.pop_front();
+        } else {
+            int value = rand();
+            queue.push(value);
+            deque.push_back(value);
+        }
+    }
+}
+
+class TFoo
+    : public virtual TRefCounted
+{
+public:
+    explicit TFoo(int& counter)
+        : Counter_(counter)
+    {
+        ++Counter_;
+    }
+
+    ~TFoo()
+    {
+        --Counter_;
+    }
+
+private:
+    int& Counter_;
+};
+
+DECLARE_REFCOUNTED_TYPE(TFoo)
+DEFINE_REFCOUNTED_TYPE(TFoo)
+
+TEST(TRingQueueTest, TestLifetimeWithRefCount)
+{
+    const int N = 100000;
+    int counter = 0;
+
+    {
+        TRingQueue<TFooPtr> queue;
+
+        for (int i = 0; i < N; ++i) {
+            queue.push(New<TFoo>(counter));
+            EXPECT_EQ(counter, std::ssize(queue));
+        }
+        queue.clear();
+        EXPECT_EQ(counter, 0);
+    }
+
+    {
+        TRingQueue<TFooPtr> queue;
+
+        for (int i = 0; i < N; ++i) {
+            queue.push(New<TFoo>(counter));
+            EXPECT_EQ(counter, std::ssize(queue));
+            queue.pop();
+            EXPECT_EQ(counter, std::ssize(queue));
+        }
+        queue.clear();
+        EXPECT_EQ(counter, 0);
+    }
+
+    {
+        TRingQueue<TFooPtr> queue;
+
+        for (int i = 0; i < N; ++i) {
+            if (!queue.empty() && rand() % 2 == 0) {
+                queue.pop();
+            } else {
+                queue.push(New<TFoo>(counter));
+            }
+            EXPECT_EQ(counter, std::ssize(queue));
+        }
+        queue.clear();
+        EXPECT_EQ(counter, 0);
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace
+} // namespace NYT
diff --git a/library/cpp/yt/containers/unittests/sentinel_optional_ut.cpp b/library/cpp/yt/containers/unittests/sentinel_optional_ut.cpp
new file mode 100644
index 00000000000..3bce427555a
--- /dev/null
+++ b/library/cpp/yt/containers/unittests/sentinel_optional_ut.cpp
@@ -0,0 +1,291 @@
+#include <library/cpp/testing/gtest/gtest.h>
+
+#include <library/cpp/yt/containers/sentinel_optional.h>
+
+#include <atomic>
+#include <type_traits>
+
+namespace NYT {
+namespace {
+
+////////////////////////////////////////////////////////////////////////////////
+
+YT_DEFINE_SENTINEL_OPTIONAL(TIntOpt, int, -1);
+
+////////////////////////////////////////////////////////////////////////////////
+
+TEST(TSentinelOptionalTest, DefaultConstructNull)
+{
+    TIntOpt opt;
+    EXPECT_FALSE(opt.has_value());
+    EXPECT_FALSE(static_cast<bool>(opt));
+    EXPECT_EQ(opt, std::nullopt);
+}
+
+TEST(TSentinelOptionalTest, NulloptConstruct)
+{
+    TIntOpt opt(std::nullopt);
+    EXPECT_FALSE(opt.has_value());
+    EXPECT_EQ(opt, std::nullopt);
+}
+
+TEST(TSentinelOptionalTest, ValueConstruct)
+{
+    TIntOpt opt(42);
+    EXPECT_TRUE(opt.has_value());
+    EXPECT_TRUE(static_cast<bool>(opt));
+    EXPECT_EQ(*opt, 42);
+}
+
+TEST(TSentinelOptionalTest, ZeroIsNotNull)
+{
+    TIntOpt opt(0);
+    EXPECT_TRUE(opt.has_value());
+    EXPECT_EQ(*opt, 0);
+}
+
+TEST(TSentinelOptionalTest, AssignValue)
+{
+    TIntOpt opt;
+    opt = 7;
+    EXPECT_TRUE(opt.has_value());
+    EXPECT_EQ(*opt, 7);
+}
+
+TEST(TSentinelOptionalTest, AssignNullopt)
+{
+    TIntOpt opt(7);
+    opt = std::nullopt;
+    EXPECT_FALSE(opt.has_value());
+}
+
+TEST(TSentinelOptionalTest, Reset)
+{
+    TIntOpt opt(7);
+    opt.reset();
+    EXPECT_FALSE(opt.has_value());
+    EXPECT_EQ(opt, std::nullopt);
+}
+
+TEST(TSentinelOptionalTest, Dereference)
+{
+    TIntOpt opt(99);
+    EXPECT_EQ(*opt, 99);
+    *opt = 100;
+    EXPECT_EQ(*opt, 100);
+}
+
+TEST(TSentinelOptionalTest, ArrowOperator)
+{
+    TSentinelOptional<int, TValueSentinel<0>> opt(42);
+    EXPECT_EQ(*opt.operator->(), 42);
+}
+
+TEST(TSentinelOptionalTest, ValueChecked)
+{
+    TIntOpt opt(5);
+    EXPECT_EQ(opt.value(), 5);
+    opt.value() = 10;
+    EXPECT_EQ(opt.value(), 10);
+}
+
+TEST(TSentinelOptionalTest, ValueOr)
+{
+    TIntOpt opt;
+    EXPECT_EQ(opt.value_or(42), 42);
+
+    opt = 7;
+    EXPECT_EQ(opt.value_or(42), 7);
+}
+
+TEST(TSentinelOptionalTest, EqualityBetweenOptionals)
+{
+    TIntOpt a;
+    TIntOpt b;
+    EXPECT_EQ(a, b);
+
+    a = 5;
+    EXPECT_NE(a, b);
+
+    b = 5;
+    EXPECT_EQ(a, b);
+
+    b = 6;
+    EXPECT_NE(a, b);
+}
+
+TEST(TSentinelOptionalTest, EqualityWithNullopt)
+{
+    TIntOpt opt;
+    EXPECT_EQ(opt, std::nullopt);
+    EXPECT_EQ(std::nullopt, opt);
+
+    opt = 1;
+    EXPECT_NE(opt, std::nullopt);
+    EXPECT_NE(std::nullopt, opt);
+}
+
+TEST(TSentinelOptionalTest, CopyConstruct)
+{
+    TIntOpt a(3);
+    TIntOpt b = a;
+    EXPECT_EQ(*b, 3);
+    *a = 4;
+    EXPECT_EQ(*b, 3); // b is independent
+}
+
+TEST(TSentinelOptionalTest, CopyAssign)
+{
+    TIntOpt a(3);
+    TIntOpt b;
+    b = a;
+    EXPECT_EQ(*b, 3);
+}
+
+TEST(TSentinelOptionalTest, ConstAccess)
+{
+    const TIntOpt opt(77);
+    EXPECT_EQ(*opt, 77);
+    EXPECT_EQ(opt.value(), 77);
+    EXPECT_EQ(*opt.operator->(), 77);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Pointer sentinel.
+
+YT_DEFINE_SENTINEL_OPTIONAL(TPtrOpt, int*, nullptr);
+
+TEST(TSentinelOptionalTest, PointerSentinel)
+{
+    TPtrOpt opt;
+    EXPECT_FALSE(opt.has_value());
+
+    int x = 42;
+    opt = &x;
+    EXPECT_TRUE(opt.has_value());
+    EXPECT_EQ(*opt, &x);
+    EXPECT_EQ(**opt, 42);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Enum sentinel.
+
+enum class EColor
+{
+    Red,
+    Green,
+    Blue,
+    Unknown,
+};
+
+YT_DEFINE_SENTINEL_OPTIONAL(TColorOpt, EColor, EColor::Unknown);
+
+TEST(TSentinelOptionalTest, EnumSentinel)
+{
+    TColorOpt opt;
+    EXPECT_FALSE(opt.has_value());
+
+    opt = EColor::Red;
+    EXPECT_TRUE(opt.has_value());
+    EXPECT_EQ(*opt, EColor::Red);
+
+    opt.reset();
+    EXPECT_FALSE(opt.has_value());
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Layout and atomic guarantees.
+
+TEST(TSentinelOptionalTest, SizeEqualsUnderlyingType)
+{
+    static_assert(sizeof(TIntOpt) == sizeof(int));
+    static_assert(sizeof(TPtrOpt) == sizeof(int*));
+    static_assert(sizeof(TColorOpt) == sizeof(EColor));
+}
+
+TEST(TSentinelOptionalTest, TriviallyCopyable)
+{
+    static_assert(std::is_trivially_copyable_v<TIntOpt>);
+    static_assert(std::is_trivially_copyable_v<TPtrOpt>);
+    static_assert(std::is_trivially_copyable_v<TColorOpt>);
+}
+
+TEST(TSentinelOptionalTest, AtomicLockFree)
+{
+    // std::atomic<TSentinelOptional<T, S>> must be lock-free whenever
+    // std::atomic<T> is lock-free.
+    if (std::atomic<int>{}.is_lock_free()) {
+        EXPECT_TRUE((std::atomic<TIntOpt>{}.is_lock_free()));
+    }
+    if (std::atomic<int*>{}.is_lock_free()) {
+        EXPECT_TRUE((std::atomic<TPtrOpt>{}.is_lock_free()));
+    }
+    if (std::atomic<EColor>{}.is_lock_free()) {
+        EXPECT_TRUE((std::atomic<TColorOpt>{}.is_lock_free()));
+    }
+}
+
+TEST(TSentinelOptionalTest, AtomicStoreLoad)
+{
+    std::atomic<TIntOpt> a;
+    a.store(TIntOpt{});
+    EXPECT_FALSE(a.load().has_value());
+
+    a.store(TIntOpt{42});
+    EXPECT_EQ(*a.load(), 42);
+
+    a.store(std::nullopt);
+    EXPECT_FALSE(a.load().has_value());
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// std::optional conversions.
+
+TEST(TSentinelOptionalTest, FromStdOptionalNull)
+{
+    TIntOpt opt = std::optional<int>{};
+    EXPECT_FALSE(opt.has_value());
+    EXPECT_EQ(opt, std::nullopt);
+}
+
+TEST(TSentinelOptionalTest, FromStdOptionalValue)
+{
+    TIntOpt opt = std::optional<int>{42};
+    EXPECT_TRUE(opt.has_value());
+    EXPECT_EQ(*opt, 42);
+}
+
+TEST(TSentinelOptionalTest, ToStdOptionalNull)
+{
+    TIntOpt opt;
+    std::optional<int> stdOpt = opt;
+    EXPECT_FALSE(stdOpt.has_value());
+}
+
+TEST(TSentinelOptionalTest, ToStdOptionalValue)
+{
+    TIntOpt opt(7);
+    std::optional<int> stdOpt = opt;
+    EXPECT_TRUE(stdOpt.has_value());
+    EXPECT_EQ(*stdOpt, 7);
+}
+
+TEST(TSentinelOptionalTest, RoundTripThroughStdOptional)
+{
+    TIntOpt original(99);
+    TIntOpt roundTripped = std::optional<int>(original);
+    EXPECT_TRUE(roundTripped.has_value());
+    EXPECT_EQ(*roundTripped, 99);
+}
+
+TEST(TSentinelOptionalTest, RoundTripNullThroughStdOptional)
+{
+    TIntOpt original;
+    TIntOpt roundTripped = std::optional<int>(original);
+    EXPECT_FALSE(roundTripped.has_value());
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace
+} // namespace NYT
diff --git a/library/cpp/yt/containers/unittests/slot_map_ut.cpp b/library/cpp/yt/containers/unittests/slot_map_ut.cpp
new file mode 100644
index 00000000000..68488b6c6eb
--- /dev/null
+++ b/library/cpp/yt/containers/unittests/slot_map_ut.cpp
@@ -0,0 +1,206 @@
+#include <library/cpp/yt/containers/slot_map.h>
+
+#include <library/cpp/yt/compact_containers/compact_vector.h>
+
+#include <library/cpp/testing/gtest/gtest.h>
+
+#include <memory>
+#include <vector>
+
+namespace NYT {
+namespace {
+
+////////////////////////////////////////////////////////////////////////////////
+
+using TIntPtr = std::shared_ptr<int>;
+
+TIntPtr MakeInt(int value)
+{
+    return std::make_shared<int>(value);
+}
+
+std::vector<int> DrainSorted(TSlotMap<TIntPtr>& map)
+{
+    std::vector<int> result;
+    map.ExtractAll([&] (TIntPtr value) {
+        result.push_back(*value);
+    });
+    std::sort(result.begin(), result.end());
+    return result;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+TEST(TSlotMapTest, Empty)
+{
+    TSlotMap<TIntPtr> map;
+    EXPECT_TRUE(map.IsEmpty());
+    EXPECT_EQ(0, map.GetSize());
+}
+
+TEST(TSlotMapTest, InsertAndExtract)
+{
+    TSlotMap<TIntPtr> map;
+
+    auto index = map.Insert(MakeInt(42));
+    EXPECT_FALSE(map.IsEmpty());
+    EXPECT_EQ(1, map.GetSize());
+
+    auto value = map.Extract(index);
+    EXPECT_EQ(42, *value);
+    EXPECT_TRUE(map.IsEmpty());
+    EXPECT_EQ(0, map.GetSize());
+}
+
+TEST(TSlotMapTest, DistinctIndices)
+{
+    TSlotMap<TIntPtr> map;
+
+    auto a = map.Insert(MakeInt(1));
+    auto b = map.Insert(MakeInt(2));
+    auto c = map.Insert(MakeInt(3));
+
+    EXPECT_NE(a, b);
+    EXPECT_NE(b, c);
+    EXPECT_NE(a, c);
+    EXPECT_EQ(3, map.GetSize());
+    EXPECT_THAT(DrainSorted(map), ::testing::ElementsAre(1, 2, 3));
+}
+
+TEST(TSlotMapTest, SlotReuse)
+{
+    TSlotMap<TIntPtr> map;
+
+    auto a = map.Insert(MakeInt(1));
+    map.Insert(MakeInt(2));
+
+    EXPECT_EQ(1, *map.Extract(a));
+
+    // The freed slot should be recycled by the next insert.
+    auto c = map.Insert(MakeInt(3));
+    EXPECT_EQ(a, c);
+    EXPECT_EQ(2, map.GetSize());
+    EXPECT_THAT(DrainSorted(map), ::testing::ElementsAre(2, 3));
+}
+
+TEST(TSlotMapTest, ExtractAllSkipsHoles)
+{
+    TSlotMap<TIntPtr> map;
+
+    auto a = map.Insert(MakeInt(1));
+    map.Insert(MakeInt(2));
+    auto c = map.Insert(MakeInt(3));
+    map.Insert(MakeInt(4));
+
+    map.Extract(a);
+    map.Extract(c);
+
+    EXPECT_THAT(DrainSorted(map), ::testing::ElementsAre(2, 4));
+    EXPECT_TRUE(map.IsEmpty());
+
+    // The map is fully reusable after draining.
+    auto index = map.Insert(MakeInt(5));
+    EXPECT_EQ(TSlotMapIndex(0), index);
+    EXPECT_EQ(5, *map.Extract(index));
+}
+
+TEST(TSlotMapTest, DestroysValueOnExtract)
+{
+    TSlotMap<TIntPtr> map;
+
+    auto value = MakeInt(1);
+    std::weak_ptr<int> weak = value;
+    auto index = map.Insert(std::move(value));
+    EXPECT_FALSE(weak.expired());
+
+    // The map no longer holds a reference; only the extracted value does.
+    auto extracted = map.Extract(index);
+    extracted.reset();
+    EXPECT_TRUE(weak.expired());
+}
+
+TEST(TSlotMapTest, DestroysValuesOnExtractAll)
+{
+    TSlotMap<TIntPtr> map;
+
+    auto value = MakeInt(1);
+    std::weak_ptr<int> weak = value;
+    map.Insert(std::move(value));
+
+    map.ExtractAll([] (TIntPtr) { });
+    EXPECT_TRUE(weak.expired());
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+// A stateful traits object using a caller-supplied sentinel as the tombstone.
+struct TSentinelTraits
+{
+    int Sentinel = 0;
+
+    template <class U>
+    bool IsEmpty(const U& value) const
+    {
+        return value == Sentinel;
+    }
+
+    template <class U>
+    U MakeEmpty() const
+    {
+        return Sentinel;
+    }
+};
+
+TEST(TSlotMapTest, CustomTraits)
+{
+    TSlotMap<int, std::vector, TSentinelTraits> map(TSentinelTraits{.Sentinel = -1});
+
+    // Zero is an ordinary value here since the sentinel is -1.
+    auto a = map.Insert(0);
+    map.Insert(5);
+    EXPECT_EQ(2, map.GetSize());
+
+    EXPECT_EQ(0, map.Extract(a));
+    auto c = map.Insert(7);
+    EXPECT_EQ(a, c);
+
+    std::vector<int> values;
+    map.ExtractAll([&] (int value) {
+        values.push_back(value);
+    });
+    std::sort(values.begin(), values.end());
+    EXPECT_THAT(values, ::testing::ElementsAre(5, 7));
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+template <class U>
+using TCompactVector2 = TCompactVector<U, 2>;
+
+TEST(TSlotMapTest, CustomVector)
+{
+    TSlotMap<TIntPtr, TCompactVector2> map;
+
+    auto a = map.Insert(MakeInt(1));
+    map.Insert(MakeInt(2));
+    // Force reallocation past the inline capacity.
+    map.Insert(MakeInt(3));
+
+    EXPECT_EQ(3, map.GetSize());
+    EXPECT_EQ(1, *map.Extract(a));
+
+    auto d = map.Insert(MakeInt(4));
+    EXPECT_EQ(a, d);
+
+    std::vector<int> values;
+    map.ExtractAll([&] (TIntPtr value) {
+        values.push_back(*value);
+    });
+    std::sort(values.begin(), values.end());
+    EXPECT_THAT(values, ::testing::ElementsAre(2, 3, 4));
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace
+} // namespace NYT
diff --git a/library/cpp/yt/containers/unittests/static_ring_queue_ut.cpp b/library/cpp/yt/containers/unittests/static_ring_queue_ut.cpp
new file mode 100644
index 00000000000..b3898463c2b
--- /dev/null
+++ b/library/cpp/yt/containers/unittests/static_ring_queue_ut.cpp
@@ -0,0 +1,130 @@
+#include <library/cpp/yt/containers/static_ring_queue.h>
+
+#include <library/cpp/testing/gtest/gtest.h>
+
+#include <deque>
+#include <random>
+#include <vector>
+
+namespace NYT {
+namespace {
+
+////////////////////////////////////////////////////////////////////////////////
+
+constexpr size_t Capacity = 8;
+
+using TQueue = TStaticRingQueue<int, Capacity>;
+
+std::vector<int> MakeRange(int begin, int end)
+{
+    std::vector<int> result;
+    for (int value = begin; value < end; ++value) {
+        result.push_back(value);
+    }
+    return result;
+}
+
+void Append(TQueue* queue, const std::vector<int>& values)
+{
+    queue->Append(values.data(), values.data() + values.size());
+}
+
+std::vector<int> CopyTail(const TQueue& queue, size_t size)
+{
+    std::vector<int> result(size);
+    queue.CopyTailTo(size, result.data());
+    return result;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+TEST(TStaticRingQueueTest, Empty)
+{
+    TQueue queue;
+    EXPECT_EQ(0u, queue.Size());
+    EXPECT_TRUE(CopyTail(queue, 0).empty());
+}
+
+TEST(TStaticRingQueueTest, AppendBelowCapacity)
+{
+    TQueue queue;
+    Append(&queue, MakeRange(0, 3));
+
+    EXPECT_EQ(3u, queue.Size());
+    EXPECT_EQ(MakeRange(0, 3), CopyTail(queue, 3));
+    EXPECT_EQ(MakeRange(1, 3), CopyTail(queue, 2));
+    EXPECT_EQ(MakeRange(2, 3), CopyTail(queue, 1));
+}
+
+TEST(TStaticRingQueueTest, AppendExactlyCapacity)
+{
+    TQueue queue;
+    Append(&queue, MakeRange(0, Capacity));
+
+    EXPECT_EQ(Capacity, queue.Size());
+    EXPECT_EQ(MakeRange(0, Capacity), CopyTail(queue, Capacity));
+}
+
+TEST(TStaticRingQueueTest, SingleAppendAboveCapacityKeepsTail)
+{
+    TQueue queue;
+    Append(&queue, MakeRange(0, 100));
+
+    EXPECT_EQ(Capacity, queue.Size());
+    EXPECT_EQ(MakeRange(100 - Capacity, 100), CopyTail(queue, Capacity));
+}
+
+TEST(TStaticRingQueueTest, AppendsWrapAround)
+{
+    TQueue queue;
+    for (int index = 0; index < 10; ++index) {
+        Append(&queue, MakeRange(3 * index, 3 * index + 3));
+    }
+
+    EXPECT_EQ(Capacity, queue.Size());
+    EXPECT_EQ(MakeRange(30 - Capacity, 30), CopyTail(queue, Capacity));
+}
+
+TEST(TStaticRingQueueTest, EmptyAppendIsNoop)
+{
+    TQueue queue;
+    Append(&queue, MakeRange(0, 5));
+    Append(&queue, {});
+
+    EXPECT_EQ(5u, queue.Size());
+    EXPECT_EQ(MakeRange(0, 5), CopyTail(queue, 5));
+}
+
+TEST(TStaticRingQueueTest, RandomOperations)
+{
+    TQueue queue;
+    std::deque<int> reference;
+
+    std::mt19937 generator(42);
+    int next = 0;
+
+    for (int iteration = 0; iteration < 1000; ++iteration) {
+        int appendSize = generator() % (2 * Capacity + 1);
+        auto values = MakeRange(next, next + appendSize);
+        next += appendSize;
+
+        Append(&queue, values);
+        for (auto value : values) {
+            reference.push_back(value);
+        }
+        while (reference.size() > Capacity) {
+            reference.pop_front();
+        }
+
+        ASSERT_EQ(reference.size(), queue.Size());
+
+        size_t copySize = generator() % (reference.size() + 1);
+        std::vector<int> expected(reference.end() - copySize, reference.end());
+        ASSERT_EQ(expected, CopyTail(queue, copySize));
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace
+} // namespace NYT
diff --git a/library/cpp/yt/exception/attributes.h b/library/cpp/yt/exception/attributes.h
index f60d733880d..4289db668b0 100644
--- a/library/cpp/yt/exception/attributes.h
+++ b/library/cpp/yt/exception/attributes.h
@@ -2,7 +2,7 @@
 
 #include <library/cpp/yt/misc/guid.h>
 
-#include <util/generic/string.h>
+#include <string>
 
 #include <variant>
 
@@ -12,8 +12,8 @@ namespace NYT {
 
 struct TExceptionAttribute
 {
-    using TKey = TString;
-    using TValue = std::variant<i64, double, bool, TString>;
+    using TKey = std::string;
+    using TValue = std::variant<i64, double, bool, std::string>;
 
     TKey Key;
     TValue Value;
diff --git a/library/cpp/yt/exception/exception.cpp b/library/cpp/yt/exception/exception.cpp
index 71ece1ff2e0..5a1e33d7a6f 100644
--- a/library/cpp/yt/exception/exception.cpp
+++ b/library/cpp/yt/exception/exception.cpp
@@ -20,14 +20,14 @@ void AddAttributes(TSimpleException::TAttributes& attrs, TRange&& range)
 
 ////////////////////////////////////////////////////////////////////////////////
 
-TSimpleException::TSimpleException(TString message)
+TSimpleException::TSimpleException(std::string message)
     : Message_(std::move(message))
     , What_(Message_)
 { }
 
 TSimpleException::TSimpleException(
     const std::exception& exception,
-    TString message)
+    std::string message)
     : InnerException_(std::current_exception())
     , Message_(std::move(message))
     , What_(Message_ + "\n" + exception.what())
@@ -43,7 +43,7 @@ const char* TSimpleException::what() const noexcept
     return What_.c_str();
 }
 
-const TString& TSimpleException::GetMessage() const
+const std::string& TSimpleException::GetMessage() const
 {
     return Message_;
 }
diff --git a/library/cpp/yt/exception/exception.h b/library/cpp/yt/exception/exception.h
index 2898b99f0de..6e939d072ab 100644
--- a/library/cpp/yt/exception/exception.h
+++ b/library/cpp/yt/exception/exception.h
@@ -25,15 +25,15 @@ class TSimpleException
         { ex <<= std::forward<TValue>(operand) } -> std::same_as<TSimpleException&>;
     };
 
-    explicit TSimpleException(TString message);
+    explicit TSimpleException(std::string message);
     TSimpleException(
         const std::exception& exception,
-        TString message);
+        std::string message);
 
     const std::exception_ptr& GetInnerException() const;
     const char* what() const noexcept override;
 
-    const TString& GetMessage() const;
+    const std::string& GetMessage() const;
 
     const TAttributes& GetAttributes() const &;
     TAttributes&& GetAttributes() &&;
@@ -65,8 +65,8 @@ class TSimpleException
 
 private:
     const std::exception_ptr InnerException_;
-    const TString Message_;
-    const TString What_;
+    const std::string Message_;
+    const std::string What_;
 
     TAttributes Attributes_;
 };
diff --git a/library/cpp/yt/malloc/malloc.cpp b/library/cpp/yt/malloc/malloc.cpp
index de45aa37fa4..b52c33634a6 100644
--- a/library/cpp/yt/malloc/malloc.cpp
+++ b/library/cpp/yt/malloc/malloc.cpp
@@ -12,7 +12,12 @@ extern "C" Y_WEAK size_t nallocx(size_t size, int /*flags*/) noexcept
     return size;
 }
 
-#ifndef _win_
+#if defined(__ANDROID__)
+extern "C" Y_WEAK size_t malloc_usable_size(const void* /*ptr*/)
+{
+    return 0;
+}
+#elif !defined(_win_)
 extern "C" Y_WEAK size_t malloc_usable_size(void* /*ptr*/) noexcept
 {
     return 0;
@@ -23,7 +28,7 @@ void* aligned_malloc(size_t size, size_t alignment)
 {
 #if defined(_win_)
     return _aligned_malloc(size, alignment);
-#elif defined(_darwin_) || defined(_linux_)
+#elif defined(_darwin_) || defined(_linux_) || defined(__FreeBSD__)
     void* ptr = nullptr;
     ::posix_memalign(&ptr, alignment, size);
     return ptr;
diff --git a/library/cpp/yt/malloc/malloc.h b/library/cpp/yt/malloc/malloc.h
index 2b3efbfd008..8e3f03ccb44 100644
--- a/library/cpp/yt/malloc/malloc.h
+++ b/library/cpp/yt/malloc/malloc.h
@@ -1,8 +1,13 @@
 #include <cstddef>
 
+
 ////////////////////////////////////////////////////////////////////////////////
 
+#if defined(__ANDROID__)
+extern "C" size_t malloc_usable_size(const void* ptr);
+#else
 extern "C" size_t malloc_usable_size(void* ptr) noexcept;
+#endif
 
 extern "C" size_t nallocx(size_t size, int flags) noexcept;
 
diff --git a/library/cpp/yt/memory/allocation_tags.h b/library/cpp/yt/memory/allocation_tags.h
new file mode 100644
index 00000000000..5bd0f415c60
--- /dev/null
+++ b/library/cpp/yt/memory/allocation_tags.h
@@ -0,0 +1,16 @@
+#pragma once
+
+#include <string>
+#include <utility>
+
+namespace NYT {
+
+////////////////////////////////////////////////////////////////////////////////
+
+using TAllocationTagKey = std::string;
+using TAllocationTagValue = std::string;
+using TAllocationTag = std::pair<TAllocationTagKey, TAllocationTagValue>;
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace NYT
diff --git a/library/cpp/yt/memory/allocation_tags_hooks.cpp b/library/cpp/yt/memory/allocation_tags_hooks.cpp
new file mode 100644
index 00000000000..dc6d531f3e8
--- /dev/null
+++ b/library/cpp/yt/memory/allocation_tags_hooks.cpp
@@ -0,0 +1,27 @@
+#include "allocation_tags_hooks.h"
+
+namespace NYT {
+
+////////////////////////////////////////////////////////////////////////////////
+
+Y_WEAK const TAllocationTagsHooks& GetAllocationTagsHooks()
+{
+    static const TAllocationTagsHooks hooks{
+        .CreateAllocationTags = [] () -> void* {
+            return nullptr;
+        },
+        .CopyAllocationTags = [] (void* /*opaque*/) -> void* {
+            return nullptr;
+        },
+        .DestroyAllocationTags = [] (void* /*opaque*/) {
+        },
+        .ReadAllocationTags = [] (void* /*opaque*/) -> TRange<TAllocationTag> {
+            return {};
+        },
+    };
+    return hooks;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace NYT
diff --git a/library/cpp/yt/memory/allocation_tags_hooks.h b/library/cpp/yt/memory/allocation_tags_hooks.h
new file mode 100644
index 00000000000..57673f68b0a
--- /dev/null
+++ b/library/cpp/yt/memory/allocation_tags_hooks.h
@@ -0,0 +1,23 @@
+#pragma once
+
+#include "allocation_tags.h"
+
+#include <library/cpp/yt/memory/range.h>
+
+namespace NYT {
+
+////////////////////////////////////////////////////////////////////////////////
+
+struct TAllocationTagsHooks
+{
+    void* (*CreateAllocationTags)();
+    void* (*CopyAllocationTags)(void* opaque);
+    void (*DestroyAllocationTags)(void* opaque);
+    TRange<TAllocationTag> (*ReadAllocationTags)(void* opaque);
+};
+
+const TAllocationTagsHooks& GetAllocationTagsHooks();
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace NYT
diff --git a/library/cpp/yt/memory/atomic-inl.h b/library/cpp/yt/memory/atomic-inl.h
new file mode 100644
index 00000000000..7408d171d69
--- /dev/null
+++ b/library/cpp/yt/memory/atomic-inl.h
@@ -0,0 +1,29 @@
+#ifndef ATOMIC_INL_H_
+#error "Direct inclusion of this file is not allowed, include atomic.h"
+// For the sake of sane code completion.
+#include "atomic.h"
+#endif
+
+namespace NYT {
+
+////////////////////////////////////////////////////////////////////////////////
+
+template <class T>
+T SingleWriterFetchAdd(std::atomic<T>& atomic, T delta)
+{
+    auto oldValue = atomic.load(std::memory_order::relaxed);
+    atomic.store(oldValue + delta, std::memory_order::relaxed);
+    return oldValue;
+}
+
+template <class T>
+T SingleWriterFetchSub(std::atomic<T>& atomic, T delta)
+{
+    auto oldValue = atomic.load(std::memory_order::relaxed);
+    atomic.store(oldValue - delta, std::memory_order::relaxed);
+    return oldValue;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace NYT
diff --git a/library/cpp/yt/memory/atomic.h b/library/cpp/yt/memory/atomic.h
new file mode 100644
index 00000000000..b4a1dd7234a
--- /dev/null
+++ b/library/cpp/yt/memory/atomic.h
@@ -0,0 +1,23 @@
+#pragma once
+
+#include <atomic>
+
+namespace NYT {
+
+////////////////////////////////////////////////////////////////////////////////
+
+//! A (much) faster version of |fetch_add| for a single-writer case.
+template <class T>
+T SingleWriterFetchAdd(std::atomic<T>& atomic, T delta);
+
+//! A (much) faster version of |fetch_sub| for a single-writer case.
+template <class T>
+T SingleWriterFetchSub(std::atomic<T>& atomic, T delta);
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace NYT
+
+#define ATOMIC_INL_H_
+#include "atomic-inl.h"
+#undef ATOMIC_INL_H_
diff --git a/library/cpp/yt/memory/atomic_intrusive_ptr-inl.h b/library/cpp/yt/memory/atomic_intrusive_ptr-inl.h
index 21cd8b94120..4211806880f 100644
--- a/library/cpp/yt/memory/atomic_intrusive_ptr-inl.h
+++ b/library/cpp/yt/memory/atomic_intrusive_ptr-inl.h
@@ -3,7 +3,6 @@
 // For the sake of sane code completion.
 #include "atomic_intrusive_ptr.h"
 #endif
-#undef ATOMIC_INTRUSIVE_PTR_INL_H_
 
 #include <util/system/spinlock.h>
 
@@ -15,36 +14,114 @@ template <class T>
 TAtomicIntrusivePtr<T>::TAtomicIntrusivePtr(std::nullptr_t)
 { }
 
+template <class T>
+TAtomicIntrusivePtr<T>& TAtomicIntrusivePtr<T>::operator=(TIntrusivePtr<T> other)
+{
+    Store(std::move(other));
+    return *this;
+}
+
+template <class T>
+TAtomicIntrusivePtr<T>& TAtomicIntrusivePtr<T>::operator=(std::nullptr_t)
+{
+    Reset();
+    return *this;
+}
+
+template <class T>
+TAtomicIntrusivePtr<T>::operator bool() const
+{
+    return Get();
+}
+
+#if defined(_lsan_enabled_) || defined(_asan_enabled_)
+
 template <class T>
 TAtomicIntrusivePtr<T>::TAtomicIntrusivePtr(TIntrusivePtr<T> other)
-    : Ptr_(AcquireObject(other.Release(), true))
+    : Ptr_(std::move(other))
 { }
 
 template <class T>
-TAtomicIntrusivePtr<T>::TAtomicIntrusivePtr(TAtomicIntrusivePtr&& other)
-    : Ptr_(other.Ptr_.load(std::memory_order::relaxed))
+TAtomicIntrusivePtr<T>::TAtomicIntrusivePtr(TAtomicIntrusivePtr&& other) noexcept
+    : Ptr_(std::move(other))
+{ }
+
+template <class T>
+TAtomicIntrusivePtr<T>::~TAtomicIntrusivePtr() = default;
+
+template <class T>
+TIntrusivePtr<T> TAtomicIntrusivePtr<T>::Acquire() const
 {
-    other.Ptr_.store(nullptr, std::memory_order::relaxed);
+    auto guard = Guard(Lock_);
+    return Ptr_;
 }
 
 template <class T>
-TAtomicIntrusivePtr<T>::~TAtomicIntrusivePtr()
+TIntrusivePtr<T> TAtomicIntrusivePtr<T>::Exchange(TIntrusivePtr<T> other)
 {
-    ReleaseObject(Ptr_.load());
+    auto guard = Guard(Lock_);
+    Ptr_.Swap(other);
+    return other;
 }
 
 template <class T>
-TAtomicIntrusivePtr<T>& TAtomicIntrusivePtr<T>::operator=(TIntrusivePtr<T> other)
+void TAtomicIntrusivePtr<T>::Store(TIntrusivePtr<T> other)
 {
-    Store(std::move(other));
-    return *this;
+    Exchange(std::move(other));
 }
 
 template <class T>
-TAtomicIntrusivePtr<T>& TAtomicIntrusivePtr<T>::operator=(std::nullptr_t)
+void TAtomicIntrusivePtr<T>::Reset()
 {
-    Reset();
-    return *this;
+    Exchange(nullptr);
+}
+
+template <class T>
+bool TAtomicIntrusivePtr<T>::CompareAndSwap(TRawPtr& comparePtr, T* target)
+{
+    auto guard = Guard(Lock_);
+    if (Ptr_.Get() != comparePtr) {
+        comparePtr = Ptr_.Get();
+        return false;
+    }
+    auto targetPtr = TIntrusivePtr<T>(target, /*addReference*/ false);
+    Ptr_.Swap(targetPtr);
+    guard.Release();
+    // targetPtr will die here.
+    return true;
+}
+
+template <class T>
+bool TAtomicIntrusivePtr<T>::CompareAndSwap(TRawPtr& comparePtr, TIntrusivePtr<T> target)
+{
+    return CompareAndSwap(comparePtr, target.Release());
+}
+
+template <class T>
+typename TAtomicIntrusivePtr<T>::TRawPtr TAtomicIntrusivePtr<T>::Get() const
+{
+    auto guard = Guard(Lock_);
+    return Ptr_.Get();
+}
+
+#else
+
+template <class T>
+TAtomicIntrusivePtr<T>::TAtomicIntrusivePtr(TIntrusivePtr<T> other)
+    : Ptr_(AcquireObject(other.Release(), /*consumeRef*/ true))
+{ }
+
+template <class T>
+TAtomicIntrusivePtr<T>::TAtomicIntrusivePtr(TAtomicIntrusivePtr&& other) noexcept
+    : Ptr_(other.Ptr_.load(std::memory_order::relaxed))
+{
+    other.Ptr_.store(TPackedPtr(), std::memory_order::relaxed);
+}
+
+template <class T>
+TAtomicIntrusivePtr<T>::~TAtomicIntrusivePtr()
+{
+    ReleaseObject(Ptr_.load());
 }
 
 template <class T>
@@ -100,7 +177,7 @@ TIntrusivePtr<T> TAtomicIntrusivePtr<T>::Acquire() const
 template <class T>
 TIntrusivePtr<T> TAtomicIntrusivePtr<T>::Exchange(TIntrusivePtr<T> other)
 {
-    auto [obj, localRefs] = TTaggedPtr<T>::Unpack(Ptr_.exchange(AcquireObject(other.Release(), true)));
+    auto [obj, localRefs] = TTaggedPtr<T>::Unpack(Ptr_.exchange(AcquireObject(other.Release(), /*consumeRef*/ true)));
     DoRelease(obj, localRefs + 1);
     return TIntrusivePtr<T>(obj, false);
 }
@@ -108,19 +185,19 @@ TIntrusivePtr<T> TAtomicIntrusivePtr<T>::Exchange(TIntrusivePtr<T> other)
 template <class T>
 void TAtomicIntrusivePtr<T>::Store(TIntrusivePtr<T> other)
 {
-    ReleaseObject(Ptr_.exchange(AcquireObject(other.Release(), true)));
+    ReleaseObject(Ptr_.exchange(AcquireObject(other.Release(), /*consumeRef*/ true)));
 }
 
 template <class T>
 void TAtomicIntrusivePtr<T>::Reset()
 {
-    ReleaseObject(Ptr_.exchange(0));
+    ReleaseObject(Ptr_.exchange(TPackedPtr()));
 }
 
 template <class T>
 bool TAtomicIntrusivePtr<T>::CompareAndSwap(TRawPtr& comparePtr, T* target)
 {
-    auto* targetPtr = AcquireObject(target, false);
+    auto* targetPtr = AcquireObject(target, /*consumeRef*/ false);
 
     auto currentPtr = Ptr_.load();
     if (UnpackPointer<T>(currentPtr).Ptr == comparePtr && Ptr_.compare_exchange_strong(currentPtr, targetPtr)) {
@@ -138,7 +215,7 @@ template <class T>
 bool TAtomicIntrusivePtr<T>::CompareAndSwap(TRawPtr& comparePtr, TIntrusivePtr<T> target)
 {
     // TODO(lukyan): Make helper for packed owning ptr?
-    auto targetPtr = AcquireObject(target.Release(), true);
+    auto targetPtr = AcquireObject(target.Release(), /*consumeRef*/ true);
 
     auto currentPtr = Ptr_.load();
     if (TTaggedPtr<T>::Unpack(currentPtr).Ptr == comparePtr && Ptr_.compare_exchange_strong(currentPtr, targetPtr)) {
@@ -159,7 +236,7 @@ typename TAtomicIntrusivePtr<T>::TRawPtr TAtomicIntrusivePtr<T>::Get() const
 }
 
 template <class T>
-TAtomicIntrusivePtr<T>::operator bool() const
+typename TAtomicIntrusivePtr<T>::TRawPtr TAtomicIntrusivePtr<T>::get() const
 {
     return Get();
 }
@@ -168,7 +245,7 @@ template <class T>
 TPackedPtr TAtomicIntrusivePtr<T>::AcquireObject(T* obj, bool consumeRef)
 {
     if (obj) {
-        Ref(obj, static_cast<int>(ReservedRefCount - consumeRef));
+        Ref(obj, ReservedRefCount - static_cast<int>(consumeRef));
     }
 
     return TTaggedPtr(obj).Pack();
@@ -185,10 +262,12 @@ template <class T>
 void TAtomicIntrusivePtr<T>::DoRelease(T* obj, int refs)
 {
     if (obj) {
-        Unref(obj, static_cast<int>(ReservedRefCount - refs));
+        Unref(obj, ReservedRefCount - refs);
     }
 }
 
+#endif
+
 ////////////////////////////////////////////////////////////////////////////////
 
 template <class T>
diff --git a/library/cpp/yt/memory/atomic_intrusive_ptr.h b/library/cpp/yt/memory/atomic_intrusive_ptr.h
index ae0a307182d..5069fc67634 100644
--- a/library/cpp/yt/memory/atomic_intrusive_ptr.h
+++ b/library/cpp/yt/memory/atomic_intrusive_ptr.h
@@ -2,26 +2,32 @@
 
 #include "intrusive_ptr.h"
 
-namespace NYT {
-
-////////////////////////////////////////////////////////////////////////////////
+#include <util/system/compiler.h>
 
-// Atomic ptr based on https://github.com/facebook/folly/blob/main/folly/concurrency/AtomicSharedPtr.h
+#if defined(_lsan_enabled_) || defined(_asan_enabled_)
+#include <util/system/spinlock.h>
+#endif
 
-// Operators * and -> for TAtomicIntrusivePtr are useless because it is not safe to work with atomic ptr such way
-// Safe usage is to convert to TIntrusivePtr.
+namespace NYT {
 
-// Max TAtomicIntrusivePtr count per object is (2**16 = 2**32 / 2**16).
+////////////////////////////////////////////////////////////////////////////////
 
+//! Atomic pointer with split reference counting.
+/*
+ *  \see https://github.com/facebook/folly/blob/main/folly/concurrency/AtomicSharedPtr.h
+*/
 template <class T>
 class TAtomicIntrusivePtr
 {
 public:
+    using TUnderlying = T;
+    using element_type = T;
+
     TAtomicIntrusivePtr() = default;
     TAtomicIntrusivePtr(std::nullptr_t);
 
     explicit TAtomicIntrusivePtr(TIntrusivePtr<T> other);
-    TAtomicIntrusivePtr(TAtomicIntrusivePtr&& other);
+    TAtomicIntrusivePtr(TAtomicIntrusivePtr&& other) noexcept;
 
     ~TAtomicIntrusivePtr();
 
@@ -39,9 +45,12 @@ class TAtomicIntrusivePtr
     bool CompareAndSwap(TRawPtr& comparePtr, T* target);
     bool CompareAndSwap(TRawPtr& comparePtr, TIntrusivePtr<T> target);
 
-    // Result is suitable only for comparison. Not dereference.
+    //! Result is only suitable for comparison, not dereference.
     TRawPtr Get() const;
 
+    //! Result is only suitable for comparison, not dereference.
+    TRawPtr get() const;
+
     explicit operator bool() const;
 
 private:
@@ -57,22 +66,26 @@ class TAtomicIntrusivePtr
     template <class U>
     friend bool operator!=(const TIntrusivePtr<U>& lhs, const TAtomicIntrusivePtr<U>& rhs);
 
+#if defined(_lsan_enabled_) || defined(_asan_enabled_)
+    ::TSpinLock Lock_;
+    TIntrusivePtr<T> Ptr_;
+#else
     // Keeps packed pointer (localRefCount, objectPtr).
     // Atomic ptr holds N references, where N = ReservedRefCount - localRefCount.
     // LocalRefCount is incremented in Acquire method.
     // When localRefCount exceeds ReservedRefCount / 2 a new portion of refs are required globally.
     // This field is marked mutable in order to make Acquire const-qualified in accordance to its semantics.
-    mutable std::atomic<TPackedPtr> Ptr_ = 0;
+    static_assert(std::atomic<TPackedPtr>::is_always_lock_free);
+    mutable std::atomic<TPackedPtr> Ptr_;
 
     constexpr static int CounterBits = PackedPtrTagBits;
     constexpr static int ReservedRefCount = (1 << CounterBits) - 1;
 
     // Consume ref if ownership is transferred.
-    // AcquireObject(ptr.Release(), true)
-    // AcquireObject(ptr.Get(), false)
     static TPackedPtr AcquireObject(T* obj, bool consumeRef = false);
     static void ReleaseObject(TPackedPtr packedPtr);
     static void DoRelease(T* obj, int refs);
+#endif
 };
 
 ////////////////////////////////////////////////////////////////////////////////
diff --git a/library/cpp/yt/memory/blob.cpp b/library/cpp/yt/memory/blob.cpp
index 9c17cffad00..2517446ec7e 100644
--- a/library/cpp/yt/memory/blob.cpp
+++ b/library/cpp/yt/memory/blob.cpp
@@ -4,6 +4,8 @@
 
 #include <library/cpp/yt/malloc/malloc.h>
 
+#include <library/cpp/yt/system/exit.h>
+
 namespace NYT {
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -14,7 +16,7 @@ static constexpr double BlobCapacityMultiplier = 1.5;
 TBlob::TBlob(
     TRefCountedTypeCookie tagCookie,
     size_t size,
-    bool initiailizeStorage,
+    bool initializeStorage,
     bool pageAligned)
     : PageAligned_(pageAligned)
 {
@@ -24,7 +26,7 @@ TBlob::TBlob(
     } else {
         Allocate(std::max(size, InitialBlobCapacity));
         Size_ = size;
-        if (initiailizeStorage) {
+        if (initializeStorage) {
             ::memset(Begin_, 0, Size_);
         }
     }
@@ -147,9 +149,17 @@ void TBlob::Reset()
 
 char* TBlob::DoAllocate(size_t size)
 {
-    return static_cast<char*>(PageAligned_
+    auto* allocated = static_cast<char*>(PageAligned_
         ? ::aligned_malloc(size, GetPageSize())
         : ::malloc(size));
+
+    if (Y_UNLIKELY(!allocated)) {
+        AbortProcessDramatically(
+            EProcessExitCode::OutOfMemory,
+            "Out-of-memory during TBlob allocation");
+    }
+
+    return allocated;
 }
 
 void TBlob::Allocate(size_t newCapacity)
@@ -197,6 +207,8 @@ void TBlob::SetTagCookie(TRefCountedTypeCookie tagCookie)
 {
 #ifdef YT_ENABLE_REF_COUNTED_TRACKING
     TagCookie_ = tagCookie;
+#else
+    Y_UNUSED(tagCookie);
 #endif
 }
 
@@ -204,6 +216,8 @@ void TBlob::SetTagCookie(const TBlob& other)
 {
 #ifdef YT_ENABLE_REF_COUNTED_TRACKING
     TagCookie_ = other.TagCookie_;
+#else
+    Y_UNUSED(other);
 #endif
 }
 
diff --git a/library/cpp/yt/memory/blob.h b/library/cpp/yt/memory/blob.h
index 42cab83017b..a14ac742b29 100644
--- a/library/cpp/yt/memory/blob.h
+++ b/library/cpp/yt/memory/blob.h
@@ -26,7 +26,7 @@ class TBlob
     explicit TBlob(
         TRefCountedTypeCookie tagCookie = GetRefCountedTypeCookie<TDefaultBlobTag>(),
         size_t size = 0,
-        bool initiailizeStorage = true,
+        bool initializeStorage = true,
         bool pageAligned = false);
 
     //! Copies a chunk of memory into a new instance.
diff --git a/library/cpp/yt/memory/chunked_memory_allocator.h b/library/cpp/yt/memory/chunked_memory_allocator.h
index 4804a969cf7..372fa5ce7e2 100644
--- a/library/cpp/yt/memory/chunked_memory_allocator.h
+++ b/library/cpp/yt/memory/chunked_memory_allocator.h
@@ -31,7 +31,9 @@ class TChunkedMemoryAllocator
             chunkSize,
             maxSmallBlockSizeRatio,
             GetRefCountedTypeCookie<TTag>())
-    { }
+    {
+        static_assert(IsEmptyClass<TTag>());
+    }
 
     //! Allocates #sizes bytes without any alignment.
     TSharedMutableRef AllocateUnaligned(i64 size);
diff --git a/library/cpp/yt/memory/chunked_memory_pool-inl.h b/library/cpp/yt/memory/chunked_memory_pool-inl.h
index 58a0cefcc2f..68d346167f9 100644
--- a/library/cpp/yt/memory/chunked_memory_pool-inl.h
+++ b/library/cpp/yt/memory/chunked_memory_pool-inl.h
@@ -6,6 +6,8 @@
 
 #include "serialize.h"
 
+#include <library/cpp/yt/system/exit.h>
+
 #include <library/cpp/yt/malloc/malloc.h>
 
 #include <util/system/align.h>
@@ -29,6 +31,11 @@ TDerived* TAllocationHolder::Allocate(size_t size, TRefCountedTypeCookie cookie)
 {
     auto requestedSize = sizeof(TDerived) + size;
     auto* ptr = ::malloc(requestedSize);
+    if (Y_UNLIKELY(!ptr)) {
+        AbortProcessDramatically(
+            EProcessExitCode::OutOfMemory,
+            "Out-of-memory during chunked memory pool allocation");
+    }
 
 #ifndef _win_
     auto allocatedSize = ::malloc_usable_size(ptr);
@@ -64,12 +71,14 @@ inline TChunkedMemoryPool::TChunkedMemoryPool(
     : TChunkedMemoryPool(
         GetRefCountedTypeCookie<TTag>(),
         startChunkSize)
-{ }
+{
+    static_assert(IsEmptyClass<TTag>());
+}
 
 inline char* TChunkedMemoryPool::AllocateUnaligned(size_t size)
 {
     // Fast path.
-    if (FreeZoneEnd_ >= FreeZoneBegin_ + size) {
+    if (FreeZoneBegin_ && FreeZoneEnd_ >= FreeZoneBegin_ + size) {
         FreeZoneEnd_ -= size;
         Size_ += size;
         return FreeZoneEnd_;
@@ -81,15 +90,17 @@ inline char* TChunkedMemoryPool::AllocateUnaligned(size_t size)
 
 inline char* TChunkedMemoryPool::AllocateAligned(size_t size, int align)
 {
-    // NB: This can lead to FreeZoneBegin_ >= FreeZoneEnd_ in which case the chunk is full.
-    FreeZoneBegin_ = AlignUp(FreeZoneBegin_, align);
-
-    // Fast path.
-    if (FreeZoneBegin_ + size <= FreeZoneEnd_) {
-        char* result = FreeZoneBegin_;
-        Size_ += size;
-        FreeZoneBegin_ += size;
-        return result;
+    if (FreeZoneBegin_) {
+        // NB: This can lead to FreeZoneBegin_ >= FreeZoneEnd_ in which case the chunk is full.
+        FreeZoneBegin_ = AlignUp(FreeZoneBegin_, align);
+
+        // Fast path.
+        if (FreeZoneBegin_ + size <= FreeZoneEnd_) {
+            char* result = FreeZoneBegin_;
+            Size_ += size;
+            FreeZoneBegin_ += size;
+            return result;
+        }
     }
 
     // Slow path.
diff --git a/library/cpp/yt/memory/chunked_memory_pool.cpp b/library/cpp/yt/memory/chunked_memory_pool.cpp
index a10a6fe724f..69794dcee19 100644
--- a/library/cpp/yt/memory/chunked_memory_pool.cpp
+++ b/library/cpp/yt/memory/chunked_memory_pool.cpp
@@ -15,6 +15,8 @@ TAllocationHolder::TAllocationHolder(TMutableRef ref, TRefCountedTypeCookie cook
         TRefCountedTrackerFacade::AllocateTagInstance(Cookie_);
         TRefCountedTrackerFacade::AllocateSpace(Cookie_, Ref_.Size());
     }
+#else
+    Y_UNUSED(cookie);
 #endif
 }
 
@@ -56,6 +58,7 @@ TChunkedMemoryPool::TChunkedMemoryPool(
     , ChunkProviderHolder_(std::move(chunkProvider))
     , ChunkProvider_(ChunkProviderHolder_.Get())
 {
+    YT_VERIFY(ChunkProviderHolder_);
     Initialize(startChunkSize);
 }
 
diff --git a/library/cpp/yt/memory/chunked_memory_pool.h b/library/cpp/yt/memory/chunked_memory_pool.h
index d5771480ac2..b65f4987276 100644
--- a/library/cpp/yt/memory/chunked_memory_pool.h
+++ b/library/cpp/yt/memory/chunked_memory_pool.h
@@ -117,7 +117,7 @@ class TChunkedMemoryPool
 
 private:
     const TRefCountedTypeCookie TagCookie_;
-    // A common usecase is to construct TChunkedMemoryPool with the default
+    // A common use case is to construct TChunkedMemoryPool with the default
     // memory chunk provider. The latter is ref-counted and is shared between
     // a multitude of TChunkedMemoryPool instances. This could potentially
     // lead to a contention over IMemoryChunkProvider's ref-counter.
diff --git a/library/cpp/yt/memory/chunked_output_stream.cpp b/library/cpp/yt/memory/chunked_output_stream.cpp
index 90ec36fe23f..bf62412e00d 100644
--- a/library/cpp/yt/memory/chunked_output_stream.cpp
+++ b/library/cpp/yt/memory/chunked_output_stream.cpp
@@ -8,9 +8,12 @@ namespace NYT {
 
 TChunkedOutputStream::TChunkedOutputStream(
     TRefCountedTypeCookie tagCookie,
+    ISimpleMemoryUsageTrackerPtr memoryUsageTracker,
     size_t initialReserveSize,
     size_t maxReserveSize)
-    : MaxReserveSize_(RoundUpToPage(maxReserveSize))
+    : MemoryUsageTracker_(std::move(memoryUsageTracker))
+    , CurrentChunkMemoryUsageGuard_(TSimpleMemoryUsageTrackerGuard::Build(MemoryUsageTracker_))
+    , MaxReserveSize_(RoundUpToPage(maxReserveSize))
     , CurrentReserveSize_(RoundUpToPage(initialReserveSize))
     , CurrentChunk_(tagCookie, /*size*/ 0)
 {
@@ -23,7 +26,11 @@ TChunkedOutputStream::TChunkedOutputStream(
 
 std::vector<TSharedRef> TChunkedOutputStream::Finish()
 {
-    FinishedChunks_.push_back(TSharedRef::FromBlob(std::move(CurrentChunk_)));
+    FinishedChunks_.push_back(TrackMemory(
+        MemoryUsageTracker_,
+        TSharedRef::FromBlob(std::move(CurrentChunk_))));
+
+    CurrentChunkMemoryUsageGuard_.Release();
 
     YT_ASSERT(CurrentChunk_.IsEmpty());
     FinishedSize_ = 0;
@@ -49,9 +56,13 @@ void TChunkedOutputStream::ReserveNewChunk(size_t spaceRequired)
 {
     YT_ASSERT(CurrentChunk_.Size() == CurrentChunk_.Capacity());
     FinishedSize_ += CurrentChunk_.Size();
-    FinishedChunks_.push_back(TSharedRef::FromBlob(std::move(CurrentChunk_)));
+    FinishedChunks_.push_back(TrackMemory(
+        MemoryUsageTracker_,
+        TSharedRef::FromBlob(std::move(CurrentChunk_))));
+
     CurrentReserveSize_ = std::min(2 * CurrentReserveSize_, MaxReserveSize_);
     CurrentChunk_.Reserve(std::max(RoundUpToPage(spaceRequired), CurrentReserveSize_));
+    UpdateCurrentChunkMemoryUsage();
 }
 
 void TChunkedOutputStream::DoWrite(const void* buffer, size_t length)
@@ -68,6 +79,7 @@ void TChunkedOutputStream::DoWrite(const void* buffer, size_t length)
         ReserveNewChunk(spaceRequired);
         CurrentChunk_.Append(static_cast<const char*>(buffer) + spaceAvailable, spaceRequired);
     }
+    UpdateCurrentChunkMemoryUsage();
 }
 
 size_t TChunkedOutputStream::DoNext(void** ptr)
@@ -84,6 +96,7 @@ size_t TChunkedOutputStream::DoNext(void** ptr)
     YT_ASSERT(spaceAvailable > 0);
     *ptr = CurrentChunk_.End();
     CurrentChunk_.Resize(CurrentChunk_.Capacity(), /*initializeStorage*/ false);
+    UpdateCurrentChunkMemoryUsage();
     return spaceAvailable;
 }
 
@@ -91,6 +104,7 @@ void TChunkedOutputStream::DoUndo(size_t len)
 {
     YT_VERIFY(CurrentChunk_.Size() >= len);
     CurrentChunk_.Resize(CurrentChunk_.Size() - len);
+    UpdateCurrentChunkMemoryUsage();
 }
 
 char* TChunkedOutputStream::Preallocate(size_t size)
@@ -98,12 +112,15 @@ char* TChunkedOutputStream::Preallocate(size_t size)
     size_t available = CurrentChunk_.Capacity() - CurrentChunk_.Size();
     if (available < size) {
         FinishedSize_ += CurrentChunk_.Size();
-        FinishedChunks_.push_back(TSharedRef::FromBlob(std::move(CurrentChunk_)));
+        FinishedChunks_.push_back(TrackMemory(
+            MemoryUsageTracker_,
+            TSharedRef::FromBlob(std::move(CurrentChunk_))));
 
         CurrentReserveSize_ = std::min(2 * CurrentReserveSize_, MaxReserveSize_);
 
         CurrentChunk_.Reserve(std::max(RoundUpToPage(size), CurrentReserveSize_));
     }
+    UpdateCurrentChunkMemoryUsage();
     return CurrentChunk_.End();
 }
 
@@ -111,6 +128,12 @@ void TChunkedOutputStream::Advance(size_t size)
 {
     YT_ASSERT(CurrentChunk_.Size() + size <= CurrentChunk_.Capacity());
     CurrentChunk_.Resize(CurrentChunk_.Size() + size, false);
+    UpdateCurrentChunkMemoryUsage();
+}
+
+void TChunkedOutputStream::UpdateCurrentChunkMemoryUsage()
+{
+    CurrentChunkMemoryUsageGuard_.SetSize(CurrentChunk_.Capacity());
 }
 
 ////////////////////////////////////////////////////////////////////////////////
diff --git a/library/cpp/yt/memory/chunked_output_stream.h b/library/cpp/yt/memory/chunked_output_stream.h
index 57bf6c318df..ffca883dc81 100644
--- a/library/cpp/yt/memory/chunked_output_stream.h
+++ b/library/cpp/yt/memory/chunked_output_stream.h
@@ -1,6 +1,7 @@
 #pragma once
 
 #include "blob.h"
+#include "simple_memory_usage_tracker.h"
 
 #include <library/cpp/yt/memory/ref.h>
 
@@ -21,6 +22,7 @@ class TChunkedOutputStream
 public:
     explicit TChunkedOutputStream(
         TRefCountedTypeCookie tagCookie = GetRefCountedTypeCookie<TDefaultChunkedOutputStreamTag>(),
+        ISimpleMemoryUsageTrackerPtr memoryUsageTracker = GetNullSimpleMemoryUsageTracker(),
         size_t initialReserveSize = 4_KB,
         size_t maxReserveSize = 64_KB);
 
@@ -46,6 +48,9 @@ class TChunkedOutputStream
     void Advance(size_t size);
 
 private:
+    const ISimpleMemoryUsageTrackerPtr MemoryUsageTracker_;
+
+    TSimpleMemoryUsageTrackerGuard CurrentChunkMemoryUsageGuard_;
     size_t MaxReserveSize_;
     size_t CurrentReserveSize_;
 
@@ -54,9 +59,10 @@ class TChunkedOutputStream
     TBlob CurrentChunk_;
     std::vector<TSharedRef> FinishedChunks_;
 
-
     void ReserveNewChunk(size_t spaceRequired);
 
+    void UpdateCurrentChunkMemoryUsage();
+
     void DoWrite(const void* buf, size_t len) override;
     size_t DoNext(void** ptr) override;
     void DoUndo(size_t len) override;
diff --git a/library/cpp/yt/memory/erased_storage-inl.h b/library/cpp/yt/memory/erased_storage-inl.h
index e4dc148e11e..a9230d01d59 100644
--- a/library/cpp/yt/memory/erased_storage-inl.h
+++ b/library/cpp/yt/memory/erased_storage-inl.h
@@ -4,34 +4,46 @@
 #include "erased_storage.h"
 #endif
 
+#include <algorithm>
+#include <new>
+
 namespace NYT {
 
 ////////////////////////////////////////////////////////////////////////////////
 
-template <CTriviallyErasable TDecayedConcrete>
-TErasedStorage::TErasedStorage(TDecayedConcrete concrete) noexcept
+template <size_t MaxByteSize>
+template <CTriviallyErasable<MaxByteSize> TDecayedConcrete>
+TErasedStorage<MaxByteSize>::TErasedStorage(TDecayedConcrete concrete) noexcept
 {
+    // NB(arkady-e1ppa): We want to be able to compare
+    // erased objects as if they are not erased.
+    // Assuming erased type's operator ==
+    // is equivalent to bitwise comparison.
+    std::ranges::fill(Bytes_, std::byte(0));
     std::construct_at(
         &AsConcrete<TDecayedConcrete>(),
         concrete);
 }
 
-template <CTriviallyErasable TDecayedConcrete>
-TDecayedConcrete& TErasedStorage::AsConcrete() & noexcept
+template <size_t MaxByteSize>
+template <CTriviallyErasable<MaxByteSize> TDecayedConcrete>
+TDecayedConcrete& TErasedStorage<MaxByteSize>::AsConcrete() & noexcept
 {
     using TPtr = TDecayedConcrete*;
     return *std::launder(reinterpret_cast<TPtr>(&Bytes_));
 }
 
-template <CTriviallyErasable TDecayedConcrete>
-const TDecayedConcrete& TErasedStorage::AsConcrete() const & noexcept
+template <size_t MaxByteSize>
+template <CTriviallyErasable<MaxByteSize> TDecayedConcrete>
+const TDecayedConcrete& TErasedStorage<MaxByteSize>::AsConcrete() const & noexcept
 {
     using TPtr = const TDecayedConcrete*;
     return *std::launder(reinterpret_cast<TPtr>(&Bytes_));
 }
 
-template <CTriviallyErasable TDecayedConcrete>
-TDecayedConcrete&& TErasedStorage::AsConcrete() && noexcept
+template <size_t MaxByteSize>
+template <CTriviallyErasable<MaxByteSize> TDecayedConcrete>
+TDecayedConcrete&& TErasedStorage<MaxByteSize>::AsConcrete() && noexcept
 {
     using TPtr = TDecayedConcrete*;
     return std::move(*std::launder(reinterpret_cast<TPtr>(&Bytes_)));
diff --git a/library/cpp/yt/memory/erased_storage.h b/library/cpp/yt/memory/erased_storage.h
index 8e85430d0ba..54870f7e071 100644
--- a/library/cpp/yt/memory/erased_storage.h
+++ b/library/cpp/yt/memory/erased_storage.h
@@ -2,20 +2,34 @@
 
 #include <concepts>
 #include <memory>
+#include <type_traits>
 
 namespace NYT {
 
 ////////////////////////////////////////////////////////////////////////////////
 
-constexpr size_t ErasedStorageMaxByteSize = 32;
+template <size_t MaxByteSize>
+class TErasedStorage;
 
 ////////////////////////////////////////////////////////////////////////////////
 
-class TErasedStorage;
+namespace NDetail {
+
+template <class T>
+struct TIsErasedStorage
+    : public std::false_type
+{ };
+
+template <size_t N>
+struct TIsErasedStorage<TErasedStorage<N>>
+    : public std::true_type
+{ };
+
+} // namespace NDetail
 
 ////////////////////////////////////////////////////////////////////////////////
 
-template <class T>
+template <class T, size_t ErasedStorageMaxByteSize>
 concept CTriviallyErasable =
     std::default_initializable<T> &&
     std::is_trivially_destructible_v<T> &&
@@ -23,33 +37,38 @@ concept CTriviallyErasable =
     (sizeof(T) <= ErasedStorageMaxByteSize) &&
     (alignof(T) <= ErasedStorageMaxByteSize) &&
     !std::is_reference_v<T> &&
-    !std::same_as<T, TErasedStorage>;
+    !NDetail::TIsErasedStorage<T>::value;
 
 ////////////////////////////////////////////////////////////////////////////////
 
 // This class does not call dtor of erased object
 // thus we require trivial destructability.
+template <size_t MaxByteSize>
 class TErasedStorage
 {
 public:
-    template <CTriviallyErasable TDecayedConcrete>
+    static constexpr size_t ByteSize = MaxByteSize;
+
+    template <CTriviallyErasable<MaxByteSize> TDecayedConcrete>
     explicit TErasedStorage(TDecayedConcrete concrete) noexcept;
 
     TErasedStorage(const TErasedStorage& other) = default;
     TErasedStorage& operator=(const TErasedStorage& other) = default;
 
-    template <CTriviallyErasable TDecayedConcrete>
+    template <CTriviallyErasable<MaxByteSize> TDecayedConcrete>
     TDecayedConcrete& AsConcrete() & noexcept;
 
-    template <CTriviallyErasable TDecayedConcrete>
+    template <CTriviallyErasable<MaxByteSize> TDecayedConcrete>
     const TDecayedConcrete& AsConcrete() const & noexcept;
 
-    template <CTriviallyErasable TDecayedConcrete>
+    template <CTriviallyErasable<MaxByteSize> TDecayedConcrete>
     TDecayedConcrete&& AsConcrete() && noexcept;
 
+    bool operator==(const TErasedStorage& other) const = default;
+
 private:
     // NB(arkady-e1ppa): aligned_storage is deprecated.
-    alignas(ErasedStorageMaxByteSize) std::byte Bytes_[ErasedStorageMaxByteSize];
+    alignas(MaxByteSize) std::byte Bytes_[MaxByteSize];
 };
 
 ////////////////////////////////////////////////////////////////////////////////
diff --git a/library/cpp/yt/memory/exact_ref_counted_cast-inl.h b/library/cpp/yt/memory/exact_ref_counted_cast-inl.h
new file mode 100644
index 00000000000..71163e26e0a
--- /dev/null
+++ b/library/cpp/yt/memory/exact_ref_counted_cast-inl.h
@@ -0,0 +1,46 @@
+#ifndef EXACT_REF_COUNTED_CAST_INL_H_
+#error "Direct inclusion of this file is not allowed, include exact_ref_counted_cast.h"
+// For the sake of sane code completion.
+#include "exact_ref_counted_cast.h"
+#endif
+
+#include "new.h"
+
+#include <typeinfo>
+
+namespace NYT {
+
+////////////////////////////////////////////////////////////////////////////////
+
+template <class T, class U>
+std::conditional_t<std::is_const_v<U>, const T, T>* ExactRefCountedCast(U* ptr) noexcept
+{
+    static_assert(std::is_polymorphic_v<U>,
+        "ExactRefCountedCast requires a polymorphic operand type");
+    static_assert(std::is_base_of_v<TRefCountedBase, T>,
+        "ExactRefCountedCast target must derive from TRefCountedBase");
+    static_assert(std::is_final_v<TRefCountedWrapper<T>>,
+        "TRefCountedWrapper must stay final for this cast to remain O(1)");
+
+    using TWrapper = std::conditional_t<std::is_const_v<U>, const TRefCountedWrapper<T>, TRefCountedWrapper<T>>;
+    // Wrapper is final, so dynamic_cast lowers to one type_info compare.
+    return dynamic_cast<TWrapper*>(ptr);
+}
+
+template <class T, class U>
+std::conditional_t<std::is_const_v<U>, const T, T>& ExactRefCountedCast(U& ref)
+{
+    static_assert(std::is_polymorphic_v<U>,
+        "ExactRefCountedCast requires a polymorphic operand type");
+    static_assert(std::is_base_of_v<TRefCountedBase, T>,
+        "ExactRefCountedCast target must derive from TRefCountedBase");
+    static_assert(std::is_final_v<TRefCountedWrapper<T>>,
+        "TRefCountedWrapper must stay final for this cast to remain O(1)");
+
+    using TWrapper = std::conditional_t<std::is_const_v<U>, const TRefCountedWrapper<T>, TRefCountedWrapper<T>>;
+    return dynamic_cast<TWrapper&>(ref);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace NYT
diff --git a/library/cpp/yt/memory/exact_ref_counted_cast.h b/library/cpp/yt/memory/exact_ref_counted_cast.h
new file mode 100644
index 00000000000..3b186103f3a
--- /dev/null
+++ b/library/cpp/yt/memory/exact_ref_counted_cast.h
@@ -0,0 +1,36 @@
+#pragma once
+
+#include "ref_counted.h"
+
+#include <type_traits>
+
+namespace NYT {
+
+////////////////////////////////////////////////////////////////////////////////
+
+//! A downcast that succeeds iff the object was allocated as *exactly* |New<T>()|
+//! (not a subclass, not some other allocation path).
+/*!
+ *  |New<T>()| does not construct a |T| but a final |TRefCountedWrapper<T>|
+ *  deriving from |T|, so |T| is never a leaf and |dynamic_cast<T*>| takes the
+ *  slow is-a path. This casts to the wrapper instead and upcasts back to |T*|;
+ *  since the wrapper is final, dynamic_cast lowers to one type_info compare --
+ *  O(1), as cheap on a miss as on a hit.
+ *
+ *  Pointer form returns |nullptr| on a miss (or null operand); reference form
+ *  throws |std::bad_cast|. Constness is preserved. |T| must derive from
+ *  |TRefCountedBase| and |U| must be polymorphic. Requires RTTI.
+ */
+template <class T, class U>
+[[nodiscard]] std::conditional_t<std::is_const_v<U>, const T, T>* ExactRefCountedCast(U* ptr) noexcept;
+
+template <class T, class U>
+[[nodiscard]] std::conditional_t<std::is_const_v<U>, const T, T>& ExactRefCountedCast(U& ref);
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace NYT
+
+#define EXACT_REF_COUNTED_CAST_INL_H_
+#include "exact_ref_counted_cast-inl.h"
+#undef EXACT_REF_COUNTED_CAST_INL_H_
diff --git a/library/cpp/yt/memory/free_list-inl.h b/library/cpp/yt/memory/free_list-inl.h
index d428b824982..a7adbb0e238 100644
--- a/library/cpp/yt/memory/free_list-inl.h
+++ b/library/cpp/yt/memory/free_list-inl.h
@@ -4,22 +4,37 @@
 #include "free_list.h"
 #endif
 
+#include <util/system/sanitizers.h>
+
 namespace NYT {
 
 ////////////////////////////////////////////////////////////////////////////////
 
-// DCAS is supported in Clang with option -mcx16, is not supported in GCC. See following links.
+namespace NDetail {
+
+#if defined(_64_)
+
+// DCAS is natively supported in Clang with -mcx16 and is not supported in GCC.
 // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=84522
 // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=80878
-
 template <class T1, class T2>
-Y_FORCE_INLINE bool CompareAndSet(
-    TAtomicUint128* atomic,
+Y_FORCE_INLINE bool CasFreeListPackedPair(
+    TFreeListPackedPair* atomic,
     T1& expected1,
     T2& expected2,
     T1 new1,
     T2 new2)
 {
+#if defined(_tsan_enabled_)
+    __tsan_acquire(const_cast<unsigned __int128*>(atomic));
+    __tsan_release(const_cast<unsigned __int128*>(atomic));
+    // NB(sabdenovch): release must happen before cmpxchg to avoid the situation
+    // where producer writes to non-atomic memory does CAS,
+    // sleeps without letting thread sanitizer know about release,
+    // then consumer does CAS, informs thread sanitizer about acquire and reads non-atomic memory.
+    // No real race exists anyway, this is a workaround for TSAN false positives.
+#endif
+
 #if defined(__x86_64__)
     bool success;
     __asm__ __volatile__
@@ -88,7 +103,6 @@ Y_FORCE_INLINE bool CompareAndSet(
             , [dst] "r" (atomic)
             : "memory"
         );
-
     } while (Y_UNLIKELY(fail));
     return true;
 #else
@@ -96,6 +110,36 @@ Y_FORCE_INLINE bool CompareAndSet(
 #endif
 }
 
+#elif defined(_32_)
+
+template <class T1, class T2>
+Y_FORCE_INLINE bool CasFreeListPackedPair(
+    TFreeListPackedPair* atomic,
+    T1& expected1,
+    T2& expected2,
+    T1 new1,
+    T2 new2)
+{
+    auto packedExpected =
+        static_cast<ui64>(reinterpret_cast<ui32>(expected1)) |
+        (static_cast<ui64>(reinterpret_cast<ui32>(expected2)) << 32);
+    auto packedNew =
+        static_cast<ui64>(reinterpret_cast<ui32>(new1)) |
+        (static_cast<ui64>(reinterpret_cast<ui32>(new2)) << 32);
+    if (atomic->compare_exchange_weak(packedExpected, packedNew)) {
+        return true;
+    }
+    expected1 = reinterpret_cast<T1>(static_cast<ui32>(packedExpected));
+    expected2 = reinterpret_cast<T2>(static_cast<ui32>(packedExpected >> 32));
+    return false;
+}
+
+#else
+    #error Unsupported platform
+#endif
+
+} // namespace NDetail
+
 ////////////////////////////////////////////////////////////////////////////////
 
 template <class TItem>
@@ -109,7 +153,7 @@ TFreeList<TItem>::TFreeList()
 { }
 
 template <class TItem>
-TFreeList<TItem>::TFreeList(TFreeList<TItem>&& other)
+TFreeList<TItem>::TFreeList(TFreeList<TItem>&& other) noexcept
     : Head_(other.ExtractAll())
 { }
 
@@ -121,7 +165,6 @@ TFreeList<TItem>::~TFreeList()
 
 template <class TItem>
 template <class TPredicate>
-Y_NO_SANITIZE("thread")
 bool TFreeList<TItem>::PutIf(TItem* head, TItem* tail, TPredicate predicate)
 {
     auto* current = Head_.Pointer.load(std::memory_order::relaxed);
@@ -129,7 +172,7 @@ bool TFreeList<TItem>::PutIf(TItem* head, TItem* tail, TPredicate predicate)
 
     while (predicate(current)) {
         tail->Next.store(current, std::memory_order::release);
-        if (CompareAndSet(&AtomicHead_, current, epoch, head, epoch + 1)) {
+        if (NDetail::CasFreeListPackedPair(&PackedHead_, current, epoch, head, epoch + 1)) {
             return true;
         }
     }
@@ -139,9 +182,7 @@ bool TFreeList<TItem>::PutIf(TItem* head, TItem* tail, TPredicate predicate)
     return false;
 }
 
-
 template <class TItem>
-Y_NO_SANITIZE("thread")
 void TFreeList<TItem>::Put(TItem* head, TItem* tail)
 {
     auto* current = Head_.Pointer.load(std::memory_order::relaxed);
@@ -149,7 +190,7 @@ void TFreeList<TItem>::Put(TItem* head, TItem* tail)
 
     do {
         tail->Next.store(current, std::memory_order::release);
-    } while (!CompareAndSet(&AtomicHead_, current, epoch, head, epoch + 1));
+    } while (!NDetail::CasFreeListPackedPair(&PackedHead_, current, epoch, head, epoch + 1));
 }
 
 template <class TItem>
@@ -159,7 +200,6 @@ void TFreeList<TItem>::Put(TItem* item)
 }
 
 template <class TItem>
-Y_NO_SANITIZE("thread")
 TItem* TFreeList<TItem>::Extract()
 {
     auto* current = Head_.Pointer.load(std::memory_order::relaxed);
@@ -170,7 +210,7 @@ TItem* TFreeList<TItem>::Extract()
         // there can be any writes at address &current->Next.
         // The only guaranteed thing is that address is valid (memory is not freed).
         auto next = current->Next.load(std::memory_order::acquire);
-        if (CompareAndSet(&AtomicHead_, current, epoch, next, epoch + 1)) {
+        if (NDetail::CasFreeListPackedPair(&PackedHead_, current, epoch, next, epoch + 1)) {
             current->Next.store(nullptr, std::memory_order::release);
             return current;
         }
@@ -186,7 +226,7 @@ TItem* TFreeList<TItem>::ExtractAll()
     auto epoch = Head_.Epoch.load(std::memory_order::relaxed);
 
     while (current) {
-        if (CompareAndSet<TItem*, size_t>(&AtomicHead_, current, epoch, nullptr, epoch + 1)) {
+        if (NDetail::CasFreeListPackedPair<TItem*, TEpoch>(&PackedHead_, current, epoch, nullptr, epoch + 1)) {
             return current;
         }
     }
diff --git a/library/cpp/yt/memory/free_list.h b/library/cpp/yt/memory/free_list.h
index 8c06bcb7a53..daf8bddfe29 100644
--- a/library/cpp/yt/memory/free_list.h
+++ b/library/cpp/yt/memory/free_list.h
@@ -1,6 +1,7 @@
 #pragma once
 
 #include "public.h"
+#include "tagged_ptr.h"
 
 #include <atomic>
 
@@ -8,59 +9,76 @@ namespace NYT {
 
 ////////////////////////////////////////////////////////////////////////////////
 
+namespace NDetail {
+
+#if defined(_64_)
+
+using TFreeListPackedPairComponent = ui64;
+using TFreeListPackedPair = volatile unsigned __int128  __attribute__((aligned(16)));
+
+#elif defined(_32_)
+
+using TFreeListPackedPairComponent = ui32;
+using TFreeListPackedPair = std::atomic<ui64>;
+
+#else
+    #error Unsupported platform
+#endif
+
+} // namespace NDetail
+
+////////////////////////////////////////////////////////////////////////////////
+
 template <class T>
 struct TFreeListItemBase
 {
     std::atomic<T*> Next = nullptr;
 };
 
-using TAtomicUint128 = volatile unsigned __int128  __attribute__((aligned(16)));
-
 template <class TItem>
 class TFreeList
 {
 private:
+    using TEpoch = NDetail::TFreeListPackedPairComponent;
+
     struct THead
     {
         std::atomic<TItem*> Pointer = nullptr;
-        std::atomic<size_t> Epoch = 0;
+        std::atomic<TEpoch> Epoch = 0;
 
         THead() = default;
 
         explicit THead(TItem* pointer);
-
     };
 
+    static_assert(sizeof(THead) == sizeof(NDetail::TFreeListPackedPair));
+
     union
     {
         THead Head_;
-        TAtomicUint128 AtomicHead_;
+        NDetail::TFreeListPackedPair PackedHead_;
     };
 
     // Avoid false sharing.
-    char Padding[CacheLineSize - sizeof(TAtomicUint128)];
+    [[maybe_unused]] char Padding_[CacheLineSize - sizeof(THead)];
 
 public:
     TFreeList();
-
-    TFreeList(TFreeList&& other);
+    TFreeList(TFreeList&& other) noexcept;
 
     ~TFreeList();
 
     template <class TPredicate>
     bool PutIf(TItem* head, TItem* tail, TPredicate predicate);
-
     void Put(TItem* head, TItem* tail);
-
     void Put(TItem* item);
 
     TItem* Extract();
-
     TItem* ExtractAll();
 
-    bool IsEmpty() const;
-
     void Append(TFreeList& other);
+
+    bool IsEmpty() const;
 };
 
 ////////////////////////////////////////////////////////////////////////////////
diff --git a/library/cpp/yt/memory/intrusive_ptr.h b/library/cpp/yt/memory/intrusive_ptr.h
index 91b15279aec..613b2f58c49 100644
--- a/library/cpp/yt/memory/intrusive_ptr.h
+++ b/library/cpp/yt/memory/intrusive_ptr.h
@@ -18,6 +18,9 @@ class TIntrusivePtr
 public:
     using TUnderlying = T;
 
+    //! For compatibility with std:: smart pointers.
+    using element_type = T;
+
     constexpr TIntrusivePtr() noexcept
     { }
 
@@ -29,10 +32,10 @@ class TIntrusivePtr
      * Note that this constructor could be racy due to unsynchronized operations
      * on the object and on the counter.
      *
-     * Note that it notoriously hard to make this constructor explicit
+     * Note that it is notoriously hard to make this constructor explicit
      * given the current amount of code written.
      */
-    TIntrusivePtr(T* obj, bool addReference = true) noexcept
+    constexpr TIntrusivePtr(T* obj, bool addReference = true) noexcept
         : T_(obj)
     {
         if (T_ && addReference) {
@@ -54,9 +57,7 @@ class TIntrusivePtr
     TIntrusivePtr(const TIntrusivePtr<U>& other) noexcept
         : T_(other.Get())
     {
-        static_assert(
-            std::derived_from<T, TRefCountedBase>,
-            "Cast allowed only for types derived from TRefCountedBase");
+        ValidateCastFrom<U>();
         if (T_) {
             Ref(T_);
         }
@@ -74,9 +75,7 @@ class TIntrusivePtr
     TIntrusivePtr(TIntrusivePtr<U>&& other) noexcept
         : T_(other.Get())
     {
-        static_assert(
-            std::derived_from<T, TRefCountedBase>,
-            "Cast allowed only for types derived from TRefCountedBase");
+        ValidateCastFrom<U>();
         other.T_ = nullptr;
     }
 
@@ -102,9 +101,7 @@ class TIntrusivePtr
         static_assert(
             std::is_convertible_v<U*, T*>,
             "U* must be convertible to T*");
-        static_assert(
-            std::derived_from<T, TRefCountedBase>,
-            "Cast allowed only for types derived from TRefCountedBase");
+        ValidateCastFrom<U>();
         TIntrusivePtr(other).Swap(*this);
         return *this;
     }
@@ -123,9 +120,7 @@ class TIntrusivePtr
         static_assert(
             std::is_convertible_v<U*, T*>,
             "U* must be convertible to T*");
-        static_assert(
-            std::derived_from<T, TRefCountedBase>,
-            "Cast allowed only for types derived from TRefCountedBase");
+        ValidateCastFrom<U>();
         TIntrusivePtr(std::move(other)).Swap(*this);
         return *this;
     }
@@ -148,6 +143,12 @@ class TIntrusivePtr
         return T_;
     }
 
+    //! Returns the pointer, for compatibility with std:: smart pointers.
+    T* get() const noexcept
+    {
+        return T_;
+    }
+
     //! Returns the pointer and releases the ownership.
     T* Release() noexcept
     {
@@ -184,6 +185,16 @@ class TIntrusivePtr
     friend class TIntrusivePtr;
 
     T* T_ = nullptr;
+
+    template <class U>
+    static constexpr void ValidateCastFrom() noexcept
+    {
+        if constexpr (!std::is_same_v<const U, T>) {
+            static_assert(
+                std::derived_from<T, TRefCountedBase>,
+                "Cast allowed only for types derived from TRefCountedBase");
+        }
+    }
 };
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -256,99 +267,115 @@ TIntrusivePtr<T> DynamicPointerCast(const TIntrusivePtr<U>& ptr)
 ////////////////////////////////////////////////////////////////////////////////
 
 template <class T>
-bool operator<(const TIntrusivePtr<T>& lhs, const TIntrusivePtr<T>& rhs)
+std::strong_ordering operator<=>(const TIntrusivePtr<T>& lhs, const TIntrusivePtr<T>& rhs)
 {
-    return lhs.Get() < rhs.Get();
+    return lhs.Get() <=> rhs.Get();
 }
 
 template <class T>
-bool operator>(const TIntrusivePtr<T>& lhs, const TIntrusivePtr<T>& rhs)
+std::strong_ordering operator<=>(const TIntrusivePtr<T>& lhs, T* rhs)
 {
-    return lhs.Get() > rhs.Get();
+    return lhs.Get() <=> rhs;
 }
 
-template <class T, class U>
-bool operator==(const TIntrusivePtr<T>& lhs, const TIntrusivePtr<U>& rhs)
+template <class T>
+std::strong_ordering operator<=>(T* lhs, const TIntrusivePtr<T>& rhs)
 {
-    static_assert(
-        std::is_convertible_v<U*, T*>,
-        "U* must be convertible to T*");
-    return lhs.Get() == rhs.Get();
+    return lhs <=> rhs.Get();
 }
 
 template <class T, class U>
-bool operator!=(const TIntrusivePtr<T>& lhs, const TIntrusivePtr<U>& rhs)
+    requires std::equality_comparable_with<T*, U*>
+bool operator==(const TIntrusivePtr<T>& lhs, const TIntrusivePtr<U>& rhs)
 {
-    static_assert(
-        std::is_convertible_v<U*, T*>,
-        "U* must be convertible to T*");
-    return lhs.Get() != rhs.Get();
+    return lhs.Get() == rhs.Get();
 }
 
 template <class T, class U>
+    requires std::equality_comparable_with<T*, U*>
 bool operator==(const TIntrusivePtr<T>& lhs, U* rhs)
 {
     return lhs.Get() == rhs;
 }
 
 template <class T, class U>
-bool operator!=(const TIntrusivePtr<T>& lhs, U* rhs)
-{
-    static_assert(
-        std::is_convertible_v<U*, T*>,
-        "U* must be convertible to T*");
-    return lhs.Get() != rhs;
-}
-
-template <class T, class U>
+    requires std::equality_comparable_with<T*, U*>
 bool operator==(T* lhs, const TIntrusivePtr<U>& rhs)
 {
     return lhs == rhs.Get();
 }
 
-template <class T, class U>
-bool operator!=(T* lhs, const TIntrusivePtr<U>& rhs)
-{
-    static_assert(
-        std::is_convertible_v<U*, T*>,
-        "U* must be convertible to T*");
-    return lhs != rhs.Get();
-}
-
 template <class T>
 bool operator==(std::nullptr_t, const TIntrusivePtr<T>& rhs)
 {
     return nullptr == rhs.Get();
 }
 
-template <class T>
-bool operator!=(std::nullptr_t, const TIntrusivePtr<T>& rhs)
-{
-    return nullptr != rhs.Get();
-}
-
 template <class T>
 bool operator==(const TIntrusivePtr<T>& lhs, std::nullptr_t)
 {
     return nullptr == lhs.Get();
 }
 
-template <class T>
-bool operator!=(const TIntrusivePtr<T>& lhs, std::nullptr_t)
+////////////////////////////////////////////////////////////////////////////////
+
+//! Abseil hash support for TIntrusivePtr.
+template <class THash, class T>
+THash AbslHashValue(THash hash, const TIntrusivePtr<T>& ptr)
 {
-    return nullptr != lhs.Get();
+    return THash::combine(std::move(hash), ptr.Get());
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
-} //namespace NYT
+} // namespace NYT
 
 //! A hasher for TIntrusivePtr.
 template <class T>
 struct THash<NYT::TIntrusivePtr<T>>
 {
-    Y_FORCE_INLINE size_t operator () (const NYT::TIntrusivePtr<T>& ptr) const
+    using is_transparent = void;
+
+    Y_FORCE_INLINE size_t operator()(const NYT::TIntrusivePtr<T>& ptr) const
     {
         return THash<T*>()(ptr.Get());
     }
+
+    Y_FORCE_INLINE size_t operator()(T* ptr) const
+    {
+        return THash<T*>()(ptr);
+    }
+};
+
+template <class T>
+struct TEqualTo<NYT::TIntrusivePtr<T>>
+{
+    using is_transparent = void;
+
+    template <class U>
+        requires std::equality_comparable_with<NYT::TIntrusivePtr<T>, const U&>
+    bool operator()(const NYT::TIntrusivePtr<T>& lhs, const U& rhs) const
+    {
+        return lhs == rhs;
+    }
+};
+
+template <class T>
+struct TLess<NYT::TIntrusivePtr<T>>
+{
+    using is_transparent = void;
+
+    template <class U>
+        requires std::three_way_comparable_with<const NYT::TIntrusivePtr<T>&, const U&>
+    bool operator()(const NYT::TIntrusivePtr<T>& lhs, const U& rhs) const
+    {
+        return lhs < rhs;
+    }
+
+    template <class U>
+        requires std::three_way_comparable_with<T*, const U&>
+    bool operator()(T* lhs, const U& rhs) const
+    {
+        return lhs < rhs;
+    }
 };
diff --git a/library/cpp/yt/memory/leaky_ref_counted_singleton-inl.h b/library/cpp/yt/memory/leaky_ref_counted_singleton-inl.h
index 1fba63c427a..f4bccbbaf9d 100644
--- a/library/cpp/yt/memory/leaky_ref_counted_singleton-inl.h
+++ b/library/cpp/yt/memory/leaky_ref_counted_singleton-inl.h
@@ -30,9 +30,6 @@ TIntrusivePtr<T> LeakyRefCountedSingleton(TArgs&&... args)
         auto ptr = New<T>(std::forward<TArgs>(args)...);
         Ref(ptr.Get());
         Ptr.store(ptr.Get());
-#if defined(_asan_enabled_)
-        NSan::MarkAsIntentionallyLeaked(ptr.Get());
-#endif
     });
 
     return Ptr.load();
diff --git a/library/cpp/yt/memory/memory_tag-inl.h b/library/cpp/yt/memory/memory_tag-inl.h
index 42065b4899a..d26bfab1866 100644
--- a/library/cpp/yt/memory/memory_tag-inl.h
+++ b/library/cpp/yt/memory/memory_tag-inl.h
@@ -24,7 +24,7 @@ inline TMemoryTagGuard::TMemoryTagGuard(TMemoryTag tag)
     SetCurrentMemoryTag(tag);
 }
 
-inline TMemoryTagGuard::TMemoryTagGuard(TMemoryTagGuard&& other)
+inline TMemoryTagGuard::TMemoryTagGuard(TMemoryTagGuard&& other) noexcept
     : Active_(other.Active_)
     , PreviousTag_(other.PreviousTag_)
 {
diff --git a/library/cpp/yt/memory/memory_tag.h b/library/cpp/yt/memory/memory_tag.h
index 9c975ae1702..8b16dc4f5e7 100644
--- a/library/cpp/yt/memory/memory_tag.h
+++ b/library/cpp/yt/memory/memory_tag.h
@@ -39,7 +39,7 @@ class TMemoryTagGuard
     explicit TMemoryTagGuard(TMemoryTag tag);
 
     TMemoryTagGuard(const TMemoryTagGuard& other) = delete;
-    TMemoryTagGuard(TMemoryTagGuard&& other);
+    TMemoryTagGuard(TMemoryTagGuard&& other) noexcept;
 
     ~TMemoryTagGuard();
 
diff --git a/library/cpp/yt/memory/new-inl.h b/library/cpp/yt/memory/new-inl.h
index c21bd37a0ce..724fe6d1b9e 100644
--- a/library/cpp/yt/memory/new-inl.h
+++ b/library/cpp/yt/memory/new-inl.h
@@ -37,7 +37,7 @@ struct TRefCountedCookieHolder
 
 template <class T>
 struct TRefCountedWrapper final
-    : public T
+    : public std::remove_const_t<T>
     , public TRefTracked<T>
 {
     template <class... TArgs>
@@ -55,7 +55,7 @@ struct TRefCountedWrapper final
 
 template <class T, class TDeleter>
 class TRefCountedWrapperWithDeleter final
-    : public T
+    : public std::remove_const_t<T>
     , public TRefTracked<T>
 {
 public:
@@ -78,7 +78,7 @@ class TRefCountedWrapperWithDeleter final
 
 template <class T>
 struct TRefCountedWrapperWithCookie final
-    : public T
+    : public std::remove_const_t<T>
     , public TRefCountedCookieHolder
 {
     template <class... TArgs>
@@ -176,18 +176,44 @@ Y_FORCE_INLINE TIntrusivePtr<T> SafeConstruct(void* ptr, As&&... args)
     }
 }
 
+void AbortOnOom();
+
 template <size_t Size, size_t Alignment>
-void* AllocateConstSizeAligned()
+Y_FORCE_INLINE void* AllocateConstSizeAlignedOrCrash()
+{
+    void* ptr;
+#ifdef _win_
+    ptr = ::aligned_malloc(Size, Alignment);
+#else
+    if (Alignment <= alignof(std::max_align_t)) {
+        ptr = ::malloc(Size);
+    } else {
+        ptr = ::aligned_malloc(Size, Alignment);
+    }
+#endif
+    if (Y_UNLIKELY(!ptr)) {
+        AbortOnOom();
+    }
+    return ptr;
+}
+
+template <size_t Alignment>
+Y_FORCE_INLINE void* AllocateOrCrash(size_t size)
 {
+    void* ptr;
 #ifdef _win_
-    return ::aligned_malloc(Size, Alignment);
+    ptr = ::aligned_malloc(size, Alignment);
 #else
     if (Alignment <= alignof(std::max_align_t)) {
-        return ::malloc(Size);
+        ptr = ::malloc(size);
     } else {
-        return ::aligned_malloc(Size, Alignment);
+        ptr = ::aligned_malloc(size, Alignment);
     }
 #endif
+    if (Y_UNLIKELY(!ptr)) {
+        AbortOnOom();
+    }
+    return ptr;
 }
 
 } // namespace NDetail
@@ -198,25 +224,36 @@ template <class T, class... As, class>
 Y_FORCE_INLINE TIntrusivePtr<T> New(
     As&&... args)
 {
-    void* ptr = NYT::NDetail::AllocateConstSizeAligned<
+    void* ptr = NYT::NDetail::AllocateConstSizeAlignedOrCrash<
         NYT::NDetail::TConstructHelper<T>::Size,
         NYT::NDetail::TConstructHelper<T>::Alignment>();
-
     return NYT::NDetail::SafeConstruct<T>(ptr, std::forward<As>(args)...);
 }
 
 template <class T, class... As, class>
-Y_FORCE_INLINE TIntrusivePtr<T> New(
+Y_FORCE_INLINE TIntrusivePtr<T> TryNew(
     typename T::TAllocator* allocator,
     As&&... args)
 {
     auto* ptr = allocator->Allocate(NYT::NDetail::TConstructHelper<T>::Size);
-    if (!ptr) {
+    if (Y_UNLIKELY(!ptr)) {
         return nullptr;
     }
     return NYT::NDetail::SafeConstruct<T>(ptr, std::forward<As>(args)...);
 }
 
+template <class T, class... As, class>
+Y_FORCE_INLINE TIntrusivePtr<T> New(
+    typename T::TAllocator* allocator,
+    As&&... args)
+{
+    auto obj = TryNew<T>(allocator, std::forward<As>(args)...);
+    if (Y_UNLIKELY(!obj)) {
+        NYT::NDetail::AbortOnOom();
+    }
+    return obj;
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 
 template <class T, class... As, class>
@@ -225,69 +262,63 @@ Y_FORCE_INLINE TIntrusivePtr<T> NewWithExtraSpace(
     As&&... args)
 {
     auto totalSize = NYT::NDetail::TConstructHelper<T>::Size + extraSpaceSize;
-    void* ptr = nullptr;
-
-#ifdef _win_
-    ptr = ::aligned_malloc(totalSize, NYT::NDetail::TConstructHelper<T>::Alignment);
-#else
-    if (NYT::NDetail::TConstructHelper<T>::Alignment <= alignof(std::max_align_t)) {
-        ptr = ::malloc(totalSize);
-    } else {
-        ptr = ::aligned_malloc(totalSize, NYT::NDetail::TConstructHelper<T>::Alignment);
-    }
-#endif
-
+    void* ptr = NYT::NDetail::AllocateOrCrash<NYT::NDetail::TConstructHelper<T>::Alignment>(totalSize);
     return NYT::NDetail::SafeConstruct<T>(ptr, std::forward<As>(args)...);
 }
 
 template <class T, class... As, class>
-Y_FORCE_INLINE TIntrusivePtr<T> NewWithExtraSpace(
+Y_FORCE_INLINE TIntrusivePtr<T> TryNewWithExtraSpace(
     typename T::TAllocator* allocator,
     size_t extraSpaceSize,
     As&&... args)
 {
     auto totalSize = NYT::NDetail::TConstructHelper<T>::Size + extraSpaceSize;
     auto* ptr = allocator->Allocate(totalSize);
-    if (!ptr) {
+    if (Y_UNLIKELY(!ptr)) {
         return nullptr;
     }
     return NYT::NDetail::SafeConstruct<T>(ptr, std::forward<As>(args)...);
 }
 
+template <class T, class... As, class>
+Y_FORCE_INLINE TIntrusivePtr<T> NewWithExtraSpace(
+    typename T::TAllocator* allocator,
+    size_t extraSpaceSize,
+    As&&... args)
+{
+    auto obj = TryNewWithExtraSpace<T>(allocator, extraSpaceSize, std::forward<As>(args)...);
+    if (Y_UNLIKELY(!obj)) {
+        NYT::NDetail::AbortOnOom();
+    }
+    return obj;
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 
 template <class T, class TDeleter, class... As>
 Y_FORCE_INLINE TIntrusivePtr<T> NewWithDeleter(TDeleter deleter, As&&... args)
 {
     using TWrapper = TRefCountedWrapperWithDeleter<T, TDeleter>;
-    void* ptr = NYT::NDetail::AllocateConstSizeAligned<sizeof(TWrapper), alignof(TWrapper)>();
-
+    void* ptr = NYT::NDetail::AllocateConstSizeAlignedOrCrash<sizeof(TWrapper), alignof(TWrapper)>();
     auto* instance = NYT::NDetail::NewEpilogue<TWrapper>(
         ptr,
         std::move(deleter),
         std::forward<As>(args)...);
-
     return TIntrusivePtr<T>(instance, /*addReference*/ false);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
-template <class T, class TTag, int Counter, class... As>
+template <class T, auto LocationLite, class... As>
 Y_FORCE_INLINE TIntrusivePtr<T> NewWithLocation(
-    const TSourceLocation& location,
     As&&... args)
 {
     using TWrapper = TRefCountedWrapperWithCookie<T>;
-    void* ptr = NYT::NDetail::AllocateConstSizeAligned<sizeof(TWrapper), alignof(TWrapper)>();
-
+    void* ptr = NYT::NDetail::AllocateConstSizeAlignedOrCrash<sizeof(TWrapper), alignof(TWrapper)>();
     auto* instance = NYT::NDetail::NewEpilogue<TWrapper>(ptr, std::forward<As>(args)...);
-
 #ifdef YT_ENABLE_REF_COUNTED_TRACKING
-    instance->InitializeTracking(GetRefCountedTypeCookieWithLocation<T, TTag, Counter>(location));
-#else
-    Y_UNUSED(location);
+    instance->InitializeTracking(GetRefCountedTypeCookieWithLocation<T, LocationLite>());
 #endif
-
     return TIntrusivePtr<T>(instance, /*addReference*/ false);
 }
 
@@ -306,12 +337,17 @@ void* TWithExtraSpace<T>::GetExtraSpacePtr()
 }
 
 template <class T>
-size_t TWithExtraSpace<T>::GetUsableSpaceSize() const
+std::optional<size_t> TWithExtraSpace<T>::GetUsableSpaceSize() const
 {
 #ifdef _win_
     return 0;
 #else
-    return malloc_usable_size(const_cast<T*>(static_cast<const T*>(this))) - sizeof(T);
+    size_t usableSize = malloc_usable_size(const_cast<T*>(static_cast<const T*>(this)));
+    if (usableSize == 0) {
+        return std::nullopt;
+    }
+    YT_ASSERT(usableSize >= sizeof(T));
+    return usableSize - sizeof(T);
 #endif
 }
 
diff --git a/library/cpp/yt/memory/new.cpp b/library/cpp/yt/memory/new.cpp
new file mode 100644
index 00000000000..0b4a4b3b8b8
--- /dev/null
+++ b/library/cpp/yt/memory/new.cpp
@@ -0,0 +1,18 @@
+#include "new.h"
+
+#include <library/cpp/yt/system/exit.h>
+
+namespace NYT::NDetail {
+
+////////////////////////////////////////////////////////////////////////////////
+
+void AbortOnOom()
+{
+    AbortProcessDramatically(
+        EProcessExitCode::OutOfMemory,
+        "Out-of-memory during object allocation");
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace NYT::NDetail
diff --git a/library/cpp/yt/memory/new.h b/library/cpp/yt/memory/new.h
index a9591724edc..50f594c990a 100644
--- a/library/cpp/yt/memory/new.h
+++ b/library/cpp/yt/memory/new.h
@@ -6,6 +6,8 @@
 
 #include <util/system/defaults.h>
 
+#include <optional>
+
 namespace NYT {
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -78,28 +80,45 @@ struct THasAllocator<T, std::void_t<typename T::TAllocator>>
 
 ////////////////////////////////////////////////////////////////////////////////
 
-//! Allocates a new instance of |T|.
+//! Allocates a new instance of |T| using the standard allocator.
+//! Aborts the process on out-of-memory condition.
 template <class T, class... As, class = typename THasAllocator<T>::TFalse>
 TIntrusivePtr<T> New(As&&... args);
 
+//! Allocates a new instance of |T| using a custom #allocator.
+//! Returns null on allocation failure.
+template <class T, class... As, class = typename THasAllocator<T>::TTrue>
+TIntrusivePtr<T> TryNew(typename T::TAllocator* allocator, As&&... args);
+
+//! Same as #TryNewWit but aborts on allocation failure.
 template <class T, class... As, class = typename THasAllocator<T>::TTrue>
 TIntrusivePtr<T> New(typename T::TAllocator* allocator, As&&... args);
 
-//! Allocates an instance of |T| with additional storage of #extraSpaceSize bytes.
+//! Allocates an instance of |T|
+//! Aborts the process on out-of-memory condition.
 template <class T, class... As, class = typename THasAllocator<T>::TFalse>
 TIntrusivePtr<T> NewWithExtraSpace(size_t extraSpaceSize, As&&... args);
 
+//! Allocates a new instance of |T| with additional storage of #extraSpaceSize bytes
+//! using a custom #allocator.
+//! Returns null on allocation failure.
+template <class T, class... As, class = typename THasAllocator<T>::TTrue>
+TIntrusivePtr<T> TryNewWithExtraSpace(typename T::TAllocator* allocator, size_t extraSpaceSize, As&&... args);
+
+//! Same as #TryNewWithExtraSpace but aborts on allocation failure.
 template <class T, class... As, class = typename THasAllocator<T>::TTrue>
 TIntrusivePtr<T> NewWithExtraSpace(typename T::TAllocator* allocator, size_t extraSpaceSize, As&&... args);
 
 //! Allocates a new instance of |T| with a custom #deleter.
+//! Aborts the process on out-of-memory condition.
 template <class T, class TDeleter, class... As>
 TIntrusivePtr<T> NewWithDeleter(TDeleter deleter, As&&... args);
 
 //! Allocates a new instance of |T|.
 //! The allocation is additionally marked with #location.
-template <class T, class TTag, int Counter, class... As>
-TIntrusivePtr<T> NewWithLocation(const TSourceLocation& location, As&&... args);
+//! Aborts the process on out-of-memory condition.
+template <class T, auto LocationLite, class... As>
+TIntrusivePtr<T> NewWithLocation(As&&... args);
 
 //! Enables calling #New and co for types with private ctors.
 #define DECLARE_NEW_FRIEND() \
@@ -113,9 +132,14 @@ template <class T>
 class TWithExtraSpace
 {
 protected:
+    //! Returns the pointer to the extra space associated with this instance.
     const void* GetExtraSpacePtr() const;
     void* GetExtraSpacePtr();
-    size_t GetUsableSpaceSize() const;
+
+    //! Returns the size of the extra space associated with this instance.
+    //! This is determined via the call to |malloc_usable_size| and may be
+    //! null if the allocator support is unavailable.
+    std::optional<size_t> GetUsableSpaceSize() const;
 };
 
 ////////////////////////////////////////////////////////////////////////////////
diff --git a/library/cpp/yt/memory/non_null_ptr-inl.h b/library/cpp/yt/memory/non_null_ptr-inl.h
new file mode 100644
index 00000000000..a53697816e8
--- /dev/null
+++ b/library/cpp/yt/memory/non_null_ptr-inl.h
@@ -0,0 +1,56 @@
+#pragma once
+#ifndef NON_NULL_PTR_H_
+#error "Direct inclusion of this file is not allowed, include non_null_ptr.h"
+// For the sake of sane code completion.
+#include "non_null_ptr.h"
+#endif
+
+#include <library/cpp/yt/assert/assert.h>
+
+namespace NYT {
+
+////////////////////////////////////////////////////////////////////////////////
+
+template <class T>
+TNonNullPtrBase<T>::TNonNullPtrBase(T* ptr) noexcept
+    : Ptr_(ptr)
+{
+    YT_VERIFY(ptr);
+}
+
+template <class T>
+TNonNullPtrBase<T>::TNonNullPtrBase(TIntrusivePtr<T> ptr) noexcept
+    : Ptr_(ptr.Get())
+{
+    YT_VERIFY(ptr);
+}
+
+template <class T>
+T* TNonNullPtrBase<T>::operator->() const noexcept
+{
+    return Ptr_;
+}
+
+template <class T>
+T& TNonNullPtrBase<T>::operator*() const noexcept
+{
+    return *Ptr_;
+}
+
+template <class T>
+TNonNullPtrBase<T>::TNonNullPtrBase() noexcept
+    : Ptr_(nullptr)
+{ }
+
+template <class T>
+TNonNullPtr<T> GetPtr(T& ref) noexcept
+{
+    TNonNullPtr<T> ptr;
+    ptr.Ptr_ = &ref;
+
+    return ptr;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace NYT
diff --git a/library/cpp/yt/memory/non_null_ptr.h b/library/cpp/yt/memory/non_null_ptr.h
new file mode 100644
index 00000000000..3f4cd105db9
--- /dev/null
+++ b/library/cpp/yt/memory/non_null_ptr.h
@@ -0,0 +1,84 @@
+#pragma once
+
+#include "public.h"
+
+#include <library/cpp/yt/misc/concepts.h>
+
+namespace NYT {
+
+////////////////////////////////////////////////////////////////////////////////
+
+// We have one really strange rule in our codestyle - mutable arguments are passed by pointer.
+// But if you are not a fan of making your life indefinite,
+// you can use this helper, that will validate that pointer you pass is not null.
+template <class T>
+class TNonNullPtr;
+
+template <class T>
+class TNonNullPtrBase
+{
+public:
+    TNonNullPtrBase(T* ptr) noexcept;
+    TNonNullPtrBase(TIntrusivePtr<T> ptr) noexcept;
+    TNonNullPtrBase(const TNonNullPtrBase& other) = default;
+
+    TNonNullPtrBase(std::nullptr_t) = delete;
+    TNonNullPtrBase& operator=(const TNonNullPtrBase&) = default;
+
+    T* operator->() const noexcept;
+    T& operator*() const noexcept;
+
+protected:
+    T* Ptr_;
+
+    TNonNullPtrBase() noexcept;
+};
+
+template <class T>
+TNonNullPtr<T> GetPtr(T& ref) noexcept;
+
+template <class T>
+class TNonNullPtr
+    : public TNonNullPtrBase<T>
+{
+    using TConstPtr = TNonNullPtr<const T>;
+    friend TConstPtr;
+
+    using TNonNullPtrBase<T>::TNonNullPtrBase;
+
+    friend TNonNullPtr<T> GetPtr<T>(T& ref) noexcept;
+};
+
+// NB(pogorelov): Method definitions placed in .h file (instead of -inl.h) because of clang16 bug.
+// TODO(pogorelov): Move method definitions to helpers-inl.h when new clang will be used.
+template <CConst T>
+class TNonNullPtr<T>
+    : public TNonNullPtrBase<T>
+{
+    using TMutablePtr = TNonNullPtr<std::remove_const_t<T>>;
+
+    using TNonNullPtrBase<T>::TNonNullPtrBase;
+
+    friend TNonNullPtr<T> GetPtr<T>(T& ref) noexcept;
+
+public:
+    TNonNullPtr(TMutablePtr mutPtr) noexcept
+        : TNonNullPtrBase<T>()
+    {
+        TNonNullPtrBase<T>::Ptr_ = mutPtr.Ptr_;
+    }
+
+    TNonNullPtr(TIntrusivePtr<std::remove_pointer_t<TMutablePtr>> ptr) noexcept
+        : TNonNullPtrBase<T>()
+    {
+        TNonNullPtrBase<T>::Ptr_ = ptr.Get();
+    }
+};
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace NYT
+
+#define NON_NULL_PTR_H_
+#include "non_null_ptr-inl.h"
+#undef NON_NULL_PTR_H_
diff --git a/library/cpp/yt/memory/poison-inl.h b/library/cpp/yt/memory/poison-inl.h
new file mode 100644
index 00000000000..0f2998fdc04
--- /dev/null
+++ b/library/cpp/yt/memory/poison-inl.h
@@ -0,0 +1,77 @@
+#pragma once
+#ifndef POISON_INL_H_
+#error "Direct inclusion of this file is not allowed, include poison.h"
+// For the sake of sane code completion.
+#include "poison.h"
+#endif
+
+#include <util/system/compiler.h>
+
+namespace NYT {
+
+////////////////////////////////////////////////////////////////////////////////
+
+#if defined(_asan_enabled_)
+
+extern "C" {
+void __asan_poison_memory_region(void const volatile *addr, size_t size);
+void __asan_unpoison_memory_region(void const volatile *addr, size_t size);
+} // extern "C"
+
+Y_FORCE_INLINE void PoisonUninitializedMemory(TMutableRef /*ref*/)
+{ }
+
+Y_FORCE_INLINE void PoisonFreedMemory(TMutableRef ref)
+{
+    __asan_poison_memory_region(ref.data(), ref.size());
+}
+
+Y_FORCE_INLINE void RecycleFreedMemory(TMutableRef ref)
+{
+    __asan_unpoison_memory_region(ref.data(), ref.size());
+}
+
+Y_FORCE_INLINE void PoisonUnitializedOrFreedMemory(TMutableRef /*ref*/)
+{ }
+
+#elif defined(_msan_enabled_)
+
+extern "C" {
+void __msan_poison(const volatile void* a, size_t size);
+} // extern "C"
+
+Y_FORCE_INLINE void PoisonUninitializedMemory(TMutableRef ref)
+{
+    __msan_poison(ref.data(), ref.size());
+}
+
+Y_FORCE_INLINE void PoisonFreedMemory(TMutableRef ref)
+{
+    __msan_poison(ref.data(), ref.size());
+}
+
+Y_FORCE_INLINE void RecycleFreedMemory(TMutableRef /*ref*/)
+{ }
+
+Y_FORCE_INLINE void PoisonUnitializedOrFreedMemory(TMutableRef /*ref*/)
+{ }
+
+#elif defined(NDEBUG)
+
+Y_FORCE_INLINE void PoisonUninitializedMemory(TMutableRef /*ref*/)
+{ }
+
+Y_FORCE_INLINE void PoisonFreedMemory(TMutableRef /*ref*/)
+{ }
+
+Y_FORCE_INLINE void RecycleFreedMemory(TMutableRef /*ref*/)
+{ }
+
+Y_FORCE_INLINE void PoisonUnitializedOrFreedMemory(TMutableRef /*ref*/)
+{ }
+
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace NYT
diff --git a/library/cpp/yt/memory/poison.cpp b/library/cpp/yt/memory/poison.cpp
new file mode 100644
index 00000000000..dbb561ea39f
--- /dev/null
+++ b/library/cpp/yt/memory/poison.cpp
@@ -0,0 +1,64 @@
+#include "poison.h"
+
+namespace NYT {
+
+////////////////////////////////////////////////////////////////////////////////
+
+namespace {
+
+template <char Byte0, char Byte1, char Byte2, char Byte3>
+void ClobberMemory(char* __restrict__ ptr, size_t size)
+{
+    while (size >= 4) {
+        *ptr++ = Byte0;
+        *ptr++ = Byte1;
+        *ptr++ = Byte2;
+        *ptr++ = Byte3;
+        size -= 4;
+    }
+
+    switch (size) {
+        case 3:
+            *ptr++ = Byte0;
+            [[fallthrough]];
+        case 2:
+            *ptr++ = Byte1;
+            [[fallthrough]];
+        case 1:
+            *ptr++ = Byte2;
+    }
+}
+
+} // namespace
+
+#if !defined(NDEBUG) && !defined(_asan_enabled_) && !defined(_msan_enabled_)
+
+void PoisonUninitializedMemory(TMutableRef ref)
+{
+    // BAADBOBA
+    ClobberMemory<'\xba', '\xad', '\xb0', '\xba'>(ref.data(), ref.size());
+}
+
+void PoisonFreedMemory(TMutableRef ref)
+{
+    // DEADBEEF
+    ClobberMemory<'\xde', '\xad', '\xbe', '\xef'>(ref.data(), ref.size());
+}
+
+void RecycleFreedMemory(TMutableRef ref)
+{
+    // COOLBIBA
+    ClobberMemory<'\xc0', '\x01', '\xb1', '\xba'>(ref.data(), ref.size());
+}
+
+void PoisonUnitializedOrFreedMemory(TMutableRef ref)
+{
+    // BADBLOOD
+    ClobberMemory<'\xba', '\xdb', '\x10', '\x0d'>(ref.data(), ref.size());
+}
+
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace NYT
diff --git a/library/cpp/yt/memory/poison.h b/library/cpp/yt/memory/poison.h
new file mode 100644
index 00000000000..d28b5464551
--- /dev/null
+++ b/library/cpp/yt/memory/poison.h
@@ -0,0 +1,53 @@
+#pragma once
+
+#include "ref.h"
+
+namespace NYT {
+
+////////////////////////////////////////////////////////////////////////////////
+
+//! Poisons an uninitialized slice of memory.
+/*
+ * In release builds, does nothing.
+ * In checked builds, clobbers memory with a garbage pattern.
+ * In ASAN builds, does nothing.
+ * In MSAN builds, invokes sanitizer poisoning to catch uninit-read.
+ */
+void PoisonUninitializedMemory(TMutableRef ref);
+
+//! Poisons a freed slice of memory.
+/*
+ * In release builds, does nothing.
+ * In checked builds, clobbers memory with a garbage pattern.
+ * In ASAN and MSAN builds, invokes sanitizer poisoning to catch use-after-free.
+ */
+void PoisonFreedMemory(TMutableRef ref);
+
+//! Indicates that a slice of memory that was previously given to #PoisonFreedMemory
+//! has been recycled and can be reused.
+/*!
+ * In release builds, does nothing.
+ * In checked builds, clobbers memory with a garbage pattern.
+ * In ASAN builds, invokes sanitizer unpoisoning.
+ * In MSAN builds, does nothing (the memory remains poisoned to catch uninit-read).
+ */
+void RecycleFreedMemory(TMutableRef ref);
+
+//! Poisons an uninitialized or freed slice of memory.
+//! Unlike the functions above, it is intended to be used with system allocator,
+//! for which ASAN and MSAN already wrap malloc and free calls.
+/*
+ * In release builds, does nothing.
+ * In checked builds, clobbers memory with a garbage pattern.
+ * In ASAN builds, does nothing.
+ * In MSAN builds, does nothing.
+ */
+void PoisonUnitializedOrFreedMemory(TMutableRef ref);
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace NYT
+
+#define POISON_INL_H_
+#include "poison-inl.h"
+#undef POISON_INL_H_
diff --git a/library/cpp/yt/memory/public.h b/library/cpp/yt/memory/public.h
index e348c23439c..1d27782affa 100644
--- a/library/cpp/yt/memory/public.h
+++ b/library/cpp/yt/memory/public.h
@@ -12,6 +12,7 @@ constexpr size_t CacheLineSize = 64;
 class TChunkedMemoryPool;
 
 DECLARE_REFCOUNTED_STRUCT(IMemoryChunkProvider)
+DECLARE_REFCOUNTED_STRUCT(ISimpleMemoryUsageTracker)
 DECLARE_REFCOUNTED_STRUCT(TSharedRangeHolder)
 
 using TMemoryTag = ui32;
diff --git a/library/cpp/yt/memory/range.h b/library/cpp/yt/memory/range.h
index 10f2ea43ec2..ddd114719e8 100644
--- a/library/cpp/yt/memory/range.h
+++ b/library/cpp/yt/memory/range.h
@@ -4,10 +4,12 @@
 
 #include <library/cpp/yt/misc/hash.h>
 
-#include <vector>
 #include <array>
-#include <optional>
 #include <initializer_list>
+#include <optional>
+#include <span>
+#include <vector>
+#include <type_traits>
 
 // For size_t.
 #include <stddef.h>
@@ -59,6 +61,12 @@ class TRange
     using const_iterator = const T*;
     using size_type = size_t;
 
+    static constexpr bool CAnyRepeatedField = requires {
+        { google::protobuf::RepeatedField<T>{} }
+            ->
+        std::same_as<google::protobuf::RepeatedField<T>>;
+    };
+
     //! Constructs a null TRange.
     TRange()
         : Data_(nullptr)
@@ -91,6 +99,12 @@ class TRange
         , Length_(elements.size())
     { }
 
+    //! Constructs a TRange from an std::span.
+    TRange(std::span<const T> elements)
+        : Data_(elements.data())
+        , Length_(elements.size())
+    { }
+
     //! Constructs a TRange from a C array.
     template <size_t N>
     TRange(const T (&elements)[N])
@@ -118,6 +132,21 @@ class TRange
         , Length_(element ? 1 : 0)
     { }
 
+    //! Constructs a TRange from RepeatedField.
+    template<std::same_as<T> U = T>
+    requires CAnyRepeatedField
+    TRange(const google::protobuf::RepeatedField<U>& elements)
+        : Data_(elements.data())
+        , Length_(elements.size())
+    { }
+
+    //! Constructs a TRange from RepeatedPtrField.
+    template<class TPointed>
+    TRange(const google::protobuf::RepeatedPtrField<TPointed>& elements)
+        : Data_(elements.data())
+        , Length_(elements.size())
+    { }
+
     const_iterator Begin() const
     {
         return Data_;
@@ -228,70 +257,11 @@ typename TRange<T>::const_iterator end(TRange<T> ref)
     return ref.End();
 }
 
-////////////////////////////////////////////////////////////////////////////////
-
-//! Constructs a TRange from a pointer and length.
-template <class T>
-TRange<T> MakeRange(const T* data, size_t length)
-{
-    return TRange<T>(data, length);
-}
-
-//! Constructs a TRange from a native range.
-template <class T>
-TRange<T> MakeRange(const T* begin, const T* end)
-{
-    return TRange<T>(begin, end);
-}
-
-//! Constructs a TRange from a TCompactVector.
-template <class T, size_t N>
-TRange<T> MakeRange(const TCompactVector<T, N>& elements)
-{
-    return elements;
-}
-
-//! "Copy-constructor".
-template <class T>
-TRange<T> MakeRange(TRange<T> range)
-{
-    return range;
-}
+// Deduction guide for the constructor from RepeatedPtrField.
+template<class TPointed>
+TRange(const google::protobuf::RepeatedPtrField<TPointed>& elements) -> TRange<const TPointed*>;
 
-//! Constructs a TRange from an std::vector.
-template <class T>
-TRange<T> MakeRange(const std::vector<T>& elements)
-{
-    return elements;
-}
-
-//! Constructs a TRange from an std::array.
-template <class T, size_t N>
-TRange<T> MakeRange(const std::array<T, N>& elements)
-{
-    return elements;
-}
-
-//! Constructs a TRange from a C array.
-template <class T, size_t N>
-TRange<T> MakeRange(const T (& elements)[N])
-{
-    return TRange<T>(elements);
-}
-
-//! Constructs a TRange from RepeatedField.
-template <class T>
-TRange<T> MakeRange(const google::protobuf::RepeatedField<T>& elements)
-{
-    return TRange<T>(elements.data(), elements.size());
-}
-
-//! Constructs a TRange from RepeatedPtrField.
-template <class T>
-TRange<const T*> MakeRange(const google::protobuf::RepeatedPtrField<T>& elements)
-{
-    return TRange<const T*>(elements.data(), elements.size());
-}
+////////////////////////////////////////////////////////////////////////////////
 
 template <class U, class T>
 TRange<U> ReinterpretCastRange(TRange<T> range)
@@ -348,6 +318,11 @@ class TMutableRange
         : TRange<T>(elements)
     { }
 
+    //! Constructs a TMutableRange from an std::span.
+    TMutableRange(std::span<T>& elements)
+        : TRange<T>(elements)
+    { }
+
     //! Constructs a TMutableRange from std::array.
     template <size_t N>
     TMutableRange(std::array<T, N>& elements)
@@ -366,12 +341,36 @@ class TMutableRange
         : TRange<T>(elements)
     { }
 
+    //! Constructs a TMutableRange from RepeatedField.
+    template<std::same_as<T> U = T>
+    requires TRange<T>::CAnyRepeatedField
+    TMutableRange(google::protobuf::RepeatedField<U>& elements)
+        : TRange<T>(elements)
+    { }
+
+    //! Constructs a TMutableRange from RepeatedPtrField.
+    template<class TPointed>
+    TMutableRange(google::protobuf::RepeatedPtrField<TPointed>& elements)
+        : TRange<T>(elements)
+    { }
+
+    using TRange<T>::Data;
     using TRange<T>::Begin;
     using TRange<T>::End;
     using TRange<T>::Front;
     using TRange<T>::Back;
     using TRange<T>::operator[];
 
+    T* Data() const
+    {
+        return const_cast<T*>(this->Data_);
+    }
+
+    T* data() const
+    {
+        return Data();
+    }
+
     iterator Begin() const
     {
         return const_cast<T*>(this->Data_);
@@ -439,70 +438,11 @@ typename TMutableRange<T>::iterator end(TMutableRange<T> ref)
     return ref.End();
 }
 
-////////////////////////////////////////////////////////////////////////////////
-
-//! Constructs a TMutableRange from a pointer and length.
-template <class T>
-TMutableRange<T> MakeMutableRange(T* data, size_t length)
-{
-    return TMutableRange<T>(data, length);
-}
-
-//! Constructs a TMutableRange from a native range.
-template <class T>
-TMutableRange<T> MakeMutableRange(T* begin, T* end)
-{
-    return TMutableRange<T>(begin, end);
-}
-
-//! Constructs a TMutableRange from a TCompactVector.
-template <class T, size_t N>
-TMutableRange<T> MakeMutableRange(TCompactVector<T, N>& elements)
-{
-    return elements;
-}
-
-//! "Copy-constructor".
-template <class T>
-TMutableRange<T> MakeMutableRange(TMutableRange<T> range)
-{
-    return range;
-}
+// Deduction guide for the constructor from RepeatedPtrField.
+template<class TPointed>
+TMutableRange(google::protobuf::RepeatedPtrField<TPointed>& elements) -> TMutableRange<TPointed*>;
 
-//! Constructs a TMutableRange from an std::vector.
-template <class T>
-TMutableRange<T> MakeMutableRange(std::vector<T>& elements)
-{
-    return elements;
-}
-
-//! Constructs a TMutableRange from an std::array.
-template <class T, size_t N>
-TMutableRange<T> MakeMutableRange(std::array<T, N>& elements)
-{
-    return elements;
-}
-
-//! Constructs a TMutableRange from a C array.
-template <class T, size_t N>
-TMutableRange<T> MakeMutableRange(T (& elements)[N])
-{
-    return TMutableRange<T>(elements);
-}
-
-//! Constructs a TMutableRange from RepeatedField.
-template <class T>
-TMutableRange<T> MakeMutableRange(google::protobuf::RepeatedField<T>& elements)
-{
-    return TMutableRange<T>(elements.data(), elements.size());
-}
-
-//! Constructs a TMutableRange from RepeatedPtrField.
-template <class T>
-TMutableRange<T*> MakeMutableRange(google::protobuf::RepeatedPtrField<T>& elements)
-{
-    return TMutableRange<const T*>(elements.data(), elements.size());
-}
+////////////////////////////////////////////////////////////////////////////////
 
 template <class U, class T>
 TMutableRange<U> ReinterpretCastMutableRange(TMutableRange<T> range)
diff --git a/library/cpp/yt/memory/ref-inl.h b/library/cpp/yt/memory/ref-inl.h
index 14b21903c05..5c6dc11e0a2 100644
--- a/library/cpp/yt/memory/ref-inl.h
+++ b/library/cpp/yt/memory/ref-inl.h
@@ -4,6 +4,8 @@
 #include "ref.h"
 #endif
 
+#include <library/cpp/yt/misc/concepts.h>
+
 namespace NYT {
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -49,7 +51,7 @@ template <class T>
 Y_FORCE_INLINE TRef TRef::FromPod(const T& data)
 {
     static_assert(TTypeTraits<T>::IsPod || (std::is_standard_layout_v<T> && std::is_trivial_v<T>), "T must be a pod-type.");
-    return TRef(&data, sizeof (data));
+    return TRef(&data, sizeof(data));
 }
 
 Y_FORCE_INLINE TStringBuf TRef::ToStringBuf() const
@@ -63,6 +65,11 @@ Y_FORCE_INLINE TRef TRef::Slice(size_t startOffset, size_t endOffset) const
     return TRef(Begin() + startOffset, endOffset - startOffset);
 }
 
+Y_FORCE_INLINE bool TRef::Contains(TRef other) const
+{
+    return other.Begin() >= Begin() && other.End() <= End();
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 
 Y_FORCE_INLINE TMutableRef::TMutableRef(void* data, size_t size)
@@ -87,7 +94,7 @@ template <class T>
 Y_FORCE_INLINE TMutableRef TMutableRef::FromPod(T& data)
 {
     static_assert(TTypeTraits<T>::IsPod || (std::is_standard_layout_v<T> && std::is_trivial_v<T>), "T must be a pod-type.");
-    return TMutableRef(&data, sizeof (data));
+    return TMutableRef(&data, sizeof(data));
 }
 
 Y_FORCE_INLINE TMutableRef TMutableRef::FromString(TString& str)
@@ -96,6 +103,11 @@ Y_FORCE_INLINE TMutableRef TMutableRef::FromString(TString& str)
     return TMutableRef(str.begin(), str.length());
 }
 
+Y_FORCE_INLINE TMutableRef TMutableRef::FromString(std::string& str)
+{
+    return TMutableRef(str.data(), str.length());
+}
+
 Y_FORCE_INLINE TMutableRef TMutableRef::Slice(size_t startOffset, size_t endOffset) const
 {
     YT_ASSERT(endOffset >= startOffset && endOffset <= Size());
@@ -129,6 +141,7 @@ Y_FORCE_INLINE TSharedRef::operator TRef() const
 template <class TTag>
 Y_FORCE_INLINE TSharedRef TSharedRef::FromString(TString str)
 {
+    static_assert(IsEmptyClass<TTag>());
     return FromString(std::move(str), GetRefCountedTypeCookie<TTag>());
 }
 
@@ -137,6 +150,18 @@ Y_FORCE_INLINE TSharedRef TSharedRef::FromString(TString str)
     return FromString<TDefaultSharedBlobTag>(std::move(str));
 }
 
+template <class TTag>
+Y_FORCE_INLINE TSharedRef TSharedRef::FromString(std::string str)
+{
+    static_assert(IsEmptyClass<TTag>());
+    return FromString(std::move(str), GetRefCountedTypeCookie<TTag>());
+}
+
+Y_FORCE_INLINE TSharedRef TSharedRef::FromString(std::string str)
+{
+    return FromString<TDefaultSharedBlobTag>(std::move(str));
+}
+
 Y_FORCE_INLINE TStringBuf TSharedRef::ToStringBuf() const
 {
     return TStringBuf(Begin(), Size());
@@ -145,6 +170,7 @@ Y_FORCE_INLINE TStringBuf TSharedRef::ToStringBuf() const
 template <class TTag>
 Y_FORCE_INLINE TSharedRef TSharedRef::MakeCopy(TRef ref)
 {
+    static_assert(IsEmptyClass<TTag>());
     return MakeCopy(ref, GetRefCountedTypeCookie<TTag>());
 }
 
@@ -205,9 +231,15 @@ Y_FORCE_INLINE TSharedMutableRef TSharedMutableRef::AllocatePageAligned(size_t s
     return AllocatePageAligned<TDefaultSharedBlobTag>(size, options);
 }
 
+Y_FORCE_INLINE TSharedMutableRef TSharedMutableRef::AllocateViaMmap(size_t size, TSharedMutableRefAllocateViaMmapOptions options)
+{
+    return AllocateViaMmap<TDefaultSharedBlobTag>(size, options);
+}
+
 template <class TTag>
 Y_FORCE_INLINE TSharedMutableRef TSharedMutableRef::MakeCopy(TRef ref)
 {
+    static_assert(IsEmptyClass<TTag>());
     return MakeCopy(ref, GetRefCountedTypeCookie<TTag>());
 }
 
@@ -227,15 +259,24 @@ Y_FORCE_INLINE TSharedMutableRef TSharedMutableRef::Slice(void* begin, void* end
 template <class TTag>
 Y_FORCE_INLINE TSharedMutableRef TSharedMutableRef::Allocate(size_t size, TSharedMutableRefAllocateOptions options)
 {
+    static_assert(IsEmptyClass<TTag>());
     return Allocate(size, options, GetRefCountedTypeCookie<TTag>());
 }
 
 template <class TTag>
 Y_FORCE_INLINE TSharedMutableRef TSharedMutableRef::AllocatePageAligned(size_t size, TSharedMutableRefAllocateOptions options)
 {
+    static_assert(IsEmptyClass<TTag>());
     return AllocatePageAligned(size, options, GetRefCountedTypeCookie<TTag>());
 }
 
+template <class TTag>
+Y_FORCE_INLINE TSharedMutableRef TSharedMutableRef::AllocateViaMmap(size_t size, TSharedMutableRefAllocateViaMmapOptions options)
+{
+    static_assert(IsEmptyClass<TTag>());
+    return AllocateViaMmap(size, options, GetRefCountedTypeCookie<TTag>());
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 
 Y_FORCE_INLINE size_t GetByteSize(TRef ref)
@@ -256,7 +297,7 @@ size_t GetByteSize(TRange<T> parts)
 template <class T>
 size_t GetByteSize(const std::vector<T>& parts)
 {
-    return GetByteSize(MakeRange(parts));
+    return GetByteSize(TRange(parts));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -465,7 +506,7 @@ Y_FORCE_INLINE TSharedRefArray::TSharedRefArray(const TParts& parts, TSharedRefA
 
 template <class TParts>
 Y_FORCE_INLINE TSharedRefArray::TSharedRefArray(TParts&& parts, TSharedRefArray::TMoveParts)
-    : Impl_(NewImpl(parts.size(), 0, GetRefCountedTypeCookie<TSharedRefArrayTag>(), std::move(parts), TSharedRefArray::TMoveParts{}))
+    : Impl_(NewImpl(parts.size(), 0, GetRefCountedTypeCookie<TSharedRefArrayTag>(), std::forward<TParts>(parts), TSharedRefArray::TMoveParts{}))
 { }
 
 Y_FORCE_INLINE TSharedRefArray& TSharedRefArray::operator=(const TSharedRefArray& other)
@@ -474,7 +515,7 @@ Y_FORCE_INLINE TSharedRefArray& TSharedRefArray::operator=(const TSharedRefArray
     return *this;
 }
 
-Y_FORCE_INLINE TSharedRefArray& TSharedRefArray::operator=(TSharedRefArray&& other)
+Y_FORCE_INLINE TSharedRefArray& TSharedRefArray::operator=(TSharedRefArray&& other) noexcept
 {
     Impl_ = std::move(other.Impl_);
     return *this;
@@ -528,7 +569,7 @@ TSharedRefArrayImplPtr TSharedRefArray::NewImpl(
     TRefCountedTypeCookie tagCookie,
     As&&... args)
 {
-    auto extraSpaceSize = sizeof (TSharedRef) * size + poolCapacity;
+    auto extraSpaceSize = sizeof(TSharedRef) * size + poolCapacity;
     return NewWithExtraSpace<TSharedRefArrayImpl>(
         extraSpaceSize,
         extraSpaceSize,
diff --git a/library/cpp/yt/memory/ref.cpp b/library/cpp/yt/memory/ref.cpp
index c01094846ee..eddae004ca6 100644
--- a/library/cpp/yt/memory/ref.cpp
+++ b/library/cpp/yt/memory/ref.cpp
@@ -1,6 +1,9 @@
 #include "ref.h"
 
 #include "blob.h"
+#include "poison.h"
+
+#include <library/cpp/yt/exception/exception.h>
 
 #include <library/cpp/yt/malloc/malloc.h>
 
@@ -8,9 +11,20 @@
 
 #include <library/cpp/yt/string/format.h>
 
+#include <util/generic/size_literals.h>
+
+#include <util/string/printf.h>
+
 #include <util/system/info.h>
 #include <util/system/align.h>
 
+#ifdef _linux_
+#include <errno.h>
+#include <string.h>
+
+#include <sys/mman.h>
+#endif
+
 namespace NYT {
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -46,6 +60,7 @@ class TBlobHolder
 
 ////////////////////////////////////////////////////////////////////////////////
 
+template <class TString>
 class TStringHolder
     : public TSharedRangeHolder
 {
@@ -59,6 +74,8 @@ class TStringHolder
 #ifdef YT_ENABLE_REF_COUNTED_TRACKING
         TRefCountedTrackerFacade::AllocateTagInstance(Cookie_);
         TRefCountedTrackerFacade::AllocateSpace(Cookie_, String_.length());
+#else
+        Y_UNUSED(cookie);
 #endif
     }
     ~TStringHolder()
@@ -119,15 +136,26 @@ class TAllocationHolderBase
         TRefCountedTypeCookie cookie)
     {
         Size_ = size;
+#ifdef YT_ENABLE_REF_COUNTED_TRACKING
         Cookie_ = cookie;
+#else
+        Y_UNUSED(cookie);
+#endif
         if (options.InitializeStorage) {
             ::memset(static_cast<TDerived*>(this)->GetBegin(), 0, Size_);
+        } else {
+            PoisonUnitializedOrFreedMemory(GetRef());
         }
 #ifdef YT_ENABLE_REF_COUNTED_TRACKING
         TRefCountedTrackerFacade::AllocateTagInstance(Cookie_);
         TRefCountedTrackerFacade::AllocateSpace(Cookie_, Size_);
 #endif
     }
+
+    void Finalize()
+    {
+        PoisonUnitializedOrFreedMemory(GetRef());
+    }
 };
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -143,13 +171,18 @@ class TDefaultAllocationHolder
         TRefCountedTypeCookie cookie)
     {
         if (options.ExtendToUsableSize) {
-            if (auto usableSize = GetUsableSpaceSize(); usableSize != 0) {
-                size = usableSize;
+            if (auto usableSize = GetUsableSpaceSize()) {
+                size = *usableSize;
             }
         }
         Initialize(size, options, cookie);
     }
 
+    ~TDefaultAllocationHolder()
+    {
+        Finalize();
+    }
+
     char* GetBegin()
     {
         return static_cast<char*>(GetExtraSpacePtr());
@@ -164,6 +197,45 @@ class TDefaultAllocationHolder
 
 ////////////////////////////////////////////////////////////////////////////////
 
+class TCustomAlignedAllocationHolder
+    : public TAllocationHolderBase<TCustomAlignedAllocationHolder>
+{
+public:
+    TCustomAlignedAllocationHolder(
+        size_t size,
+        size_t alignment,
+        TSharedMutableRefAllocateOptions options,
+        TRefCountedTypeCookie cookie)
+        : Begin_(static_cast<char*>(::aligned_malloc(size, alignment)))
+        , Alignment_(alignment)
+    {
+        Initialize(size, options, cookie);
+    }
+
+    ~TCustomAlignedAllocationHolder()
+    {
+        Finalize();
+        ::free(Begin_);
+    }
+
+    char* GetBegin()
+    {
+        return Begin_;
+    }
+
+    // TSharedRangeHolder overrides.
+    std::optional<size_t> GetTotalByteSize() const override
+    {
+        return AlignUp(Size_, Alignment_);
+    }
+
+private:
+    char* const Begin_;
+    size_t Alignment_;
+};
+
+////////////////////////////////////////////////////////////////////////////////
+
 class TPageAlignedAllocationHolder
     : public TAllocationHolderBase<TPageAlignedAllocationHolder>
 {
@@ -179,6 +251,7 @@ class TPageAlignedAllocationHolder
 
     ~TPageAlignedAllocationHolder()
     {
+        Finalize();
         ::free(Begin_);
     }
 
@@ -199,6 +272,71 @@ class TPageAlignedAllocationHolder
 
 ////////////////////////////////////////////////////////////////////////////////
 
+#ifdef _linux_
+
+class TMmapAllocationHolder
+    : public TAllocationHolderBase<TMmapAllocationHolder>
+{
+public:
+    TMmapAllocationHolder(
+        size_t size,
+        TSharedMutableRefAllocateViaMmapOptions options,
+        TRefCountedTypeCookie cookie)
+    {
+        // Round the mapping up to the huge page size when huge pages are
+        // requested so that the whole region can be backed by them.
+        auto alignment = options.UseThp ? TransparentPageSize : GetPageSize();
+        MappedSize_ = AlignUp(size, alignment);
+        auto* ptr = ::mmap(
+            nullptr,
+            MappedSize_,
+            PROT_READ | PROT_WRITE,
+            MAP_PRIVATE | MAP_ANONYMOUS,
+            -1,
+            0);
+        if (ptr == MAP_FAILED) {
+            throw TSimpleException(Sprintf("Failed to mmap %" PRISZT " bytes: %s", MappedSize_, strerror(errno)));
+        }
+        Begin_ = static_cast<char*>(ptr);
+#ifdef MADV_HUGEPAGE
+        if (options.UseThp) {
+            // Hint before the first touch so that faults are served by huge
+            // pages directly rather than relying on khugepaged to collapse
+            // already-populated small pages.
+            YT_VERIFY(::madvise(Begin_, MappedSize_, MADV_HUGEPAGE) == 0);
+        }
+#endif
+        Initialize(size, {.InitializeStorage = options.InitializeStorage}, cookie);
+    }
+
+    ~TMmapAllocationHolder()
+    {
+        Finalize();
+        YT_VERIFY(::munmap(Begin_, MappedSize_) == 0);
+    }
+
+    char* GetBegin()
+    {
+        return Begin_;
+    }
+
+    // TSharedRangeHolder overrides.
+    std::optional<size_t> GetTotalByteSize() const override
+    {
+        return MappedSize_;
+    }
+
+private:
+    static constexpr size_t TransparentPageSize = 2_MB;
+
+    char* Begin_;
+    size_t MappedSize_;
+};
+
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
+
 TRef TRef::FromBlob(const TBlob& blob)
 {
     return TRef(blob.Begin(), blob.Size());
@@ -226,7 +364,18 @@ TMutableRef TMutableRef::FromBlob(TBlob& blob)
 
 TSharedRef TSharedRef::FromString(TString str, TRefCountedTypeCookie tagCookie)
 {
-    auto holder = New<TStringHolder>(std::move(str), tagCookie);
+    return FromStringImpl(std::move(str), tagCookie);
+}
+
+TSharedRef TSharedRef::FromString(std::string str, TRefCountedTypeCookie tagCookie)
+{
+    return FromStringImpl(std::move(str), tagCookie);
+}
+
+template <class TString>
+TSharedRef TSharedRef::FromStringImpl(TString str, TRefCountedTypeCookie tagCookie)
+{
+    auto holder = New<TStringHolder<TString>>(std::move(str), tagCookie);
     auto ref = TRef::FromString(holder->String());
     return TSharedRef(ref, std::move(holder));
 }
@@ -255,11 +404,15 @@ std::vector<TSharedRef> TSharedRef::Split(size_t partSize) const
 {
     YT_VERIFY(partSize > 0);
     std::vector<TSharedRef> result;
+    if (partSize >= Size()) {
+        result.push_back(Slice(Begin(), End()));
+        return result;
+    }
     result.reserve(Size() / partSize + 1);
     auto sliceBegin = Begin();
     while (sliceBegin < End()) {
         auto sliceEnd = sliceBegin + partSize;
-        if (sliceEnd < sliceBegin || sliceEnd > End()) {
+        if (sliceEnd > End()) {
             sliceEnd = End();
         }
         result.push_back(Slice(sliceBegin, sliceEnd));
@@ -284,6 +437,28 @@ TSharedMutableRef TSharedMutableRef::AllocatePageAligned(size_t size, TSharedMut
     return TSharedMutableRef(ref, std::move(holder));
 }
 
+TSharedMutableRef TSharedMutableRef::AllocateViaMmap(size_t size, TSharedMutableRefAllocateViaMmapOptions options, TRefCountedTypeCookie tagCookie)
+{
+#ifdef _linux_
+    auto holder = New<TMmapAllocationHolder>(size, options, tagCookie);
+    auto ref = holder->GetRef();
+    return TSharedMutableRef(ref, std::move(holder));
+#else
+    // No mmap/huge page support; fall back to a plain page-aligned allocation.
+    return AllocatePageAligned(
+        size,
+        TSharedMutableRefAllocateOptions{.InitializeStorage = options.InitializeStorage},
+        tagCookie);
+#endif
+}
+
+TSharedMutableRef TSharedMutableRef::AllocateAligned(size_t size, size_t alignment, TSharedMutableRefAllocateOptions options, TRefCountedTypeCookie tagCookie)
+{
+    auto holder = New<TCustomAlignedAllocationHolder>(size, alignment, options, tagCookie);
+    auto ref = holder->GetRef();
+    return TSharedMutableRef(ref, std::move(holder));
+}
+
 TSharedMutableRef TSharedMutableRef::FromBlob(TBlob&& blob)
 {
     auto ref = TMutableRef::FromBlob(blob);
@@ -406,6 +581,21 @@ TSharedRefArray TSharedRefArray::MakeCopy(
     return builder.Finish();
 }
 
+bool TSharedRefArray::AreBitwiseEqual(
+    const TSharedRefArray& lhs,
+    const TSharedRefArray& rhs)
+{
+    if (lhs.Size() != rhs.Size()) {
+        return false;
+    }
+    for (size_t index = 0; index < lhs.Size(); ++index) {
+        if (!TRef::AreBitwiseEqual(lhs[index], rhs[index])) {
+            return false;
+        }
+    }
+    return true;
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 
 TSharedRefArrayBuilder::TSharedRefArrayBuilder(
diff --git a/library/cpp/yt/memory/ref.h b/library/cpp/yt/memory/ref.h
index 2dfe861e759..91bce3fde6a 100644
--- a/library/cpp/yt/memory/ref.h
+++ b/library/cpp/yt/memory/ref.h
@@ -54,6 +54,9 @@ class TRef
     //! Creates a TRef for a part of existing range.
     TRef Slice(size_t startOffset, size_t endOffset) const;
 
+    //! Returns |true| if #other's range lies entirely within this range.
+    bool Contains(TRef other) const;
+
     //! Compares the content for bitwise equality.
     static bool AreBitwiseEqual(TRef lhs, TRef rhs);
 };
@@ -90,10 +93,13 @@ class TMutableRef
     template <class T>
     static TMutableRef FromPod(T& data);
 
-    //! Creates a non-owning TMutableRef for a given string.
+    //! Creates a non-owning TMutableRef for a given TString.
     //! Ensures that the string is not shared.
     static TMutableRef FromString(TString& str);
 
+    //! Creates a non-owning TMutableRef for a given std::string.
+    static TMutableRef FromString(std::string& str);
+
     //! Creates a TMutableRef for a part of existing range.
     TMutableRef Slice(size_t startOffset, size_t endOffset) const;
 };
@@ -131,22 +137,31 @@ class TSharedRef
     operator TRef() const;
 
 
-    //! Creates a TSharedRef from a string.
-    //! Since strings are ref-counted, no data is copied.
+    //! Creates a TSharedRef from TString.
+    //! Since strings are ref-counted, no data is being copied.
     //! The memory is marked with a given tag.
     template <class TTag>
     static TSharedRef FromString(TString str);
 
-    //! Creates a TSharedRef from a string.
-    //! Since strings are ref-counted, no data is copied.
-    //! The memory is marked with TDefaultSharedBlobTag.
+    //! Same as above but the memory is marked with TDefaultSharedBlobTag.
     static TSharedRef FromString(TString str);
 
-    //! Creates a TSharedRef reference from a string.
-    //! Since strings are ref-counted, no data is copied.
-    //! The memory is marked with a given tag.
+    //! Same as above but the memory tag is specified in #tagCookie.
     static TSharedRef FromString(TString str, TRefCountedTypeCookie tagCookie);
 
+    //! Creates a TSharedRef from std::string.
+    //! No data is being copied in #FromString itself but since #str is passed by value
+    //! a copy may occur at caller's side.
+    //! The memory is marked with a given tag.
+    template <class TTag>
+    static TSharedRef FromString(std::string str);
+
+    //! Same as above but the memory is marked with TDefaultSharedBlobTag.
+    static TSharedRef FromString(std::string str);
+
+    //! Same as above but the memory tag is specified in #tagCookie.
+    static TSharedRef FromString(std::string str, TRefCountedTypeCookie tagCookie);
+
     //! Creates a TSharedRef for a given blob taking ownership of its content.
     static TSharedRef FromBlob(TBlob&& blob);
 
@@ -173,17 +188,32 @@ class TSharedRef
 
 private:
     friend class TSharedRefArrayImpl;
+
+    template <class TString>
+    static TSharedRef FromStringImpl(TString str, TRefCountedTypeCookie tagCookie);
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 
-//! Various options for allocating TSharedMutableRef.
+//! Various options for allocating TSharedMutableRef via malloc.
 struct TSharedMutableRefAllocateOptions
 {
+    //! If true, the storage is zero-initialized; otherwise its contents are undefined.
     bool InitializeStorage = true;
+    //! If true, the allocation is extended to the usable size reported by the allocator.
     bool ExtendToUsableSize = false;
 };
 
+//! Various options for allocating TSharedMutableRef via mmap.
+struct TSharedMutableRefAllocateViaMmapOptions
+{
+    //! See TSharedMutableRefAllocateOptions::InitializeStorage.
+    bool InitializeStorage = true;
+    //! Hints the kernel to back the region with transparent huge pages.
+    //! Best-effort; ignored on non-Linux systems.
+    bool UseThp = false;
+};
+
 //! A reference to a mutable range of memory with shared ownership.
 //! Use with caution :)
 class TSharedMutableRef
@@ -244,6 +274,27 @@ class TSharedMutableRef
     //! The memory is marked with a given tag.
     static TSharedMutableRef AllocatePageAligned(size_t size, TSharedMutableRefAllocateOptions options, TRefCountedTypeCookie tagCookie);
 
+    //! Allocates a new shared block of memory backed by an anonymous mmap region.
+    //! Optionally requests transparent huge pages; see #UseThp.
+    //! Falls back to AllocatePageAligned on non-Linux systems.
+    //! The memory is marked with a given tag.
+    template <class TTag>
+    static TSharedMutableRef AllocateViaMmap(size_t size, TSharedMutableRefAllocateViaMmapOptions options = {});
+
+    //! Allocates a new shared block of memory backed by an anonymous mmap region.
+    //! The memory is marked with TDefaultSharedBlobTag.
+    static TSharedMutableRef AllocateViaMmap(size_t size, TSharedMutableRefAllocateViaMmapOptions options = {});
+
+    //! Allocates a new shared block of memory backed by an anonymous mmap region.
+    //! The memory is marked with a given tag.
+    static TSharedMutableRef AllocateViaMmap(size_t size, TSharedMutableRefAllocateViaMmapOptions options, TRefCountedTypeCookie tagCookie);
+
+    //! Allocates a new aligned shared block of memory.
+    //! #size must be divisible by alignment size.
+    //! The memory is marked with a given tag.
+    //! Unlike AllocatePageAligned, this method also stores size_t inside holder.
+    static TSharedMutableRef AllocateAligned(size_t size, size_t alignment, TSharedMutableRefAllocateOptions options, TRefCountedTypeCookie tagCookie);
+
     //! Creates a TSharedMutableRef for the whole blob taking ownership of its content.
     static TSharedMutableRef FromBlob(TBlob&& blob);
 
@@ -289,7 +340,7 @@ class TSharedRefArray
     TSharedRefArray(TParts&& parts, TMoveParts);
 
     TSharedRefArray& operator = (const TSharedRefArray& other);
-    TSharedRefArray& operator = (TSharedRefArray&& other);
+    TSharedRefArray& operator = (TSharedRefArray&& other) noexcept;
 
     explicit operator bool() const;
 
@@ -311,6 +362,9 @@ class TSharedRefArray
     //! The memory is marked with a given tag.
     static TSharedRefArray MakeCopy(const TSharedRefArray& array, TRefCountedTypeCookie tagCookie);
 
+    //! Checks if #lhs and #rhs consist of the same number of bitwise-equal parts.
+    static bool AreBitwiseEqual(const TSharedRefArray& lhs, const TSharedRefArray& rhs);
+
 private:
     friend class TSharedRefArrayBuilder;
 
@@ -343,7 +397,7 @@ class TSharedRefArrayBuilder
      *  The user must provide the total (resulting) part count in #size.
      *
      *  Additionally, the user may request a certain memory pool of size #poolCapacity
-     *  to be created. Parts occupiying space in the above pool are created with #AllocateAndAdd
+     *  to be created. Parts occupying space in the above pool are created with #AllocateAndAdd
      *  calls.
      *
      *  The pool (if any) and the array are created within a single memory allocation tagged with
@@ -406,6 +460,12 @@ size_t GetByteSize(const std::vector<T>& parts);
 #include "ref-inl.h"
 #undef REF_INL_H_
 
-//! Serialize TSharedRef like vector<char>. Useful for ::Save, ::Load serialization/deserialization. See util/ysaveload.h.
+//! Serialize TSharedRef like vector<char>.
+/*!
+ *  Useful for ::Save, ::Load serialization/deserialization.
+ *  See util/ysaveload.h.
+ */
 template <>
-class TSerializer<NYT::TSharedRef>: public TVectorSerializer<NYT::TSharedRange<char>> {};
+class TSerializer<NYT::TSharedRef>
+    : public TVectorSerializer<NYT::TSharedRange<char>>
+{ };
diff --git a/library/cpp/yt/memory/ref_counted-inl.h b/library/cpp/yt/memory/ref_counted-inl.h
index f86f634ffd7..ce3c686ee28 100644
--- a/library/cpp/yt/memory/ref_counted-inl.h
+++ b/library/cpp/yt/memory/ref_counted-inl.h
@@ -8,12 +8,53 @@
 
 #include <util/system/sanitizers.h>
 
+#ifdef YT_ENABLE_REF_COUNTED_SIGNATURE
+#include <util/system/types.h>
+#endif
+
+#include <stdlib.h>
+
 namespace NYT {
 
 ////////////////////////////////////////////////////////////////////////////////
 
+#ifdef YT_ENABLE_REF_COUNTED_SIGNATURE
+
+namespace NDetail {
+
+// A distinctive marker held by a live signature (after address salting).
+constexpr ui64 RefCountedAliveSignatureMagic = 0xa11e0b1ec70a11e0ULL;
+
+// A distinct poison written into the signature once the object is destroyed.
+constexpr ui64 RefCountedDeadSignatureMagic = 0xdeadbeefdeadbeefULL;
+
+//! The alive signature for a signature word living at #address: the magic XOR-ed
+//! with the word's own address.
+//!
+//! The signature is embedded as the first word of every TRefCounter: the ctor
+//! stamps ComputeRefCountedAliveSignature(&signature) and strong-death overwrites
+//! it with RefCountedDeadSignatureMagic. A coredump walker tells a live object
+//! from freed-but-unreclaimed memory: for a word at address S,
+//! *S == ComputeRefCountedAliveSignature(S) means alive,
+//! *S == RefCountedDeadSignatureMagic means freed. The address salt keeps a
+//! signature from validating if copied verbatim elsewhere (it carries the old
+//! address) and makes a chance match of arbitrary memory a ~2^-64 event.
+Y_FORCE_INLINE ui64 ComputeRefCountedAliveSignature(const void* address) noexcept
+{
+    return RefCountedAliveSignatureMagic ^ reinterpret_cast<uintptr_t>(address);
+}
+
+} // namespace NDetail
+
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
+
 // TODO(babenko): move to hazard pointers
-void RetireHazardPointer(TPackedPtr packedPtr, void (*reclaimer)(TPackedPtr));
+void RetireHazardPointer(
+    void* protectedPtr,
+    void* reclaimPtr,
+    void (*reclaimer)(void* reclaimPtr));
 
 ////////////////////////////////////////////////////////////////////////////////
 
@@ -60,12 +101,11 @@ struct TMemoryReleaser<T, std::enable_if_t<T::EnableHazard>>
 {
     static void Do(void* ptr, ui16 offset)
     {
-        // Base pointer is used in HazardPtr as the identity of object.
-        auto packedPtr = TTaggedPtr<char>{static_cast<char*>(ptr) + offset, offset}.Pack();
-        RetireHazardPointer(packedPtr, [] (TPackedPtr packedPtr) {
-            // Base ptr and the beginning of allocated memory region may differ.
-            auto [ptr, offset] = TTaggedPtr<char>::Unpack(packedPtr);
-            TFreeMemory<T>::Do(ptr - offset);
+        RetireHazardPointer(
+            static_cast<char*>(ptr) + offset,
+            ptr,
+            [] (void* reclaimPtr) {
+                TFreeMemory<T>::Do(reclaimPtr);
         });
     }
 };
@@ -84,14 +124,19 @@ Y_FORCE_INLINE void DestroyRefCountedImpl(T* obj)
     // No virtual call when T is final.
     obj->~T();
 
+    // The ref-counter is a base subobject of *obj, so obj->~T() above poisons it
+    // under -fsanitize-memory-use-after-dtor. Unpoison before accessing it.
+    NSan::Unpoison(refCounter, sizeof(TRefCounter));
+
     // Fast path. Weak refs cannot appear if there are neither strong nor weak refs.
     if (refCounter->GetWeakRefCount() == 1) {
         NYT::NDetail::TMemoryReleaser<T>::Do(obj, offset);
         return;
     }
 
-    YT_ASSERT(offset < std::numeric_limits<ui16>::max());
+    YT_ASSERT(offset < (1ULL << PackedPtrTagBits));
 
+    static_assert(sizeof(TRefCountedBase) >= sizeof(TPackedPtr));
     auto* vTablePtr = reinterpret_cast<TPackedPtr*>(basePtr);
     *vTablePtr = TTaggedPtr<void(void*, ui16)>(&NYT::NDetail::TMemoryReleaser<T>::Do, offset).Pack();
 
@@ -149,6 +194,10 @@ struct TRefCountedTraits
 template <class T>
 struct TRefCountedTraits<T, true>
 {
+    static_assert(
+        sizeof(T) < (1ULL << PackedPtrTagBits),
+        "Ref counted object derived from TRefCountedBase exceedes max size");
+
     Y_FORCE_INLINE static const TRefCounter* GetRefCounter(const T* obj)
     {
         return obj;
@@ -161,6 +210,7 @@ struct TRefCountedTraits<T, true>
 
     Y_FORCE_INLINE static void Deallocate(const TRefCountedBase* obj)
     {
+        static_assert(sizeof(TRefCountedBase) >= sizeof(TPackedPtr));
         auto* ptr = reinterpret_cast<TPackedPtr*>(const_cast<TRefCountedBase*>(obj));
         auto [ptrToDeleter, offset] = TTaggedPtr<void(void*, ui16)>::Unpack(*ptr);
 
@@ -180,10 +230,39 @@ Y_FORCE_INLINE int TRefCounter::GetRefCount() const noexcept
     return StrongCount_.load(std::memory_order::acquire);
 }
 
+#ifdef YT_ENABLE_REF_COUNTED_SIGNATURE
+
+Y_FORCE_INLINE TRefCounter::TRefCounter() noexcept
+    : Signature_(NDetail::ComputeRefCountedAliveSignature(this))
+{ }
+
+Y_FORCE_INLINE ui64 TRefCounter::GetSignature() const noexcept
+{
+    return Signature_;
+}
+
+#endif
+
 Y_FORCE_INLINE void TRefCounter::Ref(int n) const noexcept
 {
+    YT_ASSERT(n >= 0);
+
     // It is safe to use relaxed here, since new reference is always created from another live reference.
-    StrongCount_.fetch_add(n, std::memory_order::relaxed);
+    auto value = StrongCount_.fetch_add(n, std::memory_order::relaxed);
+    YT_ASSERT(value > 0);
+    YT_ASSERT(value <= std::numeric_limits<TRefCount>::max() - n);
+
+    YT_ASSERT(WeakCount_.load(std::memory_order::relaxed) > 0);
+}
+
+Y_FORCE_INLINE void TRefCounter::DangerousRef(int n) const noexcept
+{
+    YT_ASSERT(n >= 0);
+
+    // Relaxed is fine as per lukyan@, the caller guarantees object liveness.
+    auto value = StrongCount_.fetch_add(n, std::memory_order::relaxed);
+    YT_ASSERT(value >= 0);
+    YT_ASSERT(value <= std::numeric_limits<TRefCount>::max() - n);
 
     YT_ASSERT(WeakCount_.load(std::memory_order::relaxed) > 0);
 }
@@ -191,6 +270,7 @@ Y_FORCE_INLINE void TRefCounter::Ref(int n) const noexcept
 Y_FORCE_INLINE bool TRefCounter::TryRef() const noexcept
 {
     auto value = StrongCount_.load(std::memory_order::relaxed);
+    YT_ASSERT(value >= 0 && value < std::numeric_limits<TRefCount>::max());
     YT_ASSERT(WeakCount_.load(std::memory_order::relaxed) > 0);
 
     while (value != 0 && !StrongCount_.compare_exchange_weak(value, value + 1));
@@ -199,6 +279,8 @@ Y_FORCE_INLINE bool TRefCounter::TryRef() const noexcept
 
 Y_FORCE_INLINE bool TRefCounter::Unref(int n) const
 {
+    YT_ASSERT(n >= 0);
+
     // We must properly synchronize last access to object with it destruction.
     // Otherwise compiler might reorder access to object past this decrement.
     //
@@ -209,6 +291,11 @@ Y_FORCE_INLINE bool TRefCounter::Unref(int n) const
     if (oldStrongCount == n) {
         std::atomic_thread_fence(std::memory_order::acquire);
         NSan::Acquire(&StrongCount_);
+#ifdef YT_ENABLE_REF_COUNTED_SIGNATURE
+        // Last strong ref gone: the object is about to be destroyed. Poison now so
+        // a core walker sees freed-but-unreclaimed memory as dead.
+        Signature_ = NDetail::RefCountedDeadSignatureMagic;
+#endif
         return true;
     } else {
         return false;
diff --git a/library/cpp/yt/memory/ref_counted.h b/library/cpp/yt/memory/ref_counted.h
index 6ef546de0df..e82d22936e4 100644
--- a/library/cpp/yt/memory/ref_counted.h
+++ b/library/cpp/yt/memory/ref_counted.h
@@ -25,6 +25,13 @@ class TRefCountedBase
     virtual ~TRefCountedBase() noexcept = default;
 
     virtual void DestroyRefCounted() = 0;
+
+#ifdef _32_
+private:
+    // We need TRefCountedBase to fit TPackedPtr.
+    // See TRefCountedTraits for details.
+    [[maybe_unused]] ui32 Padding_;
+#endif
 };
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -32,6 +39,10 @@ class TRefCountedBase
 class TRefCounter
 {
 public:
+#ifdef YT_ENABLE_REF_COUNTED_SIGNATURE
+    TRefCounter() noexcept;
+#endif
+
     //! Returns current number of strong references to the object.
     /*!
      * Note that you should never ever use this method in production code.
@@ -40,8 +51,13 @@ class TRefCounter
     int GetRefCount() const noexcept;
 
     //! Increments the strong reference counter.
+    //! The current strong RC must be positive.
     void Ref(int n = 1) const noexcept;
 
+    //! Increments the strong reference counter.
+    //! The current strong RC may be zero.
+    void DangerousRef(int n = 1) const noexcept;
+
     //! Increments the strong reference counter if it is not null.
     bool TryRef() const noexcept;
 
@@ -57,9 +73,26 @@ class TRefCounter
     //! Decrements the weak reference counter.
     bool WeakUnref() const;
 
+#ifdef YT_ENABLE_REF_COUNTED_SIGNATURE
+    //! Returns the raw signature word. Used only by unit tests; the coredump
+    //! walker reads the word directly from memory.
+    ui64 GetSignature() const noexcept;
+#endif
+
 private:
-    mutable std::atomic<int> StrongCount_ = 1;
-    mutable std::atomic<int> WeakCount_ = 1;
+#ifdef YT_ENABLE_REF_COUNTED_SIGNATURE
+    // An address-salted liveness marker. NB: Must be the first member -- the
+    // salt is its own address and a core validator keys off its offset. Stamped
+    // alive by the ctor (see -inl); poisoned at strong-death (see Unref).
+    // TRefCounter is already non-copyable (atomics below), so the salted value
+    // can't be copied astray.
+    mutable ui64 Signature_;
+#endif
+
+    // NB: Must be 64 bit as TAtomicIntrusivePtr grabs refs in 64K batches.
+    using TRefCount = i64;
+    mutable std::atomic<TRefCount> StrongCount_ = 1;
+    mutable std::atomic<TRefCount> WeakCount_ = 1;
 };
 
 ////////////////////////////////////////////////////////////////////////////////
diff --git a/library/cpp/yt/memory/ref_tracked-inl.h b/library/cpp/yt/memory/ref_tracked-inl.h
index 0c16c02ff88..cf1c4515c32 100644
--- a/library/cpp/yt/memory/ref_tracked-inl.h
+++ b/library/cpp/yt/memory/ref_tracked-inl.h
@@ -29,8 +29,8 @@ Y_FORCE_INLINE TRefCountedTypeCookie GetRefCountedTypeCookie()
     return cookieValue;
 }
 
-template <class T, class TTag, int Counter>
-Y_FORCE_INLINE TRefCountedTypeCookie GetRefCountedTypeCookieWithLocation(const TSourceLocation& location)
+template <class T, auto LocationLite>
+Y_FORCE_INLINE TRefCountedTypeCookie GetRefCountedTypeCookieWithLocation()
 {
     static std::atomic<TRefCountedTypeCookie> cookie{NullRefCountedTypeCookie};
     auto cookieValue = cookie.load(std::memory_order::relaxed);
@@ -38,7 +38,7 @@ Y_FORCE_INLINE TRefCountedTypeCookie GetRefCountedTypeCookieWithLocation(const T
         cookieValue = TRefCountedTrackerFacade::GetCookie(
             GetRefCountedTypeKey<T>(),
             sizeof(T),
-            location);
+            TSourceLocation::FromLite<LocationLite>());
         cookie.store(cookieValue, std::memory_order::relaxed);
     }
     return cookieValue;
@@ -63,7 +63,7 @@ TRefTracked<T>::TRefTracked(const TRefTracked&)
 }
 
 template <class T>
-TRefTracked<T>::TRefTracked(TRefTracked&&)
+TRefTracked<T>::TRefTracked(TRefTracked&&) noexcept
 {
     auto cookie = GetRefCountedTypeCookie<T>();
     TRefCountedTrackerFacade::AllocateInstance(cookie);
diff --git a/library/cpp/yt/memory/ref_tracked.h b/library/cpp/yt/memory/ref_tracked.h
index df6a06fcf07..f3d75528660 100644
--- a/library/cpp/yt/memory/ref_tracked.h
+++ b/library/cpp/yt/memory/ref_tracked.h
@@ -13,10 +13,10 @@ namespace NYT {
 
 ////////////////////////////////////////////////////////////////////////////////
 
-YT_DEFINE_STRONG_TYPEDEF(TRefCountedTypeCookie, int)
+YT_DEFINE_STRONG_TYPEDEF(TRefCountedTypeCookie, int);
 constexpr TRefCountedTypeCookie NullRefCountedTypeCookie{-1};
 
-YT_DEFINE_STRONG_TYPEDEF(TRefCountedTypeKey, const std::type_info*)
+YT_DEFINE_STRONG_TYPEDEF(TRefCountedTypeKey, const std::type_info*);
 
 ////////////////////////////////////////////////////////////////////////////////
 
@@ -45,23 +45,14 @@ class TRefCountedTrackerFacade
 
 ////////////////////////////////////////////////////////////////////////////////
 
-namespace {
-
-//! A per-translation unit tag type.
-struct TCurrentTranslationUnitTag
-{ };
-
-} // namespace
-
 template <class T>
 TRefCountedTypeKey GetRefCountedTypeKey();
 
 template <class T>
 TRefCountedTypeCookie GetRefCountedTypeCookie();
 
-template <class T, class TTag, int Counter>
-TRefCountedTypeCookie GetRefCountedTypeCookieWithLocation(
-    const TSourceLocation& location);
+template <class T, auto LocationLite>
+TRefCountedTypeCookie GetRefCountedTypeCookieWithLocation();
 
 ////////////////////////////////////////////////////////////////////////////////
 
@@ -79,7 +70,7 @@ class TRefTracked
 #ifdef YT_ENABLE_REF_COUNTED_TRACKING
     TRefTracked();
     TRefTracked(const TRefTracked&);
-    TRefTracked(TRefTracked&&);
+    TRefTracked(TRefTracked&&) noexcept;
     ~TRefTracked();
 #endif
 };
diff --git a/library/cpp/yt/memory/shared_range.h b/library/cpp/yt/memory/shared_range.h
index de5fc354eaa..15a34d79e1a 100644
--- a/library/cpp/yt/memory/shared_range.h
+++ b/library/cpp/yt/memory/shared_range.h
@@ -58,7 +58,7 @@ class TSharedRange
 
     //! Constructs an empty TSharedRange from a nullptr expression.
     TSharedRange(std::nullptr_t)
-        : TRange<T>(nullptr, 0UL)
+        : TRange<T>(nullptr, static_cast<size_t>(0))
         , Holder_(nullptr)
     { }
 
@@ -142,7 +142,7 @@ class TSharedRange
         return TSharedRange<T>(begin, end, Holder_);
     }
 
-    const TSharedRangeHolderPtr& GetHolder() const
+    const TSharedRangeHolderPtr& GetHolder() const Y_LIFETIME_BOUND
     {
         return Holder_;
     }
@@ -180,25 +180,34 @@ TSharedRangeHolderPtr MakeSharedRangeHolder(THolders&&... holders)
 template <class T, class TContainer, class... THolders>
 TSharedRange<T> DoMakeSharedRange(TContainer&& elements, THolders&&... holders)
 {
+    using THoldersTuple = std::tuple<typename std::decay_t<THolders>...>;
+
     struct THolder
         : public TSharedRangeHolder
     {
-        typename std::decay<TContainer>::type Elements;
-        std::tuple<typename std::decay<THolders>::type...> Holders;
+        typename std::decay_t<TContainer> Elements;
+        THoldersTuple Holders;
+
+        THolder(
+            std::decay_t<TContainer> elements,
+            THoldersTuple holders)
+            : Elements(std::move(elements))
+            , Holders(std::move(holders))
+        { }
     };
 
-    auto holder = New<THolder>();
-    holder->Holders = std::tuple<THolders...>(std::forward<THolders>(holders)...);
-    holder->Elements = std::forward<TContainer>(elements);
+    auto holder = New<THolder>(
+        std::forward<TContainer>(elements),
+        THoldersTuple(std::forward<THolders>(holders)...));
 
-    auto range = MakeRange<T>(holder->Elements);
+    auto range = TRange<T>(holder->Elements);
 
     return TSharedRange<T>(range, std::move(holder));
 }
 
 //! Constructs a TSharedRange by taking ownership of an std::vector.
-template <class T, class... THolders>
-TSharedRange<T> MakeSharedRange(std::vector<T>&& elements, THolders&&... holders)
+template <class T, class A = std::allocator<T>, class... THolders>
+TSharedRange<T> MakeSharedRange(std::vector<T, A>&& elements, THolders&&... holders)
 {
     return DoMakeSharedRange<T>(std::move(elements), std::forward<THolders>(holders)...);
 }
@@ -211,8 +220,8 @@ TSharedRange<T> MakeSharedRange(TCompactVector<T, N>&& elements, THolders&&... h
 }
 
 //! Constructs a TSharedRange by copying an std::vector.
-template <class T, class... THolders>
-TSharedRange<T> MakeSharedRange(const std::vector<T>& elements, THolders&&... holders)
+template <class T, class A = std::allocator<T>, class... THolders>
+TSharedRange<T> MakeSharedRange(const std::vector<T, A>& elements, THolders&&... holders)
 {
     return DoMakeSharedRange<T>(elements, std::forward<THolders>(holders)...);
 }
@@ -329,7 +338,7 @@ class TSharedMutableRange
         return TSharedMutableRange<T>(begin, end, Holder_);
     }
 
-    TSharedRangeHolderPtr GetHolder() const
+    const TSharedRangeHolderPtr& GetHolder() const Y_LIFETIME_BOUND
     {
         return Holder_;
     }
diff --git a/library/cpp/yt/memory/simple_memory_usage_tracker.cpp b/library/cpp/yt/memory/simple_memory_usage_tracker.cpp
new file mode 100644
index 00000000000..f51b1edcfbf
--- /dev/null
+++ b/library/cpp/yt/memory/simple_memory_usage_tracker.cpp
@@ -0,0 +1,117 @@
+#include "simple_memory_usage_tracker.h"
+
+#include "leaky_ref_counted_singleton.h"
+
+namespace NYT {
+
+////////////////////////////////////////////////////////////////////////////////
+
+class TNullSimpleMemoryUsageTracker
+    : public ISimpleMemoryUsageTracker
+{
+public:
+    bool Acquire(i64 /*size*/) override
+    {
+        return false;
+    }
+
+    void Release(i64 /*size*/) override
+    { }
+
+    TSharedRef Track(TSharedRef reference, bool /*keepExistingTracking*/) override
+    {
+        return reference;
+    }
+};
+
+////////////////////////////////////////////////////////////////////////////////
+
+TSimpleMemoryUsageTrackerGuard::TSimpleMemoryUsageTrackerGuard(TSimpleMemoryUsageTrackerGuard&& other) noexcept
+{
+    MoveFrom(std::move(other));
+}
+
+TSimpleMemoryUsageTrackerGuard::~TSimpleMemoryUsageTrackerGuard()
+{
+    Release();
+}
+
+TSimpleMemoryUsageTrackerGuard& TSimpleMemoryUsageTrackerGuard::operator=(TSimpleMemoryUsageTrackerGuard&& other) noexcept
+{
+    if (this != &other) {
+        Release();
+        MoveFrom(std::move(other));
+    }
+    return *this;
+}
+
+void TSimpleMemoryUsageTrackerGuard::MoveFrom(TSimpleMemoryUsageTrackerGuard&& other) noexcept
+{
+    Tracker_ = other.Tracker_;
+    AcquiredSize_ = other.AcquiredSize_;
+
+    other.Tracker_ = nullptr;
+    other.AcquiredSize_ = 0;
+}
+
+TSimpleMemoryUsageTrackerGuard TSimpleMemoryUsageTrackerGuard::Build(ISimpleMemoryUsageTrackerPtr tracker)
+{
+    if (!tracker) {
+        return {};
+    }
+
+    TSimpleMemoryUsageTrackerGuard guard;
+    guard.Tracker_ = tracker;
+    return guard;
+}
+
+void TSimpleMemoryUsageTrackerGuard::Release() noexcept
+{
+    if (Tracker_) {
+        if (AcquiredSize_) {
+            Tracker_->Release(AcquiredSize_);
+        }
+
+        Tracker_.Reset();
+        AcquiredSize_ = 0;
+    }
+}
+
+void TSimpleMemoryUsageTrackerGuard::SetSize(i64 size)
+{
+    if (!Tracker_) {
+        return;
+    }
+
+    YT_VERIFY(size >= 0);
+
+    if (size > AcquiredSize_) {
+        Tracker_->Acquire(size - AcquiredSize_);
+    } else if (size < AcquiredSize_) {
+        Tracker_->Release(AcquiredSize_ - size);
+    }
+
+    AcquiredSize_ = size;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+ISimpleMemoryUsageTrackerPtr GetNullSimpleMemoryUsageTracker()
+{
+    return LeakyRefCountedSingleton<TNullSimpleMemoryUsageTracker>();
+}
+
+TSharedRef TrackMemory(
+    const ISimpleMemoryUsageTrackerPtr& tracker,
+    TSharedRef reference,
+    bool keepExistingTracking)
+{
+    if (!tracker || !reference) {
+        return reference;
+    }
+    return tracker->Track(std::move(reference), keepExistingTracking);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace NYT
diff --git a/library/cpp/yt/memory/simple_memory_usage_tracker.h b/library/cpp/yt/memory/simple_memory_usage_tracker.h
new file mode 100644
index 00000000000..126ab7867d9
--- /dev/null
+++ b/library/cpp/yt/memory/simple_memory_usage_tracker.h
@@ -0,0 +1,57 @@
+#pragma once
+
+#include "ref.h"
+
+namespace NYT {
+
+////////////////////////////////////////////////////////////////////////////////
+
+struct ISimpleMemoryUsageTracker
+    : public TRefCounted
+{
+    virtual bool Acquire(i64 size) = 0;
+    virtual void Release(i64 size) = 0;
+    virtual TSharedRef Track(TSharedRef reference, bool keepExistingTracking) = 0;
+};
+
+DEFINE_REFCOUNTED_TYPE(ISimpleMemoryUsageTracker)
+
+////////////////////////////////////////////////////////////////////////////////
+
+class TSimpleMemoryUsageTrackerGuard
+    : private TNonCopyable
+{
+public:
+    TSimpleMemoryUsageTrackerGuard() = default;
+    TSimpleMemoryUsageTrackerGuard(const TSimpleMemoryUsageTrackerGuard& other) = delete;
+    TSimpleMemoryUsageTrackerGuard(TSimpleMemoryUsageTrackerGuard&& other) noexcept;
+    ~TSimpleMemoryUsageTrackerGuard();
+
+    TSimpleMemoryUsageTrackerGuard& operator=(const TSimpleMemoryUsageTrackerGuard& other) = delete;
+    TSimpleMemoryUsageTrackerGuard& operator=(TSimpleMemoryUsageTrackerGuard&& other) noexcept;
+
+    static TSimpleMemoryUsageTrackerGuard Build(ISimpleMemoryUsageTrackerPtr tracker);
+
+    void SetSize(i64 size);
+
+    void Release() noexcept;
+
+private:
+    ISimpleMemoryUsageTrackerPtr Tracker_;
+    i64 AcquiredSize_ = 0;
+    void MoveFrom(TSimpleMemoryUsageTrackerGuard&& other) noexcept;
+
+};
+
+////////////////////////////////////////////////////////////////////////////////
+
+ISimpleMemoryUsageTrackerPtr GetNullSimpleMemoryUsageTracker();
+
+TSharedRef TrackMemory(
+    const ISimpleMemoryUsageTrackerPtr& tracker,
+    TSharedRef reference,
+    bool keepExistingTracking = false);
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace NYT
diff --git a/library/cpp/yt/memory/tagged_ptr-inl.h b/library/cpp/yt/memory/tagged_ptr-inl.h
index fa1c93de6eb..3b551cae125 100644
--- a/library/cpp/yt/memory/tagged_ptr-inl.h
+++ b/library/cpp/yt/memory/tagged_ptr-inl.h
@@ -27,16 +27,18 @@ Y_FORCE_INLINE TTaggedPtr<T>::TTaggedPtr(T* ptr)
 template <class T>
 Y_FORCE_INLINE TPackedPtr TTaggedPtr<T>::Pack() const
 {
-    YT_ASSERT((reinterpret_cast<TPackedPtr>(Ptr) & PackedPtrTagMask) == 0);
-    return (static_cast<TPackedPtr>(Tag) << PackedPtrAddressBits) | reinterpret_cast<TPackedPtr>(Ptr);
+    YT_ASSERT((reinterpret_cast<TPackedPtr::TUnderlying>(Ptr) & PackedPtrTagMask) == 0);
+    return TPackedPtr(
+        (static_cast<TPackedPtr::TUnderlying>(Tag) << PackedPtrAddressBits) |
+        reinterpret_cast<TPackedPtr::TUnderlying>(Ptr));
 }
 
 template <class T>
 Y_FORCE_INLINE TTaggedPtr<T> TTaggedPtr<T>::Unpack(TPackedPtr packedPtr)
 {
     return {
-        reinterpret_cast<T*>(packedPtr & PackedPtrAddressMask),
-        static_cast<ui16>(packedPtr >> PackedPtrAddressBits),
+        reinterpret_cast<T*>(packedPtr.Underlying() & PackedPtrAddressMask),
+        static_cast<ui16>(packedPtr.Underlying() >> PackedPtrAddressBits),
     };
 }
 
diff --git a/library/cpp/yt/memory/tagged_ptr.h b/library/cpp/yt/memory/tagged_ptr.h
index c1a42f55074..25f56885103 100644
--- a/library/cpp/yt/memory/tagged_ptr.h
+++ b/library/cpp/yt/memory/tagged_ptr.h
@@ -2,17 +2,24 @@
 
 #include <util/system/types.h>
 
+#include <library/cpp/yt/misc/strong_typedef.h>
+
 namespace NYT {
 
 ////////////////////////////////////////////////////////////////////////////////
 
-using TPackedPtr = uintptr_t;
-static_assert(sizeof(TPackedPtr) == 8);
+YT_DEFINE_STRONG_TYPEDEF(TPackedPtr, ui64);
 
-constexpr size_t PackedPtrAddressBits = 48;
+#if defined(_64_)
+    constexpr size_t PackedPtrAddressBits = 48;
+#elif defined(_32_)
+    constexpr size_t PackedPtrAddressBits = 32;
+#else
+    #error Unsupported platform
+#endif
 constexpr size_t PackedPtrTagBits = 16;
-constexpr TPackedPtr PackedPtrAddressMask = (1ULL << PackedPtrAddressBits) - 1;
-constexpr TPackedPtr PackedPtrTagMask = ~PackedPtrAddressMask;
+constexpr TPackedPtr::TUnderlying PackedPtrAddressMask = (1ULL << PackedPtrAddressBits) - 1;
+constexpr TPackedPtr::TUnderlying PackedPtrTagMask = ~PackedPtrAddressMask;
 
 ////////////////////////////////////////////////////////////////////////////////
 
@@ -23,8 +30,8 @@ struct TTaggedPtr
     TTaggedPtr(T* ptr, ui16 tag);
     explicit TTaggedPtr(T* ptr);
 
-    T* Ptr;
-    ui16 Tag;
+    T* Ptr = nullptr;
+    ui16 Tag = 0;
 
     TPackedPtr Pack() const;
     static TTaggedPtr<T> Unpack(TPackedPtr packedPtr);
diff --git a/library/cpp/yt/memory/type_erasure.h b/library/cpp/yt/memory/type_erasure.h
new file mode 100644
index 00000000000..3b2dbe34015
--- /dev/null
+++ b/library/cpp/yt/memory/type_erasure.h
@@ -0,0 +1,428 @@
+#pragma once
+
+#include "type_erasure_detail.h"
+
+namespace NYT {
+
+////////////////////////////////////////////////////////////////////////////////
+
+namespace NDetail {
+
+////////////////////////////////////////////////////////////////////////////////
+
+template <class T, class TCpo>
+struct TTypeErasableTraits;
+
+template <class T, auto Cpo, class TRet, bool NoExcept, class TCvThis, class... TArgs>
+struct TTypeErasableTraits<T, TOverloadedCpo<Cpo, TRet(TCvThis, TArgs...) noexcept(NoExcept)>>
+{
+    using TReplaced = TFromThis<T, TCvThis>;
+
+    static constexpr bool Value = NoExcept
+        ? requires (TReplaced t, TArgs... args) {
+            { Cpo(std::forward<TReplaced>(t), std::forward<TArgs>(args)...) } noexcept -> std::same_as<TRet>;
+        }
+        : requires (TReplaced t, TArgs... args) {
+            { Cpo(std::forward<TReplaced>(t), std::forward<TArgs>(args)...) } -> std::same_as<TRet>;
+        };
+};
+
+template <class T, class... TCpos>
+concept CAnyRefErasable = (TTypeErasableTraits<std::remove_cvref_t<T>, TCpos>::Value && ...);
+
+template <class T, bool EnableCopy, class... TCpos>
+concept CAnyObjectErasable =
+    CAnyRefErasable<T, TCpos...> &&
+    std::movable<std::remove_cvref_t<T>> &&
+    (!EnableCopy || std::copyable<std::remove_cvref_t<T>>);
+
+////////////////////////////////////////////////////////////////////////////////
+
+struct TBadAnyCast
+    : public std::exception
+{ };
+
+////////////////////////////////////////////////////////////////////////////////
+
+// AnyRef.
+
+template <bool UseStaticVTable, class... TCpos>
+class TAnyRef
+    : private TAnyFragment<TAnyRef<UseStaticVTable, TCpos...>, TCpos>...
+{
+public:
+    using TStorage = TNonOwningStorage;
+
+    TAnyRef() = default;
+
+    template <class TConcrete>
+        requires
+            CAnyRefErasable<std::remove_cvref_t<TConcrete>, TCpos...> &&
+            (!std::same_as<std::remove_cvref_t<TConcrete>, TAnyRef>)
+    TAnyRef(TConcrete& concRef) noexcept
+    {
+        using TDecayed = std::remove_cvref_t<TConcrete>;
+
+        Storage_.Set(const_cast<void*>(reinterpret_cast<const void*>(std::addressof(concRef))));
+        Holder_ = THolder::template Create<TDecayed>();
+    }
+
+    // Copy/Move are trivial copy. Dtor is also trivial.
+
+    const auto& GetStorage() const &
+    {
+        return Storage_;
+    }
+
+    auto& GetStorage() &
+    {
+        return Storage_;
+    }
+
+    auto&& GetStorage() &&
+    {
+        return std::move(Storage_);
+    }
+
+    const auto& GetVTable() const
+    {
+        return Holder_.GetVTable();
+    }
+
+    template <class T>
+        requires CAnyRefErasable<T, TCpos...>
+    T& AnyCast() &
+    {
+        const auto& vtable = GetVTable();
+        if (!vtable.IsValid() || !vtable.template HoldsType<T>()) {
+            throw TBadAnyCast{};
+        }
+
+        return Storage_.template As<T>();
+    }
+
+    template <class T>
+        requires CAnyRefErasable<T, TCpos...>
+    const T& AnyCast() const &
+    {
+        const auto& vtable = Holder_.GetVTable();
+        if (!vtable.IsValid() || !vtable.template HoldsType<T>()) {
+            throw TBadAnyCast{};
+        }
+
+        return Storage_.template As<T>();
+    }
+
+private:
+    using TVTable = TVTable<TStorage, TCpos...>;
+    using THolder = TVTableHolder<TStorage, TVTable, UseStaticVTable>;
+
+    TStorage Storage_ = {};
+    THolder Holder_ = {};
+};
+
+////////////////////////////////////////////////////////////////////////////////
+
+template <class... TCpos>
+struct TAnyRefPublicHelper
+{
+    using T = TAnyRef<(sizeof...(TCpos) >= 3), TCpos...>;
+};
+
+template <>
+struct TAnyRefPublicHelper<>
+{
+    using T = TAnyRef<false, TTagInvokeTag<NoopCpo>>;
+};
+
+////////////////////////////////////////////////////////////////////////////////
+
+template <class T>
+struct TIsAnyRef
+    : public std::false_type
+{ };
+
+template <bool UseStaticVTable, class... TCpos>
+struct TIsAnyRef<TAnyRef<UseStaticVTable, TCpos...>>
+    : public std::true_type
+{ };
+
+////////////////////////////////////////////////////////////////////////////////
+
+template <bool EnableCopy, CStorage TStorage, class... TCpos>
+struct TRebindVTable
+{
+    using TVTable = TVTable<
+        TStorage,
+        TTagInvokeTag<Deleter>,
+        TTagInvokeTag<Mover<TStorage>>,
+        TTagInvokeTag<Copier<TStorage>>,
+        TCpos...>;
+};
+
+template <CStorage TStorage, class... TCpos>
+struct TRebindVTable<false, TStorage, TCpos...>
+{
+    using TVTable = TVTable<
+        TStorage,
+        TTagInvokeTag<Deleter>,
+        TTagInvokeTag<Mover<TStorage>>,
+        TCpos...>;
+};
+
+////////////////////////////////////////////////////////////////////////////////
+
+template <bool UseStaticVTable, bool EnableCopy, size_t SmallObjectSize, size_t SmallObjectAlign, class... TCpos>
+class TAnyObject
+    : private TAnyFragment<
+        TAnyObject<
+            UseStaticVTable,
+            EnableCopy,
+            SmallObjectSize,
+            SmallObjectAlign,
+            TCpos...>,
+        TCpos>...
+{
+public:
+    using TStorage = TOwningStorage<SmallObjectSize, SmallObjectAlign>;
+
+    TAnyObject() = default;
+
+    template <class TConcrete>
+        requires
+            (!std::same_as<std::remove_cvref_t<TConcrete>, TAnyObject>) &&
+            std::constructible_from<std::remove_cvref_t<TConcrete>, TConcrete> &&
+            CAnyObjectErasable<std::remove_cvref_t<TConcrete>, EnableCopy, TCpos...> &&
+            (!TIsAnyRef<std::remove_cvref_t<TConcrete>>::value)
+    TAnyObject(TConcrete&& concrete)
+    {
+        Set<TConcrete>(std::forward<TConcrete>(concrete));
+    }
+
+    template <class TConcrete, class... TArgs>
+        requires
+            (!std::same_as<std::remove_cvref_t<TConcrete>, TAnyObject>) &&
+            std::constructible_from<std::remove_cvref_t<TConcrete>, TArgs...> &&
+            (!std::is_const_v<TConcrete>) &&
+            CAnyObjectErasable<std::remove_cvref_t<TConcrete>, EnableCopy, TCpos...> &&
+            (!TIsAnyRef<std::remove_cvref_t<TConcrete>>::value)
+    TAnyObject(std::in_place_type_t<TConcrete>, TArgs&&... args)
+    {
+        Set<TConcrete>(std::forward<TArgs>(args)...);
+    }
+
+    TAnyObject(TAnyObject&& other) noexcept
+        : Holder_(other.Holder_)
+    {
+        if (IsValid()) {
+            auto* mover = GetVTable().template GetFunctor<Mover<TStorage>>();
+            mover(std::move(other).GetStorage(), GetStorage());
+
+            other.Reset();
+        }
+    }
+
+    TAnyObject& operator=(TAnyObject&& other) noexcept
+    {
+        if (this == &other) {
+            return *this;
+        }
+
+        Reset();
+
+        Holder_ = other.Holder_;
+
+        if (IsValid()) {
+            auto* mover = GetVTable().template GetFunctor<Mover<TStorage>>();
+            mover(std::move(other).GetStorage(), GetStorage());
+
+            other.Reset();
+        }
+
+        return *this;
+    }
+
+    TAnyObject(const TAnyObject& other) requires EnableCopy
+        : Holder_(other.Holder_)
+    {
+        if (IsValid()) {
+            auto* copier = GetVTable().template GetFunctor<Copier<TStorage>>();
+            copier(other.GetStorage(), GetStorage());
+        }
+    }
+
+    TAnyObject& operator=(const TAnyObject& other) requires EnableCopy
+    {
+        if (this == &other) {
+            return *this;
+        }
+
+        Reset();
+
+        Holder_ = other.Holder_;
+
+        if (IsValid()) {
+            auto* copier = GetVTable().template GetFunctor<Copier<TStorage>>();
+            copier(other.GetStorage(), GetStorage());
+        }
+
+        return *this;
+    }
+
+    constexpr explicit operator bool() const
+    {
+        return IsValid();
+    }
+
+    ~TAnyObject()
+    {
+        Reset();
+    }
+
+    Y_FORCE_INLINE const auto& GetStorage() const &
+    {
+        return Storage_;
+    }
+
+    Y_FORCE_INLINE auto& GetStorage() &
+    {
+        return Storage_;
+    }
+
+    Y_FORCE_INLINE auto&& GetStorage() &&
+    {
+        return std::move(Storage_);
+    }
+
+    Y_FORCE_INLINE const auto& GetVTable() const
+    {
+        return Holder_.GetVTable();
+    }
+
+    template <class T>
+    Y_FORCE_INLINE T& AnyCast() &
+    {
+        using TDecayed = std::remove_cvref_t<T>;
+        using TWrapped = TOwningWrapper<TDecayed, TStorage, EnableCopy, TCpos...>;
+
+        const auto& vtable = GetVTable();
+        if (!vtable.IsValid() || !vtable.template HoldsType<TWrapped>()) {
+            throw TBadAnyCast{};
+        }
+
+        return Storage_.template As<TWrapped>().Unwrap();
+    }
+
+    template <class T>
+    Y_FORCE_INLINE const T& AnyCast() const &
+    {
+        using TDecayed = std::remove_cvref_t<T>;
+        using TWrapped = TOwningWrapper<TDecayed, TStorage, EnableCopy, TCpos...>;
+
+        const auto& vtable = GetVTable();
+        if (!vtable.IsValid() || !vtable.template HoldsType<TWrapped>()) {
+            throw TBadAnyCast{};
+        }
+
+        return Storage_.template As<TWrapped>().Unwrap();
+    }
+
+    template <class T>
+    Y_FORCE_INLINE bool Holds() const
+    {
+        using TDecayed = std::remove_cvref_t<T>;
+        using TWrapped = TOwningWrapper<TDecayed, TStorage, EnableCopy, TCpos...>;
+
+        const auto& vtable = GetVTable();
+        return vtable.IsValid() && vtable.template HoldsType<TWrapped>();
+    }
+
+    Y_FORCE_INLINE bool IsValid() const
+    {
+        return Holder_.IsValid();
+    }
+
+private:
+    using TVTable = typename TRebindVTable<EnableCopy, TStorage, TCpos...>::TVTable;
+    using THolder = TVTableHolder<TStorage, TVTable, UseStaticVTable>;
+    using TTraits = std::allocator_traits<std::allocator<std::byte>>;
+
+    TStorage Storage_ = {};
+    THolder Holder_ = {};
+
+    static inline std::allocator<std::byte> Allocator = {};
+
+    Y_FORCE_INLINE void Reset() noexcept
+    {
+        const auto& vtable = Holder_.GetVTable();
+        if (Holder_.IsValid()) {
+            auto* deleter = vtable.template GetFunctor<Deleter>();
+            deleter(Storage_);
+
+            Holder_.Reset();
+        }
+    }
+
+    template <class TConcrete, class... TArgs>
+    Y_FORCE_INLINE void Set(TArgs&&... args)
+    {
+        using TDecayed = std::remove_cvref_t<TConcrete>;
+        using TWrapped = TOwningWrapper<TDecayed, TStorage, EnableCopy, TCpos...>;
+
+        Reset();
+
+        Holder_ = THolder::template Create<TWrapped>();
+
+        if constexpr (TStorage::template IsStatic<TWrapped>) {
+            Storage_.Set();
+        } else {
+            Storage_.Set(TTraits::allocate(Allocator, sizeof(TWrapped)));
+        }
+
+        TTraits::template construct<TWrapped>(
+            Allocator,
+            &Storage_.template As<TWrapped>(),
+            std::forward<TArgs>(args)...);
+    }
+};
+
+} // namespace NDetail
+
+////////////////////////////////////////////////////////////////////////////////
+
+// A simple placeholder for overloaded cpo usage.
+using NDetail::TErasedThis;
+
+////////////////////////////////////////////////////////////////////////////////
+
+// A wrapper class which carries all the necessary information for type erasure.
+template <auto Cpo, class TSignature>
+using TOverload = NDetail::TOverloadedCpo<Cpo, TSignature>;
+
+////////////////////////////////////////////////////////////////////////////////
+
+// A non-owning reference.
+template <class... TCpos>
+using TAnyRef = typename NDetail::TAnyRefPublicHelper<TCpos...>::T;
+
+////////////////////////////////////////////////////////////////////////////////
+
+template <class... TCpos>
+using TAnyObject = NDetail::TAnyObject<
+    (sizeof...(TCpos) >= 3),
+    /*EnableCopy*/ true,
+    /*SmallObjectSize*/ sizeof(void*) * 2,
+    /*SmallObjectAlign*/ alignof(void*) * 2,
+    TCpos...>;
+
+template <class... TCpos>
+using TAnyUnique = NDetail::TAnyObject<
+    (sizeof...(TCpos) >= 3),
+    /*EnableCopy*/ false,
+    /*SmallObjectSize*/ sizeof(void*) * 2,
+    /*SmallObjectAlign*/ alignof(void*) * 2,
+    TCpos...>;
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace NYT
diff --git a/library/cpp/yt/memory/type_erasure_detail.h b/library/cpp/yt/memory/type_erasure_detail.h
new file mode 100644
index 00000000000..76b611a2d67
--- /dev/null
+++ b/library/cpp/yt/memory/type_erasure_detail.h
@@ -0,0 +1,729 @@
+#pragma once
+
+#include <library/cpp/yt/assert/assert.h>
+
+#include <library/cpp/yt/misc/tag_invoke_cpo.h>
+
+#include <util/system/compiler.h>
+
+#include <concepts>
+#include <memory>
+#include <numeric>
+
+namespace NYT::NDetail {
+
+////////////////////////////////////////////////////////////////////////////////
+
+// NB(arkady-e1ppa): clang16 has bug which causes it
+// ignore noexcept specifier of reference to static member methods.
+#if (!__clang__ || __clang_major__ < 18)
+    #define YT_TYPE_ERASURE_NOEXCEPT(NoExcept)
+#else
+    #define YT_TYPE_ERASURE_NOEXCEPT(NoExcept) noexcept(NoExcept)
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
+
+// NB(arkady-e1ppa): Next section of code is about most general type erasure storage.
+// There are two kinds: One which simply holds a pointer to data stored elsewhere
+// and the one which holds the data on its own. The latter can store it inline
+// on the byte array or on heap depending on the object size (small object optimization).
+// Classes below feature bare-bone implementations of said storages which do not
+// control when and which object are being placed inside the storage for they do not
+// have access to the virtual table (ctors/dtors) of the type. Said operations are handled
+// by type erasure containers themselves.
+////////////////////////////////////////////////////////////////////////////////
+
+// NB(arkady-e1ppa): This class is used to check
+// whether some class has a templated method which
+// accepts any type parameter.
+struct TConceptWitness
+{ };
+
+////////////////////////////////////////////////////////////////////////////////
+
+// Semantic requirement:
+// 1) Pointer provided by |Ptr| call
+// must be pointing to the beginning of some object.
+// 2) IsStatic must be a constexpr variable.
+// NB(arkady-e1ppa): value of bool template in Ptr
+// is whether currently stored object is static or not.
+template <class T>
+concept CPointerProvider = requires (T* t, const T* ct) {
+    { t->template Ptr<true>() } -> std::same_as<void*>;
+    { ct->template Ptr<true>() } -> std::same_as<void*>;
+    { t->template Ptr<false>() } -> std::same_as<void*>;
+    { ct->template Ptr<false>() } -> std::same_as<void*>;
+    { T::template IsStatic<TConceptWitness> } -> std::same_as<const bool&>;
+};
+
+////////////////////////////////////////////////////////////////////////////////
+
+// CRTP base to implement cast methods for each
+// storage.
+template <class TDerived>
+struct TStorageCasterBase
+{
+    template <bool IsStatic>
+    Y_FORCE_INLINE void* GetPtr() const noexcept
+    {
+        return static_cast<const TDerived*>(this)->template Ptr<IsStatic>();
+    }
+
+    template <class TDecayedConcrete>
+    Y_FORCE_INLINE TDecayedConcrete& As() & noexcept
+    {
+        return this->template ToRef<TDecayedConcrete, TDecayedConcrete*>();
+    }
+
+    template <class TDecayedConcrete>
+    Y_FORCE_INLINE const TDecayedConcrete& As() const & noexcept
+    {
+        return this->template ToRef<TDecayedConcrete, const TDecayedConcrete*>();
+    }
+
+    template <class TDecayedConcrete>
+    Y_FORCE_INLINE TDecayedConcrete&& As() && noexcept
+    {
+        return std::move(this->template ToRef<TDecayedConcrete, TDecayedConcrete*>());
+    }
+
+    template <class TDecayedConcrete, class TPtr>
+    Y_FORCE_INLINE decltype(auto) ToRef() const noexcept
+    {
+        static_assert(std::derived_from<TDerived, TStorageCasterBase>, "Must inherit from TStorageCasterBase");
+        static_assert(CPointerProvider<TDerived>, "Class must define Ptr method. See CPointerProvider");
+        static_assert(
+            std::same_as<
+                TDecayedConcrete,
+                std::remove_cvref_t<TDecayedConcrete>>,
+            "Submitted type must not contain const, reference or volatile qualifiers");
+
+        if constexpr (TDerived::template IsStatic<TDecayedConcrete>) {
+            return *std::launder(reinterpret_cast<TPtr>(this->template GetPtr</*IsStatic*/ true>()));
+        } else {
+            return *static_cast<TPtr>(this->template GetPtr</*IsStatic*/ false>());
+        }
+    }
+};
+
+////////////////////////////////////////////////////////////////////////////////
+
+template <class T>
+concept CStorage = requires (const T& cref, T& ref, void* ptr) {
+    { cref.template As<TConceptWitness>() } -> std::same_as<const TConceptWitness&>;
+    { ref.template As<TConceptWitness>() } -> std::same_as<TConceptWitness&>;
+    { std::move(ref).template As<TConceptWitness>() } -> std::same_as<TConceptWitness&&>;
+    { ref.Set(ptr) } -> std::same_as<void>;
+
+    // Semantic: Set() should reset the instance making it empty.
+    { ref.Set() } -> std::same_as<void>;
+} && std::default_initializable<T>;
+
+////////////////////////////////////////////////////////////////////////////////
+
+class TNonOwningStorage
+    : public TStorageCasterBase<TNonOwningStorage>
+{
+public:
+    template <bool /*IsStatic*/>
+    Y_FORCE_INLINE void* Ptr() const noexcept
+    {
+        return const_cast<void*>(Data_);
+    }
+
+    template <class T>
+    static constexpr bool IsStatic = false;
+
+    Y_FORCE_INLINE void Set(void* ptr) noexcept
+    {
+        Data_ = ptr;
+    }
+
+    Y_FORCE_INLINE void Set() noexcept
+    {
+        Data_ = nullptr;
+    }
+
+private:
+    void* Data_ = nullptr;
+};
+
+static_assert(CPointerProvider<TNonOwningStorage>);
+static_assert(CStorage<TNonOwningStorage>);
+
+////////////////////////////////////////////////////////////////////////////////
+
+template <size_t InlineSize, size_t InlineAlign>
+class TOwningStorage
+    : public TStorageCasterBase<TOwningStorage<InlineSize, InlineAlign>>
+{
+private:
+    static constexpr size_t RealSize = sizeof(void*) > InlineSize
+        ? sizeof(void*)
+        : InlineSize;
+
+    static constexpr size_t RealAlign = alignof(void*) > InlineAlign
+        ? alignof(void*)
+        : InlineAlign;
+
+public:
+    template <class T>
+    static constexpr bool IsStatic =
+        (sizeof(T) <= RealSize) &&
+        (alignof(T) <= RealAlign);
+
+    Y_FORCE_INLINE void Set(void* ptr) noexcept
+    {
+        std::construct_at<void*>(reinterpret_cast<void**>(Data_), ptr);
+    }
+
+    Y_FORCE_INLINE void Set() noexcept
+    {
+        std::construct_at(Data_);
+    }
+
+    template <bool IsStatic>
+    Y_FORCE_INLINE void* Ptr() const noexcept
+    {
+        auto* mutableThis = const_cast<TOwningStorage*>(this);
+
+        if constexpr (IsStatic) {
+            return &mutableThis->Data_;
+        } else {
+            return *std::launder(reinterpret_cast<void**>(&mutableThis->Data_));
+        }
+    }
+
+private:
+    alignas(RealAlign) std::byte Data_[RealSize] = {};
+};
+
+static_assert(CPointerProvider<TOwningStorage<1, 1>>);
+static_assert(CStorage<TOwningStorage<1, 1>>);
+static_assert(CPointerProvider<TOwningStorage<64, 64>>);
+static_assert(CStorage<TOwningStorage<64, 64>>);
+
+////////////////////////////////////////////////////////////////////////////////
+
+// NB(arkady-e1ppa): This part covers details of overloaded CPOs parcing and placeholder types.
+// Relevant to public interface parts are exposed in type_erasure.h
+////////////////////////////////////////////////////////////////////////////////
+
+// Type erasable "function" = (function name <=> cpo) + (fixed signature).
+template <auto Cpo, class TSignature>
+struct TOverloadedCpo;
+
+template <auto Cpo, class TRet, bool NoExcept, class... TArgs>
+struct TOverloadedCpo<Cpo, TRet(TArgs...) noexcept(NoExcept)>
+{ };
+
+////////////////////////////////////////////////////////////////////////////////
+
+// Each implementation of erasable method has
+// its own "this" in signature. Since in the erased methods
+// we do not have any specific type, we use placeholder.
+struct TErasedThis
+{ };
+
+////////////////////////////////////////////////////////////////////////////////
+
+template <class T, class U>
+struct TFromThisImpl
+{
+    using TT = U;
+};
+
+template <class T>
+struct TFromThisImpl<T, const TErasedThis&>
+{
+    using TT = const T&;
+};
+
+template <class T>
+struct TFromThisImpl<T, TErasedThis&>
+{
+    using TT = T&;
+};
+
+template <class T>
+struct TFromThisImpl<T, TErasedThis&&>
+{
+    using TT = T&&;
+};
+
+template <class T>
+struct TFromThisImpl<T, TErasedThis>
+{
+    using TT = T;
+};
+
+template <class T, class U>
+using TFromThis = typename TFromThisImpl<T, U>::TT;
+
+////////////////////////////////////////////////////////////////////////////////
+
+template <CStorage TStorage, class TCpo>
+class TVTableEntry;
+
+template <CStorage TStorage, auto Cpo, class TRet, bool NoExcept, class TCvThis, class... TArgs>
+class TVTableEntry<TStorage, TOverloadedCpo<Cpo, TRet(TCvThis, TArgs...) noexcept(NoExcept)>>
+{
+private:
+    using TReplaced = TFromThis<TStorage, TCvThis>;
+    using TFunction = TRet(*)(TReplaced, TArgs...) YT_TYPE_ERASURE_NOEXCEPT(NoExcept);
+
+public:
+    TVTableEntry() = default;
+
+    Y_FORCE_INLINE TFunction Get() const noexcept
+    {
+        return Function_;
+    }
+
+    template <class TConcrete>
+    Y_FORCE_INLINE static TVTableEntry Create() noexcept
+    {
+        TVTableEntry entry = {};
+
+        entry.Function_ = &TVTableEntry::StaticInvoke<TConcrete>;
+
+        return entry;
+    }
+
+    Y_FORCE_INLINE void Reset() noexcept
+    {
+        Function_ = nullptr;
+    }
+
+    Y_FORCE_INLINE bool IsValid() const noexcept
+    {
+        return Function_ != nullptr;
+    }
+
+    // NB(arkady-e1ppa): This method may or may not work correctly
+    // for dynamically-linked libraries.
+    template <class T>
+    Y_FORCE_INLINE bool HoldsType() const noexcept
+    {
+        return Function_ == &TVTableEntry::StaticInvoke<T>;
+    }
+
+private:
+    TFunction Function_ = nullptr;
+
+    template <class TConcrete>
+    static TRet StaticInvoke(TReplaced storage, TArgs... args) YT_TYPE_ERASURE_NOEXCEPT(NoExcept)
+    {
+        return Cpo(std::forward<TReplaced>(storage).template As<TConcrete>(), std::forward<TArgs>(args)...);
+    }
+};
+
+////////////////////////////////////////////////////////////////////////////////
+
+// Add vtable holder for static/local versions.
+template <CStorage TStorage, class... TCpos>
+class TVTable;
+
+// NB(arkady-e1ppa): We do not support empty vtables since there is no way
+// to check validity nor type of the object for such vtables.
+template <CStorage TStorage, class TCpo, class... TCpos>
+class TVTable<TStorage, TCpo, TCpos...>
+    : private TVTableEntry<TStorage, TCpo>
+    , private TVTableEntry<TStorage, TCpos>...
+{
+public:
+    TVTable() = default;
+
+    template <class TConcrete>
+    Y_FORCE_INLINE static TVTable Create() noexcept
+    {
+        return TVTable{TCtorTag<TConcrete>{}};
+    }
+
+    template <auto C>
+    Y_FORCE_INLINE auto GetFunctor() const noexcept
+    {
+        return TVTableEntry<TStorage, TTagInvokeTag<C>>::Get();
+    }
+
+    Y_FORCE_INLINE void Reset() noexcept
+    {
+        TVTableEntry<TStorage, TCpo>::Reset();
+    }
+
+    Y_FORCE_INLINE bool IsValid() const noexcept
+    {
+        return TVTableEntry<TStorage, TCpo>::IsValid();
+    }
+
+    template <class T>
+    Y_FORCE_INLINE bool HoldsType() const noexcept
+    {
+        return TVTableEntry<TStorage, TCpo>::template HoldsType<T>();
+    }
+
+private:
+    template <class T>
+    struct TCtorTag
+    { };
+
+    template <class T>
+    explicit TVTable(TCtorTag<T>) noexcept
+        : TVTableEntry<TStorage, TCpo>{TVTableEntry<TStorage, TCpo>::template Create<T>()}
+        , TVTableEntry<TStorage, TCpos>{TVTableEntry<TStorage, TCpos>::template Create<T>()}...
+    { }
+};
+
+////////////////////////////////////////////////////////////////////////////////
+
+template <class T, class TStorage>
+struct TIsVTable
+    : public std::false_type
+{ };
+
+template <CStorage TStorage, class... TCpos>
+struct TIsVTable<TVTable<TStorage, TCpos...>, TStorage>
+    : public std::true_type
+{ };
+
+template <class T, class TStorage>
+concept CVTableFor =
+    CStorage<TStorage> &&
+    TIsVTable<std::remove_cvref_t<T>, TStorage>::value;
+
+////////////////////////////////////////////////////////////////////////////////
+
+template <class TStorage, CVTableFor<TStorage> TTable, bool IsStatic>
+class TVTableHolder
+{
+public:
+    TVTableHolder() = default;
+
+    bool IsValid() const
+    {
+        return Table_ != nullptr && Table_->IsValid();
+    }
+
+    template <class TConcrete>
+    static TVTableHolder Create()
+    {
+        static TTable staticTable = TTable::template Create<TConcrete>();
+
+        TVTableHolder holder = {};
+        holder.Table_ = std::addressof(staticTable);
+        return holder;
+    }
+
+    const TTable& GetVTable() const
+    {
+        if (!IsValid()) {
+            return EmptyTable;
+        }
+
+        return *Table_;
+    }
+
+    void Reset()
+    {
+        Table_ = nullptr;
+    }
+
+private:
+    TTable* Table_ = nullptr;
+
+    static inline TTable EmptyTable = {};
+};
+
+template <class TStorage, CVTableFor<TStorage> TTable>
+class TVTableHolder<TStorage, TTable, false>
+{
+public:
+    TVTableHolder() = default;
+
+    bool IsValid() const
+    {
+        return Table_.IsValid();
+    }
+
+    template <class TConcrete>
+    static TVTableHolder Create()
+    {
+        TVTableHolder holder = {};
+        holder.Table_ = TTable::template Create<TConcrete>();
+        return holder;
+    }
+
+    const TTable& GetVTable() const
+    {
+        return Table_;
+    }
+
+    void Reset()
+    {
+        Table_.Reset();
+    }
+
+private:
+    TTable Table_ = {};
+};
+
+////////////////////////////////////////////////////////////////////////////////
+
+// NB(arkady-e1ppa): Below are Cpos which replicate function of default language features
+// such as copy/move ctors, dtor. More can be added later if needed.
+// But they are likely to be an overkill.
+// General formula is that we have a cpo for default feature and then
+// a wrapper of an object which serves the purpose of an adaptor between
+// native c++ expression and CPO expression of the same behavior.
+////////////////////////////////////////////////////////////////////////////////
+
+struct TDeleter
+    : public TTagInvokeCpoBase<TDeleter>
+{ };
+
+inline constexpr TOverloadedCpo<TDeleter{}, void(TErasedThis&) noexcept> Deleter = {};
+
+////////////////////////////////////////////////////////////////////////////////
+
+// NB(arkady-e1ppa): We do not use custom allocators with wacky policies
+// and therefore don't adopt reallocating move ctor.
+template <CStorage TStorage>
+struct TMover
+    : public TTagInvokeCpoBase<TMover<TStorage>>
+{ };
+
+template <CStorage TStorage>
+inline constexpr TOverloadedCpo<TMover<TStorage>{}, void(TErasedThis&&, TStorage&)> Mover = {};
+
+////////////////////////////////////////////////////////////////////////////////
+
+template <CStorage TStorage>
+struct TCopier
+    : public TTagInvokeCpoBase<TCopier<TStorage>>
+{ };
+
+template <CStorage TStorage>
+inline constexpr TOverloadedCpo<TCopier<TStorage>{}, void(const TErasedThis&, TStorage&)> Copier = {};
+
+////////////////////////////////////////////////////////////////////////////////
+
+struct TNoopCpo
+{
+    template <class... TArgs>
+    constexpr void operator() (TArgs&&... /*args*/) const
+    {
+        YT_ABORT();
+    }
+};
+
+inline constexpr TOverloadedCpo<TNoopCpo{}, void(const TErasedThis&)> NoopCpo = {};
+
+////////////////////////////////////////////////////////////////////////////////
+
+template <class W, class T>
+concept CWrapperOf = requires (W& ref, const W& cref) {
+    { ref.Unwrap() } -> std::same_as<T&>;
+    { std::move(ref).Unwrap() } -> std::same_as<T&&>;
+    { cref.Unwrap() } -> std::same_as<const T&>;
+};
+
+////////////////////////////////////////////////////////////////////////////////
+
+// Wraps value, adding TagInvoke overload for dtor and move/copy ctors.
+template <class TDerived, class TConcrete, CStorage TStorage, bool EnableCopy>
+class TOwningWrapperBase
+{
+public:
+    // NB(arkady-e1ppa): Wrapper is stored not only the object itself.
+    static constexpr bool IsStatic = TStorage::template IsStatic<TDerived>;
+
+    using TTraits = std::allocator_traits<std::allocator<std::byte>>;
+    static inline std::allocator<std::byte> Allocator = {};
+
+    template <class... TArgs>
+        requires std::constructible_from<TConcrete, TArgs...>
+    explicit TOwningWrapperBase(TArgs&&... args)
+        noexcept(std::is_nothrow_constructible_v<TConcrete, TArgs...>)
+        : Concrete_(std::forward<TArgs>(args)...)
+    { }
+
+    Y_FORCE_INLINE void Delete() & noexcept
+    {
+        TTraits::template destroy<TDerived>(Allocator, AsFinal());
+
+        if constexpr (!IsStatic) {
+            TTraits::deallocate(Allocator, reinterpret_cast<std::byte*>(AsFinal()), sizeof(TDerived));
+        }
+    }
+
+    Y_FORCE_INLINE void Move(TStorage& to) &&
+        requires std::movable<TConcrete>
+    {
+        if constexpr (IsStatic) {
+            to.Set();
+
+            TTraits::template construct<TDerived>(
+                Allocator,
+                &to.template As<TDerived>(),
+                std::move(*AsFinal()));
+        } else {
+            to.Set(static_cast<void*>(AsFinal()));
+        }
+    }
+
+    Y_FORCE_INLINE void Copy(TStorage& to) const &
+        requires (EnableCopy && std::copyable<TConcrete>)
+    {
+        if constexpr (IsStatic) {
+            to.Set();
+        } else {
+            to.Set(TTraits::allocate(Allocator, sizeof(TDerived)));
+        }
+
+        TTraits::template construct<TDerived>(
+            Allocator,
+            &to.template As<TDerived>(),
+            *AsFinal());
+    }
+
+    friend Y_FORCE_INLINE void TagInvoke(TDeleter, TDerived& this_) noexcept
+    {
+        static_assert(std::derived_from<TDerived, TOwningWrapperBase>, "Must derived from TOwningWrapperBase");
+        this_.Delete();
+    }
+
+    friend Y_FORCE_INLINE void TagInvoke(TMover<TStorage>, TDerived&& this_, TStorage& to)
+        noexcept(std::is_nothrow_move_constructible_v<TConcrete>)
+    {
+        std::move(this_).Move(to);
+    }
+
+    friend Y_FORCE_INLINE void TagInvoke(TCopier<TStorage>, const TDerived& this_, TStorage& to)
+        noexcept(std::is_nothrow_copy_constructible_v<TConcrete>)
+    {
+        this_.Copy(to);
+    }
+
+    // CWrapperOf<TConcrete>
+    Y_FORCE_INLINE TConcrete& Unwrap() &
+    {
+        return Concrete_;
+    }
+
+    Y_FORCE_INLINE const TConcrete& Unwrap() const &
+    {
+        return Concrete_;
+    }
+
+    Y_FORCE_INLINE TConcrete&& Unwrap() &&
+    {
+        return std::move(Concrete_);
+    }
+
+private:
+    TConcrete Concrete_;
+
+    Y_FORCE_INLINE TDerived* AsFinal() const
+    {
+        return static_cast<TDerived*>(const_cast<TOwningWrapperBase*>(this));
+    }
+};
+
+////////////////////////////////////////////////////////////////////////////////
+
+template <class TDerived, class TCpo>
+struct TUnwrappingTagInvokeBase;
+
+// NB(arkady-e1ppa): Technically, we could accept TErasedThis as any argument, but
+// there is barely any profit from doing so yet code becomes much more cumbersome
+// both here and around TAny(Object|Ref).
+template <class TDerived, auto Cpo, class TRet, bool NoExcept, class TCvThis, class... TArgs>
+struct TUnwrappingTagInvokeBase<TDerived, TOverloadedCpo<Cpo, TRet(TCvThis, TArgs...) noexcept(NoExcept)>>
+{
+    using TReplaced = TFromThis<TDerived, TCvThis>;
+
+    friend Y_FORCE_INLINE TRet TagInvoke(TTagInvokeTag<Cpo>, TReplaced wrapper, TArgs... args) YT_TYPE_ERASURE_NOEXCEPT(NoExcept)
+    {
+        return Cpo(std::forward<TReplaced>(wrapper).Unwrap(), std::forward<TArgs>(args)...);
+    }
+};
+
+////////////////////////////////////////////////////////////////////////////////
+
+template <class TConcrete, CStorage TStorage, bool EnableCopy, class... TCpos>
+class TOwningWrapper final
+    : public TOwningWrapperBase<
+        TOwningWrapper<
+            TConcrete,
+            TStorage,
+            EnableCopy,
+            TCpos...>,
+        TConcrete,
+        TStorage,
+        EnableCopy>
+    , public TUnwrappingTagInvokeBase<
+        TOwningWrapper<
+            TConcrete,
+            TStorage,
+            EnableCopy,
+            TCpos...>,
+        TCpos>...
+{
+    using TBase = TOwningWrapperBase<
+        TOwningWrapper<
+            TConcrete,
+            TStorage,
+            EnableCopy,
+            TCpos...>,
+        TConcrete,
+        TStorage,
+        EnableCopy>;
+
+    using TBase::TBase;
+};
+
+////////////////////////////////////////////////////////////////////////////////
+
+// Every "Any-like" object must be able to provide access to storage
+// and a vtable which matches the storage provided.
+template <class T>
+concept CSomeAnyObject = requires (T& ref, const T& cref) {
+    typename T::TStorage;
+    { ref.GetStorage() } -> std::same_as<typename T::TStorage&>;
+    { std::move(ref).GetStorage() } -> std::same_as<typename T::TStorage&&>;
+    { cref.GetStorage() } -> std::same_as<const typename T::TStorage&>;
+
+    { cref.GetVTable() } -> CVTableFor<typename T::TStorage>;
+};
+
+////////////////////////////////////////////////////////////////////////////////
+
+template <class TDerived, class TCpo>
+struct TAnyFragment;
+
+template <class TDerived, auto Cpo, class TRet, bool NoExcept, class TCvThis, class... TArgs>
+struct TAnyFragment<TDerived, TOverloadedCpo<Cpo, TRet(TCvThis, TArgs...) noexcept(NoExcept)>>
+{
+    using TReplaced = TFromThis<TDerived, TCvThis>;
+    using TVTableTag = TOverloadedCpo<Cpo, TRet(TCvThis, TArgs...) noexcept(NoExcept)>;
+
+    friend Y_FORCE_INLINE TRet TagInvoke(TTagInvokeTag<Cpo>, TReplaced any, TArgs... args) YT_TYPE_ERASURE_NOEXCEPT(NoExcept)
+    {
+        static_assert(CSomeAnyObject<TDerived>);
+
+        auto&& vtable = any.GetVTable();
+
+        YT_VERIFY(vtable.IsValid());
+
+        auto* functor = vtable.template GetFunctor<TVTableTag{}>();
+
+        return functor(std::forward<TReplaced>(any).GetStorage(), std::forward<TArgs>(args)...);
+    }
+};
+
+#undef YT_TYPE_ERASURE_NOEXCEPT
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace NYT::NDetail
diff --git a/library/cpp/yt/memory/unittests/atomic_intrusive_ptr_ut.cpp b/library/cpp/yt/memory/unittests/atomic_intrusive_ptr_ut.cpp
index 68489fcdf7c..ead150c3b99 100644
--- a/library/cpp/yt/memory/unittests/atomic_intrusive_ptr_ut.cpp
+++ b/library/cpp/yt/memory/unittests/atomic_intrusive_ptr_ut.cpp
@@ -3,12 +3,17 @@
 #include <library/cpp/yt/memory/new.h>
 #include <library/cpp/yt/memory/ref_counted.h>
 #include <library/cpp/yt/memory/atomic_intrusive_ptr.h>
+#include <library/cpp/yt/memory/leaky_singleton.h>
+
+#include <util/system/compiler.h>
 
 namespace NYT {
 namespace {
 
 ////////////////////////////////////////////////////////////////////////////////
 
+#if !defined(_lsan_enabled_) && !defined(_asan_enabled_)
+
 using ::testing::IsNull;
 using ::testing::NotNull;
 using ::testing::InSequence;
@@ -168,16 +173,25 @@ class TObjectWithFullRC
 
 ////////////////////////////////////////////////////////////////////////////////
 
-TEST(TAtomicPtrTest, Empty)
+TEST(TIntrusiveAtomicPtrTest, Empty)
 {
     TIntricateObjectPtr emptyPointer;
     EXPECT_EQ(nullptr, emptyPointer.Get());
 }
 
-// Reserved ref count.
-constexpr int RRC = 65535;
+constexpr int ReservedRefCount = 65535;
 
-TEST(TAtomicPtrTest, Basic)
+TEST(TIntrusiveAtomicPtrTest, Reset)
+{
+    TIntricateObject object;
+    TIntricateObjectPtr owningPointer(&object);
+    TAtomicIntrusivePtr<TIntricateObject> atomicPointer(owningPointer);
+    atomicPointer.Reset();
+    EXPECT_EQ(nullptr, atomicPointer.Get());
+    EXPECT_THAT(object, HasRefCounts(1 + ReservedRefCount, ReservedRefCount, 0));
+}
+
+TEST(TIntrusiveAtomicPtrTest, Basic)
 {
     TIntricateObject object;
 
@@ -196,27 +210,27 @@ TEST(TAtomicPtrTest, Basic)
         TIntricateObjectPtr owningPointer(&object);
         TAtomicIntrusivePtr<TIntricateObject> atomicPointer(owningPointer);
 
-        EXPECT_THAT(object, HasRefCounts(2 + RRC, 1, 1));
+        EXPECT_THAT(object, HasRefCounts(2 + ReservedRefCount, 1, 1));
         EXPECT_EQ(&object, owningPointer.Get());
 
 
         auto p1 = atomicPointer.Acquire();
 
-        EXPECT_THAT(object, HasRefCounts(2 + RRC, 1, 1));
+        EXPECT_THAT(object, HasRefCounts(2 + ReservedRefCount, 1, 1));
 
         p1.Reset();
 
-        EXPECT_THAT(object, HasRefCounts(2 + RRC, 2, 1));
+        EXPECT_THAT(object, HasRefCounts(2 + ReservedRefCount, 2, 1));
 
         owningPointer.Reset();
 
-        EXPECT_THAT(object, HasRefCounts(2 + RRC, 3, 1));
+        EXPECT_THAT(object, HasRefCounts(2 + ReservedRefCount, 3, 1));
     }
 
-    EXPECT_THAT(object, HasRefCounts(2 + RRC, 2 + RRC, 2));
+    EXPECT_THAT(object, HasRefCounts(2 + ReservedRefCount, 2 + ReservedRefCount, 2));
 }
 
-TEST(TAtomicPtrTest, BasicConst)
+TEST(TIntrusiveAtomicPtrTest, BasicConst)
 {
     const TIntricateObject object;
 
@@ -235,86 +249,86 @@ TEST(TAtomicPtrTest, BasicConst)
         TConstIntricateObjectPtr owningPointer(&object);
         TAtomicIntrusivePtr<const TIntricateObject> atomicPointer(owningPointer);
 
-        EXPECT_THAT(object, HasRefCounts(2 + RRC, 1, 1));
+        EXPECT_THAT(object, HasRefCounts(2 + ReservedRefCount, 1, 1));
         EXPECT_EQ(&object, owningPointer.Get());
 
 
         auto p1 = atomicPointer.Acquire();
 
-        EXPECT_THAT(object, HasRefCounts(2 + RRC, 1, 1));
+        EXPECT_THAT(object, HasRefCounts(2 + ReservedRefCount, 1, 1));
 
         p1.Reset();
 
-        EXPECT_THAT(object, HasRefCounts(2 + RRC, 2, 1));
+        EXPECT_THAT(object, HasRefCounts(2 + ReservedRefCount, 2, 1));
 
         owningPointer.Reset();
 
-        EXPECT_THAT(object, HasRefCounts(2 + RRC, 3, 1));
+        EXPECT_THAT(object, HasRefCounts(2 + ReservedRefCount, 3, 1));
     }
 
-    EXPECT_THAT(object, HasRefCounts(2 + RRC, 2 + RRC, 2));
+    EXPECT_THAT(object, HasRefCounts(2 + ReservedRefCount, 2 + ReservedRefCount, 2));
 }
 
-TEST(TAtomicPtrTest, Acquire)
+TEST(TIntrusiveAtomicPtrTest, Acquire)
 {
     TIntricateObject object;
     {
         TAtomicIntrusivePtr<TIntricateObject> atomicPtr{TIntricateObjectPtr(&object)};
-        EXPECT_THAT(object, HasRefCounts(RRC, 0, 0));
+        EXPECT_THAT(object, HasRefCounts(ReservedRefCount, 0, 0));
 
-        for (int i = 0; i < RRC / 2; ++i) {
+        for (int i = 0; i < ReservedRefCount / 2; ++i) {
             {
                 auto tmp = atomicPtr.Acquire();
-                EXPECT_THAT(object, HasRefCounts(RRC, i, 0));
+                EXPECT_THAT(object, HasRefCounts(ReservedRefCount, i, 0));
             }
-            EXPECT_THAT(object, HasRefCounts(RRC, i + 1, 0));
+            EXPECT_THAT(object, HasRefCounts(ReservedRefCount, i + 1, 0));
         }
 
         {
             auto tmp = atomicPtr.Acquire();
-            EXPECT_THAT(object, HasRefCounts(RRC + RRC / 2, RRC / 2, 0));
+            EXPECT_THAT(object, HasRefCounts(ReservedRefCount + ReservedRefCount / 2, ReservedRefCount / 2, 0));
         }
 
-        EXPECT_THAT(object, HasRefCounts(RRC + RRC / 2, RRC / 2 + 1, 0));
+        EXPECT_THAT(object, HasRefCounts(ReservedRefCount + ReservedRefCount / 2, ReservedRefCount / 2 + 1, 0));
     }
 
-    EXPECT_THAT(object, HasRefCounts(RRC + RRC / 2, RRC + RRC / 2, 1));
+    EXPECT_THAT(object, HasRefCounts(ReservedRefCount + ReservedRefCount / 2, ReservedRefCount + ReservedRefCount / 2, 1));
 }
 
-TEST(TAtomicPtrTest, AcquireConst)
+TEST(TIntrusiveAtomicPtrTest, AcquireConst)
 {
     const TIntricateObject object;
     {
         TAtomicIntrusivePtr<const TIntricateObject> atomicPtr{TConstIntricateObjectPtr(&object)};
-        EXPECT_THAT(object, HasRefCounts(RRC, 0, 0));
+        EXPECT_THAT(object, HasRefCounts(ReservedRefCount, 0, 0));
 
-        for (int i = 0; i < RRC / 2; ++i) {
+        for (int i = 0; i < ReservedRefCount / 2; ++i) {
             {
                 auto tmp = atomicPtr.Acquire();
-                EXPECT_THAT(object, HasRefCounts(RRC, i, 0));
+                EXPECT_THAT(object, HasRefCounts(ReservedRefCount, i, 0));
             }
-            EXPECT_THAT(object, HasRefCounts(RRC, i + 1, 0));
+            EXPECT_THAT(object, HasRefCounts(ReservedRefCount, i + 1, 0));
         }
 
         {
             auto tmp = atomicPtr.Acquire();
-            EXPECT_THAT(object, HasRefCounts(RRC + RRC / 2, RRC / 2, 0));
+            EXPECT_THAT(object, HasRefCounts(ReservedRefCount + ReservedRefCount / 2, ReservedRefCount / 2, 0));
         }
 
-        EXPECT_THAT(object, HasRefCounts(RRC + RRC / 2, RRC / 2 + 1, 0));
+        EXPECT_THAT(object, HasRefCounts(ReservedRefCount + ReservedRefCount / 2, ReservedRefCount / 2 + 1, 0));
     }
 
-    EXPECT_THAT(object, HasRefCounts(RRC + RRC / 2, RRC + RRC / 2, 1));
+    EXPECT_THAT(object, HasRefCounts(ReservedRefCount + ReservedRefCount / 2, ReservedRefCount + ReservedRefCount / 2, 1));
 }
 
-TEST(TAtomicPtrTest, CAS)
+TEST(TIntrusiveAtomicPtrTest, CAS)
 {
     TIntricateObject o1;
     TIntricateObject o2;
     {
 
         TAtomicIntrusivePtr<TIntricateObject> atomicPtr{TIntricateObjectPtr(&o1)};
-        EXPECT_THAT(o1, HasRefCounts(RRC, 0, 0));
+        EXPECT_THAT(o1, HasRefCounts(ReservedRefCount, 0, 0));
 
         TIntricateObjectPtr p2(&o2);
         EXPECT_THAT(o2, HasRefCounts(1, 0, 0));
@@ -323,28 +337,28 @@ TEST(TAtomicPtrTest, CAS)
         EXPECT_TRUE(atomicPtr.CompareAndSwap(rawPtr, std::move(p2)));
         EXPECT_EQ(rawPtr, &o1);
 
-        EXPECT_THAT(o1, HasRefCounts(RRC, RRC, 1));
-        EXPECT_THAT(o2, HasRefCounts(RRC, 0, 0));
+        EXPECT_THAT(o1, HasRefCounts(ReservedRefCount, ReservedRefCount, 1));
+        EXPECT_THAT(o2, HasRefCounts(ReservedRefCount, 0, 0));
 
         rawPtr = nullptr;
         EXPECT_FALSE(atomicPtr.CompareAndSwap(rawPtr, TIntricateObjectPtr(&o1)));
         EXPECT_EQ(rawPtr, &o2);
 
-        EXPECT_THAT(o1, HasRefCounts(2 * RRC, 2 * RRC, 2));
-        EXPECT_THAT(o2, HasRefCounts(RRC, 0, 0));
+        EXPECT_THAT(o1, HasRefCounts(2 * ReservedRefCount, 2 * ReservedRefCount, 2));
+        EXPECT_THAT(o2, HasRefCounts(ReservedRefCount, 0, 0));
     }
 
-    EXPECT_THAT(o2, HasRefCounts(RRC, RRC, 1));
+    EXPECT_THAT(o2, HasRefCounts(ReservedRefCount, ReservedRefCount, 1));
 }
 
-TEST(TAtomicPtrTest, CASConst)
+TEST(TIntrusiveAtomicPtrTest, CASConst)
 {
     const TIntricateObject o1;
     const TIntricateObject o2;
     {
 
         TAtomicIntrusivePtr<const TIntricateObject> atomicPtr{TConstIntricateObjectPtr(&o1)};
-        EXPECT_THAT(o1, HasRefCounts(RRC, 0, 0));
+        EXPECT_THAT(o1, HasRefCounts(ReservedRefCount, 0, 0));
 
         TConstIntricateObjectPtr p2(&o2);
         EXPECT_THAT(o2, HasRefCounts(1, 0, 0));
@@ -353,20 +367,45 @@ TEST(TAtomicPtrTest, CASConst)
         EXPECT_TRUE(atomicPtr.CompareAndSwap(rawPtr, std::move(p2)));
         EXPECT_EQ(rawPtr, &o1);
 
-        EXPECT_THAT(o1, HasRefCounts(RRC, RRC, 1));
-        EXPECT_THAT(o2, HasRefCounts(RRC, 0, 0));
+        EXPECT_THAT(o1, HasRefCounts(ReservedRefCount, ReservedRefCount, 1));
+        EXPECT_THAT(o2, HasRefCounts(ReservedRefCount, 0, 0));
 
         rawPtr = nullptr;
         EXPECT_FALSE(atomicPtr.CompareAndSwap(rawPtr, TConstIntricateObjectPtr(&o1)));
         EXPECT_EQ(rawPtr, &o2);
 
-        EXPECT_THAT(o1, HasRefCounts(2 * RRC, 2 * RRC, 2));
-        EXPECT_THAT(o2, HasRefCounts(RRC, 0, 0));
+        EXPECT_THAT(o1, HasRefCounts(2 * ReservedRefCount, 2 * ReservedRefCount, 2));
+        EXPECT_THAT(o2, HasRefCounts(ReservedRefCount, 0, 0));
     }
 
-    EXPECT_THAT(o2, HasRefCounts(RRC, RRC, 1));
+    EXPECT_THAT(o2, HasRefCounts(ReservedRefCount, ReservedRefCount, 1));
 }
 
+TEST(TIntrusiveAtomicPtrTest, LSan)
+{
+    struct S final
+    { };
+
+    struct TSingleton
+    {
+        TSingleton()
+        {
+            for (auto& ptr : Ptrs) {
+                ptr.Store(New<S>());
+                // Clobber pointer bits to prevent LSan from tracing the pointer.
+                ptr.Acquire();
+            }
+        }
+
+        // LSan has some issues detecting leaks when just one allocation is made.
+        std::array<TAtomicIntrusivePtr<S>, 100> Ptrs;
+    };
+
+    LeakySingleton<TSingleton>();
+}
+
+#endif
+
 ////////////////////////////////////////////////////////////////////////////////
 
 } // namespace
diff --git a/library/cpp/yt/memory/unittests/atomic_ut.cpp b/library/cpp/yt/memory/unittests/atomic_ut.cpp
new file mode 100644
index 00000000000..f68ce56dfcd
--- /dev/null
+++ b/library/cpp/yt/memory/unittests/atomic_ut.cpp
@@ -0,0 +1,175 @@
+#include <library/cpp/testing/gtest/gtest.h>
+
+#include <library/cpp/yt/memory/atomic.h>
+
+#include <thread>
+
+namespace NYT {
+namespace {
+
+////////////////////////////////////////////////////////////////////////////////
+
+TEST(TAtomicTest, SingleWriterFetchAdd)
+{
+    std::atomic<int> value;
+
+    // Test basic addition
+    int oldValue = SingleWriterFetchAdd(value, 5);
+    EXPECT_EQ(oldValue, 0);
+    EXPECT_EQ(value.load(), 5);
+
+    oldValue = SingleWriterFetchAdd(value, 10);
+    EXPECT_EQ(oldValue, 5);
+    EXPECT_EQ(value.load(), 15);
+
+    // Test with negative delta
+    oldValue = SingleWriterFetchAdd(value, -3);
+    EXPECT_EQ(oldValue, 15);
+    EXPECT_EQ(value.load(), 12);
+}
+
+TEST(TAtomicTest, SingleWriterFetchSub)
+{
+    std::atomic<int> value{100};
+
+    // Test basic subtraction
+    int oldValue = SingleWriterFetchSub(value, 5);
+    EXPECT_EQ(oldValue, 100);
+    EXPECT_EQ(value.load(), 95);
+
+    oldValue = SingleWriterFetchSub(value, 10);
+    EXPECT_EQ(oldValue, 95);
+    EXPECT_EQ(value.load(), 85);
+
+    // Test with negative delta (which is effectively addition)
+    oldValue = SingleWriterFetchSub(value, -3);
+    EXPECT_EQ(oldValue, 85);
+    EXPECT_EQ(value.load(), 88);
+}
+
+TEST(TAtomicTest, SingleWriterFetchAddUnsigned)
+{
+    std::atomic<unsigned int> value;
+
+    unsigned int oldValue = SingleWriterFetchAdd(value, 5u);
+    EXPECT_EQ(oldValue, 0u);
+    EXPECT_EQ(value.load(), 5u);
+
+    oldValue = SingleWriterFetchAdd(value, 10u);
+    EXPECT_EQ(oldValue, 5u);
+    EXPECT_EQ(value.load(), 15u);
+}
+
+TEST(TAtomicTest, SingleWriterFetchSubUnsigned)
+{
+    std::atomic<unsigned int> value{100};
+
+    unsigned int oldValue = SingleWriterFetchSub(value, 5u);
+    EXPECT_EQ(oldValue, 100u);
+    EXPECT_EQ(value.load(), 95u);
+
+    oldValue = SingleWriterFetchSub(value, 10u);
+    EXPECT_EQ(oldValue, 95u);
+    EXPECT_EQ(value.load(), 85u);
+}
+
+TEST(TAtomicTest, SingleWriterFetchAddMultipleOperations)
+{
+    std::atomic<int> value;
+
+    for (int i = 0; i < 100; ++i) {
+        int oldValue = SingleWriterFetchAdd(value, i);
+        EXPECT_EQ(oldValue, i * (i - 1) / 2);
+    }
+
+    EXPECT_EQ(value.load(), 4950); // Sum of 0..99
+}
+
+TEST(TAtomicTest, SingleWriterFetchSubMultipleOperations)
+{
+    std::atomic<int> value{4950};
+
+    for (int i = 0; i < 100; ++i) {
+        int oldValue = SingleWriterFetchSub(value, i);
+        EXPECT_EQ(oldValue, 4950 - i * (i - 1) / 2);
+    }
+
+    EXPECT_EQ(value.load(), 0);
+}
+
+TEST(TAtomicTest, SingleWriterFetchAddWithZero)
+{
+    std::atomic<int> value{42};
+
+    int oldValue = SingleWriterFetchAdd(value, 0);
+    EXPECT_EQ(oldValue, 42);
+    EXPECT_EQ(value.load(), 42);
+}
+
+TEST(TAtomicTest, SingleWriterFetchSubWithZero)
+{
+    std::atomic<int> value{42};
+
+    int oldValue = SingleWriterFetchSub(value, 0);
+    EXPECT_EQ(oldValue, 42);
+    EXPECT_EQ(value.load(), 42);
+}
+
+TEST(TAtomicTest, SingleWriterFetchAddLargeDelta)
+{
+    std::atomic<int64_t> value;
+
+    int64_t oldValue = SingleWriterFetchAdd(value, int64_t{1000000000});
+    EXPECT_EQ(oldValue, 0);
+    EXPECT_EQ(value.load(), int64_t{1000000000});
+
+    oldValue = SingleWriterFetchAdd(value, int64_t{2000000000});
+    EXPECT_EQ(oldValue, int64_t{1000000000});
+    EXPECT_EQ(value.load(), int64_t{3000000000});
+}
+
+TEST(TAtomicTest, SingleWriterFetchSubLargeDelta)
+{
+    std::atomic<int64_t> value{int64_t{3000000000}};
+
+    int64_t oldValue = SingleWriterFetchSub(value, int64_t{1000000000});
+    EXPECT_EQ(oldValue, int64_t{3000000000});
+    EXPECT_EQ(value.load(), int64_t{2000000000});
+
+    oldValue = SingleWriterFetchSub(value, int64_t{2000000000});
+    EXPECT_EQ(oldValue, int64_t{2000000000});
+    EXPECT_EQ(value.load(), 0);
+}
+
+TEST(TAtomicTest, SingleWriterFetchAddConsistency)
+{
+    std::atomic<int> value;
+    int sum = 0;
+
+    for (int i = 1; i <= 1000; ++i) {
+        int oldValue = SingleWriterFetchAdd(value, i);
+        sum += i;
+        EXPECT_EQ(oldValue, sum - i);
+    }
+
+    EXPECT_EQ(value.load(), sum);
+}
+
+TEST(TAtomicTest, SingleWriterFetchSubConsistency)
+{
+    std::atomic<int> value{500500}; // Sum of 1..1000
+    int sum = 500500;
+
+    for (int i = 1; i <= 1000; ++i) {
+        int oldValue = SingleWriterFetchSub(value, i);
+        EXPECT_EQ(oldValue, sum);
+        sum -= i;
+    }
+
+    EXPECT_EQ(value.load(), 0);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace
+} // namespace NYT
diff --git a/library/cpp/yt/memory/unittests/chunked_memory_pool_ut.cpp b/library/cpp/yt/memory/unittests/chunked_memory_pool_ut.cpp
index 55f9f9945af..736470653bd 100644
--- a/library/cpp/yt/memory/unittests/chunked_memory_pool_ut.cpp
+++ b/library/cpp/yt/memory/unittests/chunked_memory_pool_ut.cpp
@@ -23,7 +23,7 @@ TEST(TChunkedMemoryPoolTest, Absorb)
     auto fillPool = [&] (TChunkedMemoryPool& pool, TString prefix, int count) {
         for (int i = 0; i < count; i++) {
             TString expected = prefix + ToString(count);
-            char* buf = pool.AllocateUnaligned(expected.Size());
+            char* buf = pool.AllocateUnaligned(expected.size());
             ::memcpy(buf, expected.c_str(), expected.size());
             TStringBuf ref(buf, buf + expected.size());
             totalSize += expected.size();
diff --git a/library/cpp/yt/memory/unittests/erased_storage_ut.cpp b/library/cpp/yt/memory/unittests/erased_storage_ut.cpp
index 194c8e7fce5..5545423bcf3 100644
--- a/library/cpp/yt/memory/unittests/erased_storage_ut.cpp
+++ b/library/cpp/yt/memory/unittests/erased_storage_ut.cpp
@@ -46,6 +46,13 @@ class TWithPrivateMembers
     [[maybe_unused]] std::array<std::byte, 8> Data_;
 };
 
+// Overshadow to bind template parameter.
+inline constexpr size_t TestSize = 32;
+
+template <class T>
+concept CTriviallyErasable = ::NYT::CTriviallyErasable<T, TestSize>;
+using TErasedStorage = ::NYT::TErasedStorage<TestSize>;
+
 ////////////////////////////////////////////////////////////////////////////////
 
 TEST(TErasedStorageTest, Types)
@@ -124,6 +131,21 @@ TEST(TErasedStorageTest, MutateStorage)
     EXPECT_EQ(stor.AsConcrete<int>(), 88);
 }
 
+TEST(TErasedStorageTest, EqualityComparison)
+{
+    struct TWidget
+    {
+        alignas(8) int Value;
+
+        alignas(16) bool Flag;
+    } widget{1, false};
+
+    TErasedStorage stor1(widget);
+    TErasedStorage stor2(widget);
+
+    EXPECT_EQ(stor1, stor2);
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 
 } // namespace
diff --git a/library/cpp/yt/memory/unittests/exact_ref_counted_cast_ut.cpp b/library/cpp/yt/memory/unittests/exact_ref_counted_cast_ut.cpp
new file mode 100644
index 00000000000..75cce328dc0
--- /dev/null
+++ b/library/cpp/yt/memory/unittests/exact_ref_counted_cast_ut.cpp
@@ -0,0 +1,102 @@
+#include <library/cpp/testing/gtest/gtest.h>
+
+#include <library/cpp/yt/memory/exact_ref_counted_cast.h>
+#include <library/cpp/yt/memory/new.h>
+#include <library/cpp/yt/memory/ref_counted.h>
+
+#include <type_traits>
+#include <typeinfo>
+
+namespace NYT {
+namespace {
+
+////////////////////////////////////////////////////////////////////////////////
+
+struct TBase
+    : public TRefCounted
+{ };
+
+struct TDerived
+    : public TBase
+{
+    int Tag = 42;
+};
+
+struct TMoreDerived
+    : public TDerived
+{ };
+
+////////////////////////////////////////////////////////////////////////////////
+// Pointer form.
+
+TEST(TExactRefCountedCastTest, ExactMatch)
+{
+    auto object = New<TDerived>();
+    TBase* base = object.Get();
+    EXPECT_EQ(ExactRefCountedCast<TDerived>(base), object.Get());
+    EXPECT_EQ(ExactRefCountedCast<TDerived>(base)->Tag, 42);
+}
+
+TEST(TExactRefCountedCastTest, SubclassDoesNotMatch)
+{
+    auto object = New<TMoreDerived>();
+    TBase* base = object.Get();
+    // Object was New<TMoreDerived>(); an exact probe for TDerived must miss.
+    EXPECT_EQ(ExactRefCountedCast<TDerived>(base), nullptr);
+    // ...but the exact type matches.
+    EXPECT_EQ(ExactRefCountedCast<TMoreDerived>(base), object.Get());
+}
+
+TEST(TExactRefCountedCastTest, BaseDoesNotMatch)
+{
+    auto object = New<TDerived>();
+    TBase* base = object.Get();
+    // It is exactly a TDerived, not a TBase.
+    EXPECT_EQ(ExactRefCountedCast<TBase>(base), nullptr);
+}
+
+TEST(TExactRefCountedCastTest, Null)
+{
+    TBase* base = nullptr;
+    EXPECT_EQ(ExactRefCountedCast<TDerived>(base), nullptr);
+}
+
+TEST(TExactRefCountedCastTest, ConstnessPreserved)
+{
+    auto object = New<TDerived>();
+    const TBase* base = object.Get();
+    auto* result = ExactRefCountedCast<TDerived>(base);
+    static_assert(std::is_same_v<decltype(result), const TDerived*>);
+    EXPECT_EQ(result, object.Get());
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Reference form.
+
+TEST(TExactRefCountedCastTest, RefExactMatch)
+{
+    auto object = New<TDerived>();
+    TBase& base = *object;
+    EXPECT_EQ(&ExactRefCountedCast<TDerived>(base), object.Get());
+}
+
+TEST(TExactRefCountedCastTest, RefSubclassThrows)
+{
+    auto object = New<TMoreDerived>();
+    TBase& base = *object;
+    EXPECT_THROW((void)ExactRefCountedCast<TDerived>(base), std::bad_cast);
+    EXPECT_EQ(&ExactRefCountedCast<TMoreDerived>(base), object.Get());
+}
+
+TEST(TExactRefCountedCastTest, RefConstnessPreserved)
+{
+    auto object = New<TDerived>();
+    const TBase& base = *object;
+    static_assert(std::is_same_v<decltype(ExactRefCountedCast<TDerived>(base)), const TDerived&>);
+    EXPECT_EQ(&ExactRefCountedCast<TDerived>(base), object.Get());
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace
+} // namespace NYT
diff --git a/library/cpp/yt/memory/unittests/free_list_ut.cpp b/library/cpp/yt/memory/unittests/free_list_ut.cpp
index 3d2ecf103ef..64e00942e2e 100644
--- a/library/cpp/yt/memory/unittests/free_list_ut.cpp
+++ b/library/cpp/yt/memory/unittests/free_list_ut.cpp
@@ -15,17 +15,19 @@ using namespace std::chrono_literals;
 
 ////////////////////////////////////////////////////////////////////////////////
 
-TEST(TFreeListTest, CompareAndSet)
+TEST(TFreeListDetailsTest, CasFreeListPackedPair)
 {
-    TAtomicUint128 v = 0;
-    ui64 p1 = 0;
-    ui64 p2 = 0;
-    EXPECT_TRUE(CompareAndSet(&v, p1, p2, ui64{13}, ui64{9}));
-    EXPECT_FALSE(CompareAndSet(&v, p1, p2, ui64{100}, ui64{500}));
-    EXPECT_EQ(13u, p1);
-    EXPECT_EQ(9u, p2);
-    EXPECT_TRUE(CompareAndSet(&v, p1, p2, ui64{100}, ui64{500}));
-    EXPECT_EQ(TAtomicUint128{500} << 64 | 100, v);
+    using P = NDetail::TFreeListPackedPair;
+    using C = NDetail::TFreeListPackedPairComponent;
+    P v = 0;
+    C p1 = 0;
+    C p2 = 0;
+    EXPECT_TRUE(NDetail::CasFreeListPackedPair(&v, p1, p2, C(13), C(9)));
+    EXPECT_FALSE(NDetail::CasFreeListPackedPair(&v, p1, p2, C(100), C(500)));
+    EXPECT_EQ(C(13), p1);
+    EXPECT_EQ(C(9), p2);
+    EXPECT_TRUE(NDetail::CasFreeListPackedPair(&v, p1, p2, C(100), C(500)));
+    EXPECT_EQ((P(500) << (sizeof(C) * 8)) | 100, v);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -90,8 +92,7 @@ class TTestItemSet
     std::stack<size_t> AcquiredItemIndices_;
 };
 
-
-TEST_P(TFreeListStressTest, Stress)
+TEST_P(TFreeListStressTest, Do)
 {
     TTestItemSet::Reset();
     SetRandomSeed(0x424242);
@@ -145,7 +146,7 @@ TEST_P(TFreeListStressTest, Stress)
 }
 
 INSTANTIATE_TEST_SUITE_P(
-    TFreeListTest,
+    TFreeListStressTest,
     TFreeListStressTest,
     testing::Values(
         TTestConfig{4, 1, 15s},
@@ -154,5 +155,90 @@ INSTANTIATE_TEST_SUITE_P(
 
 ////////////////////////////////////////////////////////////////////////////////
 
+struct TFreeListItem
+    : public TFreeListItemBase<TFreeListItem>
+{
+    explicit TFreeListItem(i64 value)
+        : Value(value)
+    { }
+    i64 Value;
+};
+
+static std::chrono::steady_clock::time_point Now()
+{
+    return std::chrono::steady_clock::now();
+}
+
+void ProducerThread(TFreeList<TFreeListItem>* freeList, i64 startValue, std::chrono::steady_clock::time_point until)
+{
+    i64 v = startValue;
+    while (Now() < until) {
+        freeList->Put(new TFreeListItem(v));
+        v += 2;
+    }
+}
+
+void ConsumerThread(TFreeList<TFreeListItem>* freeList, std::chrono::steady_clock::time_point until)
+{
+    i64 latestEven = -2;
+    i64 latestOdd = -1;
+    std::vector<i64> buffer;
+    while (Now() < until) {
+        buffer.clear();
+        auto* extractedList = freeList->ExtractAll();
+        while (extractedList) {
+            buffer.push_back(extractedList->Value);
+            auto* next = extractedList->Next.load(std::memory_order::acquire);
+            delete extractedList;
+            extractedList = next;
+        }
+
+        for (auto it = buffer.rbegin(); it != buffer.rend(); ++it) {
+            auto value = *it;
+            if (value % 2 == 0) {
+                ASSERT_GT(value, latestEven);
+                latestEven = value;
+            } else {
+                ASSERT_GT(value, latestOdd);
+                latestOdd = value;
+            }
+        }
+    }
+}
+
+void Cleanup(TFreeList<TFreeListItem>* freeList)
+{
+    auto* node = freeList->ExtractAll();
+    while (node) {
+        auto* next = node->Next.load(std::memory_order::acquire);
+        delete node;
+        node = next;
+    }
+}
+
+TEST(TFreeListTest, ProducerConsumer)
+{
+    auto now = Now();
+    auto until = now + std::chrono::seconds(5);
+
+    auto freeList = TFreeList<TFreeListItem>();
+
+    std::vector<std::thread> threads;
+
+    threads.emplace_back(ProducerThread, &freeList, 0, until);
+    threads.emplace_back(ProducerThread, &freeList, 1, until);
+
+    threads.emplace_back(ConsumerThread, &freeList, until);
+    threads.emplace_back(ConsumerThread, &freeList, until);
+
+    for (auto& thread : threads) {
+        thread.join();
+    }
+
+    Cleanup(&freeList);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
 } // namespace
 } // namespace NYT
diff --git a/library/cpp/yt/memory/unittests/function_view_ut.cpp b/library/cpp/yt/memory/unittests/function_view_ut.cpp
index 99af41793cc..3835d13eca8 100644
--- a/library/cpp/yt/memory/unittests/function_view_ut.cpp
+++ b/library/cpp/yt/memory/unittests/function_view_ut.cpp
@@ -18,7 +18,7 @@ struct TNoCopy
 
     TNoCopy(const TNoCopy&) = delete;
 
-    TNoCopy(TNoCopy&&)
+    TNoCopy(TNoCopy&&) noexcept
     { }
 };
 
diff --git a/library/cpp/yt/memory/unittests/intrusive_ptr_ut.cpp b/library/cpp/yt/memory/unittests/intrusive_ptr_ut.cpp
index f20e5cff10f..86b6341f915 100644
--- a/library/cpp/yt/memory/unittests/intrusive_ptr_ut.cpp
+++ b/library/cpp/yt/memory/unittests/intrusive_ptr_ut.cpp
@@ -5,6 +5,8 @@
 #include <library/cpp/yt/memory/serialize.h>
 
 #include <util/generic/buffer.h>
+#include <util/generic/hash_set.h>
+#include <util/generic/set.h>
 
 #include <util/stream/buffer.h>
 
@@ -635,6 +637,96 @@ TEST(TIntrusivePtrTest, TestObjectConstructionFail)
     ASSERT_THROW(New<TObjectWithExceptionInConstructor>(), int);
 }
 
+TEST(TIntrusivePtrTest, TestConstCast)
+{
+    struct TUi64Pair final
+    {
+        ui64 First;
+        ui64 Second;
+
+        bool operator==(const TUi64Pair&) const = default;
+    };
+
+    auto ptr = New<TUi64Pair>(TUi64Pair{1, 2});
+    TIntrusivePtr<const TUi64Pair> constPtr = ptr;
+    EXPECT_EQ(ptr.Get(), constPtr.Get());
+    EXPECT_EQ(*ptr, *constPtr);
+}
+
+TEST(TIntrusivePtrTest, HeterogeneousLookup)
+{
+    TIntricateObject object;
+    TIntricateObject object2;
+    auto ptr = TIntricateObjectPtr(&object);
+    auto ptr2 = TIntricateObjectPtr(&object2);
+    EXPECT_EQ(ptr->Increments, 1);
+    EXPECT_EQ(ptr2->Increments, 1);
+
+    {
+        THashSet<TIntricateObjectPtr> set;
+        set.insert(ptr);
+
+        EXPECT_TRUE(set.contains(ptr.Get()));
+        EXPECT_FALSE(set.contains(ptr2.Get()));
+
+        EXPECT_EQ(ptr->Increments, 2);
+        EXPECT_EQ(ptr2->Increments, 1);
+
+        EXPECT_FALSE(set.contains((TIntricateObject*)0xDEADBEEF));
+    }
+
+    {
+        TSet<TIntricateObjectPtr> set;
+        set.insert(ptr);
+
+        EXPECT_TRUE(set.contains(ptr.Get()));
+        EXPECT_FALSE(set.contains(ptr2.Get()));
+
+        EXPECT_EQ(ptr->Increments, 3);
+        EXPECT_EQ(ptr2->Increments, 1);
+
+        EXPECT_FALSE(set.contains((TIntricateObject*)0xDEADBEEF));
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+#ifdef YT_ENABLE_REF_COUNTED_SIGNATURE
+
+TEST(TRefCountedSignatureTest, FinalType)
+{
+    // Final, non-derived type: New lays a TRefCounter right before the object.
+    struct TObject final
+    {
+        ui64 Data = 0;
+    };
+
+    auto obj = New<TObject>();
+    const auto* refCounter = GetRefCounter(obj.Get());
+
+    // The signature is salted purely by the counter's own address.
+    EXPECT_EQ(refCounter->GetSignature(), NDetail::ComputeRefCountedAliveSignature(refCounter));
+    EXPECT_NE(refCounter->GetSignature(), NDetail::RefCountedDeadSignatureMagic);
+}
+
+TEST(TRefCountedSignatureTest, DerivedType)
+{
+    // Polymorphic (TRefCounted-derived) type: the counter is a base subobject.
+    struct TObject
+        : public TRefCounted
+    {
+        ui64 Data = 0;
+    };
+
+    auto obj = New<TObject>();
+    const auto* refCounter = GetRefCounter(obj.Get());
+
+    EXPECT_EQ(refCounter->GetSignature(), NDetail::ComputeRefCountedAliveSignature(refCounter));
+    EXPECT_NE(refCounter->GetSignature(), NDetail::RefCountedDeadSignatureMagic);
+}
+
+#endif
+
 ////////////////////////////////////////////////////////////////////////////////
 
 } // namespace
diff --git a/library/cpp/yt/memory/unittests/non_null_ptr_ut.cpp b/library/cpp/yt/memory/unittests/non_null_ptr_ut.cpp
new file mode 100644
index 00000000000..364a2f4ca27
--- /dev/null
+++ b/library/cpp/yt/memory/unittests/non_null_ptr_ut.cpp
@@ -0,0 +1,139 @@
+#include <library/cpp/testing/gtest/gtest.h>
+
+#include <library/cpp/yt/memory/new.h>
+#include <library/cpp/yt/memory/non_null_ptr.h>
+#include <library/cpp/yt/memory/ref_counted.h>
+
+namespace NYT {
+namespace {
+
+////////////////////////////////////////////////////////////////////////////////
+
+enum class EFuncResult
+{
+    Base,
+    ConstBase,
+    Derived,
+    ConstDerived,
+};
+
+enum class EBinaryFuncResult
+{
+    OK,
+    NotOK,
+};
+
+struct TBase
+{ };
+
+struct TDerived
+    : public TBase
+{ };
+
+EFuncResult Foo(TNonNullPtr<TBase> /*base*/)
+{
+    return EFuncResult::Base;
+}
+
+EFuncResult Foo(TNonNullPtr<const TBase> /*base*/)
+{
+    return EFuncResult::ConstBase;
+}
+
+EFuncResult Foo(TNonNullPtr<TDerived> /*derived*/)
+{
+    return EFuncResult::Derived;
+}
+
+EFuncResult Foo(TNonNullPtr<const TDerived> /*derived*/)
+{
+    return EFuncResult::ConstDerived;
+}
+
+[[maybe_unused]] EBinaryFuncResult Foo(int* /*derived*/)
+{
+    return EBinaryFuncResult::NotOK;
+}
+
+EBinaryFuncResult Foo(TNonNullPtr<int> /*derived*/)
+{
+    return EBinaryFuncResult::OK;
+}
+
+EBinaryFuncResult Bar(TNonNullPtr<const int> /*arg*/)
+{
+    return EBinaryFuncResult::OK;
+}
+
+EBinaryFuncResult Baz(TNonNullPtr<int> /*arg*/)
+{
+    return EBinaryFuncResult::OK;
+}
+
+class TClass
+    : public TRefCounted
+{
+public:
+    TClass() = default;
+};
+
+EBinaryFuncResult Bar(TNonNullPtr<TClass> /*arg*/)
+{
+    return EBinaryFuncResult::OK;
+}
+
+EBinaryFuncResult Baz(TNonNullPtr<const TClass> /*arg*/)
+{
+    return EBinaryFuncResult::OK;
+}
+
+TEST(TNonNullPtrTest, Simple)
+{
+    TDerived derived{};
+    const auto& constDerived = derived;
+    EXPECT_EQ(EFuncResult::Derived, Foo(GetPtr(derived)));
+    EXPECT_EQ(EFuncResult::ConstDerived, Foo(GetPtr(constDerived)));
+
+    TBase base{};
+    const auto& constBase = base;
+    EXPECT_EQ(EFuncResult::Base, Foo(GetPtr(base)));
+    EXPECT_EQ(EFuncResult::ConstBase, Foo(GetPtr(constBase)));
+
+    int i{};
+    EXPECT_EQ(EBinaryFuncResult::OK, Foo(GetPtr(i)));
+}
+
+TEST(TNonNullPtrTest, CastToConst)
+{
+    int i{};
+
+    EXPECT_EQ(EBinaryFuncResult::OK, Bar(GetPtr(i)));
+}
+
+TEST(TNonNullPtrTest, ConstructionFromRawPointer)
+{
+    int i{};
+
+    EXPECT_EQ(EBinaryFuncResult::OK, Baz(&i));
+}
+
+TEST(TNonNullPtrTest, ConstructionFromIntrusivePtr)
+{
+    TIntrusivePtr<TClass> obj = New<TClass>();
+    EXPECT_EQ(EBinaryFuncResult::OK, Bar(obj));
+}
+
+TEST(TNonNullPtrTest, ConstructionConstFromIntrusivePtr)
+{
+    TIntrusivePtr<TClass> obj1 = New<TClass>();
+    TNonNullPtr<TClass> obj1Ptr = obj1;
+    EXPECT_EQ(EBinaryFuncResult::OK, Baz(obj1Ptr));
+
+    TIntrusivePtr<const TClass> obj2 = obj1;
+    EXPECT_EQ(EBinaryFuncResult::OK, Baz(obj2));
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace
+} // namespace NYT
diff --git a/library/cpp/yt/memory/unittests/range_protobuf_repeated_field_ut.cpp b/library/cpp/yt/memory/unittests/range_protobuf_repeated_field_ut.cpp
new file mode 100644
index 00000000000..35581468a4e
--- /dev/null
+++ b/library/cpp/yt/memory/unittests/range_protobuf_repeated_field_ut.cpp
@@ -0,0 +1,76 @@
+#include <library/cpp/testing/gtest/gtest.h>
+
+#include <library/cpp/testing/gtest_extensions/assertions.h>
+
+#include <library/cpp/yt/memory/range.h>
+#include <vector>
+
+namespace {
+
+////////////////////////////////////////////////////////////////////////////////
+
+/*
+    Test build
+    https://a.yandex-team.ru/arcadia/yt/yt/library/backtrace_introspector/introspect.cpp?rev=r14560536#L165
+*/
+
+TEST(TRangeVector, ImmutableRange)
+{
+    std::vector<const void*> backtrace;
+    [[maybe_unused]] auto range = NYT::TRange(backtrace);
+}
+
+TEST(TRangeVector, MutableRange)
+{
+    std::vector<const void*> backtrace;
+    [[maybe_unused]] auto range = NYT::TMutableRange(backtrace);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+/*
+    Test build
+    https://a.yandex-team.ru/arcadia/yt/yt/library/oom/oom.cpp?rev=r14560536#L112
+*/
+
+static const char* TDummyStringArray[] = {
+    "xxx",
+    "yyy",
+    "zzz",
+};
+
+TEST(TRangeArrayOfStrings, ImmutableRange)
+{
+    [[maybe_unused]] auto range = NYT::TRange(TDummyStringArray);
+}
+
+TEST(TRangeArrayOfStrings, MutableRange)
+{
+    [[maybe_unused]] auto range = NYT::TMutableRange(TDummyStringArray);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+/*
+    Test build
+    https://a.yandex-team.ru/arcadia/yt/yt/orm/server/access_control/object_cluster.cpp?rev=r14560536#L188
+*/
+
+TEST(TRangeRawPtr, ImmutableRange)
+{
+    struct TDummyData{};
+    TDummyData** ptr = nullptr;
+    constexpr int size = 0x10;
+    [[maybe_unused]] auto range = NYT::TRange<TDummyData*>(ptr, size);
+}
+
+TEST(TRangeRawPtr, MutableRange)
+{
+    struct TDummyData{};
+    TDummyData** ptr = nullptr;
+    constexpr int size = 0x10;
+    [[maybe_unused]] auto range = NYT::TMutableRange<TDummyData*>(ptr, size);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+} // namespace
diff --git a/library/cpp/yt/memory/unittests/ref_ut.cpp b/library/cpp/yt/memory/unittests/ref_ut.cpp
index 8ecd57e15d2..175ca2bb00e 100644
--- a/library/cpp/yt/memory/unittests/ref_ut.cpp
+++ b/library/cpp/yt/memory/unittests/ref_ut.cpp
@@ -4,6 +4,8 @@
 
 #include <library/cpp/yt/memory/ref.h>
 
+#include <util/generic/size_literals.h>
+
 namespace NYT::NYson {
 namespace {
 
@@ -11,12 +13,95 @@ namespace {
 
 TEST(TSharedRefTest, Save)
 {
-    const TSharedRef expected = TSharedRef::FromString("My tests data");
+    const TSharedRef expected = TSharedRef::FromString(std::string("My tests data"));
     TStringStream s;
     ::Save(&s, expected);  // only Save supported for TSharedRef. You can ::Load serialized data to vector.
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
+constexpr char Payload = 0x42;
+
+TEST(TSharedMutableRefTest, Allocate)
+{
+    auto ref = TSharedMutableRef::Allocate(64_KB);
+    EXPECT_EQ(ref.Size(), 64_KB);
+
+    // InitializeStorage defaults to true.
+    for (char ch : ref) {
+        EXPECT_EQ(ch, 0);
+    }
+
+    // The whole range must be writable.
+    ::memset(ref.Begin(), Payload, ref.Size());
+    EXPECT_EQ(ref[0], Payload);
+    EXPECT_EQ(ref[ref.Size() - 1], Payload);
+}
+
+TEST(TSharedMutableRefTest, AllocateNoInitialize)
+{
+    auto ref = TSharedMutableRef::Allocate(64_KB, {.InitializeStorage = false});
+    EXPECT_EQ(ref.Size(), 64_KB);
+    ::memset(ref.Begin(), Payload, ref.Size());
+}
+
+TEST(TSharedMutableRefTest, AllocateExtendToUsableSize)
+{
+    auto ref = TSharedMutableRef::Allocate(64_KB, {.ExtendToUsableSize = true});
+    EXPECT_GE(ref.Size(), 64_KB);
+
+    // InitializeStorage defaults to true.
+    for (char ch : ref) {
+        EXPECT_EQ(ch, 0);
+    }
+
+    ::memset(ref.Begin(), Payload, ref.Size());
+    EXPECT_EQ(ref[ref.Size() - 1], Payload);
+}
+
+TEST(TSharedMutableRefTest, AllocateNoInitializeExtendToUsableSize)
+{
+    auto ref = TSharedMutableRef::Allocate(
+        64_KB,
+        {.InitializeStorage = false, .ExtendToUsableSize = true});
+    EXPECT_GE(ref.Size(), 64_KB);
+    ::memset(ref.Begin(), Payload, ref.Size());
+}
+
+TEST(TSharedMutableRefTest, AllocateViaMmap)
+{
+    auto ref = TSharedMutableRef::AllocateViaMmap(64_KB);
+    EXPECT_EQ(ref.Size(), 64_KB);
+
+    // InitializeStorage defaults to true.
+    for (char ch : ref) {
+        EXPECT_EQ(ch, 0);
+    }
+
+    // The whole range must be writable.
+    ::memset(ref.Begin(), Payload, ref.Size());
+    EXPECT_EQ(ref[0], Payload);
+    EXPECT_EQ(ref[ref.Size() - 1], Payload);
+}
+
+TEST(TSharedMutableRefTest, AllocateViaMmapNoInitialize)
+{
+    auto ref = TSharedMutableRef::AllocateViaMmap(64_KB, {.InitializeStorage = false});
+    EXPECT_EQ(ref.Size(), 64_KB);
+    ::memset(ref.Begin(), Payload, ref.Size());
+}
+
+TEST(TSharedMutableRefTest, AllocateViaMmapThp)
+{
+    // Larger than a single huge page to exercise the rounded-up mapping.
+    constexpr size_t Size = 5_MB;
+    auto ref = TSharedMutableRef::AllocateViaMmap(Size, {.UseThp = true});
+    EXPECT_EQ(ref.Size(), Size);
+    ::memset(ref.Begin(), Payload, ref.Size());
+    EXPECT_EQ(ref[Size - 1], Payload);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
 } // namespace
 } // namespace NYT::NYson
diff --git a/library/cpp/yt/memory/unittests/type_erasure_ut.cpp b/library/cpp/yt/memory/unittests/type_erasure_ut.cpp
new file mode 100644
index 00000000000..c923ec29a11
--- /dev/null
+++ b/library/cpp/yt/memory/unittests/type_erasure_ut.cpp
@@ -0,0 +1,361 @@
+#include <library/cpp/testing/gtest/gtest.h>
+
+#include <library/cpp/yt/memory/type_erasure.h>
+
+namespace NYT {
+namespace {
+
+////////////////////////////////////////////////////////////////////////////////
+
+struct TTestCpo1
+    : public TTagInvokeCpoBase<TTestCpo1>
+{ };
+
+inline constexpr TTestCpo1 TestCpo = {};
+
+struct TCustomized
+{
+    int Value = 42;
+
+    friend int TagInvoke(TTagInvokeTag<TestCpo>, const TCustomized& this_)
+    {
+        return this_.Value + 1;
+    }
+};
+
+struct TOtherCustomized
+{
+    friend int TagInvoke(TTagInvokeTag<TestCpo>, const TOtherCustomized&)
+    {
+        return 0;
+    }
+};
+
+////////////////////////////////////////////////////////////////////////////////
+
+// 2 CPOs won't trigger static vtable.
+static_assert(
+    sizeof(
+        TAnyRef<
+            TOverload<
+                TestCpo,
+                void(TErasedThis&)>,
+            TOverload<
+                TestCpo,
+                void(TErasedThis&&)>>)
+    == 3 * sizeof(intptr_t));
+
+// 3 CPOs trigger static vtable.
+static_assert(
+    sizeof(
+        TAnyRef<
+            TOverload<
+                TestCpo,
+                void(TErasedThis&)>,
+            TOverload<
+                TestCpo,
+                void(TErasedThis&&)>,
+            TOverload<
+                TestCpo,
+                void(TErasedThis, int)>>)
+    == 2 * sizeof(intptr_t));
+
+////////////////////////////////////////////////////////////////////////////////
+
+TEST(TAnyRefTest, JustWorks)
+{
+    using TAnyRef = TAnyRef<TOverload<TestCpo, int(const TErasedThis&)>>;
+    TCustomized concrete{.Value = 42};
+
+    TAnyRef any{concrete};
+    EXPECT_EQ(TestCpo(any), 43);
+
+    auto copy = any;
+    EXPECT_EQ(TestCpo(copy), 43);
+
+    auto movedOut = std::move(any);
+    EXPECT_EQ(TestCpo(movedOut), 43);
+}
+
+TEST(TAnyRefTest, EmptyRef)
+{
+    TCustomized concrete{.Value = 11};
+
+    TAnyRef<> any{concrete};
+
+    static_assert(!std::invocable<TTagInvokeTag<TestCpo>, decltype(any)>);
+    const auto& conc = any.AnyCast<TCustomized>();
+    EXPECT_EQ(conc.Value, 11);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+struct TNoCopy
+{
+    TNoCopy() = default;
+
+    TNoCopy(const TNoCopy&) = delete;
+
+    TNoCopy(TNoCopy&&) noexcept
+    { }
+
+    TNoCopy& operator=(TNoCopy&&) noexcept
+    {
+        return *this;
+    }
+
+    int Val = 123;
+};
+
+static_assert(std::movable<TNoCopy>);
+
+struct TCustomized2
+{
+    int Value = 1;
+    static inline int DtorCount = 0;
+
+    TCustomized2() = default;
+
+    TCustomized2(const TCustomized2&)
+    { }
+
+    TCustomized2& operator=(const TCustomized2&)
+    {
+        return *this;
+    }
+
+    TCustomized2(TCustomized2&& other) noexcept
+        : Value(other.Value)
+    {
+        other.Value = -1;
+    }
+
+    TCustomized2& operator=(TCustomized2&& other) noexcept
+    {
+        if (this == &other) {
+            return *this;
+        }
+
+        Value = std::exchange(other.Value, -1);
+        return *this;
+    }
+
+    ~TCustomized2()
+    {
+        ++DtorCount;
+    }
+
+    friend const TNoCopy& TagInvoke(TTagInvokeTag<TestCpo>, TCustomized2&)
+    {
+        static TNoCopy noCp;
+        noCp.Val = 11;
+        return noCp;
+    }
+
+    friend int TagInvoke(TTagInvokeTag<TestCpo>, TCustomized2&& this_)
+    {
+        auto v = std::move(this_);
+
+        return 1212;
+    }
+
+    friend int TagInvoke(TTagInvokeTag<TestCpo>, TCustomized2&, int)
+    {
+        return 42;
+    }
+};
+
+static_assert(std::copyable<TCustomized2>);
+
+////////////////////////////////////////////////////////////////////////////////
+
+TEST(TAnyRefTest, CvRefCorrectness)
+{
+    using TAnyRef = TAnyRef<
+        TOverload<TestCpo, const TNoCopy&(TErasedThis&)>,
+        TOverload<TestCpo, int(TErasedThis&&)>>;
+
+    TCustomized2 cust = {};
+
+    cust.DtorCount = 0;
+    EXPECT_EQ(cust.Value, 1);
+
+    {
+        TAnyRef ref{cust};
+
+        EXPECT_EQ(TestCpo(ref).Val, 11);
+    }
+
+    EXPECT_EQ(cust.DtorCount, 0);
+    EXPECT_EQ(cust.Value, 1);
+
+    {
+        TAnyRef ref(cust);
+
+        EXPECT_EQ(TestCpo(std::move(ref)), 1212);
+    }
+
+    EXPECT_EQ(cust.DtorCount, 1);
+    EXPECT_EQ(cust.Value, -1);
+
+    cust.Value = 1;
+    TAnyRef any{cust};
+    {
+        TAnyRef copy{any};
+        TAnyRef movedOut{std::move(any)};
+        EXPECT_EQ(TestCpo(copy).Val, 11);
+        EXPECT_EQ(TestCpo(movedOut).Val, 11);
+    }
+
+    EXPECT_EQ(cust.DtorCount, 1);
+    EXPECT_EQ(cust.Value, 1);
+}
+
+TEST(TAnyRefTest, StaticVTableForAnyRef)
+{
+    using TAnyRef = TAnyRef<
+        TOverload<TestCpo, const TNoCopy&(TErasedThis&)>,
+        TOverload<TestCpo, int(TErasedThis&&)>,
+        TOverload<TestCpo, int(TErasedThis&, int)>
+    >;
+
+    TCustomized2 cst = {};
+    cst.Value = 1111;
+    cst.DtorCount = 0;
+
+    TAnyRef any{cst};
+    {
+        TAnyRef copy{any};
+        TAnyRef movedOut{std::move(any)};
+        EXPECT_EQ(TestCpo(copy).Val, 11);
+        EXPECT_EQ(TestCpo(movedOut).Val, 11);
+    }
+    EXPECT_EQ(cst.Value, 1111);
+    EXPECT_EQ(cst.DtorCount, 0);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+TEST(TAnyObjectTest, JustWorks)
+{
+    TCustomized concrete{.Value = 42};
+
+    TAnyObject<TOverload<TestCpo, int(const TErasedThis&)>> any{concrete};
+    EXPECT_EQ(TestCpo(any), 43);
+
+    auto copy = any;
+    EXPECT_EQ(TestCpo(copy), 43);
+
+    auto movedOut = std::move(any);
+    EXPECT_EQ(TestCpo(movedOut), 43);
+}
+
+TEST(TAnyObjectTest, EmptyAny)
+{
+    TCustomized concrete{.Value = 11};
+
+    TAnyObject<> any{concrete};
+
+    static_assert(!std::invocable<TTagInvokeTag<TestCpo>, decltype(any)>);
+    const auto& conc = any.AnyCast<TCustomized>();
+    EXPECT_EQ(conc.Value, 11);
+}
+
+TEST(TAnyObjectTest, Holds)
+{
+    using TAnyObject = TAnyObject<TOverload<TestCpo, int(const TErasedThis&)>>;
+
+    TAnyObject any{TCustomized{.Value = 42}};
+    EXPECT_TRUE(any.Holds<TCustomized>());
+    EXPECT_FALSE(any.Holds<TOtherCustomized>());
+
+    TAnyObject other{TOtherCustomized{}};
+    EXPECT_TRUE(other.Holds<TOtherCustomized>());
+    EXPECT_FALSE(other.Holds<TCustomized>());
+
+    TAnyObject empty;
+    EXPECT_FALSE(empty.Holds<TCustomized>());
+}
+
+TEST(TAnyObjectTest, CvRefCorrectness)
+{
+    using TAnyObject = TAnyObject<
+        TOverload<TestCpo, const TNoCopy&(TErasedThis&)>,
+        TOverload<TestCpo, int(TErasedThis&&)>>;
+
+    TCustomized2 cust = {};
+
+    cust.DtorCount = 0;
+    EXPECT_EQ(cust.Value, 1);
+
+    {
+        TAnyObject any{cust};
+
+        EXPECT_EQ(TestCpo(any).Val, 11);
+    }
+
+    // Any object itself.
+    EXPECT_EQ(cust.DtorCount, 1);
+    EXPECT_EQ(cust.Value, 1);
+
+    {
+        TAnyObject any(cust);
+
+        EXPECT_EQ(TestCpo(std::move(any)), 1212);
+    }
+
+    // Second any object + moved out object.
+    EXPECT_EQ(cust.DtorCount, 3);
+    EXPECT_EQ(cust.Value, 1);
+
+    TAnyObject any{cust};
+    {
+        TAnyObject copy{any};
+        TAnyObject movedOut{std::move(any)};
+        EXPECT_EQ(TestCpo(copy).Val, 11);
+        EXPECT_EQ(TestCpo(movedOut).Val, 11);
+    }
+
+    // NB(arkady-e1ppa): Moved out any should be
+    // actually empty thus moving out both moves object out
+    // and destroys the moved out object.
+    EXPECT_EQ(cust.DtorCount, 6);
+    EXPECT_THROW(any.AnyCast<TCustomized2>(), NDetail::TBadAnyCast);
+}
+
+TEST(TAnyObjectTest, StaticVTableForAnyRef)
+{
+    using TAnyObject = TAnyObject<
+        TOverload<TestCpo, const TNoCopy&(TErasedThis&)>,
+        TOverload<TestCpo, int(TErasedThis&&)>,
+        TOverload<TestCpo, int(TErasedThis&, int)>
+    >;
+
+    TCustomized2 cst = {};
+    cst.Value = 1111;
+    cst.DtorCount = 0;
+
+    TAnyObject any{cst};
+    {
+        TAnyObject copy{any};
+        TAnyObject movedOut{std::move(any)};
+        EXPECT_EQ(TestCpo(copy).Val, 11);
+        EXPECT_EQ(TestCpo(movedOut).Val, 11);
+    }
+    EXPECT_EQ(cst.Value, 1111);
+    // NB(arkady-e1ppa): See comment in previous test.
+    EXPECT_EQ(cst.DtorCount, 3);
+    EXPECT_FALSE(any.IsValid());
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+TEST(TAnyObjectTest, AnyMoveOnly)
+{
+    TAnyUnique<> any{std::in_place_type<TNoCopy>};
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace
+} // namespace NYT
diff --git a/library/cpp/yt/memory/unittests/weak_ptr_ut.cpp b/library/cpp/yt/memory/unittests/weak_ptr_ut.cpp
index f19809100fe..cfb269d5f02 100644
--- a/library/cpp/yt/memory/unittests/weak_ptr_ut.cpp
+++ b/library/cpp/yt/memory/unittests/weak_ptr_ut.cpp
@@ -2,8 +2,10 @@
 
 #include <library/cpp/yt/memory/new.h>
 #include <library/cpp/yt/memory/weak_ptr.h>
+#include <library/cpp/yt/threading/event_count.h>
 
 #include <array>
+#include <thread>
 
 namespace NYT {
 namespace {
@@ -18,8 +20,10 @@ using ::testing::StrictMock;
 // Auxiliary types and functions.
 ////////////////////////////////////////////////////////////////////////////////
 
-static int ConstructorShadowState = 0;
-static int DestructorShadowState = 0;
+static std::atomic<int> ConstructorShadowState = 0;
+static std::atomic<int> DestructorShadowState = 0;
+
+std::unique_ptr<NThreading::TEvent> DeathEvent;
 
 void ResetShadowState()
 {
@@ -58,9 +62,9 @@ class TIntricateObject
 private:
     // Explicitly non-copyable.
     TIntricateObject(const TIntricateObject&);
-    TIntricateObject(TIntricateObject&&);
+    TIntricateObject(TIntricateObject&&) noexcept;
     TIntricateObject& operator=(const TIntricateObject&);
-    TIntricateObject& operator=(TIntricateObject&&);
+    TIntricateObject& operator=(TIntricateObject&&) noexcept;
 };
 
 using TIntricateObjectPtr = TIntrusivePtr<TIntricateObject>;
@@ -304,7 +308,8 @@ TEST_F(TWeakPtrTest, IsEmpty)
 {
     TIntricateObjectWkPtr ptr;
 
-    EXPECT_TRUE(ptr == nullptr);
+    EXPECT_EQ(ptr.Get(), nullptr);
+    EXPECT_TRUE(ptr.IsExpired());
 }
 
 TEST_F(TWeakPtrTest, UpCast)
@@ -346,9 +351,9 @@ class TIntricateObjectVirtual
 private:
     // Explicitly non-copyable.
     TIntricateObjectVirtual(const TIntricateObjectVirtual&);
-    TIntricateObjectVirtual(TIntricateObjectVirtual&&);
+    TIntricateObjectVirtual(TIntricateObjectVirtual&&) noexcept;
     TIntricateObjectVirtual& operator=(const TIntricateObjectVirtual&);
-    TIntricateObjectVirtual& operator=(TIntricateObjectVirtual&&);
+    TIntricateObjectVirtual& operator=(TIntricateObjectVirtual&&) noexcept;
 };
 
 TEST_F(TWeakPtrTest, VirtualBase)
@@ -360,7 +365,6 @@ TEST_F(TWeakPtrTest, VirtualBase)
     ptr.Reset();
 }
 
-#if 0
 class TSlowlyDyingObject
     : public TRefCounted
 {
@@ -386,17 +390,12 @@ void PrintTo(const TSlowlyDyingObject& arg, ::std::ostream* os)
 using TSlowlyDyingObjectPtr = TIntrusivePtr<TSlowlyDyingObject>;
 using TSlowlyDyingObjectWkPtr = TWeakPtr<TSlowlyDyingObject>;
 
-static void* AsynchronousDeleter(void* param)
+static void AsynchronousDeleter(TSlowlyDyingObjectPtr& indirectObject)
 {
-    TSlowlyDyingObjectPtr* indirectObject =
-        reinterpret_cast<TSlowlyDyingObjectPtr*>(param);
-    indirectObject->Reset();
-    return nullptr;
+    indirectObject.Reset();
 }
 
-std::unique_ptr<NThreading::TEvent> DeathEvent;
-
-TEST_F(TWeakPtrTest, DISABLED_AcquisionOfSlowlyDyingObject)
+TEST_F(TWeakPtrTest, AcquisitionOfSlowlyDyingObject)
 {
     DeathEvent.reset(new NThreading::TEvent());
 
@@ -412,8 +411,7 @@ TEST_F(TWeakPtrTest, DISABLED_AcquisionOfSlowlyDyingObject)
     ASSERT_EQ(0, DestructorShadowState);
 
     // Kick off object deletion in the background.
-    TThread thread(&AsynchronousDeleter, &object);
-    thread.Start();
+    std::thread thread(AsynchronousDeleter, std::ref(object));
     Sleep(TDuration::Seconds(0.100));
 
     ASSERT_EQ(1, ConstructorShadowState);
@@ -424,7 +422,7 @@ TEST_F(TWeakPtrTest, DISABLED_AcquisionOfSlowlyDyingObject)
 
     // Finalize object destruction.
     DeathEvent->NotifyAll();
-    thread.Join();
+    thread.join();
 
     ASSERT_EQ(1, ConstructorShadowState);
     ASSERT_EQ(2, DestructorShadowState);
@@ -432,7 +430,62 @@ TEST_F(TWeakPtrTest, DISABLED_AcquisionOfSlowlyDyingObject)
     EXPECT_EQ(TSlowlyDyingObjectPtr(), ptr.Lock());
 }
 
-#endif
+////////////////////////////////////////////////////////////////////////////////
+
+constexpr int Depth = 10;
+constexpr int Attempts = 1000;
+volatile int SomeNumbers[Depth + 1];
+
+template <int N>
+class TClassStack;
+
+template <>
+class TClassStack<0>
+    : public virtual TRefCounted
+{
+public:
+    virtual int Get() const
+    {
+        return SomeNumbers[0];
+    }
+    virtual ~TClassStack()
+    {
+        SomeNumbers[0] = Get() + 1;
+    }
+};
+
+template <int N>
+class TClassStack
+    : public TClassStack<N - 1>
+{
+public:
+    virtual int Get() const override
+    {
+        return SomeNumbers[N];
+    }
+    virtual ~TClassStack()
+    {
+        SomeNumbers[N] = Get() + 1;
+    }
+};
+
+using TClassStackObject = TClassStack<Depth>;
+using TClassStackPtr = TIntrusivePtr<TClassStackObject>;
+using TClassStackWeakPtr = TWeakPtr<TClassStackObject>;
+
+TEST_F(TWeakPtrTest, WeakVirtualRef)
+{
+    for (int i = 0; i < Attempts; i++) {
+        auto strong = New<TClassStackObject>();
+        TClassStackWeakPtr weak(strong);
+        std::thread thread([&] {
+            TClassStackWeakPtr copy(weak);
+            copy.Lock();
+        });
+        strong.Reset();
+        thread.join();
+    }
+}
 
 ////////////////////////////////////////////////////////////////////////////////
 
diff --git a/library/cpp/yt/memory/weak_ptr-inl.h b/library/cpp/yt/memory/weak_ptr-inl.h
new file mode 100644
index 00000000000..0e5ad795774
--- /dev/null
+++ b/library/cpp/yt/memory/weak_ptr-inl.h
@@ -0,0 +1,356 @@
+#ifndef WEAK_PTR_INL_H_
+#error "Direct inclusion of this file is not allowed, include weak_ptr.h"
+// For the sake of sane code completion.
+#include "weak_ptr.h"
+#endif
+
+#include <util/system/sanitizers.h>
+
+namespace NYT {
+
+////////////////////////////////////////////////////////////////////////////////
+
+template <class T>
+TWeakPtr<T>::TWeakPtr(std::nullptr_t)
+{ }
+
+template <class T>
+TWeakPtr<T>::TWeakPtr(T* p) noexcept
+    : T_(p)
+{
+#if defined(_tsan_enabled_) || defined(_msan_enabled_)
+    if (T_) {
+        // p may legitimately point to an object whose destructor has already run
+        // while its ref-counter is still alive (weak count > 0). When T derives
+        // from TRefCounted virtually, the upcast below reads p's vptr, poisoned
+        // by -fsanitize-memory-use-after-dtor. Unpoison it (no-op for a live object).
+        NSan::Unpoison(T_, sizeof(void*));
+        RefCounter_ = GetRefCounter(T_);
+    }
+#endif
+    AcquireRef();
+}
+
+template <class T>
+TWeakPtr<T>::TWeakPtr(const TIntrusivePtr<T>& ptr) noexcept
+    : TWeakPtr(ptr.Get())
+{ }
+
+template <class T>
+template <class U, class>
+TWeakPtr<T>::TWeakPtr(const TIntrusivePtr<U>& ptr) noexcept
+    : TWeakPtr(ptr.Get())
+{
+    static_assert(
+        std::derived_from<T, TRefCountedBase>,
+        "Cast allowed only for types derived from TRefCountedBase");
+}
+
+template <class T>
+TWeakPtr<T>::TWeakPtr(const TWeakPtr& other) noexcept
+    : T_(other.T_)
+#if defined(_tsan_enabled_) || defined(_msan_enabled_)
+    , RefCounter_(other.RefCounter_)
+#endif
+{
+    AcquireRef();
+}
+
+template <class T>
+template <class U, class>
+TWeakPtr<T>::TWeakPtr(const TWeakPtr<U>& other) noexcept
+    : TWeakPtr(other.Lock())
+{
+    static_assert(
+        std::derived_from<T, TRefCountedBase>,
+        "Cast allowed only for types derived from TRefCountedBase");
+}
+
+template <class T>
+TWeakPtr<T>::TWeakPtr(TWeakPtr&& other) noexcept
+{
+    other.Swap(*this);
+}
+
+template <class T>
+template <class U, class>
+TWeakPtr<T>::TWeakPtr(TWeakPtr<U>&& other) noexcept
+{
+    static_assert(
+        std::derived_from<T, TRefCountedBase>,
+        "Cast allowed only for types derived from TRefCountedBase");
+    TIntrusivePtr<U> strongOther = other.Lock();
+    if (strongOther) {
+        T_ = other.T_;
+        other.T_ = nullptr;
+
+#if defined(_tsan_enabled_) || defined(_msan_enabled_)
+        RefCounter_ = other.RefCounter_;
+        other.RefCounter_ = nullptr;
+#endif
+    }
+}
+
+template <class T>
+TWeakPtr<T>::~TWeakPtr()
+{
+    ReleaseRef();
+}
+
+template <class T>
+template <class U>
+TWeakPtr<T>& TWeakPtr<T>::operator=(const TIntrusivePtr<U>& ptr) noexcept
+{
+    static_assert(
+        std::is_convertible_v<U*, T*>,
+        "U* must be convertible to T*");
+    TWeakPtr(ptr).Swap(*this);
+    return *this;
+}
+
+template <class T>
+TWeakPtr<T>& TWeakPtr<T>::operator=(const TWeakPtr& other) noexcept
+{
+    TWeakPtr(other).Swap(*this);
+    return *this;
+}
+
+template <class T>
+template <class U>
+TWeakPtr<T>& TWeakPtr<T>::operator=(const TWeakPtr<U>& other) noexcept
+{
+    static_assert(
+        std::is_convertible_v<U*, T*>,
+        "U* must be convertible to T*");
+    TWeakPtr(other).Swap(*this);
+    return *this;
+}
+
+template <class T>
+TWeakPtr<T>& TWeakPtr<T>::operator=(TWeakPtr&& other) noexcept
+{
+    other.Swap(*this);
+    return *this;
+}
+
+template <class T>
+template <class U>
+TWeakPtr<T>& TWeakPtr<T>::operator=(TWeakPtr<U>&& other) noexcept
+{
+    static_assert(
+        std::is_convertible_v<U*, T*>,
+        "U* must be convertible to T*");
+    TWeakPtr(std::move(other)).Swap(*this);
+    return *this;
+}
+
+template <class T>
+void TWeakPtr<T>::Reset() // noexcept
+{
+    TWeakPtr().Swap(*this);
+}
+
+template <class T>
+void TWeakPtr<T>::Reset(T* p) // noexcept
+{
+    TWeakPtr(p).Swap(*this);
+}
+
+template <class T>
+template <class U>
+void TWeakPtr<T>::Reset(const TIntrusivePtr<U>& ptr) // noexcept
+{
+    static_assert(
+        std::is_convertible_v<U*, T*>,
+        "U* must be convertible to T*");
+    TWeakPtr(ptr).Swap(*this);
+}
+
+template <class T>
+void TWeakPtr<T>::Swap(TWeakPtr& other) noexcept
+{
+    DoSwap(T_, other.T_);
+#if defined(_tsan_enabled_) || defined(_msan_enabled_)
+    DoSwap(RefCounter_, other.RefCounter_);
+#endif
+}
+
+template <class T>
+TIntrusivePtr<T> TWeakPtr<T>::Lock() const noexcept
+{
+    return T_ && GetRefCounterImpl()->TryRef()
+        ? TIntrusivePtr<T>(T_, false)
+        : TIntrusivePtr<T>();
+}
+
+template <class T>
+bool TWeakPtr<T>::IsExpired() const noexcept
+{
+    return !T_ || (GetRefCounterImpl()->GetRefCount() == 0);
+}
+
+template <class T>
+T* TWeakPtr<T>::Get() const noexcept
+{
+    return T_;
+}
+
+template <class T>
+const TRefCounter* TWeakPtr<T>::TryGetRefCounterImpl() const
+{
+    return T_ ? GetRefCounterImpl() : nullptr;
+}
+
+template <class T>
+void TWeakPtr<T>::AcquireRef()
+{
+    if (T_) {
+        GetRefCounterImpl()->WeakRef();
+    }
+}
+
+template <class T>
+void TWeakPtr<T>::ReleaseRef()
+{
+    if (T_) {
+        // Support incomplete type.
+        if (GetRefCounterImpl()->WeakUnref()) {
+            // The object's destructor has fully completed at this point
+            // and has poisoned T_'s vptr word under -fsanitize-memory-use-after-dtor.
+            // The upcast inside DeallocateRefCounted still needs that word
+            // to locate the virtual base.
+            NSan::Unpoison(T_, sizeof(void*));
+            DeallocateRefCounted(T_);
+        }
+    }
+}
+
+#if defined(_tsan_enabled_) || defined(_msan_enabled_)
+template <class T>
+const TRefCounter* TWeakPtr<T>::GetRefCounterImpl() const
+{
+    return RefCounter_;
+}
+#else
+template <class T>
+const TRefCounter* TWeakPtr<T>::GetRefCounterImpl() const
+{
+    return GetRefCounter(T_);
+}
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
+
+template <class T1, class T2>
+bool operator==(const TWeakPtr<T1>& lhs, const TWeakPtr<T2>& rhs)
+{
+    return lhs.Get() == rhs.Get();
+}
+
+template <class T1, class T2>
+bool operator==(const TIntrusivePtr<T1>& lhs, const TWeakPtr<T2>& rhs)
+{
+    return lhs.Get() == rhs.Get();
+}
+
+template <class T1, class T2>
+bool operator==(const TWeakPtr<T1>& lhs, const TIntrusivePtr<T2>& rhs)
+{
+    return lhs.Get() == rhs.Get();
+}
+
+template <class T1, class T2>
+bool operator==(T1* lhs, const TWeakPtr<T2>& rhs)
+{
+    return lhs == rhs.Get();
+}
+
+template <class T1, class T2>
+bool operator==(const TWeakPtr<T1>& lhs, T2* rhs)
+{
+    return lhs.Get() == rhs;
+}
+
+template <class T2>
+bool operator==(std::nullptr_t, const TWeakPtr<T2>& rhs)
+{
+    return nullptr == rhs.Get();
+}
+
+template <class T1>
+bool operator==(const TWeakPtr<T1>& lhs, std::nullptr_t)
+{
+    return lhs.Get() == nullptr;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+template <class T>
+TWeakPtr<T> MakeWeak(T* p)
+{
+    return TWeakPtr<T>(p);
+}
+
+template <class T>
+TWeakPtr<T> MakeWeak(const TIntrusivePtr<T>& p)
+{
+    return TWeakPtr<T>(p);
+}
+
+template <typename T>
+int ResetAndGetResidualRefCount(TIntrusivePtr<T>& pointer)
+{
+    auto weakPointer = MakeWeak(pointer);
+    pointer.Reset();
+    pointer = weakPointer.Lock();
+    if (pointer) {
+        // This _may_ return 0 if we are again the only holder of the pointee.
+        return pointer->GetRefCount() - 1;
+    } else {
+        return 0;
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+template <class T>
+std::size_t TTransparentWeakPtrHasher::operator()(const TWeakPtr<T>& ptr) const
+{
+    return THash<const NYT::TRefCountedBase*>()(ptr.Get());
+}
+
+template <class T>
+std::size_t TTransparentWeakPtrHasher::operator()(const TIntrusivePtr<T>& ptr) const
+{
+    return THash<const NYT::TRefCountedBase*>()(ptr.Get());
+}
+
+template <class T>
+std::size_t TTransparentWeakPtrHasher::operator()(T* ptr) const
+{
+    return THash<const NYT::TRefCountedBase*>()(ptr);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+//! Abseil hash support for TWeakPtr.
+template <class THash, class T>
+THash AbslHashValue(THash hash, const TWeakPtr<T>& ptr)
+{
+    return THash::combine(std::move(hash), ptr.Get());
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace NYT
+
+////////////////////////////////////////////////////////////////////////////////
+
+//! A hasher for TWeakPtr.
+template <class T>
+size_t THash<NYT::TWeakPtr<T>>::operator()(const NYT::TWeakPtr<T>& ptr) const
+{
+    return THash<const NYT::TRefCountedBase*>()(ptr.Get());
+}
+
+////////////////////////////////////////////////////////////////////////////////
diff --git a/library/cpp/yt/memory/weak_ptr.h b/library/cpp/yt/memory/weak_ptr.h
index c647198aaf5..c98abe15194 100644
--- a/library/cpp/yt/memory/weak_ptr.h
+++ b/library/cpp/yt/memory/weak_ptr.h
@@ -13,245 +13,136 @@ class TWeakPtr
 {
 public:
     using TUnderlying = T;
+    using element_type = T;
 
-    //! Empty constructor.
+    //! Default constructor.
     TWeakPtr() = default;
 
-    TWeakPtr(std::nullptr_t)
-    { }
+    //! Null constructor.
+    TWeakPtr(std::nullptr_t);
 
     //! Constructor from an unqualified reference.
     /*!
      * Note that this constructor could be racy due to unsynchronized operations
      * on the object and on the counter.
      */
-    explicit TWeakPtr(T* p) noexcept
-        : T_(p)
-    {
-
-#if defined(_tsan_enabled_)
-        if (T_) {
-            RefCounter_ = GetRefCounter(T_);
-        }
-#endif
-        AcquireRef();
-    }
+    explicit TWeakPtr(T* p) noexcept;
 
     //! Constructor from a strong reference.
-    TWeakPtr(const TIntrusivePtr<T>& ptr) noexcept
-        : TWeakPtr(ptr.Get())
-    { }
+    TWeakPtr(const TIntrusivePtr<T>& ptr) noexcept;
 
     //! Constructor from a strong reference with an upcast.
     template <class U, class = typename std::enable_if_t<std::is_convertible_v<U*, T*>>>
-    TWeakPtr(const TIntrusivePtr<U>& ptr) noexcept
-        : TWeakPtr(ptr.Get())
-    {
-        static_assert(
-            std::derived_from<T, TRefCountedBase>,
-            "Cast allowed only for types derived from TRefCountedBase");
-    }
+    TWeakPtr(const TIntrusivePtr<U>& ptr) noexcept;
 
     //! Copy constructor.
-    TWeakPtr(const TWeakPtr& other) noexcept
-        : TWeakPtr(other.T_)
-    { }
+    TWeakPtr(const TWeakPtr& other) noexcept;
 
     //! Copy constructor with an upcast.
     template <class U, class = typename std::enable_if_t<std::is_convertible_v<U*, T*>>>
-    TWeakPtr(const TWeakPtr<U>& other) noexcept
-        : TWeakPtr(other.Lock())
-    {
-        static_assert(
-            std::derived_from<T, TRefCountedBase>,
-            "Cast allowed only for types derived from TRefCountedBase");
-    }
+    TWeakPtr(const TWeakPtr<U>& other) noexcept;
 
     //! Move constructor.
-    TWeakPtr(TWeakPtr&& other) noexcept
-    {
-        other.Swap(*this);
-    }
+    TWeakPtr(TWeakPtr&& other) noexcept;
 
     //! Move constructor with an upcast.
     template <class U, class = typename std::enable_if_t<std::is_convertible_v<U*, T*>>>
-    TWeakPtr(TWeakPtr<U>&& other) noexcept
-    {
-        static_assert(
-            std::derived_from<T, TRefCountedBase>,
-            "Cast allowed only for types derived from TRefCountedBase");
-        TIntrusivePtr<U> strongOther = other.Lock();
-        if (strongOther) {
-            T_ = other.T_;
-            other.T_ = nullptr;
-
-#if defined(_tsan_enabled_)
-            RefCounter_ = other.RefCounter_;
-            other.RefCounter_ = nullptr;
-#endif
-        }
-    }
+    TWeakPtr(TWeakPtr<U>&& other) noexcept;
 
     //! Destructor.
-    ~TWeakPtr()
-    {
-        ReleaseRef();
-    }
+    ~TWeakPtr();
 
     //! Assignment operator from a strong reference.
     template <class U>
-    TWeakPtr& operator=(const TIntrusivePtr<U>& ptr) noexcept
-    {
-        static_assert(
-            std::is_convertible_v<U*, T*>,
-            "U* must be convertible to T*");
-        TWeakPtr(ptr).Swap(*this);
-        return *this;
-    }
+    TWeakPtr& operator=(const TIntrusivePtr<U>& ptr) noexcept;
 
     //! Copy assignment operator.
-    TWeakPtr& operator=(const TWeakPtr& other) noexcept
-    {
-        TWeakPtr(other).Swap(*this);
-        return *this;
-    }
+    TWeakPtr& operator=(const TWeakPtr& other) noexcept;
 
     //! Copy assignment operator with an upcast.
     template <class U>
-    TWeakPtr& operator=(const TWeakPtr<U>& other) noexcept
-    {
-        static_assert(
-            std::is_convertible_v<U*, T*>,
-            "U* must be convertible to T*");
-        TWeakPtr(other).Swap(*this);
-        return *this;
-    }
+    TWeakPtr& operator=(const TWeakPtr<U>& other) noexcept;
 
     //! Move assignment operator.
-    TWeakPtr& operator=(TWeakPtr&& other) noexcept
-    {
-        other.Swap(*this);
-        return *this;
-    }
+    TWeakPtr& operator=(TWeakPtr&& other) noexcept;
 
     //! Move assignment operator with an upcast.
     template <class U>
-    TWeakPtr& operator=(TWeakPtr<U>&& other) noexcept
-    {
-        static_assert(
-            std::is_convertible_v<U*, T*>,
-            "U* must be convertible to T*");
-        TWeakPtr(std::move(other)).Swap(*this);
-        return *this;
-    }
+    TWeakPtr& operator=(TWeakPtr<U>&& other) noexcept;
 
     //! Drop the pointer.
-    void Reset() // noexcept
-    {
-        TWeakPtr().Swap(*this);
-    }
+    void Reset(); // noexcept
 
     //! Replace the pointer with a specified one.
-    void Reset(T* p) // noexcept
-    {
-        TWeakPtr(p).Swap(*this);
-    }
+    void Reset(T* p); // noexcept
 
     //! Replace the pointer with a specified one.
     template <class U>
-    void Reset(const TIntrusivePtr<U>& ptr) // noexcept
-    {
-        static_assert(
-            std::is_convertible_v<U*, T*>,
-            "U* must be convertible to T*");
-        TWeakPtr(ptr).Swap(*this);
-    }
+    void Reset(const TIntrusivePtr<U>& ptr); // noexcept
 
     //! Swap the pointer with the other one.
-    void Swap(TWeakPtr& other) noexcept
-    {
-        DoSwap(T_, other.T_);
-#if defined(_tsan_enabled_)
-        DoSwap(RefCounter_, other.RefCounter_);
-#endif
-    }
+    void Swap(TWeakPtr& other) noexcept;
 
     //! Acquire a strong reference to the pointee and return a strong pointer.
-    TIntrusivePtr<T> Lock() const noexcept
-    {
-        return T_ && RefCounter()->TryRef()
-            ? TIntrusivePtr<T>(T_, false)
-            : TIntrusivePtr<T>();
-    }
-
-    bool IsExpired() const noexcept
-    {
-        return !T_ || (RefCounter()->GetRefCount() == 0);
-    }
-
-    const TRefCounter* TryGetRefCounter() const
-    {
-        return T_
-            ? RefCounter()
-            : nullptr;
-    }
+    TIntrusivePtr<T> Lock() const noexcept;
+
+    //! Returns true if the pointee is null or already expired.
+    bool IsExpired() const noexcept;
+
+    //! Returns the underlying raw pointer. Note that it may point to an already
+    //! expired object.
+    T* Get() const noexcept;
 
 private:
-    void AcquireRef()
-    {
-        if (T_) {
-            RefCounter()->WeakRef();
-        }
-    }
-
-    void ReleaseRef()
-    {
-        if (T_) {
-            // Support incomplete type.
-            if (RefCounter()->WeakUnref()) {
-                DeallocateRefCounted(T_);
-            }
-        }
-    }
+    void AcquireRef();
+    void ReleaseRef();
 
     template <class U>
     friend class TWeakPtr;
-    template <class U>
-    friend struct ::THash;
 
     T* T_ = nullptr;
-#if defined(_tsan_enabled_)
+#if defined(_tsan_enabled_) || defined(_msan_enabled_)
     const TRefCounter* RefCounter_ = nullptr;
-
-    const TRefCounter* RefCounter() const
-    {
-        return RefCounter_;
-    }
-#else
-    const TRefCounter* RefCounter() const
-    {
-        return GetRefCounter(T_);
-    }
 #endif
+
+    const TRefCounter* GetRefCounterImpl() const;
+    const TRefCounter* TryGetRefCounterImpl() const;
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 
+template <class T1, class T2>
+bool operator==(const TWeakPtr<T1>& lhs, const TWeakPtr<T2>& rhs);
+
+template <class T1, class T2>
+bool operator==(const TIntrusivePtr<T1>& lhs, const TWeakPtr<T2>& rhs);
+
+template <class T1, class T2>
+bool operator==(const TWeakPtr<T1>& lhs, const TIntrusivePtr<T2>& rhs);
+
+template <class T1, class T2>
+bool operator==(T1* lhs, const TWeakPtr<T2>& rhs);
+
+template <class T1, class T2>
+bool operator==(const TWeakPtr<T1>& lhs, T2* rhs);
+
+template <class T2>
+bool operator==(std::nullptr_t, const TWeakPtr<T2>& rhs);
+
+template <class T1>
+bool operator==(const TWeakPtr<T1>& lhs, std::nullptr_t);
+
+////////////////////////////////////////////////////////////////////////////////
+
 //! Creates a weak pointer wrapper for a given raw pointer.
 //! Compared to |TWeakPtr<T>::ctor|, type inference enables omitting |T|.
 template <class T>
-TWeakPtr<T> MakeWeak(T* p)
-{
-    return TWeakPtr<T>(p);
-}
+TWeakPtr<T> MakeWeak(T* p);
 
 //! Creates a weak pointer wrapper for a given intrusive pointer.
 //! Compared to |TWeakPtr<T>::ctor|, type inference enables omitting |T|.
 template <class T>
-TWeakPtr<T> MakeWeak(const TIntrusivePtr<T>& p)
-{
-    return TWeakPtr<T>(p);
-}
+TWeakPtr<T> MakeWeak(const TIntrusivePtr<T>& p);
 
 //! A helper for acquiring weak pointer for pointee, resetting intrusive pointer and then
 //! returning the pointee reference count using the acquired weak pointer.
@@ -260,74 +151,34 @@ TWeakPtr<T> MakeWeak(const TIntrusivePtr<T>& p)
 //! NB: it is possible to rewrite this helper making it working event with intrinsic refcounted objects,
 //! but it requires much nastier integration with the intrusive pointer destruction routines.
 template <typename T>
-int ResetAndGetResidualRefCount(TIntrusivePtr<T>& pointer)
-{
-    auto weakPointer = MakeWeak(pointer);
-    pointer.Reset();
-    pointer = weakPointer.Lock();
-    if (pointer) {
-        // This _may_ return 0 if we are again the only holder of the pointee.
-        return pointer->GetRefCount() - 1;
-    } else {
-        return 0;
-    }
-}
+int ResetAndGetResidualRefCount(TIntrusivePtr<T>& pointer);
 
 ////////////////////////////////////////////////////////////////////////////////
 
-template <class T, class U>
-bool operator==(const TWeakPtr<T>& lhs, const TWeakPtr<U>& rhs)
-{
-    static_assert(
-        std::is_convertible_v<U*, T*>,
-        "U* must be convertible to T*");
-    return lhs.TryGetRefCounter() == rhs.TryGetRefCounter();
-}
-
-template <class T, class U>
-bool operator!=(const TWeakPtr<T>& lhs, const TWeakPtr<U>& rhs)
-{
-    static_assert(
-        std::is_convertible_v<U*, T*>,
-        "U* must be convertible to T*");
-    return lhs.TryGetRefCounter() != rhs.TryGetRefCounter();
-}
-
-template <class T>
-bool operator==(std::nullptr_t, const TWeakPtr<T>& rhs)
+struct TTransparentWeakPtrHasher
 {
-    return nullptr == rhs.TryGetRefCounter();
-}
+    using is_transparent = void;
 
-template <class T>
-bool operator!=(std::nullptr_t, const TWeakPtr<T>& rhs)
-{
-    return nullptr != rhs.TryGetRefCounter();
-}
+    template <class T>
+    std::size_t operator()(const TWeakPtr<T>& ptr) const;
 
-template <class T>
-bool operator==(const TWeakPtr<T>& lhs, std::nullptr_t)
-{
-    return nullptr == lhs.TryGetRefCounter();
-}
+    template <class T>
+    std::size_t operator()(const TIntrusivePtr<T>& ptr) const;
 
-template <class T>
-bool operator!=(const TWeakPtr<T>& lhs, std::nullptr_t)
-{
-    return nullptr != lhs.TryGetRefCounter();
-}
+    template <class T>
+    std::size_t operator()(T* ptr) const;
+};
 
 ////////////////////////////////////////////////////////////////////////////////
 
 } // namespace NYT
 
-
-//! A hasher for TWeakPtr.
 template <class T>
 struct THash<NYT::TWeakPtr<T>>
 {
-    size_t operator () (const NYT::TWeakPtr<T>& ptr) const
-    {
-        return THash<const NYT::TRefCountedBase*>()(ptr.T_);
-    }
+    size_t operator()(const NYT::TWeakPtr<T>& ptr) const;
 };
+
+#define WEAK_PTR_INL_H_
+#include "weak_ptr-inl.h"
+#undef WEAK_PTR_INL_H_
diff --git a/library/cpp/yt/misc/arcadia_enum-inl.h b/library/cpp/yt/misc/arcadia_enum-inl.h
index 17a10bb3b22..01633b4f4de 100644
--- a/library/cpp/yt/misc/arcadia_enum-inl.h
+++ b/library/cpp/yt/misc/arcadia_enum-inl.h
@@ -33,7 +33,7 @@ struct TArcadiaEnumTraitsImpl
     static std::optional<T> FindValueByLiteral(TStringBuf literal)
     {
         static const auto LiteralToValue = [] {
-            THashMap<TString, T> result;
+            THashMap<std::string, T> result;
             for (const auto& [value, name] : GetEnumNames<T>()) {
                 result.emplace(name, value);
             }
@@ -42,6 +42,18 @@ struct TArcadiaEnumTraitsImpl
         auto it = LiteralToValue.find(literal);
         return it == LiteralToValue.end() ? std::nullopt : std::make_optional(it->second);
     }
+
+    static bool IsKnownValue(T value)
+    {
+        static const auto Values = [] {
+            THashSet<T> result;
+            for (const auto& [value, _] : GetEnumNames<T>()) {
+                result.insert(value);
+            }
+            return result;
+        }();
+        return Values.contains(value);
+    }
 };
 
 ////////////////////////////////////////////////////////////////////////////////
diff --git a/library/cpp/yt/misc/cast-inl.h b/library/cpp/yt/misc/cast-inl.h
index a694394f88d..e86f420431b 100644
--- a/library/cpp/yt/misc/cast-inl.h
+++ b/library/cpp/yt/misc/cast-inl.h
@@ -18,35 +18,35 @@ namespace NYT {
 namespace NDetail {
 
 template <class T, class S>
-bool IsInIntegralRange(S value)
+constexpr bool IsInIntegralRange(S value)
     requires std::is_signed_v<T> && std::is_signed_v<S>
 {
     return value >= std::numeric_limits<T>::lowest() && value <= std::numeric_limits<T>::max();
 }
 
 template <class T, class S>
-bool IsInIntegralRange(S value)
+constexpr bool IsInIntegralRange(S value)
     requires std::is_signed_v<T> && std::is_unsigned_v<S>
 {
     return value <= static_cast<typename std::make_unsigned<T>::type>(std::numeric_limits<T>::max());
 }
 
 template <class T, class S>
-bool IsInIntegralRange(S value)
+constexpr bool IsInIntegralRange(S value)
     requires std::is_unsigned_v<T> && std::is_signed_v<S>
 {
     return value >= 0 && static_cast<typename std::make_unsigned<S>::type>(value) <= std::numeric_limits<T>::max();
 }
 
 template <class T, class S>
-bool IsInIntegralRange(S value)
+constexpr bool IsInIntegralRange(S value)
     requires std::is_unsigned_v<T> && std::is_unsigned_v<S>
 {
     return value <= std::numeric_limits<T>::max();
 }
 
 template <class T, class S>
-bool IsInIntegralRange(S value)
+constexpr bool IsInIntegralRange(S value)
     requires std::is_enum_v<S>
 {
     return IsInIntegralRange<T>(static_cast<std::underlying_type_t<S>>(value));
@@ -79,21 +79,34 @@ inline TString FormatInvalidCastValue(char8_t value)
 
 ////////////////////////////////////////////////////////////////////////////////
 
+
+template <class T, class S>
+constexpr bool CanFitSubtype()
+{
+    return NYT::NDetail::IsInIntegralRange<T>(std::numeric_limits<S>::min()) &&
+        NYT::NDetail::IsInIntegralRange<T>(std::numeric_limits<S>::max());
+}
+
 template <class T, class S>
-bool TryIntegralCast(S value, T* result)
+constexpr bool IsInIntegralRange(S value)
 {
-    if (!NYT::NDetail::IsInIntegralRange<T>(value)) {
-        return false;
+    return NYT::NDetail::IsInIntegralRange<T>(value);
+}
+
+template <class T, class S>
+constexpr std::optional<T> TryCheckedIntegralCast(S value)
+{
+    [[unlikely]] if (!NYT::NDetail::IsInIntegralRange<T>(value)) {
+        return std::nullopt;
     }
-    *result = static_cast<T>(value);
-    return true;
+    return static_cast<T>(value);
 }
 
 template <class T, class S>
 T CheckedIntegralCast(S value)
 {
-    T result;
-    if (!TryIntegralCast<T>(value, &result)) {
+    auto result = TryCheckedIntegralCast<T>(value);
+    if (!result) {
         throw TSimpleException(Sprintf("Error casting %s value \"%s\" to %s: value is out of expected range [%s; %s]",
             TypeName<S>().c_str(),
             NYT::NDetail::FormatInvalidCastValue(value).c_str(),
@@ -101,35 +114,52 @@ T CheckedIntegralCast(S value)
             ::ToString(std::numeric_limits<T>::lowest()).c_str(),
             ::ToString(std::numeric_limits<T>::max()).c_str()));
     }
-    return result;
+    return *result;
 }
 
 template <class T, class S>
-bool TryEnumCast(S value, T* result)
+    requires TEnumTraits<T>::IsEnum
+constexpr std::optional<T> TryCheckedEnumCast(S value, bool enableUnknown)
 {
-    std::underlying_type_t<T> underlying;
-    if (!TryIntegralCast<std::underlying_type_t<T>>(value, &underlying)) {
-        return false;
+    auto underlying = TryCheckedIntegralCast<std::underlying_type_t<T>>(value);
+    [[unlikely]] if (!underlying) {
+        return std::nullopt;
     }
-    auto candidate = static_cast<T>(underlying);
-    if (!TEnumTraits<T>::FindLiteralByValue(candidate)) {
-        return false;
+    auto candidate = static_cast<T>(*underlying);
+    [[unlikely]] if (!TEnumTraits<T>::IsValidValue(candidate)) {
+        if (enableUnknown) {
+            if constexpr (constexpr auto optionalUnknownValue = TEnumTraits<T>::TryGetUnknownValue()) {
+                if constexpr (TEnumTraits<T>::IsBitEnum) {
+                    return static_cast<T>(*underlying & ToUnderlying(TEnumTraits<T>::GetAllSetValue())) | *optionalUnknownValue;
+                } else {
+                    return *optionalUnknownValue;
+                }
+            }
+        }
+        return std::nullopt;
     }
-    *result = candidate;
-    return true;
+    return candidate;
 }
 
 template <class T, class S>
+    requires TEnumTraits<T>::IsEnum
 T CheckedEnumCast(S value)
 {
-    T result;
-    if (!TryEnumCast<T>(value, &result)) {
-        throw TSimpleException(Sprintf("Error casting %s value \"%d\" to enum %s",
-            TypeName<S>().c_str(),
-            static_cast<int>(value),
-            TEnumTraits<T>::GetTypeName().data()));
+    auto result = TryCheckedEnumCast<T>(value, /*enableUnknown*/ true);
+    [[unlikely]] if (!result) {
+        if constexpr (std::is_signed_v<S>) {
+            throw TSimpleException(Sprintf("Error casting %s value \"%" PRIi64 "\" to enum %s",
+                TypeName<S>().c_str(),
+                static_cast<i64>(value),
+                TEnumTraits<T>::GetTypeName().data()));
+        } else {
+            throw TSimpleException(Sprintf("Error casting %s value \"%" PRIu64 "\" to enum %s",
+                TypeName<S>().c_str(),
+                static_cast<ui64>(value),
+                TEnumTraits<T>::GetTypeName().data()));
+        }
     }
-    return result;
+    return *result;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
diff --git a/library/cpp/yt/misc/cast.h b/library/cpp/yt/misc/cast.h
index c7565c9e6d3..ccf1eb21a6b 100644
--- a/library/cpp/yt/misc/cast.h
+++ b/library/cpp/yt/misc/cast.h
@@ -1,13 +1,23 @@
 #pragma once
 
+#include "enum.h"
+
 #include <library/cpp/yt/exception/exception.h>
 
+#include <optional>
+
 namespace NYT {
 
 ////////////////////////////////////////////////////////////////////////////////
 
 template <class T, class S>
-bool TryIntegralCast(S value, T* result);
+constexpr bool CanFitSubtype();
+
+template <class T, class S>
+constexpr bool IsInIntegralRange(S value);
+
+template <class T, class S>
+constexpr std::optional<T> TryCheckedIntegralCast(S value);
 
 template <class T, class S>
 T CheckedIntegralCast(S value);
@@ -15,9 +25,11 @@ T CheckedIntegralCast(S value);
 ////////////////////////////////////////////////////////////////////////////////
 
 template <class T, class S>
-bool TryEnumCast(S value, T* result);
+    requires TEnumTraits<T>::IsEnum
+constexpr std::optional<T> TryCheckedEnumCast(S value, bool enableUnknown = false);
 
 template <class T, class S>
+    requires TEnumTraits<T>::IsEnum
 T CheckedEnumCast(S value);
 
 ////////////////////////////////////////////////////////////////////////////////
diff --git a/library/cpp/yt/misc/compare-inl.h b/library/cpp/yt/misc/compare-inl.h
new file mode 100644
index 00000000000..b9dfb5319f5
--- /dev/null
+++ b/library/cpp/yt/misc/compare-inl.h
@@ -0,0 +1,71 @@
+#ifndef COMPARE_INL_H_
+#error "Direct inclusion of this file is not allowed, include compare.h"
+// For the sake of sane code completion.
+#include "compare.h"
+#endif
+
+#include "numeric_helpers.h"
+
+#include <util/generic/string.h>
+
+#include <string>
+#include <string_view>
+
+namespace NYT {
+
+////////////////////////////////////////////////////////////////////////////////
+
+template <class T>
+Y_FORCE_INLINE int TernaryCompare(const T& lhs, const T& rhs)
+{
+    if (lhs == rhs) {
+        return 0;
+    } else if (lhs < rhs) {
+        return -1;
+    } else {
+        return +1;
+    }
+}
+
+//! An optimized version for string types.
+template <class T>
+    requires
+        std::is_same_v<T, TString> ||
+        std::is_same_v<T, TStringBuf> ||
+        std::is_same_v<T, std::string> ||
+        std::is_same_v<T, std::string_view>
+Y_FORCE_INLINE int TernaryCompare(const T& lhs, const T& rhs)
+{
+    return GetSign(std::string_view(lhs).compare(std::string_view(rhs)));
+}
+
+template <class T>
+Y_FORCE_INLINE int NaNSafeTernaryCompare(const T& lhs, const T& rhs)
+{
+    return TernaryCompare(lhs, rhs);
+}
+
+template <class T>
+    requires std::is_floating_point_v<T>
+Y_FORCE_INLINE int NaNSafeTernaryCompare(const T& lhs, const T& rhs)
+{
+    if (lhs < rhs) {
+        return -1;
+    } else if (lhs > rhs) {
+        return +1;
+    } else if (std::isnan(lhs)) {
+        if (std::isnan(rhs)) {
+            return 0;
+        } else {
+            return +1;
+        }
+    } else if (std::isnan(rhs)) {
+        return -1;
+    } else {
+        return 0;
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace NYT
diff --git a/library/cpp/yt/misc/compare.h b/library/cpp/yt/misc/compare.h
new file mode 100644
index 00000000000..22e452b355c
--- /dev/null
+++ b/library/cpp/yt/misc/compare.h
@@ -0,0 +1,28 @@
+#pragma once
+
+#include <util/generic/string.h>
+
+#include <string_view>
+
+namespace NYT {
+
+////////////////////////////////////////////////////////////////////////////////
+
+//! Compares #lhs with #rhs;
+//! returns -1 (if |lhs < rhs|), 0 (if |lhs == rhs|), or 1 (|lhs > rhs|).
+template <class T>
+int TernaryCompare(const T& lhs, const T& rhs);
+
+//! Same as #TernaryCompare but handles NaN values gracefully
+//! (assuming NaNs are larger than any regular number and all NaNs are equal).
+//! If |T| is not a floating-point type, #NaNSafeTernaryCompare is equivalent to #TernaryCompare.
+template <class T>
+int NaNSafeTernaryCompare(const T& lhs, const T& rhs);
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace NYT
+
+#define COMPARE_INL_H_
+#include "compare-inl.h"
+#undef COMPARE_INL_H_
diff --git a/library/cpp/yt/misc/concepts.h b/library/cpp/yt/misc/concepts.h
index aecad4fe60b..61a722d6d65 100644
--- a/library/cpp/yt/misc/concepts.h
+++ b/library/cpp/yt/misc/concepts.h
@@ -30,6 +30,15 @@ struct TIsInvocable<T, TResult(TArgs...) noexcept(NoExcept)>
         (!NoExcept || IsNoThrowInvocable_);
 };
 
+template <class T>
+struct TIsEmpty
+    : public T
+{
+    int Dummy;
+
+    static constexpr bool Value = (sizeof(TIsEmpty) == sizeof(int));
+};
+
 } // namespace NDetail
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -77,7 +86,15 @@ template <class T>
 concept CConstRawPtr = CRawPtr<T> && CConst<decltype(*std::declval<T>())>;
 
 template <class T>
-concept CMutRawPtr = CRawPtr<T> && !CConstRawPtr<T>;
+concept CMutableRawPtr = CRawPtr<T> && !CConstRawPtr<T>;
+
+////////////////////////////////////////////////////////////////////////////////
+
+template <class T>
+constexpr bool IsEmptyClass()
+{
+    return NDetail::TIsEmpty<T>::Value;
+}
 
 ////////////////////////////////////////////////////////////////////////////////
 
diff --git a/library/cpp/yt/misc/enum-inl.h b/library/cpp/yt/misc/enum-inl.h
index 5e1d04da1fb..bcac588ae34 100644
--- a/library/cpp/yt/misc/enum-inl.h
+++ b/library/cpp/yt/misc/enum-inl.h
@@ -11,6 +11,8 @@
 #include <util/generic/cast.h>
 
 #include <algorithm>
+#include <bit>
+#include <numeric>
 #include <stdexcept>
 
 namespace NYT {
@@ -38,6 +40,14 @@ namespace NYT {
 
 ////////////////////////////////////////////////////////////////////////////////
 
+template <class T>
+constexpr std::optional<T> TryGetEnumUnknownValueImpl(T)
+{
+    return std::nullopt;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
 namespace NDetail {
 
 template <typename TValues>
@@ -106,13 +116,14 @@ constexpr bool CheckDomainNames(const TNames& names)
         [[maybe_unused]] static constexpr bool IsMonotonic = \
             ::NYT::NDetail::CheckValuesMonotonic(Values); \
         \
-        static TStringBuf GetTypeName() \
+        static constexpr TStringBuf TypeName = PP_STRINGIZE(enumType); \
+        \
+        static constexpr TStringBuf GetTypeName() \
         { \
-            static constexpr TStringBuf Result = PP_STRINGIZE(enumType); \
-            return Result; \
+            return TypeName; \
         } \
         \
-        static const std::optional<TStringBuf> FindLiteralByValue(T value) \
+        static constexpr std::optional<TStringBuf> FindLiteralByValue(T value) \
         { \
             for (int i = 0; i < GetDomainSize(); ++i) { \
                 if (Values[i] == value) { \
@@ -122,7 +133,7 @@ constexpr bool CheckDomainNames(const TNames& names)
             return std::nullopt; \
         } \
         \
-        static std::optional<T> FindValueByLiteral(TStringBuf literal) \
+        static constexpr std::optional<T> FindValueByLiteral(TStringBuf literal) \
         { \
             for (int i = 0; i < GetDomainSize(); ++i) { \
                 if (Names[i] == literal) { \
@@ -132,6 +143,13 @@ constexpr bool CheckDomainNames(const TNames& names)
             return std::nullopt; \
         } \
         \
+        static constexpr bool IsKnownValue(T value) \
+        { \
+            return false  \
+                PP_FOR_EACH(ENUM__IS_KNOWN_VALUE_ITEM, seq) \
+            ; \
+        } \
+        \
         static constexpr const std::array<TStringBuf, DomainSize>& GetDomainNames() \
         { \
             return Names; \
@@ -184,6 +202,19 @@ constexpr bool CheckDomainNames(const TNames& names)
 #define ENUM__GET_DOMAIN_NAMES_ITEM_ATOMIC(item) \
     TStringBuf(PP_STRINGIZE(item)),
 
+#define ENUM__IS_KNOWN_VALUE_ITEM(item) \
+    PP_IF( \
+        PP_IS_SEQUENCE(item), \
+        ENUM__IS_KNOWN_VALUE_ITEM_SEQ, \
+        ENUM__IS_KNOWN_VALUE_ITEM_ATOMIC \
+    )(item)
+
+#define ENUM__IS_KNOWN_VALUE_ITEM_SEQ(seq) \
+    ENUM__IS_KNOWN_VALUE_ITEM_ATOMIC(PP_ELEMENT(seq, 0))
+
+#define ENUM__IS_KNOWN_VALUE_ITEM_ATOMIC(item) \
+    || value == T::item
+
 #define ENUM__VALIDATE_UNIQUE(enumType) \
     static_assert(IsMonotonic || ::NYT::NDetail::CheckValuesUnique(Values), \
         "Enumeration " #enumType " contains duplicate values");
@@ -197,7 +228,7 @@ constexpr bool CheckDomainNames(const TNames& names)
     } \
     \
     using ::ToString; \
-    [[maybe_unused]] inline TString ToString(enumType value) \
+    [[maybe_unused]] inline std::string ToString(enumType value) \
     { \
         return ::NYT::TEnumTraits<enumType>::ToString(value); \
     }
@@ -226,18 +257,31 @@ template <class T>
 constexpr T TEnumTraitsWithKnownDomain<T, true>::GetMinValue()
     requires (!TEnumTraitsImpl<T>::IsBitEnum)
 {
-    const auto& values = GetDomainValues();
-    static_assert(!values.empty()); \
-    return *std::min_element(std::begin(values), std::end(values));
+    // NB: GetDomainValues() is a static constexpr array, but a constexpr function called from
+    // a runtime context is not guaranteed to be constant-folded. Without binding the result to
+    // a constexpr local, clang (at -O2/-O3) emits a runtime std::min_element scan over the whole
+    // domain on every call -- which is hot, e.g. in TEnumIndexedArray::operator[] bounds checks.
+    constexpr auto values = GetDomainValues();
+    static_assert(!values.empty());
+    constexpr T result = *std::min_element(std::begin(values), std::end(values));
+    return result;
 }
 
 template <class T>
 constexpr T TEnumTraitsWithKnownDomain<T, true>::GetMaxValue()
     requires (!TEnumTraitsImpl<T>::IsBitEnum)
 {
-    const auto& values = GetDomainValues();
-    static_assert(!values.empty()); \
-    return *std::max_element(std::begin(values), std::end(values));
+    constexpr auto values = GetDomainValues();
+    static_assert(!values.empty());
+    constexpr T result = *std::max_element(std::begin(values), std::end(values));
+    return result;
+}
+
+template <class T>
+constexpr T TEnumTraitsWithKnownDomain<T, true>::GetAllSetValue()
+    requires (TEnumTraitsImpl<T>::IsBitEnum)
+{
+    return TEnumTraitsImpl<T>::GetAllSetValue();
 }
 
 template <class T>
@@ -256,31 +300,55 @@ std::vector<T> TEnumTraitsWithKnownDomain<T, true>::Decompose(T value)
 ////////////////////////////////////////////////////////////////////////////////
 
 template <class T>
-TStringBuf TEnumTraits<T, true>::GetTypeName()
+constexpr TStringBuf TEnumTraits<T, true>::GetTypeName()
 {
     return TEnumTraitsImpl<T>::GetTypeName();
 }
 
 template <class T>
-std::optional<T> TEnumTraits<T, true>::FindValueByLiteral(TStringBuf literal)
+constexpr std::optional<T> TEnumTraits<T, true>::TryGetUnknownValue()
+{
+    using NYT::TryGetEnumUnknownValueImpl;
+    return TryGetEnumUnknownValueImpl(T());
+}
+
+template <class T>
+constexpr std::optional<T> TEnumTraits<T, true>::FindValueByLiteral(TStringBuf literal)
 {
     return TEnumTraitsImpl<T>::FindValueByLiteral(literal);
 }
 
 template <class T>
-std::optional<TStringBuf> TEnumTraits<T, true>::FindLiteralByValue(T value)
+constexpr std::optional<TStringBuf> TEnumTraits<T, true>::FindLiteralByValue(T value)
 {
     return TEnumTraitsImpl<T>::FindLiteralByValue(value);
 }
 
 template <class T>
-TString TEnumTraits<T, true>::ToString(T value)
+constexpr bool TEnumTraits<T, true>::IsKnownValue(T value)
+    requires (!TEnumTraitsImpl<T>::IsBitEnum)
+{
+    return TEnumTraitsImpl<T>::IsKnownValue(value);
+}
+
+template <class T>
+constexpr bool TEnumTraits<T, true>::IsValidValue(T value)
+{
+    if constexpr (IsBitEnum) {
+        return (value & TEnumTraits<T>::GetAllSetValue()) == value;
+    } else {
+        return IsKnownValue(value);
+    }
+}
+
+template <class T>
+std::string TEnumTraits<T, true>::ToString(T value)
 {
     using ::ToString;
     if (auto optionalLiteral = TEnumTraits<T>::FindLiteralByValue(value)) {
         return ToString(*optionalLiteral);
     }
-    TString result;
+    std::string result;
     result = TEnumTraits<T>::GetTypeName();
     result += "(";
     result += ToString(ToUnderlying(value));
@@ -289,7 +357,7 @@ TString TEnumTraits<T, true>::ToString(T value)
 }
 
 template <class T>
-T TEnumTraits<T, true>::FromString(TStringBuf literal)
+constexpr T TEnumTraits<T, true>::FromString(TStringBuf literal)
 {
     auto optionalValue = FindValueByLiteral(literal);
     if (!optionalValue) {
@@ -308,7 +376,7 @@ T TEnumTraits<T, true>::FromString(TStringBuf literal)
         return T(ToUnderlying(lhs) op ToUnderlying(rhs)); \
     } \
     \
-    [[maybe_unused]] inline T& operator assignOp (T& lhs, T rhs) \
+    [[maybe_unused]] inline constexpr T& operator assignOp (T& lhs, T rhs) \
     { \
         lhs = T(ToUnderlying(lhs) op ToUnderlying(rhs)); \
         return lhs; \
@@ -326,13 +394,13 @@ T TEnumTraits<T, true>::FromString(TStringBuf literal)
         return T(ToUnderlying(lhs) op rhs); \
     } \
     \
-    [[maybe_unused]] inline T& operator assignOp (T& lhs, size_t rhs) \
+    [[maybe_unused]] inline constexpr T& operator assignOp (T& lhs, size_t rhs) \
     { \
         lhs = T(ToUnderlying(lhs) op rhs); \
         return lhs; \
     }
 
-#define ENUM__BITWISE_OPS(enumType) \
+#define ENUM__BITWISE_OPS(enumType)                 \
     ENUM__BINARY_BITWISE_OPERATOR(enumType, &=, &)  \
     ENUM__BINARY_BITWISE_OPERATOR(enumType, |=, | ) \
     ENUM__BINARY_BITWISE_OPERATOR(enumType, ^=, ^)  \
@@ -340,6 +408,16 @@ T TEnumTraits<T, true>::FromString(TStringBuf literal)
     ENUM__BIT_SHIFT_OPERATOR(enumType, <<=, << )    \
     ENUM__BIT_SHIFT_OPERATOR(enumType, >>=, >> )
 
+#define ENUM__ALL_SET_VALUE(enumType, seq)             \
+    static constexpr enumType GetAllSetValue()         \
+    {                                                  \
+        return std::accumulate(                        \
+            Values.begin(),                            \
+            Values.end(),                              \
+            enumType(),                                \
+            [] (auto a, auto b) { return a | b; });    \
+    }
+
 ////////////////////////////////////////////////////////////////////////////////
 
 template <typename E>
@@ -356,6 +434,13 @@ constexpr bool None(E value) noexcept
     return ToUnderlying(value) == 0;
 }
 
+template <typename E>
+    requires TEnumTraits<E>::IsBitEnum
+constexpr int PopCount(E value)
+{
+    return std::popcount(static_cast<std::underlying_type_t<E>>(value));
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 
 } // namespace NYT
diff --git a/library/cpp/yt/misc/enum.h b/library/cpp/yt/misc/enum.h
index 954b63cbc03..1db8099df16 100644
--- a/library/cpp/yt/misc/enum.h
+++ b/library/cpp/yt/misc/enum.h
@@ -26,22 +26,18 @@ namespace NYT {
 template <class T>
 void GetEnumTraitsImpl(T);
 
+template <class T, class S>
+constexpr bool CanFitSubtype();
+
 template <class T>
 using TEnumTraitsImpl = decltype(GetEnumTraitsImpl(T()));
 
 template <class T>
-constexpr bool IsEnumDomainSizeKnown()
-{
-    if constexpr(requires{ TEnumTraitsImpl<T>::DomainSize; }) {
-        return true;
-    } else {
-        return false;
-    }
-}
+constexpr std::optional<T> TryGetEnumUnknownValueImpl(T);
 
 template <
     class T,
-    bool = IsEnumDomainSizeKnown<T>()
+    bool DomainSizeKnown = requires{ TEnumTraitsImpl<T>::DomainSize; }
 >
 struct TEnumTraitsWithKnownDomain
 { };
@@ -59,7 +55,7 @@ struct TEnumTraits
 };
 
 template <class T>
-struct TEnumTraitsWithKnownDomain<T, true>
+struct TEnumTraitsWithKnownDomain<T, /*DomainSizeKnown*/ true>
 {
     static constexpr int GetDomainSize();
 
@@ -73,6 +69,8 @@ struct TEnumTraitsWithKnownDomain<T, true>
         requires (!TEnumTraitsImpl<T>::IsBitEnum);
 
     // For bit enums only.
+    static constexpr T GetAllSetValue()
+        requires (TEnumTraitsImpl<T>::IsBitEnum);
     static std::vector<T> Decompose(T value)
         requires (TEnumTraitsImpl<T>::IsBitEnum);
 };
@@ -86,20 +84,25 @@ struct TEnumTraits<T, true>
     static constexpr bool IsStringSerializableEnum = TEnumTraitsImpl<T>::IsStringSerializableEnum;
     static constexpr bool IsMonotonic = TEnumTraitsImpl<T>::IsMonotonic;
 
-    static TStringBuf GetTypeName();
+    static constexpr TStringBuf GetTypeName();
 
-    static std::optional<TStringBuf> FindLiteralByValue(T value);
-    static std::optional<T> FindValueByLiteral(TStringBuf literal);
+    static constexpr std::optional<T> TryGetUnknownValue();
+    static constexpr std::optional<TStringBuf> FindLiteralByValue(T value);
+    static constexpr std::optional<T> FindValueByLiteral(TStringBuf literal);
 
-    static TString ToString(T value);
-    static T FromString(TStringBuf literal);
+    static constexpr bool IsKnownValue(T value)
+        requires (!TEnumTraitsImpl<T>::IsBitEnum);
+    static constexpr bool IsValidValue(T value);
+
+    static std::string ToString(T value);
+    static constexpr T FromString(TStringBuf literal);
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 
 //! Defines a smart enumeration with a specific underlying type.
 /*!
- * \param enumType Enumeration enumType.
+ * \param enumType Enumeration type.
  * \param seq Enumeration domain encoded as a <em>sequence</em>.
  * \param underlyingType Underlying type.
  */
@@ -124,35 +127,37 @@ struct TEnumTraits<T, true>
 
 //! Defines a smart enumeration with a specific underlying type.
 /*!
- * \param enumType Enumeration enumType.
+ * \param enumType Enumeration type.
  * \param seq Enumeration domain encoded as a <em>sequence</em>.
  * \param underlyingType Underlying type.
  */
 #define DEFINE_BIT_ENUM_WITH_UNDERLYING_TYPE(enumType, underlyingType, seq) \
     ENUM__CLASS(enumType, underlyingType, seq) \
+    ENUM__BITWISE_OPS(enumType) \
     ENUM__BEGIN_TRAITS(enumType, underlyingType, true, false, seq) \
     ENUM__VALIDATE_UNIQUE(enumType) \
+    ENUM__ALL_SET_VALUE(enumType, seq) \
     ENUM__END_TRAITS(enumType) \
-    ENUM__BITWISE_OPS(enumType) \
     static_assert(true)
 
 //! Defines a smart enumeration with a specific underlying type.
 //! Duplicate enumeration values are allowed.
 /*!
- * \param enumType Enumeration enumType.
+ * \param enumType Enumeration type.
  * \param seq Enumeration domain encoded as a <em>sequence</em>.
  * \param underlyingType Underlying type.
  */
 #define DEFINE_AMBIGUOUS_BIT_ENUM_WITH_UNDERLYING_TYPE(enumType, underlyingType, seq) \
     ENUM__CLASS(enumType, underlyingType, seq) \
+    ENUM__BITWISE_OPS(enumType) \
     ENUM__BEGIN_TRAITS(enumType, underlyingType, true, false, seq) \
+    ENUM__ALL_SET_VALUE(enumType, seq) \
     ENUM__END_TRAITS(enumType) \
-    ENUM__BITWISE_OPS(enumType) \
     static_assert(true)
 
 //! Defines a smart enumeration with the default |unsigned int| underlying type.
 /*!
- * \param enumType Enumeration enumType.
+ * \param enumType Enumeration type.
  * \param seq Enumeration domain encoded as a <em>sequence</em>.
  */
 #define DEFINE_BIT_ENUM(enumType, seq) \
@@ -160,7 +165,7 @@ struct TEnumTraits<T, true>
 
 //! Defines a smart enumeration with a specific underlying type and IsStringSerializable attribute.
 /*!
- * \param enumType Enumeration enumType.
+ * \param enumType Enumeration type.
  * \param seq Enumeration domain encoded as a <em>sequence</em>.
  * \param underlyingType Underlying type.
  */
@@ -183,6 +188,18 @@ struct TEnumTraits<T, true>
 #define DEFINE_STRING_SERIALIZABLE_ENUM(enumType, seq) \
     DEFINE_STRING_SERIALIZABLE_ENUM_WITH_UNDERLYING_TYPE(enumType, int, seq)
 
+//! When enum from another representation (e.g. string or protobuf integer),
+//! instructs the parser to treat undeclared values as |unknownValue|.
+/*!
+ * \param enumType Enumeration type.
+ * \param unknownValue A sentinel value of #enumType.
+ */
+#define DEFINE_ENUM_UNKNOWN_VALUE(enumType, unknownValue) \
+    [[maybe_unused]] constexpr std::optional<enumType> TryGetEnumUnknownValueImpl(enumType) \
+    { \
+        return enumType::unknownValue; \
+    }
+
 ////////////////////////////////////////////////////////////////////////////////
 
 //! Returns |true| iff the enumeration value is not bitwise zero.
@@ -195,6 +212,23 @@ template <typename E>
     requires TEnumTraits<E>::IsBitEnum
 constexpr bool None(E value) noexcept;
 
+//! Returns the number of set bits in |value|.
+//!
+//! Note that this may not be equivalent of "number of set variants", because
+//! variants themselves are not required to have popcount of 1.
+//!
+//! For example, given an enum:
+//! DEFINE_BIT_ENUM(EMyEnum,
+//!    ((Read)  (1))
+//!    ((Write) (2))
+//!    ((Both)  (3))
+//! );
+//!
+//! `PopCount(EMyEnum::Both)` will return 2.
+template <typename E>
+    requires TEnumTraits<E>::IsBitEnum
+constexpr int PopCount(E value);
+
 ////////////////////////////////////////////////////////////////////////////////
 
 } // namespace NYT
diff --git a/library/cpp/yt/misc/global.h b/library/cpp/yt/misc/global.h
index c8bc2c03f00..0c8af0f2768 100644
--- a/library/cpp/yt/misc/global.h
+++ b/library/cpp/yt/misc/global.h
@@ -3,7 +3,7 @@
 //! Defines a global variable that is initialized on its first access.
 /*!
  *  In contrast to a usual variable with static storage duration, this one
- *  is not susceptible to initialization order fisco issues.
+ *  is not susceptible to initialization order fiasco issues.
  */
 #define YT_DEFINE_GLOBAL(type, name, ...) \
     inline type& name() \
diff --git a/library/cpp/yt/misc/guid-inl.h b/library/cpp/yt/misc/guid-inl.h
index 0e79a3aaa87..fd5d988f6cc 100644
--- a/library/cpp/yt/misc/guid-inl.h
+++ b/library/cpp/yt/misc/guid-inl.h
@@ -73,6 +73,15 @@ Y_FORCE_INLINE std::strong_ordering operator <=> (TGuid lhs, TGuid rhs) noexcept
 
 ////////////////////////////////////////////////////////////////////////////////
 
+//! Abseil hash support for TGuid.
+template <class THash>
+THash AbslHashValue(THash hash, const TGuid& guid)
+{
+    return THash::combine(std::move(hash), guid.Parts64[0], guid.Parts64[1]);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
 } // namespace NYT
 
 Y_FORCE_INLINE size_t THash<NYT::TGuid>::operator()(const NYT::TGuid& guid) const
diff --git a/library/cpp/yt/misc/guid.cpp b/library/cpp/yt/misc/guid.cpp
index fc4f1465328..86c4c8849bb 100644
--- a/library/cpp/yt/misc/guid.cpp
+++ b/library/cpp/yt/misc/guid.cpp
@@ -12,29 +12,10 @@ namespace NYT {
 
 namespace {
 
-const ui8 HexDigits1[16] = {
+const ui8 HexDigits[16] = {
     0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66
 };
 
-const ui16 HexDigits2[256] = {
-    0x3030, 0x3130, 0x3230, 0x3330, 0x3430, 0x3530, 0x3630, 0x3730, 0x3830, 0x3930, 0x6130, 0x6230, 0x6330, 0x6430, 0x6530, 0x6630,
-    0x3031, 0x3131, 0x3231, 0x3331, 0x3431, 0x3531, 0x3631, 0x3731, 0x3831, 0x3931, 0x6131, 0x6231, 0x6331, 0x6431, 0x6531, 0x6631,
-    0x3032, 0x3132, 0x3232, 0x3332, 0x3432, 0x3532, 0x3632, 0x3732, 0x3832, 0x3932, 0x6132, 0x6232, 0x6332, 0x6432, 0x6532, 0x6632,
-    0x3033, 0x3133, 0x3233, 0x3333, 0x3433, 0x3533, 0x3633, 0x3733, 0x3833, 0x3933, 0x6133, 0x6233, 0x6333, 0x6433, 0x6533, 0x6633,
-    0x3034, 0x3134, 0x3234, 0x3334, 0x3434, 0x3534, 0x3634, 0x3734, 0x3834, 0x3934, 0x6134, 0x6234, 0x6334, 0x6434, 0x6534, 0x6634,
-    0x3035, 0x3135, 0x3235, 0x3335, 0x3435, 0x3535, 0x3635, 0x3735, 0x3835, 0x3935, 0x6135, 0x6235, 0x6335, 0x6435, 0x6535, 0x6635,
-    0x3036, 0x3136, 0x3236, 0x3336, 0x3436, 0x3536, 0x3636, 0x3736, 0x3836, 0x3936, 0x6136, 0x6236, 0x6336, 0x6436, 0x6536, 0x6636,
-    0x3037, 0x3137, 0x3237, 0x3337, 0x3437, 0x3537, 0x3637, 0x3737, 0x3837, 0x3937, 0x6137, 0x6237, 0x6337, 0x6437, 0x6537, 0x6637,
-    0x3038, 0x3138, 0x3238, 0x3338, 0x3438, 0x3538, 0x3638, 0x3738, 0x3838, 0x3938, 0x6138, 0x6238, 0x6338, 0x6438, 0x6538, 0x6638,
-    0x3039, 0x3139, 0x3239, 0x3339, 0x3439, 0x3539, 0x3639, 0x3739, 0x3839, 0x3939, 0x6139, 0x6239, 0x6339, 0x6439, 0x6539, 0x6639,
-    0x3061, 0x3161, 0x3261, 0x3361, 0x3461, 0x3561, 0x3661, 0x3761, 0x3861, 0x3961, 0x6161, 0x6261, 0x6361, 0x6461, 0x6561, 0x6661,
-    0x3062, 0x3162, 0x3262, 0x3362, 0x3462, 0x3562, 0x3662, 0x3762, 0x3862, 0x3962, 0x6162, 0x6262, 0x6362, 0x6462, 0x6562, 0x6662,
-    0x3063, 0x3163, 0x3263, 0x3363, 0x3463, 0x3563, 0x3663, 0x3763, 0x3863, 0x3963, 0x6163, 0x6263, 0x6363, 0x6463, 0x6563, 0x6663,
-    0x3064, 0x3164, 0x3264, 0x3364, 0x3464, 0x3564, 0x3664, 0x3764, 0x3864, 0x3964, 0x6164, 0x6264, 0x6364, 0x6464, 0x6564, 0x6664,
-    0x3065, 0x3165, 0x3265, 0x3365, 0x3465, 0x3565, 0x3665, 0x3765, 0x3865, 0x3965, 0x6165, 0x6265, 0x6365, 0x6465, 0x6565, 0x6665,
-    0x3066, 0x3166, 0x3266, 0x3366, 0x3466, 0x3566, 0x3666, 0x3766, 0x3866, 0x3966, 0x6166, 0x6266, 0x6366, 0x6466, 0x6566, 0x6666
-};
-
 } // anonymous namespace
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -49,7 +30,7 @@ TGuid TGuid::FromString(TStringBuf str)
     TGuid guid;
     if (!FromString(str, &guid)) {
         throw TSimpleException(Sprintf("Error parsing GUID \"%s\"",
-            TString(str).c_str()));
+            std::string(str).c_str()));
     }
     return guid;
 }
@@ -106,7 +87,7 @@ TGuid TGuid::FromStringHex32(TStringBuf str)
     TGuid guid;
     if (!FromStringHex32(str, &guid)) {
         throw TSimpleException(Sprintf("Error parsing Hex32 GUID \"%s\"",
-            TString(str).c_str()));
+            str.data()));
     }
     return guid;
 }
@@ -143,58 +124,28 @@ bool TGuid::FromStringHex32(TStringBuf str, TGuid* result)
 
 char* WriteGuidToBuffer(char* ptr, TGuid value)
 {
-    auto writeHex1 = [&] (ui8 x) {
-        *ptr = HexDigits1[x];
-        ptr += 1;
-    };
-
-    auto writeHex2 = [&] (ui8 x) {
-        ::memcpy(ptr, &HexDigits2[x], 2);
-        ptr += 2;
-    };
-
+    // Each 32-bit component is emitted as lowercase hex with leading zeros
+    // stripped (so 1..8 digits). We derive the exact digit count from the
+    // position of the highest set bit and fill the digits back-to-front; this
+    // avoids the long branch cascade of the naive per-magnitude approach and
+    // writes exactly as many bytes as the component requires.
     auto writeComponent = [&] (ui32 x) {
-        /*  */ if (x >= 0x10000000) {
-            writeHex2((x >> 24) & 0xff);
-            writeHex2((x >> 16) & 0xff);
-            writeHex2((x >>  8) & 0xff);
-            writeHex2( x        & 0xff);
-        } else if (x >= 0x1000000) {
-            writeHex1( x >> 24);
-            writeHex2((x >> 16) & 0xff);
-            writeHex2((x >>  8) & 0xff);
-            writeHex2( x        & 0xff);
-        } else if (x >= 0x100000) {
-            writeHex2((x >> 16) & 0xff);
-            writeHex2((x >>  8) & 0xff);
-            writeHex2( x        & 0xff);
-        } else if (x >= 0x10000) {
-            writeHex1( x >> 16);
-            writeHex2((x >>  8) & 0xff);
-            writeHex2( x        & 0xff);
-        } else if (x >= 0x1000) {
-            writeHex2( x >> 8);
-            writeHex2( x        & 0xff);
-        } else if (x >= 0x100) {
-            writeHex1( x >> 8);
-            writeHex2( x        & 0xff);
-        } else if (x >= 0x10) {
-            writeHex2( x);
-        } else {
-            writeHex1( x);
-        }
-    };
-
-    auto writeDash = [&] () {
-        *ptr++ = '-';
+        int digits = x == 0 ? 1 : (35 - __builtin_clz(x)) >> 2;
+        char* start = ptr;
+        char* cursor = ptr + digits;
+        ptr = cursor;
+        do {
+            *--cursor = HexDigits[x & 0xf];
+            x >>= 4;
+        } while (cursor != start);
     };
 
     writeComponent(value.Parts32[3]);
-    writeDash();
+    *ptr++ = '-';
     writeComponent(value.Parts32[2]);
-    writeDash();
+    *ptr++ = '-';
     writeComponent(value.Parts32[1]);
-    writeDash();
+    *ptr++ = '-';
     writeComponent(value.Parts32[0]);
 
     return ptr;
diff --git a/library/cpp/yt/misc/hash-inl.h b/library/cpp/yt/misc/hash-inl.h
index 46eeefe6204..1d0b396f927 100644
--- a/library/cpp/yt/misc/hash-inl.h
+++ b/library/cpp/yt/misc/hash-inl.h
@@ -4,16 +4,56 @@
 #include "hash.h"
 #endif
 
+#include <cmath>
+
 namespace NYT {
 
 ////////////////////////////////////////////////////////////////////////////////
 
-inline void HashCombine(size_t& h, size_t k)
+inline size_t SplitMix(size_t value)
 {
-    static_assert(sizeof(size_t) == 8, "size_t must be 64 bit.");
+    // GOLDEN_GAMMA is the odd integer closest to (2 ^ {bit_depth}) / phi,
+    // where phi = (1 + sqrt(5))/2 is the golden ratio.
+    // Defined in https://gee.cs.oswego.edu/dl/papers/oopsla14.pdf
+    //
+    // The second part of algorithm is finalization mix and uses some magic constants
+    // For 32bit platforms it taken from https://github.com/aappleby/smhasher/blob/master/src/MurmurHash3.cpp#L70-L74
+    // For 64bit from http://zimbry.blogspot.com/2011/09/better-bit-mixing-improving-on.html
+#ifdef _64_
+    constexpr size_t GOLDEN_GAMMA = 0x9e3779b97f4a7c15ULL;
+    constexpr size_t C1 = 0xbf58476d1ce4e5b9ULL;
+    constexpr size_t C2 = 0x94d049bb133111ebULL;
+    constexpr size_t S0 = 30;
+    constexpr size_t S1 = 27;
+    constexpr size_t S2 = 31;
+#else
+    constexpr size_t GOLDEN_GAMMA = 0x9e3779b9UL;
+    constexpr size_t C1 = 0x85ebca6bUL;
+    constexpr size_t C2 = 0xc2b2ae35UL;
+    constexpr size_t S0 = 16;
+    constexpr size_t S1 = 13;
+    constexpr size_t S2 = 16;
+#endif
 
-    const size_t m = 0xc6a4a7935bd1e995ULL;
-    const int r = 47;
+    value += GOLDEN_GAMMA;
+    value = (value ^ (value >> S0)) * C1;
+    value = (value ^ (value >> S1)) * C2;
+    return value ^ (value >> S2);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+inline void HashCombine(size_t& h, size_t k)
+{
+    // Combine step from MurmurHash https://github.com/abrandoned/murmur2/blob/master/MurmurHash2.c
+    // 64bit constants are taken from MurmurHash64A, 32bit — MurmurHash2
+#ifdef _64_
+    constexpr size_t m = 0xc6a4a7935bd1e995ULL;
+    constexpr size_t r = 47;
+#else
+    constexpr size_t m = 0x5bd1e995;
+    constexpr size_t r = 24;
+#endif
 
     k *= m;
     k ^= k >> r;
@@ -29,6 +69,19 @@ void HashCombine(size_t& h, const T& k)
     HashCombine(h, THash<T>()(k));
 }
 
+template <class T>
+Y_FORCE_INLINE size_t NaNSafeHash(const T& value)
+{
+    return ::THash<T>()(value);
+}
+
+template <class T>
+    requires std::is_floating_point_v<T>
+Y_FORCE_INLINE size_t NaNSafeHash(const T& value)
+{
+    return std::isnan(value) ? 0 : ::THash<T>()(value);
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 
 template <class TElement, class TUnderlying>
@@ -37,9 +90,17 @@ TRandomizedHash<TElement, TUnderlying>::TRandomizedHash()
 { }
 
 template <class TElement, class TUnderlying>
-size_t TRandomizedHash<TElement, TUnderlying>::operator ()(const TElement& element) const
+TRandomizedHash<TElement, TUnderlying>::TRandomizedHash(size_t seed)
+    : Seed_(seed)
+{ }
+
+template <class TElement, class TUnderlying>
+template <class THeterogenousElement>
+size_t TRandomizedHash<TElement, TUnderlying>::operator ()(const THeterogenousElement& element) const
 {
-    return Underlying_(element) + Seed_;
+    auto result = Seed_;
+    HashCombine(result, Underlying_(element));
+    return result;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
diff --git a/library/cpp/yt/misc/hash.h b/library/cpp/yt/misc/hash.h
index 2fecf895061..7b8b9e8aafc 100644
--- a/library/cpp/yt/misc/hash.h
+++ b/library/cpp/yt/misc/hash.h
@@ -8,6 +8,15 @@ namespace NYT {
 
 ////////////////////////////////////////////////////////////////////////////////
 
+//! Finalization function that makes each bit of the output depend on each bit of the input.
+//! Needed to achieve unbiased distribution for bit-sensitive application like HLL,
+//! as opposed to raw collision minimization.
+//! This is also SplitMix64 PRNG.
+//! Cf. |http://zimbry.blogspot.com/2011/09/better-bit-mixing-improving-on.html|, |boost::random::splitmix64|.
+size_t SplitMix(size_t value);
+
+////////////////////////////////////////////////////////////////////////////////
+
 //! Updates #h with #k.
 //! Cf. |boost::hash_combine|.
 void HashCombine(size_t& h, size_t k);
@@ -17,20 +26,29 @@ void HashCombine(size_t& h, size_t k);
 template <class T>
 void HashCombine(size_t& h, const T& k);
 
+//! Computes the hash of #value handling NaN values gracefully
+//! (returning the same constant for all NaNs).
+//! If |T| is not a floating-point type, #NaNSafeHash is equivalent to #THash.
+template <class T>
+size_t NaNSafeHash(const T& value);
+
 ////////////////////////////////////////////////////////////////////////////////
 
 //! Provides a hasher that randomizes the results of another one.
+//! \note In case seed value is 0, the hash is just the underlying hash.
 template <class TElement, class TUnderlying = ::THash<TElement>>
 class TRandomizedHash
 {
 public:
     TRandomizedHash();
-    size_t operator () (const TElement& element) const;
+    explicit TRandomizedHash(size_t seed);
+
+    template <class THeterogenousElement>
+    size_t operator()(const THeterogenousElement& element) const;
 
 private:
     size_t Seed_;
     TUnderlying Underlying_;
-
 };
 
 ////////////////////////////////////////////////////////////////////////////////
diff --git a/library/cpp/yt/misc/numeric_helpers-inl.h b/library/cpp/yt/misc/numeric_helpers-inl.h
new file mode 100644
index 00000000000..c0dbc07490d
--- /dev/null
+++ b/library/cpp/yt/misc/numeric_helpers-inl.h
@@ -0,0 +1,59 @@
+#ifndef NUMERIC_HELPERS_INL_H_
+#error "Direct inclusion of this file is not allowed, include numeric_helpers.h"
+// For the sake of sane code completion.
+#include "numeric_helpers.h"
+#endif
+
+#include <cstdlib>
+#include <cinttypes>
+#include <cmath>
+#include <algorithm>
+
+#include <util/system/compiler.h>
+
+namespace NYT {
+
+////////////////////////////////////////////////////////////////////////////////
+
+template <class T>
+T DivCeil(const T& numerator, const T& denominator)
+{
+    YT_VERIFY(denominator != 0);
+    auto res = std::div(numerator, denominator);
+    return res.quot + (res.rem > static_cast<T>(0) ? static_cast<T>(1) : static_cast<T>(0));
+}
+
+template <typename T>
+T DivRound(const T& numerator, const T& denominator)
+{
+    auto res = std::div(numerator, denominator);
+    return res.quot + (res.rem >= (denominator + 1) / 2 ? static_cast<T>(1) : static_cast<T>(0));
+}
+
+template <class T>
+T RoundUp(const T& numerator, const T& denominator)
+{
+    return DivCeil(numerator, denominator) * denominator;
+}
+
+template <class T>
+T RoundDown(const T& numerator, const T& denominator)
+{
+    return (numerator / denominator) * denominator;
+}
+
+template <class T>
+Y_FORCE_INLINE int GetSign(const T& value)
+{
+    if (value < 0) {
+        return -1;
+    } else if (value > 0) {
+        return +1;
+    } else {
+        return 0;
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace NYT
diff --git a/library/cpp/yt/misc/numeric_helpers.h b/library/cpp/yt/misc/numeric_helpers.h
new file mode 100644
index 00000000000..20844029c27
--- /dev/null
+++ b/library/cpp/yt/misc/numeric_helpers.h
@@ -0,0 +1,31 @@
+#pragma once
+
+namespace NYT {
+
+////////////////////////////////////////////////////////////////////////////////
+
+template <class T>
+T DivCeil(const T& numerator, const T& denominator);
+
+//! A version of division that is a bit less noisy around the situation
+//! when numerator is almost divisible by denominator. Round up if the remainder
+//! is at least half of denominator, otherwise round down.
+template<class T>
+T DivRound(const T& numerator, const T& denominator);
+
+template <class T>
+T RoundUp(const T& numerator, const T& denominator);
+
+template <class T>
+T RoundDown(const T& numerator, const T& denominator);
+
+template <class T>
+int GetSign(const T& value);
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace NYT
+
+#define NUMERIC_HELPERS_INL_H_
+#include "numeric_helpers-inl.h"
+#undef NUMERIC_HELPERS_INL_H_
diff --git a/library/cpp/yt/misc/port.h b/library/cpp/yt/misc/port.h
index fe1c5e96de9..b7b350f4581 100644
--- a/library/cpp/yt/misc/port.h
+++ b/library/cpp/yt/misc/port.h
@@ -2,14 +2,18 @@
 
 #include <util/system/platform.h>
 
-// Check platform bitness.
-#if !defined(_64_)
-    #error YT requires 64-bit platform
+#ifndef YT_DISABLE_REF_COUNTED_TRACKING
+    // This define enables tracking of reference-counted objects to provide
+    // various insightful information on memory usage and object creation patterns.
+    #define YT_ENABLE_REF_COUNTED_TRACKING
 #endif
 
-// This define enables tracking of reference-counted objects to provide
-// various insightful information on memory usage and object creation patterns.
-#define YT_ENABLE_REF_COUNTED_TRACKING
+#if !defined(NDEBUG) && !defined(YT_DISABLE_REF_COUNTED_SIGNATURE)
+    // This define embeds a salted, poisonable signature into every TRefCounter
+    // (see ref_counted.h). It lets a coredump walker tell a live ref-counted object
+    // from freed-but-unreclaimed memory.
+    #define YT_ENABLE_REF_COUNTED_SIGNATURE
+#endif
 
 // This define enables logging with TRACE level. You can still disable trace logging
 // for particular TU by discarding this macro identifier.
@@ -34,11 +38,6 @@
     #define YT_ENABLE_SPIN_LOCK_OWNERSHIP_TRACKING
 #endif
 
-// Configure SSE usage.
-#ifdef SSE42_ENABLED
-    #define YT_USE_SSE42
-#endif
-
 #ifdef _win_
     // Someone above has defined this by including one of Windows headers.
     #undef GetMessage
@@ -60,18 +59,10 @@
 #endif
 
 #if defined(__GNUC__) || defined(__clang__)
-    #define YT_ATTRIBUTE_NO_SANITIZE_ADDRESS __attribute__((no_sanitize_address))
     // Prevent GCC from throwing out functions in release builds.
     #define YT_ATTRIBUTE_USED __attribute__((used))
 #elif defined(_MSC_VER)
-    #define YT_ATTRIBUTE_NO_SANITIZE_ADDRESS
     #define YT_ATTRIBUTE_USED
 #else
     #error Unsupported compiler
 #endif
-
-#if defined(_unix_)
-    #define YT_ATTRIBUTE_NO_UNIQUE_ADDRESS [[no_unique_address]]
-#else
-    #define YT_ATTRIBUTE_NO_UNIQUE_ADDRESS
-#endif
diff --git a/library/cpp/yt/misc/preprocessor.h b/library/cpp/yt/misc/preprocessor.h
index 5b929a03b59..818c3be3546 100644
--- a/library/cpp/yt/misc/preprocessor.h
+++ b/library/cpp/yt/misc/preprocessor.h
@@ -50,6 +50,7 @@
 #define PP_RIGHT_PARENTHESIS )
 #define PP_COMMA() ,
 #define PP_EMPTY()
+#define PP_EMPTINESS
 //! \endcond
 
 //! Removes the enclosing parens, if any.
@@ -123,6 +124,13 @@
 #define PP_ONE_OR_NONE(a, ...) PP_THIRD(a, ## __VA_ARGS__, a)
 #define PP_THIRD(a, b, ...) __VA_ARGS__
 
+//! Checks whether emptiness was passed.
+#define PP_IS_EMPTY(...) PP_IS_EMPTY_A(__VA_ARGS__)
+//! \cond Implementation
+#define PP_IS_EMPTY_A(...) PP_FIRST(__VA_OPT__(PP_FALSE,) PP_TRUE)
+#define PP_FIRST(a, ...) a
+//! \endcond
+
 //! \cond Implementation
 #define PREPROCESSOR_GEN_H_
 #include "preprocessor-gen.h"
diff --git a/library/cpp/yt/misc/property.h b/library/cpp/yt/misc/property.h
index 3c42693ef3f..e56696d97b8 100644
--- a/library/cpp/yt/misc/property.h
+++ b/library/cpp/yt/misc/property.h
@@ -17,12 +17,12 @@ protected: \
     type name##_ { __VA_ARGS__ }; \
     \
 public: \
-    Y_FORCE_INLINE type& name() noexcept \
+    Y_FORCE_INLINE type& name() noexcept Y_LIFETIME_BOUND \
     { \
         return name##_; \
     } \
     \
-    Y_FORCE_INLINE const type& name() const noexcept \
+    Y_FORCE_INLINE const type& name() const noexcept Y_LIFETIME_BOUND \
     { \
         return name##_; \
     } \
@@ -53,12 +53,12 @@ protected: \
     type name##_; \
     \
 public: \
-    Y_FORCE_INLINE type& name() noexcept override \
+    Y_FORCE_INLINE type& name() noexcept Y_LIFETIME_BOUND override \
     { \
         return name##_; \
     } \
     \
-    Y_FORCE_INLINE const type& name() const noexcept override \
+    Y_FORCE_INLINE const type& name() const noexcept Y_LIFETIME_BOUND override \
     { \
         return name##_; \
     } \
@@ -91,7 +91,7 @@ protected: \
     type name##_ { __VA_ARGS__ }; \
     \
 public: \
-    Y_FORCE_INLINE const type& name() const noexcept \
+    Y_FORCE_INLINE const type& name() const noexcept Y_LIFETIME_BOUND \
     { \
         return name##_; \
     } \
@@ -104,7 +104,7 @@ protected: \
     type name##_; \
     \
 public: \
-    Y_FORCE_INLINE const type& name() const noexcept \
+    Y_FORCE_INLINE const type& name() const noexcept Y_LIFETIME_BOUND \
     { \
         return name##_; \
     } \
@@ -117,7 +117,7 @@ protected: \
     type name##_; \
     \
 public: \
-    Y_FORCE_INLINE const type& name() const noexcept override \
+    Y_FORCE_INLINE const type& name() const noexcept Y_LIFETIME_BOUND override \
     { \
         return name##_; \
     } \
@@ -175,6 +175,19 @@ public: \
     } \
     static_assert(true)
 
+//! Defines a trivial public read-only boolean property that is passed by value.
+//! All arguments after name are used as default value (via braced-init-list).
+#define DEFINE_BYVAL_RO_BOOLEAN_PROPERTY(name, ...) \
+protected: \
+    bool name##_ { __VA_ARGS__ }; \
+    \
+public: \
+    Y_FORCE_INLINE bool Is##name() const \
+    { \
+        return name##_; \
+    } \
+    static_assert(true)
+
 //! Defines a trivial public read-write property that is passed by value.
 //! All arguments after name are used as default value (via braced-init-list).
 #define DEFINE_BYVAL_RW_PROPERTY_WITH_FLUENT_SETTER(declaringType, type, name, ...) \
@@ -324,11 +337,11 @@ public: \
     { \
         return static_cast<bool>(holder##_); \
     } \
-    Y_FORCE_INLINE const type* GetCustom##holder() const \
+    Y_FORCE_INLINE const type* GetCustom##holder() const Y_LIFETIME_BOUND \
     { \
         return holder##_.get(); \
     } \
-    Y_FORCE_INLINE type* GetCustom##holder() \
+    Y_FORCE_INLINE type* GetCustom##holder() Y_LIFETIME_BOUND \
     { \
         return holder##_.get(); \
     } \
@@ -336,6 +349,7 @@ public: \
     { \
         INITIALIZE_EXTRA_PROPERTY_HOLDER(holder); \
     } \
+    \
 private: \
     std::unique_ptr<type> holder##_; \
     static const type Default##holder##_
@@ -369,14 +383,14 @@ public: \
 //! Defines a public read-write extra property that is passed by reference.
 #define DEFINE_BYREF_RW_EXTRA_PROPERTY(holder, name) \
 public: \
-    Y_FORCE_INLINE const decltype(holder##_->name)& name() const \
+    Y_FORCE_INLINE const decltype(holder##_->name)& name() const Y_LIFETIME_BOUND \
     { \
         if (!holder##_) { \
             return Default##holder##_.name; \
         } \
         return holder##_->name; \
     } \
-    Y_FORCE_INLINE decltype(holder##_->name)& Mutable##name() \
+    Y_FORCE_INLINE decltype(holder##_->name)& Mutable##name() Y_LIFETIME_BOUND \
     { \
         INITIALIZE_EXTRA_PROPERTY_HOLDER(holder); \
         return holder##_->name; \
diff --git a/library/cpp/yt/misc/range_formatters-inl.h b/library/cpp/yt/misc/range_formatters-inl.h
new file mode 100644
index 00000000000..b1e1d1cd78f
--- /dev/null
+++ b/library/cpp/yt/misc/range_formatters-inl.h
@@ -0,0 +1,31 @@
+#ifndef RANGE_FORMATTERS_INL_H_
+#error "Direct inclusion of this file is not allowed, include range_formatters.h"
+// For the sake of sane code completion.
+#include "range_formatters.h"
+#endif
+
+namespace NYT {
+
+////////////////////////////////////////////////////////////////////////////////
+
+template <class T>
+void FormatValue(TStringBuilderBase* builder, const TRange<T>& collection, TStringBuf /*spec*/)
+{
+    NYT::FormatRange(builder, collection, TDefaultFormatter());
+}
+
+template <class T>
+void FormatValue(TStringBuilderBase* builder, const TSharedRange<T>& collection, TStringBuf /*spec*/)
+{
+    NYT::FormatRange(builder, collection, TDefaultFormatter());
+}
+
+template <std::ranges::view T>
+void FormatValue(TStringBuilderBase* builder, const T& collection, TStringBuf /*spec*/)
+{
+    NYT::FormatRange(builder, collection, TDefaultFormatter());
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace NYT
diff --git a/library/cpp/yt/misc/range_formatters.h b/library/cpp/yt/misc/range_formatters.h
new file mode 100644
index 00000000000..3ebeff17061
--- /dev/null
+++ b/library/cpp/yt/misc/range_formatters.h
@@ -0,0 +1,27 @@
+#pragma once
+
+#include <library/cpp/yt/string/format.h>
+
+#include <library/cpp/yt/memory/range.h>
+#include <library/cpp/yt/memory/shared_range.h>
+
+namespace NYT {
+
+////////////////////////////////////////////////////////////////////////////////
+
+template <class T>
+void FormatValue(TStringBuilderBase* builder, const TRange<T>& collection, TStringBuf /*spec*/);
+
+template <class T>
+void FormatValue(TStringBuilderBase* builder, const TSharedRange<T>& collection, TStringBuf /*spec*/);
+
+template <std::ranges::view T>
+void FormatValue(TStringBuilderBase* builder, const T& collection, TStringBuf /*spec*/);
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace NYT
+
+#define RANGE_FORMATTERS_INL_H_
+#include "range_formatters-inl.h"
+#undef RANGE_FORMATTERS_INL_H_
diff --git a/library/cpp/yt/misc/range_helpers-inl.h b/library/cpp/yt/misc/range_helpers-inl.h
new file mode 100644
index 00000000000..52649602903
--- /dev/null
+++ b/library/cpp/yt/misc/range_helpers-inl.h
@@ -0,0 +1,165 @@
+#ifndef RANGE_HELPERS_INL_H_
+#error "Direct inclusion of this file is not allowed, include range_helpers.h"
+// For the sake of sane code completion.
+#include "range_helpers.h"
+#endif
+
+namespace NYT {
+namespace NDetail {
+
+////////////////////////////////////////////////////////////////////////////////
+
+template <class TContainer>
+struct TAppendTo
+{ };
+
+template <class TContainer>
+    requires requires (TContainer container, typename TContainer::value_type value) {
+        container.push_back(value);
+    }
+struct TAppendTo<TContainer>
+{
+    template <class TValue>
+    static void Append(TContainer& container, TValue&& value)
+    {
+        container.push_back(std::forward<TValue>(value));
+    }
+};
+
+template <class TContainer>
+    requires requires (TContainer container, typename TContainer::value_type value) {
+        container.insert(value);
+    }
+struct TAppendTo<TContainer>
+{
+    template <class TValue>
+    static void Append(TContainer& container, TValue&& value)
+    {
+        container.insert(std::forward<TValue>(value));
+    }
+};
+
+////////////////////////////////////////////////////////////////////////////////
+
+template <class TContainer>
+struct TRangeTo
+{ };
+
+template <class TContainer>
+    requires requires (TContainer container, typename TContainer::value_type value) {
+        TAppendTo<TContainer>::Append(container, value);
+    }
+struct TRangeTo<TContainer>
+{
+    template <std::ranges::input_range TRange>
+    static auto ToContainer(TRange&& range)
+    {
+        TContainer container;
+        if constexpr (requires { std::ranges::size(range); } &&
+            requires { container.reserve(std::declval<size_t>()); })
+        {
+            container.reserve(std::ranges::size(range));
+        }
+
+        for (auto&& element : range) {
+            TAppendTo<TContainer>::Append(container, std::forward<decltype(element)>(element));
+        }
+
+        return container;
+    }
+
+    template <class... TValues>
+    static auto StaticRangeToContainer(TValues... values)
+    {
+        TContainer container;
+        if constexpr (requires { container.reserve(std::declval<size_t>()); })
+        {
+            container.reserve(sizeof...(TValues));
+        }
+
+        (TAppendTo<TContainer>::Append(container, std::forward<TValues>(values)), ...);
+        return container;
+    }
+};
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace NDetail
+
+////////////////////////////////////////////////////////////////////////////////
+
+template <std::ranges::range... TContainers>
+auto ZipMutable(TContainers&&... containers) {
+    return Zip(std::ranges::views::transform(containers, [] <class T> (T&& t) {
+        return &t;
+    })...);
+}
+
+template <class TContainer, std::ranges::input_range TRange>
+auto RangeTo(TRange&& range)
+{
+    return NDetail::TRangeTo<TContainer>::template ToContainer<TRange>(std::forward<TRange>(range));
+}
+
+template <class TContainer>
+constexpr auto RangeTo()
+{
+    return NDetail::TRangeToTag<TContainer>();
+}
+
+template<std::ranges::input_range TRange, class TContainer>
+auto operator|(TRange&& range, NDetail::TRangeToTag<TContainer>)
+{
+    return RangeTo<TContainer>(std::forward<TRange>(range));
+}
+
+template <class TContainer, std::ranges::input_range TRange, class TTransformFunction>
+auto TransformRangeTo(TRange&& range, TTransformFunction&& function)
+{
+    return RangeTo<TContainer>(std::ranges::views::transform(
+        std::forward<TRange>(range),
+        std::forward<TTransformFunction>(function)));
+}
+
+template <class TContainer, class... TValues>
+    requires (std::constructible_from<typename TContainer::value_type, TValues> && ...)
+TContainer StaticRangeTo(TValues... values)
+{
+    return NDetail::TRangeTo<TContainer>::template StaticRangeToContainer<TValues...>(std::forward<TValues>(values)...);
+}
+
+template <class... TValues>
+struct TStaticRange
+{
+public:
+    explicit TStaticRange(TValues... values)
+        : Tuple_(std::forward<TValues>(values)...)
+    { }
+
+    template <class TContainer>
+    operator TContainer() &&
+    {
+        return std::apply(&StaticRangeTo<TContainer, TValues...>, std::move(Tuple_));
+    }
+
+private:
+    std::tuple<TValues...> Tuple_;
+};
+
+template <std::ranges::range TRange, class TOperation, class TProjection>
+auto FoldRange(TRange&& range, TOperation operation, TProjection projection)
+{
+    auto iter = range.begin();
+    if (iter == range.end()) {
+        return std::remove_cvref_t<decltype(std::invoke(projection, *iter))>{};
+    }
+    auto accumulator = std::invoke(projection, *iter);
+    for (++iter; iter != range.end(); ++iter) {
+        accumulator = std::invoke(operation, accumulator, std::invoke(projection, *iter));
+    }
+    return accumulator;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace NYT
diff --git a/library/cpp/yt/misc/range_helpers.h b/library/cpp/yt/misc/range_helpers.h
new file mode 100644
index 00000000000..bab26b93824
--- /dev/null
+++ b/library/cpp/yt/misc/range_helpers.h
@@ -0,0 +1,70 @@
+#pragma once
+
+#include <library/cpp/iterator/zip.h>
+
+#include <ranges>
+
+namespace NYT {
+
+////////////////////////////////////////////////////////////////////////////////
+
+namespace NDetail {
+
+template <class TContainer>
+struct TRangeToTag
+{ };
+
+} // namespace NDetail
+
+////////////////////////////////////////////////////////////////////////////////
+
+//! An equivalent of Python's `zip()`, but resulting range consists of tuples
+//! of pointers and has length equal to the length of the shortest container.
+//! Implementation with mutable references depends on "lifetime extension in
+//! range-based for loops" from C++23.
+template <std::ranges::range... TRanges>
+auto ZipMutable(TRanges&&... ranges);
+
+//! Converts the provided range to the specified container.
+//! This is a simplified equivalent of std::ranges::to from ranges-v3.
+template <class TContainer, std::ranges::input_range TRange>
+auto RangeTo(TRange&& range);
+
+//! Range to for monadic operations
+template <class TContainer>
+constexpr auto RangeTo();
+
+//! Monadic operations to use RangeTo. Example:
+//! auto filteredHashSet = vec | std::views::filter(pred) | RangeTo<THashSet<int>>();
+template<std::ranges::input_range TRange, class TContainer>
+auto operator|(TRange&& range, NDetail::TRangeToTag<TContainer>);
+
+//! Converts a parameter pack into the specified container.
+//! Useful for constructing containers of move-only types.
+//! Note that `std::vector<TMoveOnly>{std::move(a), std::move(b)}`
+//! will not compile since std::initializer_list has only const iterators.
+//! However, `StaticRangeTo<std::vector<TMoveOnly>>(std::move(a), std::move(b))` will work.
+template <class TContainer, class... TValues>
+    requires (std::constructible_from<typename TContainer::value_type, TValues> && ...)
+TContainer StaticRangeTo(TValues... values);
+
+//! A tuple wrapper with implicit casts to containers via `StaticRangeTo`.
+//! Useful for container list-initialization e.g. `std::vector<TMoveOnly> foo = TStaticRange{std::move(bar)};`.
+template <class... TValues>
+struct TStaticRange;
+
+//! Shortcut for `RangeTo(std::ranges::views::transform)`.
+template <class TContainer, std::ranges::input_range TRange, class TTransformFunction>
+auto TransformRangeTo(TRange&& range, TTransformFunction&& function);
+
+//! An equivalent of std::ranges::fold_left from ranges-v3.
+template <std::ranges::range TRange, class TOperation, class TProjection = std::identity>
+auto FoldRange(TRange&& range, TOperation operation, TProjection projection = {});
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace NYT
+
+#define RANGE_HELPERS_INL_H_
+#include "range_helpers-inl.h"
+#undef RANGE_HELPERS_INL_H_
diff --git a/library/cpp/yt/misc/source_location-inl.h b/library/cpp/yt/misc/source_location-inl.h
index 9948260874a..8edff29812f 100644
--- a/library/cpp/yt/misc/source_location-inl.h
+++ b/library/cpp/yt/misc/source_location-inl.h
@@ -4,10 +4,22 @@
 #include "source_location.h"
 #endif
 
+#include <string>
+
 namespace NYT {
 
 ////////////////////////////////////////////////////////////////////////////////
 
+template <size_t N>
+consteval TSourceLocationLite<N> MakeSourceLocationLite(const char* fileName, i64 line)
+{
+    TSourceLocationLite<N> result{.FileName = {}, .Line = line};
+    std::char_traits<char>::copy(result.FileName, fileName, N + 1);
+    return result;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
 inline TSourceLocation::TSourceLocation(const char* fileName, int line)
     : FileName_(fileName)
     , Line_(line)
@@ -20,6 +32,12 @@ inline TSourceLocation::TSourceLocation(const std::source_location& location)
 { }
 #endif // __cpp_lib_source_location
 
+template <auto LocationLite>
+TSourceLocation TSourceLocation::FromLite()
+{
+    return TSourceLocation(LocationLite.FileName, LocationLite.Line);
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 
-} // namespace std
+} // namespace NYT
diff --git a/library/cpp/yt/misc/source_location.cpp b/library/cpp/yt/misc/source_location.cpp
index 598126f5a71..8d22d43636c 100644
--- a/library/cpp/yt/misc/source_location.cpp
+++ b/library/cpp/yt/misc/source_location.cpp
@@ -1,32 +1,11 @@
 #include "source_location.h"
 
-#include <library/cpp/yt/string/format.h>
-
 #include <string.h>
 
 namespace NYT {
 
 ////////////////////////////////////////////////////////////////////////////////
 
-#ifdef __cpp_lib_source_location
-
-void FormatValue(TStringBuilderBase* builder, const std::source_location& location, TStringBuf /*spec*/)
-{
-    if (location.file_name() != nullptr) {
-        builder->AppendFormat(
-            "%v:%v:%v",
-            location.file_name(),
-            location.line(),
-            location.column());
-    } else {
-        builder->AppendString("<unknown>");
-    }
-}
-
-#endif // __cpp_lib_source_location
-
-////////////////////////////////////////////////////////////////////////////////
-
 const char* TSourceLocation::GetFileName() const
 {
     return FileName_;
@@ -70,18 +49,6 @@ bool TSourceLocation::operator==(const TSourceLocation& other) const
         Line_ == other.Line_;
 }
 
-void FormatValue(TStringBuilderBase* builder, const TSourceLocation& location, TStringBuf /*spec*/)
-{
-    if (location.GetFileName() != nullptr) {
-        builder->AppendFormat(
-            "%v:%v",
-            location.GetFileName(),
-            location.GetLine());
-    } else {
-        builder->AppendString("<unknown>");
-    }
-}
-
 ////////////////////////////////////////////////////////////////////////////////
 
 } // namespace NYT
diff --git a/library/cpp/yt/misc/source_location.h b/library/cpp/yt/misc/source_location.h
index 286527887ae..586593867da 100644
--- a/library/cpp/yt/misc/source_location.h
+++ b/library/cpp/yt/misc/source_location.h
@@ -10,12 +10,15 @@ namespace NYT {
 
 ////////////////////////////////////////////////////////////////////////////////
 
-class TStringBuilderBase;
+template <size_t N>
+struct TSourceLocationLite
+{
+    char FileName[N + 1];
+    i64 Line;
+};
 
-// TODO(dgolear): Drop when LLVM-14 is eradicated.
-#ifdef __cpp_lib_source_location
-void FormatValue(TStringBuilderBase* builder, const std::source_location& location, TStringBuf /*spec*/);
-#endif // __cpp_lib_source_location
+template <size_t N>
+consteval TSourceLocationLite<N> MakeSourceLocationLite(const char* fileName, i64 line);
 
 ////////////////////////////////////////////////////////////////////////////////
 
@@ -28,6 +31,9 @@ class TSourceLocation
     explicit TSourceLocation(const std::source_location& location);
 #endif // __cpp_lib_source_location
 
+    template <auto LocationLite>
+    static TSourceLocation FromLite();
+
     const char* GetFileName() const;
     int GetLine() const;
     bool IsValid() const;
@@ -40,6 +46,15 @@ class TSourceLocation
     int Line_ = -1;
 };
 
+#ifdef __cpp_lib_source_location
+#define YT_CURRENT_SOURCE_LOCATION_LITE \
+    ::NYT::MakeSourceLocationLite<std::char_traits<char>::length(std::source_location::current().file_name())>( \
+        std::source_location::current().file_name(), \
+        std::source_location::current().line())
+#else
+#define YT_CURRENT_SOURCE_LOCATION_LITE ::NYT::MakeSourceLocationLite<std::char_traits<char>::length(__FILE__)>(__FILE__, __LINE__)
+#endif // __cpp_lib_source_location
+
 //! Defines a macro to record the current source location.
 #ifdef __cpp_lib_source_location
 #define YT_CURRENT_SOURCE_LOCATION ::NYT::TSourceLocation(std::source_location::current())
@@ -47,8 +62,6 @@ class TSourceLocation
 #define YT_CURRENT_SOURCE_LOCATION ::NYT::TSourceLocation(__FILE__, __LINE__)
 #endif // __cpp_lib_source_location
 
-void FormatValue(TStringBuilderBase* builder, const TSourceLocation& location, TStringBuf spec);
-
 ////////////////////////////////////////////////////////////////////////////////
 
 } // namespace NYT
diff --git a/library/cpp/yt/misc/static_initializer.h b/library/cpp/yt/misc/static_initializer.h
new file mode 100644
index 00000000000..ebaa35a1a24
--- /dev/null
+++ b/library/cpp/yt/misc/static_initializer.h
@@ -0,0 +1,19 @@
+#pragma once
+
+#include "preprocessor.h"
+
+namespace NYT {
+
+////////////////////////////////////////////////////////////////////////////////
+
+//! Static initializer will be invoked prior to entering |main|.
+//! The exact order of these invocations is, of course, undefined.
+#define YT_STATIC_INITIALIZER(...) \
+    [[maybe_unused]] static inline const void* PP_ANONYMOUS_VARIABLE(StaticInitializer) = [] { \
+        __VA_ARGS__; \
+        return nullptr; \
+    } ()
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace NYT
diff --git a/library/cpp/yt/misc/strong_typedef-fwd.h b/library/cpp/yt/misc/strong_typedef-fwd.h
new file mode 100644
index 00000000000..ec7ba65ebf5
--- /dev/null
+++ b/library/cpp/yt/misc/strong_typedef-fwd.h
@@ -0,0 +1,17 @@
+#pragma once
+
+namespace NYT {
+
+////////////////////////////////////////////////////////////////////////////////
+
+struct TStrongTypedefOptions
+{
+    bool IsComparable = true;
+};
+
+template <class T, class TTag, TStrongTypedefOptions Options = TStrongTypedefOptions()>
+class TStrongTypedef;
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace NYT
diff --git a/library/cpp/yt/misc/strong_typedef-inl.h b/library/cpp/yt/misc/strong_typedef-inl.h
index 0e9adee1867..faf1017867e 100644
--- a/library/cpp/yt/misc/strong_typedef-inl.h
+++ b/library/cpp/yt/misc/strong_typedef-inl.h
@@ -6,6 +6,8 @@
 
 #include "wrapper_traits.h"
 
+#include <util/ysaveload.h>
+
 #include <util/generic/strbuf.h>
 
 #include <functional>
@@ -14,83 +16,92 @@ namespace NYT {
 
 ////////////////////////////////////////////////////////////////////////////////
 
-template <class T, class TTag>
-constexpr TStrongTypedef<T, TTag>::TStrongTypedef()
+template <class T, class TTag, TStrongTypedefOptions Options>
+constexpr TStrongTypedef<T, TTag, Options>::TStrongTypedef()
     requires std::is_default_constructible_v<T>
     : Underlying_{}
 { }
 
-template <class T, class TTag>
-constexpr TStrongTypedef<T, TTag>::TStrongTypedef(const T& underlying)
+template <class T, class TTag, TStrongTypedefOptions Options>
+constexpr TStrongTypedef<T, TTag, Options>::TStrongTypedef(const T& underlying)
     requires std::is_copy_constructible_v<T>
     : Underlying_(underlying)
 { }
 
-template <class T, class TTag>
-constexpr TStrongTypedef<T, TTag>::TStrongTypedef(T&& underlying)
+template <class T, class TTag, TStrongTypedefOptions Options>
+constexpr TStrongTypedef<T, TTag, Options>::TStrongTypedef(T&& underlying)
     requires std::is_move_constructible_v<T>
     : Underlying_(std::move(underlying))
 { }
 
-template <class T, class TTag>
-constexpr TStrongTypedef<T, TTag>::operator const T&() const
+template <class T, class TTag, TStrongTypedefOptions Options>
+constexpr TStrongTypedef<T, TTag, Options>::operator const T&() const
 {
     return Underlying_;
 }
 
-template <class T, class TTag>
-constexpr TStrongTypedef<T, TTag>::operator T&()
+template <class T, class TTag, TStrongTypedefOptions Options>
+constexpr TStrongTypedef<T, TTag, Options>::operator T&()
 {
     return Underlying_;
 }
 
-template <class T, class TTag>
-constexpr T& TStrongTypedef<T, TTag>::Underlying() &
+template <class T, class TTag, TStrongTypedefOptions Options>
+constexpr T& TStrongTypedef<T, TTag, Options>::Underlying() &
 {
     return Underlying_;
 }
 
-template <class T, class TTag>
-constexpr const T& TStrongTypedef<T, TTag>::Underlying() const&
+template <class T, class TTag, TStrongTypedefOptions Options>
+constexpr const T& TStrongTypedef<T, TTag, Options>::Underlying() const&
 {
     return Underlying_;
 }
 
-template <class T, class TTag>
-constexpr T&& TStrongTypedef<T, TTag>::Underlying() &&
+template <class T, class TTag, TStrongTypedefOptions Options>
+constexpr T&& TStrongTypedef<T, TTag, Options>::Underlying() &&
 {
     return std::move(Underlying_);
 }
 
-#define XX(op, defaultValue) \
-    template <class T, class TTag> \
-    constexpr auto TStrongTypedef<T, TTag>::operator op(const TStrongTypedef& rhs) const \
+#define XX(returnType, op) \
+    template <class T, class TTag, TStrongTypedefOptions Options> \
+    constexpr returnType TStrongTypedef<T, TTag, Options>::operator op(const TStrongTypedef& rhs) const \
         noexcept(noexcept(Underlying_ op rhs.Underlying_)) \
-            requires requires (T lhs, T rhs) {lhs op rhs; } \
+            requires requires (T lhs, T rhs) { lhs op rhs; } && (Options.IsComparable) \
     { \
-        if constexpr (std::same_as<T, void>) { \
-            return defaultValue; \
-        } \
         return Underlying_ op rhs.Underlying_; \
     }
 
-XX(<, false)
-XX(>, false)
-XX(<=, true)
-XX(>=, true)
-XX(==, true)
-XX(!=, false)
-XX(<=>, std::strong_ordering::equal)
+XX(bool, <)
+XX(bool, >)
+XX(bool, <=)
+XX(bool, >=)
+XX(bool, ==)
+XX(bool, !=)
+XX(auto, <=>)
 
 #undef XX
 
-template <class T, class TTag>
-TStrongTypedef<T, TTag>::operator bool() const
+template <class T, class TTag, TStrongTypedefOptions Options>
+TStrongTypedef<T, TTag, Options>::operator bool() const
     noexcept(noexcept(static_cast<bool>(Underlying_)))
 {
     return static_cast<bool>(Underlying_);
 }
 
+template <class T, class TTag, TStrongTypedefOptions Options>
+void TStrongTypedef<T, TTag, Options>::Save(IOutputStream* out) const
+{
+    ::Save(out, Underlying_);
+}
+
+template <class T, class TTag, TStrongTypedefOptions Options>
+void TStrongTypedef<T, TTag, Options>::Load(IInputStream* in)
+{
+    ::Load(in, Underlying_);
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 
 template <class T>
@@ -99,8 +110,8 @@ struct TStrongTypedefTraits
     constexpr static bool IsStrongTypedef = false;
 };
 
-template <class T, class TTag>
-struct TStrongTypedefTraits<TStrongTypedef<T, TTag>>
+template <class T, class TTag, TStrongTypedefOptions Options>
+struct TStrongTypedefTraits<TStrongTypedef<T, TTag, Options>>
 {
     constexpr static bool IsStrongTypedef = true;
     using TUnderlying = T;
@@ -119,8 +130,8 @@ bool TryFromStringImpl(const TChar* data, size_t size, T& value)
 
 class TStringBuilderBase;
 
-template <class T, class TTag>
-void FormatValue(TStringBuilderBase* builder, const TStrongTypedef<T, TTag>& value, TStringBuf format)
+template <class T, class TTag, TStrongTypedefOptions Options>
+void FormatValue(TStringBuilderBase* builder, const TStrongTypedef<T, TTag, Options>& value, TStringBuf format)
     noexcept(noexcept(FormatValue(builder, value.Underlying(), format)))
 {
     FormatValue(builder, value.Underlying(), format);
@@ -128,20 +139,20 @@ void FormatValue(TStringBuilderBase* builder, const TStrongTypedef<T, TTag>& val
 
 ////////////////////////////////////////////////////////////////////////////////
 
-template <class T, class TTag>
-struct TBasicWrapperTraits<TStrongTypedef<T, TTag>>
+template <class T, class TTag, TStrongTypedefOptions Options>
+struct TBasicWrapperTraits<TStrongTypedef<T, TTag, Options>>
 {
     static constexpr bool IsTrivialWrapper = false;
 
     using TUnwrapped = T;
 
-    static constexpr bool HasValue(const TStrongTypedef<T, TTag>&) noexcept
+    static constexpr bool HasValue(const TStrongTypedef<T, TTag, Options>&) noexcept
     {
         return true;
     }
 
     template <class U>
-        requires std::same_as<std::remove_cvref_t<U>, TStrongTypedef<T, TTag>>
+        requires std::same_as<std::remove_cvref_t<U>, TStrongTypedef<T, TTag, Options>>
     static constexpr decltype(auto) Unwrap(U&& wrapper) noexcept
     {
         return std::forward<U>(wrapper).Underlying();
@@ -150,16 +161,25 @@ struct TBasicWrapperTraits<TStrongTypedef<T, TTag>>
 
 ////////////////////////////////////////////////////////////////////////////////
 
+//! Abseil hash support for TStrongTypedef.
+template <class THash, class T, class TTag, TStrongTypedefOptions Options>
+THash AbslHashValue(THash hash, const TStrongTypedef<T, TTag, Options>& value)
+{
+    return THash::combine(std::move(hash), value.Underlying());
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
 } // namespace NYT
 
 namespace std {
 
 ////////////////////////////////////////////////////////////////////////////////
 
-template <class T, class TTag>
-struct hash<NYT::TStrongTypedef<T, TTag>>
+template <class T, class TTag, NYT::TStrongTypedefOptions Options>
+struct hash<NYT::TStrongTypedef<T, TTag, Options>>
 {
-    size_t operator()(const NYT::TStrongTypedef<T, TTag>& value) const
+    size_t operator()(const NYT::TStrongTypedef<T, TTag, Options>& value) const
     {
         return std::hash<T>()(value.Underlying());
     }
@@ -167,9 +187,9 @@ struct hash<NYT::TStrongTypedef<T, TTag>>
 
 ////////////////////////////////////////////////////////////////////////////////
 
-template <class T, class TTag>
+template <class T, class TTag, NYT::TStrongTypedefOptions Options>
     requires std::numeric_limits<T>::is_specialized
-class numeric_limits<NYT::TStrongTypedef<T, TTag>>
+class numeric_limits<NYT::TStrongTypedef<T, TTag, Options>>
 {
 public:
     #define XX(name) \
@@ -202,9 +222,9 @@ class numeric_limits<NYT::TStrongTypedef<T, TTag>>
     #undef XX
 
     #define XX(name) \
-        static constexpr NYT::TStrongTypedef<T, TTag> name() noexcept \
+        static constexpr NYT::TStrongTypedef<T, TTag, Options> name() noexcept \
         { \
-            return NYT::TStrongTypedef<T, TTag>(numeric_limits<T>::name()); \
+            return NYT::TStrongTypedef<T, TTag, Options>(numeric_limits<T>::name()); \
         }
 
     XX(min)
@@ -226,10 +246,10 @@ class numeric_limits<NYT::TStrongTypedef<T, TTag>>
 
 ////////////////////////////////////////////////////////////////////////////////
 
-template <class T, class TTag>
-struct THash<NYT::TStrongTypedef<T, TTag>>
+template <class T, class TTag, NYT::TStrongTypedefOptions Options>
+struct THash<NYT::TStrongTypedef<T, TTag, Options>>
 {
-    size_t operator()(const NYT::TStrongTypedef<T, TTag>& value) const
+    size_t operator()(const NYT::TStrongTypedef<T, TTag, Options>& value) const
     {
         static constexpr bool IsHashable = requires (T value) {
             { THash<T>()(value) } -> std::same_as<size_t>;
@@ -245,8 +265,8 @@ struct THash<NYT::TStrongTypedef<T, TTag>>
 
 ////////////////////////////////////////////////////////////////////////////////
 
-template <class T, class TTag>
-IOutputStream& operator<<(IOutputStream& out, const NYT::TStrongTypedef<T, TTag>& value)
+template <class T, class TTag, NYT::TStrongTypedefOptions Options>
+IOutputStream& operator<<(IOutputStream& out, const NYT::TStrongTypedef<T, TTag, Options>& value)
 {
     return out << value.Underlying();
 }
diff --git a/library/cpp/yt/misc/strong_typedef.h b/library/cpp/yt/misc/strong_typedef.h
index 58d96ebd2cf..1cd0707f2e2 100644
--- a/library/cpp/yt/misc/strong_typedef.h
+++ b/library/cpp/yt/misc/strong_typedef.h
@@ -1,14 +1,18 @@
 #pragma once
 
+#include "strong_typedef-fwd.h"
+
 #include <utility>
 
 #include <util/generic/string.h>
 
+#include <util/stream/fwd.h>
+
 namespace NYT {
 
 ////////////////////////////////////////////////////////////////////////////////
 
-template <class T, class TTag>
+template <class T, class TTag, TStrongTypedefOptions Options>
 class TStrongTypedef
 {
 public:
@@ -32,18 +36,18 @@ class TStrongTypedef
     constexpr explicit operator const T&() const;
     constexpr explicit operator T&();
 
-    #define XX(op) \
-        constexpr auto operator op(const TStrongTypedef& rhs) const \
+    #define XX(returnType, op) \
+        constexpr returnType operator op(const TStrongTypedef& rhs) const \
             noexcept(noexcept(Underlying_ op rhs.Underlying_)) \
-                requires requires(T lhs, T rhs) {lhs op rhs; };
+            requires requires(T lhs, T rhs) { lhs op rhs; } && (Options.IsComparable);
 
-    XX(<)
-    XX(>)
-    XX(<=)
-    XX(>=)
-    XX(==)
-    XX(!=)
-    XX(<=>)
+    XX(bool, <)
+    XX(bool, >)
+    XX(bool, <=)
+    XX(bool, >=)
+    XX(bool, ==)
+    XX(bool, !=)
+    XX(auto, <=>)
 
     #undef XX
 
@@ -54,14 +58,18 @@ class TStrongTypedef
     constexpr const T& Underlying() const &;
     constexpr T&& Underlying() &&;
 
+    void Save(IOutputStream* out) const;
+    void Load(IInputStream* in);
+
 private:
     T Underlying_;
 };
 
-#define YT_DEFINE_STRONG_TYPEDEF(T, TUnderlying) \
+#define YT_DEFINE_STRONG_TYPEDEF(T, TUnderlying, ...) \
     struct T ## Tag \
     { }; \
-    using T = ::NYT::TStrongTypedef<TUnderlying, T##Tag>; \
+    using T = ::NYT::TStrongTypedef<TUnderlying, T##Tag __VA_OPT__(, ) __VA_ARGS__>; \
+    static_assert(true)
 
 template <class T>
 struct TStrongTypedefTraits;
diff --git a/library/cpp/yt/misc/tag_invoke.h b/library/cpp/yt/misc/tag_invoke.h
new file mode 100644
index 00000000000..94cec9b295d
--- /dev/null
+++ b/library/cpp/yt/misc/tag_invoke.h
@@ -0,0 +1,95 @@
+#pragma once
+
+#include "concepts.h"
+
+namespace NYT {
+
+////////////////////////////////////////////////////////////////////////////////
+
+namespace NTagInvokeDetail {
+
+// This name shadows possible overloads of TagInvoke from parent namespaces
+// which could be found by normal unqualified name lookup.
+void TagInvoke() = delete;
+
+////////////////////////////////////////////////////////////////////////////////
+
+// NB(arkady-e1ppa): We do not use trailing return type there in order to
+// allow incomplete tag types to be safely used here.
+struct TFn
+{
+    template <class TTag, class... TArgs>
+        requires requires (TTag&& tag, TArgs&&... args) {
+            // "Adl finds TagInvoke overload".
+            TagInvoke(std::forward<TTag>(tag), std::forward<TArgs>(args)...);
+        }
+    constexpr decltype(auto) operator()(TTag&& tag, TArgs&&... args) const
+        noexcept(noexcept(TagInvoke(std::forward<TTag>(tag), std::forward<TArgs>(args)...)))
+    {
+        return TagInvoke(std::forward<TTag>(tag), std::forward<TArgs>(args)...);
+    }
+};
+
+} // namespace NTagInvokeDetail
+
+////////////////////////////////////////////////////////////////////////////////
+
+// Inline namespace is required so that there is no conflict with
+// customizations of TagInvoke defined as friend function definition
+// inside a class from namespace NYT.
+inline namespace NTagInvokeCPO {
+
+inline constexpr NTagInvokeDetail::TFn TagInvoke = {};
+
+} // inline namespace NTagInvokeCPO
+
+////////////////////////////////////////////////////////////////////////////////
+
+// Some helpful concepts and aliases.
+template <class TTag, class... TArgs>
+concept CTagInvocable = requires (TTag&& tag, TArgs&&... args) {
+    NYT::TagInvoke(std::forward<TTag>(tag), std::forward<TArgs>(args)...);
+};
+
+////////////////////////////////////////////////////////////////////////////////
+
+template <class TTag, class... TArgs>
+concept CNothrowTagInvocable =
+    CTagInvocable<TTag, TArgs...> &&
+    requires (TTag&& tag, TArgs&&... args) {
+        { NYT::TagInvoke(std::forward<TTag>(tag), std::forward<TArgs>(args)...) } noexcept;
+    };
+
+////////////////////////////////////////////////////////////////////////////////
+
+template <class TTag, class... TArgs>
+using TTagInvokeResult = std::invoke_result_t<decltype(NYT::TagInvoke), TTag, TArgs...>;
+
+////////////////////////////////////////////////////////////////////////////////
+
+template <auto V>
+using TTagInvokeTag = std::decay_t<decltype(V)>;
+
+////////////////////////////////////////////////////////////////////////////////
+
+namespace NDetail {
+
+template <class TTag, class TSignature>
+struct TTagInvokeTraitsHelper;
+
+template <class TTag, class TReturn, bool NoExcept, class... TArgs>
+struct TTagInvokeTraitsHelper<TTag, TReturn(TArgs...) noexcept(NoExcept)>
+{
+    static constexpr bool IsInvocable = NYT::CInvocable<decltype(NYT::TagInvoke), TReturn(TTag, TArgs...) noexcept(NoExcept)>;
+};
+
+} // namespace NDetail
+
+////////////////////////////////////////////////////////////////////////////////
+
+template <class TTag, class TSignature>
+concept CTagInvocableS = NDetail::TTagInvokeTraitsHelper<TTag, TSignature>::IsInvocable;
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace NYT
diff --git a/library/cpp/yt/misc/tag_invoke_cpo.h b/library/cpp/yt/misc/tag_invoke_cpo.h
new file mode 100644
index 00000000000..9526df8adc0
--- /dev/null
+++ b/library/cpp/yt/misc/tag_invoke_cpo.h
@@ -0,0 +1,25 @@
+#pragma once
+
+#include "tag_invoke.h"
+
+namespace NYT {
+
+////////////////////////////////////////////////////////////////////////////////
+
+// CRTP-base which defines a baseline CPO behavior e.g.
+// "If there is TagInvoke overload with the correct tag, use it".
+template <class TThis>
+struct TTagInvokeCpoBase
+{
+    template <class... TArgs>
+        requires CTagInvocable<const TThis&, TArgs...>
+    constexpr decltype(auto) operator()(TArgs&&... args) const
+        noexcept(CNothrowTagInvocable<const TThis&, TArgs...>)
+    {
+        return NYT::TagInvoke(static_cast<const TThis&>(*this), std::forward<TArgs>(args)...);
+    }
+};
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace NYT
diff --git a/library/cpp/yt/misc/typeid-inl.h b/library/cpp/yt/misc/typeid-inl.h
new file mode 100644
index 00000000000..a4518cfa46c
--- /dev/null
+++ b/library/cpp/yt/misc/typeid-inl.h
@@ -0,0 +1,49 @@
+#ifndef TYPEID_INL_H_
+#error "Direct inclusion of this file is not allowed, include typeid.h"
+// For the sake of sane code completion.
+#include "typeid.h"
+#endif
+
+#include "port.h"
+
+#include <util/system/compiler.h>
+
+namespace NYT {
+
+////////////////////////////////////////////////////////////////////////////////
+
+namespace NDetail {
+
+template <class T>
+class TTypeidTag
+{ };
+
+} // namespace NDetail
+
+template <class T>
+const std::type_info& Typeid()
+{
+    if constexpr (requires { TypeidImpl(NDetail::TTypeidTag<T>()); }) {
+        return TypeidImpl(NDetail::TTypeidTag<T>());
+    } else {
+        return typeid(T);
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+#undef YT_DECLARE_TYPEID
+#undef YT_DEFINE_TYPEID
+
+#define YT_DECLARE_TYPEID(type) \
+    [[maybe_unused]] YT_ATTRIBUTE_USED const std::type_info& TypeidImpl(::NYT::NDetail::TTypeidTag<type>);
+
+#define YT_DEFINE_TYPEID(type) \
+    [[maybe_unused]] YT_ATTRIBUTE_USED Y_FORCE_INLINE const std::type_info& TypeidImpl(::NYT::NDetail::TTypeidTag<type>) \
+    { \
+        return typeid(type); \
+    }
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace NYT
diff --git a/library/cpp/yt/misc/typeid.h b/library/cpp/yt/misc/typeid.h
new file mode 100644
index 00000000000..d4584e64f2f
--- /dev/null
+++ b/library/cpp/yt/misc/typeid.h
@@ -0,0 +1,27 @@
+#pragma once
+
+#include <typeinfo>
+
+namespace NYT {
+
+////////////////////////////////////////////////////////////////////////////////
+// Enables accessing type_info for incomplete types.
+
+//! Place this macro in header file after forward-declaring a type.
+#define YT_DECLARE_TYPEID(type)
+
+//! Place this macro in header or source file after fully defining a type.
+#define YT_DEFINE_TYPEID(type)
+
+//! Equivalent to |typeid(T)| but also works for incomplete types
+//! annotated with YT_DECLARE_TYPEID.
+template <class T>
+const std::type_info& Typeid();
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace NYT
+
+#define TYPEID_INL_H_
+#include "typeid-inl.h"
+#undef TYPEID_INL_H_
diff --git a/library/cpp/yt/misc/unittests/cast_ut.cpp b/library/cpp/yt/misc/unittests/cast_ut.cpp
new file mode 100644
index 00000000000..ebb83485f89
--- /dev/null
+++ b/library/cpp/yt/misc/unittests/cast_ut.cpp
@@ -0,0 +1,113 @@
+#include <library/cpp/testing/gtest/gtest.h>
+
+#include <library/cpp/yt/misc/cast.h>
+#include <library/cpp/yt/misc/enum.h>
+
+namespace NYT {
+namespace {
+
+////////////////////////////////////////////////////////////////////////////////
+
+DEFINE_ENUM_WITH_UNDERLYING_TYPE(ECardinal, char,
+    ((West)  (0))
+    ((North) (1))
+    ((East)  (2))
+    ((South) (3))
+);
+
+DEFINE_BIT_ENUM_WITH_UNDERLYING_TYPE(EFeatures, ui8,
+    ((None)  (0x0000))
+    ((First) (0x0001))
+    ((Second)(0x0002))
+);
+
+DEFINE_BIT_ENUM(ELangsWithUnknown,
+    ((None)       (0x00))
+    ((Cpp)        (0x01))
+    ((Go)         (0x02))
+    ((Rust)       (0x04))
+    ((Python)     (0x08))
+    ((JavaScript) (0x10))
+    ((CppGo)      (0x03))
+    ((All)        (0x1f))
+    ((Unknown)    (0x20))
+);
+DEFINE_ENUM_UNKNOWN_VALUE(ELangsWithUnknown, Unknown);
+
+DEFINE_ENUM(EColorWithUnknown,
+    ((Red)     (0))
+    ((Green)   (1))
+    ((Unknown) (2))
+);
+DEFINE_ENUM_UNKNOWN_VALUE(EColorWithUnknown, Unknown);
+
+TEST(TCastTest, TryCheckedEnumCast)
+{
+    EXPECT_EQ((TryCheckedEnumCast<ECardinal, char>(2)), ECardinal::East);
+    EXPECT_EQ((TryCheckedEnumCast<ECardinal, int>(3)), ECardinal::South);
+
+    EXPECT_FALSE((TryCheckedEnumCast<ECardinal, char>(100)));
+    EXPECT_FALSE((TryCheckedEnumCast<ECardinal, int>(300)));
+
+    EXPECT_EQ((TryCheckedEnumCast<EFeatures, ui8>(0)), EFeatures::None);
+    EXPECT_EQ((TryCheckedEnumCast<EFeatures, ui8>(ToUnderlying(EFeatures::First))), EFeatures::First);
+    EXPECT_EQ((TryCheckedEnumCast<EFeatures, ui8>(ToUnderlying(EFeatures::Second))), EFeatures::Second);
+    EXPECT_EQ((TryCheckedEnumCast<EFeatures, int>(ToUnderlying(EFeatures::First))), EFeatures::First);
+    EXPECT_EQ((TryCheckedEnumCast<EFeatures, ui8>(ToUnderlying(EFeatures::First | EFeatures::Second))), EFeatures::First | EFeatures::Second);
+
+    EXPECT_FALSE((TryCheckedEnumCast<EFeatures, ui8>(0x10)));
+
+    EXPECT_FALSE(TryCheckedEnumCast<EColorWithUnknown>(3));
+    EXPECT_EQ(TryCheckedEnumCast<EColorWithUnknown>(3, /*enableUnknown*/ true), EColorWithUnknown::Unknown);
+
+    EXPECT_FALSE(TryCheckedEnumCast<ELangsWithUnknown>(0x40));
+    EXPECT_EQ(TryCheckedEnumCast<ELangsWithUnknown>(0x40, /*enableUnknown*/ true), ELangsWithUnknown::Unknown);
+    EXPECT_EQ(TryCheckedEnumCast<ELangsWithUnknown>(0x41, /*enableUnknown*/ true), ELangsWithUnknown::Unknown | ELangsWithUnknown::Cpp);
+}
+
+TEST(TCastTest, CheckedEnumCast)
+{
+    EXPECT_EQ((CheckedEnumCast<ECardinal, char>(2)), ECardinal::East);
+    EXPECT_EQ((CheckedEnumCast<ECardinal, int>(3)), ECardinal::South);
+
+    EXPECT_THROW((CheckedEnumCast<ECardinal, char>(100)), TSimpleException);
+    EXPECT_THROW((CheckedEnumCast<ECardinal, int>(300)), TSimpleException);
+
+    EXPECT_EQ((CheckedEnumCast<EFeatures, ui8>(0)), EFeatures::None);
+    EXPECT_EQ((CheckedEnumCast<EFeatures, ui8>(ToUnderlying(EFeatures::First))), EFeatures::First);
+    EXPECT_EQ((CheckedEnumCast<EFeatures, ui8>(ToUnderlying(EFeatures::Second))), EFeatures::Second);
+    EXPECT_EQ((CheckedEnumCast<EFeatures, int>(ToUnderlying(EFeatures::First))), EFeatures::First);
+    EXPECT_EQ((CheckedEnumCast<EFeatures, ui8>(ToUnderlying(EFeatures::First | EFeatures::Second))), EFeatures::First | EFeatures::Second);
+
+    EXPECT_THROW((CheckedEnumCast<EFeatures, ui8>(0x10)), TSimpleException);
+
+    EXPECT_EQ(CheckedEnumCast<EColorWithUnknown>(3), EColorWithUnknown::Unknown);
+
+    EXPECT_EQ(CheckedEnumCast<ELangsWithUnknown>(0x40), ELangsWithUnknown::Unknown);
+    EXPECT_EQ(CheckedEnumCast<ELangsWithUnknown>(0x41), ELangsWithUnknown::Unknown | ELangsWithUnknown::Cpp);
+}
+
+TEST(TCastTest, IntegralCasts)
+{
+    static_assert(CanFitSubtype<i64, i32>());
+    static_assert(CanFitSubtype<ui64, ui32>());
+    static_assert(CanFitSubtype<ui64, ui64>());
+    static_assert(!CanFitSubtype<ui64, i32>());
+    static_assert(!CanFitSubtype<i32, i64>());
+
+    static_assert(IsInIntegralRange<ui32>(0));
+    static_assert(IsInIntegralRange<ui32>(1ull));
+    static_assert(!IsInIntegralRange<ui32>(-1));
+    static_assert(!IsInIntegralRange<i32>(std::numeric_limits<i64>::max()));
+
+    static_assert(IsInIntegralRange<i32>(1ull));
+    static_assert(IsInIntegralRange<i32>(-1));
+    static_assert(!IsInIntegralRange<ui32>(-1));
+    static_assert(!IsInIntegralRange<ui32>(std::numeric_limits<i64>::max()));
+    static_assert(IsInIntegralRange<ui64>(std::numeric_limits<i64>::max()));
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace
+} // namespace NYT
diff --git a/library/cpp/yt/misc/unittests/compare_ut.cpp b/library/cpp/yt/misc/unittests/compare_ut.cpp
new file mode 100644
index 00000000000..da149a0690e
--- /dev/null
+++ b/library/cpp/yt/misc/unittests/compare_ut.cpp
@@ -0,0 +1,62 @@
+#include <library/cpp/testing/gtest/gtest.h>
+
+#include <library/cpp/yt/misc/compare.h>
+
+namespace NYT {
+namespace {
+
+////////////////////////////////////////////////////////////////////////////////
+
+TEST(TCompareTest, TernaryCompare)
+{
+    EXPECT_EQ(TernaryCompare(123, 123), 0);
+    EXPECT_EQ(TernaryCompare(10, 20), -1);
+    EXPECT_EQ(TernaryCompare(20, 10), +1);
+    EXPECT_EQ(TernaryCompare(std::nan("1"), std::nan("1")), +1);
+    EXPECT_EQ(TernaryCompare(std::nan("1"), std::nan("2")), +1);
+    EXPECT_EQ(TernaryCompare(std::nan("1"), 123.0), +1);
+    EXPECT_EQ(TernaryCompare(123.0, std::nan("1")), +1);
+}
+
+TEST(TCompareTest, NaNSafeTernaryCompare)
+{
+    EXPECT_EQ(NaNSafeTernaryCompare(std::nan("1"), std::nan("1")), 0);
+    EXPECT_EQ(NaNSafeTernaryCompare(std::nan("1"), std::nan("2")), 0);
+    EXPECT_EQ(NaNSafeTernaryCompare(123.0, std::nan("1")), -1);
+    EXPECT_EQ(NaNSafeTernaryCompare(std::nan("1"), 123.0), +1);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+template <class T>
+class TTernaryCompareStringTest
+    : public ::testing::Test
+{ };
+
+TYPED_TEST_SUITE_P(TTernaryCompareStringTest);
+
+TYPED_TEST_P(TTernaryCompareStringTest, Compare)
+{
+    EXPECT_EQ(TernaryCompare(TypeParam("abc"), TypeParam("abc")), 0);
+    EXPECT_EQ(TernaryCompare(TypeParam("x"), TypeParam("y")), -1);
+    EXPECT_EQ(TernaryCompare(TypeParam("y"), TypeParam("x")), +1);
+}
+
+REGISTER_TYPED_TEST_SUITE_P(TTernaryCompareStringTest, Compare);
+
+using TTernaryCompareStringTestTypes = ::testing::Types<
+    TString,
+    TStringBuf,
+    std::string,
+    std::string_view
+>;
+
+INSTANTIATE_TYPED_TEST_SUITE_P(
+    TypeParametrized,
+    TTernaryCompareStringTest,
+    TTernaryCompareStringTestTypes);
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace
+} // namespace NYT
diff --git a/library/cpp/yt/misc/unittests/enum_ut.cpp b/library/cpp/yt/misc/unittests/enum_ut.cpp
index 63b8666ae1e..e55b3ae4dfb 100644
--- a/library/cpp/yt/misc/unittests/enum_ut.cpp
+++ b/library/cpp/yt/misc/unittests/enum_ut.cpp
@@ -29,6 +29,12 @@ DEFINE_BIT_ENUM(EFlag,
     ((_4)(0x0008))
 );
 
+DEFINE_BIT_ENUM(EAmbiguousFlag,
+    ((A)  (0x1))
+    ((B)  (0x2))
+    ((AB) (0x3))
+);
+
 DEFINE_AMBIGUOUS_ENUM_WITH_UNDERLYING_TYPE(EMultipleNames, int,
      (A1)
     ((A2)(0))
@@ -50,6 +56,13 @@ DEFINE_ENUM_WITH_UNDERLYING_TYPE(ECardinal, char,
     ((South) (3))
 );
 
+DEFINE_ENUM(EWithUnknown,
+    (First)
+    (Second)
+    (Unknown)
+);
+DEFINE_ENUM_UNKNOWN_VALUE(EWithUnknown, Unknown);
+
 ////////////////////////////////////////////////////////////////////////////////
 
 template <class T, size_t N>
@@ -203,6 +216,33 @@ TEST(TEnumTest, DomainValues)
     EXPECT_EQ(colorValues, ToVector(TEnumTraits<EColor>::GetDomainValues()));
 }
 
+TEST(TEnumTest, IsKnownValue)
+{
+    EXPECT_TRUE(TEnumTraits<ESimple>::IsKnownValue(ESimple::X));
+    EXPECT_TRUE(TEnumTraits<ESimple>::IsKnownValue(ESimple::Y));
+    EXPECT_TRUE(TEnumTraits<ESimple>::IsKnownValue(ESimple::Z));
+    EXPECT_FALSE(TEnumTraits<ESimple>::IsKnownValue(static_cast<ESimple>(100)));
+}
+
+TEST(TEnumTest, IsValidValue)
+{
+    EXPECT_TRUE(TEnumTraits<ESimple>::IsValidValue(ESimple::X));
+    EXPECT_TRUE(TEnumTraits<ESimple>::IsValidValue(ESimple::Y));
+    EXPECT_TRUE(TEnumTraits<ESimple>::IsValidValue(ESimple::Z));
+    EXPECT_FALSE(TEnumTraits<ESimple>::IsValidValue(static_cast<ESimple>(100)));
+
+    EXPECT_TRUE(TEnumTraits<EFlag>::IsValidValue(EFlag()));
+    EXPECT_TRUE(TEnumTraits<EFlag>::IsValidValue(EFlag::_1));
+    EXPECT_TRUE(TEnumTraits<EFlag>::IsValidValue(EFlag::_1 | EFlag::_2));
+    EXPECT_TRUE(TEnumTraits<EFlag>::IsValidValue(EFlag::_1 | EFlag::_2 | EFlag::_3 | EFlag::_4));
+    EXPECT_FALSE(TEnumTraits<EFlag>::IsValidValue(static_cast<EFlag>(0x10)));
+}
+
+TEST(TEnumTest, AllSetValue)
+{
+    EXPECT_EQ(TEnumTraits<EFlag>::GetAllSetValue(), EFlag::_1 | EFlag::_2 | EFlag::_3 | EFlag::_4);
+}
+
 TEST(TEnumTest, Decompose1)
 {
     auto f = EFlag(0);
@@ -257,31 +297,20 @@ TEST(TEnumTest, CustomString)
     EXPECT_EQ("1_b", ToString(ECustomString::B));
 }
 
-TEST(TEnumTest, Cast)
+TEST(TEnumTest, UnknownValue)
 {
-    ECardinal cardinal;
-    {
-        char validValue = 2;
-        EXPECT_TRUE(TryEnumCast(validValue, &cardinal));
-        EXPECT_EQ(cardinal, ECardinal::East);
-    }
-    {
-        char invalidValue = 100;
-        EXPECT_FALSE(TryEnumCast(invalidValue, &cardinal));
-    }
-    {
-        int widerTypeValidValue = 3;
-        EXPECT_TRUE(TryEnumCast(widerTypeValidValue, &cardinal));
-        EXPECT_EQ(cardinal, ECardinal::South);
-    }
-    {
-        int widerTypeInvalueValue = (1 << 8) + 100;
-        EXPECT_FALSE(TryEnumCast(widerTypeInvalueValue, &cardinal));
-    }
+    EXPECT_EQ(TEnumTraits<EColor>::TryGetUnknownValue(), std::nullopt);
+    EXPECT_EQ(TEnumTraits<EWithUnknown>::TryGetUnknownValue(), EWithUnknown::Unknown);
+}
+
+TEST(TEnumTest, PopCount)
+{
+    EXPECT_EQ(PopCount(EAmbiguousFlag::A), 1);
+    EXPECT_EQ(PopCount(EAmbiguousFlag::B), 1);
+    EXPECT_EQ(PopCount(EAmbiguousFlag::AB), 2);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 } // namespace
 } // namespace NYT
-
diff --git a/library/cpp/yt/misc/unittests/hash_ut.cpp b/library/cpp/yt/misc/unittests/hash_ut.cpp
new file mode 100644
index 00000000000..0695d32d47a
--- /dev/null
+++ b/library/cpp/yt/misc/unittests/hash_ut.cpp
@@ -0,0 +1,27 @@
+#include <library/cpp/testing/gtest/gtest.h>
+
+#include <library/cpp/yt/misc/hash.h>
+
+namespace NYT {
+namespace {
+
+////////////////////////////////////////////////////////////////////////////////
+
+TEST(THashTest, NaNSafeHash)
+{
+    EXPECT_EQ(NaNSafeHash(123), THash<int>()(123));
+    EXPECT_EQ(NaNSafeHash(std::nan("1")), NaNSafeHash(std::nan("2")));
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+TEST(THashTest, SplitMix64Test)
+{
+    EXPECT_EQ(SplitMix(0), 0xe220a8397b1dcdafULL);
+    EXPECT_EQ(SplitMix(12345), 0x22118258a9d111a0ULL);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace
+} // namespace NYT
diff --git a/library/cpp/yt/misc/unittests/preprocessor_ut.cpp b/library/cpp/yt/misc/unittests/preprocessor_ut.cpp
index b712d8a48f5..e4c88a7fe8e 100644
--- a/library/cpp/yt/misc/unittests/preprocessor_ut.cpp
+++ b/library/cpp/yt/misc/unittests/preprocessor_ut.cpp
@@ -104,6 +104,19 @@ TEST(TPreprocessorTest, Deparen)
     EXPECT_STREQ("( a, b)", PP_STRINGIZE((PP_DEPAREN((a, b)))));
 }
 
+TEST(TPreprocessorTest, IsEmpty)
+{
+    EXPECT_EQ(1, PP_IF(PP_IS_EMPTY(), 1, 2));
+    EXPECT_EQ(1, PP_IF(PP_IS_EMPTY(PP_EMPTINESS), 1, 2));
+    EXPECT_EQ(1, PP_IF(PP_IS_EMPTY(PP_EMPTY()), 1, 2));
+    EXPECT_EQ(1, PP_IF(PP_IS_EMPTY(PP_EMPTY PP_LEFT_PARENTHESIS PP_RIGHT_PARENTHESIS), 1, 2));
+
+    EXPECT_EQ(2, PP_IF(PP_IS_EMPTY(()), 1, 2));
+    EXPECT_EQ(2, PP_IF(PP_IS_EMPTY(PP_EMPTY), 1, 2));
+    EXPECT_EQ(2, PP_IF(PP_IS_EMPTY(0), 1, 2));
+    EXPECT_EQ(2, PP_IF(PP_IS_EMPTY(hello), 1, 2));
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 
 } // namespace
diff --git a/library/cpp/yt/misc/unittests/range_helpers_ut.cpp b/library/cpp/yt/misc/unittests/range_helpers_ut.cpp
new file mode 100644
index 00000000000..b69c8f58d44
--- /dev/null
+++ b/library/cpp/yt/misc/unittests/range_helpers_ut.cpp
@@ -0,0 +1,127 @@
+#include <library/cpp/yt/misc/range_helpers.h>
+
+#include <library/cpp/testing/gtest/gtest.h>
+
+#include <list>
+
+namespace NYT {
+namespace {
+
+////////////////////////////////////////////////////////////////////////////////
+
+TEST(TRangeHelpersTest, ZipMutable)
+{
+    std::vector<int> vectorA(4);
+    std::vector<int> vectorB = {1, 2, 3};
+    for (auto [a, b] : ZipMutable(vectorA, vectorB)) {
+        *a = *b + 1;
+    }
+
+    auto expectedA = std::vector<int>{2, 3, 4, 0};
+    EXPECT_EQ(expectedA, vectorA);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+TEST(TRangeHelpersTest, RangeToVector)
+{
+    auto data = std::vector<std::string>{"A", "B", "C", "D"};
+    auto range = std::ranges::views::transform(data, [] (std::string x) {
+        return "_" + x;
+    });
+
+    std::initializer_list<std::string> expectedValues{"_A", "_B", "_C", "_D"};
+    EXPECT_EQ(std::vector<std::string>(expectedValues), RangeTo<std::vector<std::string>>(range));
+    using TListStrings = std::list<std::string>;
+    EXPECT_EQ(TListStrings(expectedValues), RangeTo<TListStrings>(range));
+}
+
+TEST(TRangeHelpersTest, RangeToString)
+{
+    auto data = "_sample_"sv;
+    auto range = std::ranges::views::filter(data, [] (char x) {
+        return x != '_';
+    });
+    auto expectedData = "sample"sv;
+
+    EXPECT_EQ(std::string(expectedData), RangeTo<std::string>(range));
+    EXPECT_EQ(TString(expectedData), RangeTo<TString>(range));
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+TEST(TRangeHelpersTest, MonadicRangeToVector)
+{
+    auto data = std::vector<std::string>{"A", "B", "C", "D"};
+    auto range = std::ranges::views::transform(data, [] (std::string x) {
+        return "_" + x;
+    });
+
+    std::initializer_list<std::string> expectedValues{"_A", "_B", "_C", "_D"};
+    EXPECT_EQ(std::vector<std::string>(expectedValues), range | RangeTo<std::vector<std::string>>());
+    using TListStrings = std::list<std::string>;
+    EXPECT_EQ(TListStrings(expectedValues), range  | RangeTo<TListStrings>());
+}
+
+TEST(TRangeHelpersTest, MonadicRangeToString)
+{
+    auto data = "_sample_"sv;
+    auto range = std::ranges::views::filter(data, [] (char x) {
+        return x != '_';
+    });
+    auto expectedData = "sample"sv;
+
+    EXPECT_EQ(std::string(expectedData), range | RangeTo<std::string>());
+    EXPECT_EQ(TString(expectedData), range | RangeTo<TString>());
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+TEST(TRangeHelpersTest, Fold)
+{
+    EXPECT_EQ(0, FoldRange(std::vector<int>{}, std::plus{}));
+    EXPECT_EQ(6, FoldRange(std::vector<int>{1, 2, 3}, std::plus{}));
+    EXPECT_EQ(5, FoldRange(
+        std::vector<std::vector<int>>{{1, 2}, {3, 4, 5}},
+        std::plus{},
+        std::ranges::ssize));
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+TEST(TRangeHelpersTest, StaticRangeToVector)
+{
+    EXPECT_EQ(StaticRangeTo<std::vector<int>>(1), std::vector<int>{1});
+    auto expected = std::vector<int>{1, 2, 10};
+    auto result = StaticRangeTo<std::vector<int>>(1, 2, 10);
+    EXPECT_EQ(result, expected);
+}
+
+TEST(TRangeHelpersTest, StaticRangeToVectorMoveOnly)
+{
+    auto result = StaticRangeTo<std::vector<std::unique_ptr<int>>>(std::make_unique<int>(1), std::make_unique<int>(2));
+    ASSERT_EQ(std::ssize(result), 2);
+    EXPECT_EQ(*result[0], 1);
+    EXPECT_EQ(*result[1], 2);
+}
+
+TEST(TRangeHelpersTest, TStaticRangeToVector)
+{
+    EXPECT_EQ(static_cast<std::vector<int>>(TStaticRange{1}), std::vector<int>{1});
+    auto expected = std::vector<int>{1, 2, 10};
+    std::vector<int> result = TStaticRange{1, 2, 10};
+    EXPECT_EQ(result, expected);
+}
+
+TEST(TRangeHelpersTest, TStaticRangeToVectorMoveOnly)
+{
+    std::vector<std::unique_ptr<int>> result = TStaticRange(std::make_unique<int>(1), std::make_unique<int>(2));
+    ASSERT_EQ(std::ssize(result), 2);
+    EXPECT_EQ(*result[0], 1);
+    EXPECT_EQ(*result[1], 2);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace
+} // namespace NYT
diff --git a/library/cpp/yt/misc/unittests/tag_invoke_cpo_ut.cpp b/library/cpp/yt/misc/unittests/tag_invoke_cpo_ut.cpp
new file mode 100644
index 00000000000..d7ae073c89f
--- /dev/null
+++ b/library/cpp/yt/misc/unittests/tag_invoke_cpo_ut.cpp
@@ -0,0 +1,107 @@
+#include <library/cpp/testing/gtest/gtest.h>
+
+#include <library/cpp/yt/misc/tag_invoke.h>
+#include <library/cpp/yt/misc/tag_invoke_cpo.h>
+
+namespace NYT {
+namespace {
+
+////////////////////////////////////////////////////////////////////////////////
+
+inline constexpr struct TFooFn
+{
+
+    // Customizable overload.
+    template <class... TArgs>
+        requires CTagInvocable<TFooFn, TArgs...>
+    constexpr decltype(auto) operator() (TArgs&&... args) const
+        noexcept(noexcept(NYT::TagInvoke(*this, std::forward<TArgs>(args)...)))
+    {
+        return NYT::TagInvoke(*this, std::forward<TArgs>(args)...);
+    }
+
+    // Default overload.
+    template <class... TArgs>
+        requires (!CTagInvocable<TFooFn, TArgs...>)
+    constexpr decltype(auto) operator() (TArgs&&...) const
+        noexcept
+    {
+        return 42;
+    }
+} Foo = {};
+
+////////////////////////////////////////////////////////////////////////////////
+
+TEST(TTagInvokeUsageTests, DefaultOverload)
+{
+    EXPECT_EQ(Foo(42), 42);
+
+    struct TTTT
+    { };
+
+    EXPECT_EQ(Foo(TTTT{}), 42);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+template <bool NoExcept>
+struct TCustomFoo
+{
+    int Val;
+
+    friend int TagInvoke(TTagInvokeTag<Foo>, TCustomFoo f) noexcept(NoExcept)
+    {
+        return f.Val + 11;
+    }
+};
+
+////////////////////////////////////////////////////////////////////////////////
+
+TEST(TTagInvokeUsageTests, CustomOverload)
+{
+    static_assert(CTagInvocable<TTagInvokeTag<Foo>, TCustomFoo<true>>);
+    static_assert(CTagInvocable<TTagInvokeTag<Foo>, TCustomFoo<false>>);
+    static_assert(CNothrowTagInvocable<TTagInvokeTag<Foo>, TCustomFoo<true>>);
+    static_assert(!CNothrowTagInvocable<TTagInvokeTag<Foo>, TCustomFoo<false>>);
+
+    EXPECT_EQ(Foo(TCustomFoo<true>{.Val = 42}), 53);
+    EXPECT_EQ(Foo(TCustomFoo<false>{.Val = 42}), 53);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+inline constexpr struct TBarFn
+    : public TTagInvokeCpoBase<TBarFn>
+{ } Bar = {};
+
+template <class T>
+concept CBarable = requires (T&& t) {
+    Bar(t);
+};
+
+////////////////////////////////////////////////////////////////////////////////
+
+struct THasCustom
+{
+    friend int TagInvoke(TTagInvokeTag<Bar>, THasCustom)
+    {
+        return 11;
+    }
+};
+
+////////////////////////////////////////////////////////////////////////////////
+
+TEST(TTagInvokeCpoTests, JustWorks)
+{
+    struct TNoCustom
+    { };
+    static_assert(!CBarable<TNoCustom>);
+
+    static_assert(CBarable<THasCustom>);
+    EXPECT_EQ(Bar(THasCustom{}), 11);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace
+} // namespace NYT
diff --git a/library/cpp/yt/misc/unittests/tag_invoke_impl_ut.cpp b/library/cpp/yt/misc/unittests/tag_invoke_impl_ut.cpp
new file mode 100644
index 00000000000..e3ac0b58f25
--- /dev/null
+++ b/library/cpp/yt/misc/unittests/tag_invoke_impl_ut.cpp
@@ -0,0 +1,72 @@
+////////////////////////////////////////////////////////////////////////////////
+// NB(arkady-e1ppa): This decl/def order is intentional to simulate some tricky
+// patterns of inclusion order.
+
+namespace NYT {
+namespace {
+
+////////////////////////////////////////////////////////////////////////////////
+
+// This overload should be visible by direct call
+// from namespaces enclosing ns NYT
+// but invisible to any template code
+// therefore it must not affect CTagInvocable concept.
+template <class T, class U>
+int TagInvoke(const T&, const U&)
+{
+    return 42;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace
+
+////////////////////////////////////////////////////////////////////////////////
+
+// NB(arkady-e1ppa): Weird name to avoid ODR violation while keeping the
+// struct inside of ns NYT (and not some anonymous ones).
+struct TUniquelyTaggedForTagInvokeImplUt
+{
+    friend int TagInvoke(TUniquelyTaggedForTagInvokeImplUt, int v)
+    {
+        return v + 2;
+    }
+};
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace NYT
+
+////////////////////////////////////////////////////////////////////////////////
+
+// Actual includes start.
+#include <library/cpp/testing/gtest/gtest.h>
+
+#include <library/cpp/yt/misc/tag_invoke.h>
+
+////////////////////////////////////////////////////////////////////////////////
+
+namespace NYT {
+namespace {
+
+////////////////////////////////////////////////////////////////////////////////
+
+TEST(TTagInvokeCompileTests, UnqualidTemplate)
+{
+    static_assert(!CTagInvocable<int, int>);
+    // Unqualified finds overload defined above
+    // and never the CPO since constraints fail.
+    EXPECT_EQ(TagInvoke(42, 42), 42);
+}
+
+TEST(TTagInvokeCompileTests, HiddenFriend)
+{
+    static_assert(CTagInvocable<TUniquelyTaggedForTagInvokeImplUt, int>);
+    EXPECT_EQ(TagInvoke(TUniquelyTaggedForTagInvokeImplUt{}, 42), 44);
+    EXPECT_EQ(NYT::TagInvoke(TUniquelyTaggedForTagInvokeImplUt{}, 42), 44);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace
+} // namespace NYT
diff --git a/library/cpp/yt/misc/unittests/typeid_sample.cpp b/library/cpp/yt/misc/unittests/typeid_sample.cpp
new file mode 100644
index 00000000000..9a3184e458b
--- /dev/null
+++ b/library/cpp/yt/misc/unittests/typeid_sample.cpp
@@ -0,0 +1,14 @@
+#include "typeid_sample.h"
+
+namespace NYT {
+
+////////////////////////////////////////////////////////////////////////////////
+
+struct TTypeidIncomplete
+{ };
+
+YT_DEFINE_TYPEID(TTypeidIncomplete);
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace NYT
diff --git a/library/cpp/yt/misc/unittests/typeid_sample.h b/library/cpp/yt/misc/unittests/typeid_sample.h
new file mode 100644
index 00000000000..d6b5a288b5f
--- /dev/null
+++ b/library/cpp/yt/misc/unittests/typeid_sample.h
@@ -0,0 +1,17 @@
+#pragma once
+
+#include <library/cpp/yt/misc/typeid.h>
+
+namespace NYT {
+
+////////////////////////////////////////////////////////////////////////////////
+
+struct TTypeidIncomplete;
+YT_DECLARE_TYPEID(TTypeidIncomplete);
+
+struct TTypeidComplete
+{ };
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace NYT
diff --git a/library/cpp/yt/misc/unittests/typeid_ut.cpp b/library/cpp/yt/misc/unittests/typeid_ut.cpp
new file mode 100644
index 00000000000..3400c832e26
--- /dev/null
+++ b/library/cpp/yt/misc/unittests/typeid_ut.cpp
@@ -0,0 +1,25 @@
+#include "typeid_sample.h"
+
+#include <library/cpp/yt/misc/typeid.h>
+
+#include <library/cpp/testing/gtest/gtest.h>
+
+namespace NYT {
+namespace {
+
+////////////////////////////////////////////////////////////////////////////////
+
+TEST(TTypeidTest, Complete)
+{
+    EXPECT_NE(std::string(Typeid<TTypeidComplete>().name()).find("TTypeidComplete"), std::string::npos);
+}
+
+TEST(TTypeidTest, Incomplete)
+{
+    EXPECT_NE(std::string(Typeid<TTypeidIncomplete>().name()).find("TTypeidIncomplete"), std::string::npos);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace
+} // namespace NYT
diff --git a/library/cpp/yt/misc/variant-inl.h b/library/cpp/yt/misc/variant-inl.h
deleted file mode 100644
index 4b0e04c92c7..00000000000
--- a/library/cpp/yt/misc/variant-inl.h
+++ /dev/null
@@ -1,50 +0,0 @@
-#ifndef VARIANT_INL_H_
-#error "Direct inclusion of this file is not allowed, include variant.h"
-// For the sake of sane code completion.
-#include "variant.h"
-#endif
-
-#include <type_traits>
-
-namespace NYT {
-
-////////////////////////////////////////////////////////////////////////////////
-
-namespace NDetail {
-
-template <size_t Index, class... Ts>
-struct TVariantFormatter;
-
-template <size_t Index>
-struct TVariantFormatter<Index>
-{
-    template <class TVariant>
-    static void Do(TStringBuilderBase* /*builder*/, const TVariant& /*variant*/, TStringBuf /*spec*/)
-    { }
-};
-
-template <size_t Index, class T, class... Ts>
-struct TVariantFormatter<Index, T, Ts...>
-{
-    template <class TVariant>
-    static void Do(TStringBuilderBase* builder, const TVariant& variant, TStringBuf spec)
-    {
-        if (variant.index() == Index) {
-            FormatValue(builder, std::get<Index>(variant), spec);
-        } else {
-            TVariantFormatter<Index + 1, Ts...>::Do(builder, variant, spec);
-        }
-    }
-};
-
-} // namespace NDetail
-
-template <class... Ts>
-void FormatValue(TStringBuilderBase* builder, const std::variant<Ts...>& variant, TStringBuf spec)
-{
-    NDetail::TVariantFormatter<0, Ts...>::Do(builder, variant, spec);
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-} // namespace NYT
diff --git a/library/cpp/yt/misc/variant.cpp b/library/cpp/yt/misc/variant.cpp
deleted file mode 100644
index df78563d0c9..00000000000
--- a/library/cpp/yt/misc/variant.cpp
+++ /dev/null
@@ -1,16 +0,0 @@
-#include "variant.h"
-
-#include <library/cpp/yt/string/string_builder.h>
-
-namespace NYT {
-
-////////////////////////////////////////////////////////////////////////////////
-
-void FormatValue(TStringBuilderBase* builder, const std::monostate&, TStringBuf /*spec*/)
-{
-    builder->AppendString(TStringBuf("<monostate>"));
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-} // namespace NYT
diff --git a/library/cpp/yt/misc/variant.h b/library/cpp/yt/misc/variant.h
index 9e8e1220897..7cc3d8ddda1 100644
--- a/library/cpp/yt/misc/variant.h
+++ b/library/cpp/yt/misc/variant.h
@@ -7,15 +7,6 @@ namespace NYT {
 
 ////////////////////////////////////////////////////////////////////////////////
 
-class TStringBuilderBase;
-
-template <class... Ts>
-void FormatValue(TStringBuilderBase* builder, const std::variant<Ts...>& variant, TStringBuf spec);
-
-void FormatValue(TStringBuilderBase* builder, const std::monostate&, TStringBuf /*spec*/);
-
-////////////////////////////////////////////////////////////////////////////////
-
 //! A concise way of creating a functor with an overloaded operator().
 /*!
  *  Very useful for std::visit-ing variants. For example:
@@ -50,7 +41,3 @@ auto Visit(T&& variant, U&&... visitorOverloads)
 ////////////////////////////////////////////////////////////////////////////////
 
 } // namespace NYT
-
-#define VARIANT_INL_H_
-#include "variant-inl.h"
-#undef VARIANT_INL_H_
diff --git a/library/cpp/yt/small_containers/compact_flat_map-inl.h b/library/cpp/yt/small_containers/compact_flat_map-inl.h
deleted file mode 100644
index 459d72fa2c1..00000000000
--- a/library/cpp/yt/small_containers/compact_flat_map-inl.h
+++ /dev/null
@@ -1,244 +0,0 @@
-#ifndef COMPACT_FLAT_MAP_INL_H_
-#error "Direct inclusion of this file is not allowed, include compact_flat_map.h"
-// For the sake of sane code completion.
-#include "compact_flat_map.h"
-#endif
-
-namespace NYT {
-
-///////////////////////////////////////////////////////////////////////////////
-
-template <class K, class V, size_t N>
-template <class TInputIterator>
-TCompactFlatMap<K, V, N>::TCompactFlatMap(TInputIterator begin, TInputIterator end)
-{
-    insert(begin, end);
-}
-
-template <class K, class V, size_t N>
-TCompactFlatMap<K, V, N>::TCompactFlatMap(std::initializer_list<value_type> values)
-    : TCompactFlatMap<K, V, N>(values.begin(), values.end())
-{ }
-
-template <class K, class V, size_t N>
-bool TCompactFlatMap<K, V, N>::operator==(const TCompactFlatMap& rhs) const
-{
-    return Storage_ == rhs.Storage_;
-}
-
-template <class K, class V, size_t N>
-bool TCompactFlatMap<K, V, N>::operator!=(const TCompactFlatMap& rhs) const
-{
-    return !(*this == rhs);
-}
-
-template <class K, class V, size_t N>
-typename TCompactFlatMap<K, V, N>::iterator TCompactFlatMap<K, V, N>::begin()
-{
-    return Storage_.begin();
-}
-
-template <class K, class V, size_t N>
-typename TCompactFlatMap<K, V, N>::const_iterator TCompactFlatMap<K, V, N>::begin() const
-{
-    return Storage_.begin();
-}
-
-template <class K, class V, size_t N>
-typename TCompactFlatMap<K, V, N>::const_iterator TCompactFlatMap<K, V, N>::cbegin() const
-{
-    return Storage_.begin();
-}
-
-template <class K, class V, size_t N>
-typename TCompactFlatMap<K, V, N>::iterator TCompactFlatMap<K, V, N>::end()
-{
-    return Storage_.end();
-}
-
-template <class K, class V, size_t N>
-typename TCompactFlatMap<K, V, N>::const_iterator TCompactFlatMap<K, V, N>::end() const
-{
-    return Storage_.end();
-}
-
-template <class K, class V, size_t N>
-typename TCompactFlatMap<K, V, N>::const_iterator TCompactFlatMap<K, V, N>::cend() const
-{
-    return Storage_.end();
-}
-
-template <class K, class V, size_t N>
-void TCompactFlatMap<K, V, N>::reserve(size_type n)
-{
-    Storage_.reserve(n);
-}
-
-template <class K, class V, size_t N>
-typename TCompactFlatMap<K, V, N>::size_type TCompactFlatMap<K, V, N>::size() const
-{
-    return Storage_.size();
-}
-
-template <class K, class V, size_t N>
-int TCompactFlatMap<K, V, N>::ssize() const
-{
-    return static_cast<int>(Storage_.size());
-}
-
-template <class K, class V, size_t N>
-bool TCompactFlatMap<K, V, N>::empty() const
-{
-    return Storage_.empty();
-}
-
-template <class K, class V, size_t N>
-void TCompactFlatMap<K, V, N>::clear()
-{
-    Storage_.clear();
-}
-
-template <class K, class V, size_t N>
-void TCompactFlatMap<K, V, N>::shrink_to_small()
-{
-    Storage_.shrink_to_small();
-}
-
-template <class K, class V, size_t N>
-typename TCompactFlatMap<K, V, N>::iterator TCompactFlatMap<K, V, N>::find(const K& k)
-{
-    auto [rangeBegin, rangeEnd] = equal_range(k);
-    return rangeBegin == rangeEnd ? end() : rangeBegin;
-}
-
-template <class K, class V, size_t N>
-typename TCompactFlatMap<K, V, N>::const_iterator TCompactFlatMap<K, V, N>::find(const K& k) const
-{
-    auto [rangeBegin, rangeEnd] = equal_range(k);
-    return rangeBegin == rangeEnd ? end() : rangeBegin;
-}
-
-template <class K, class V, size_t N>
-bool TCompactFlatMap<K, V, N>::contains(const K& k) const
-{
-    return find(k) != end();
-}
-
-template <class K, class V, size_t N>
-auto TCompactFlatMap<K, V, N>::insert(const value_type& value) -> std::pair<iterator, bool>
-{
-    return do_insert(value);
-}
-
-template <class K, class V, size_t N>
-auto TCompactFlatMap<K, V, N>::insert(value_type&& value) -> std::pair<iterator, bool>
-{
-    return do_insert(std::move(value));
-}
-
-template <class K, class V, size_t N>
-template <class TArg>
-auto TCompactFlatMap<K, V, N>::do_insert(TArg&& value) -> std::pair<iterator, bool>
-{
-    auto [rangeBegin, rangeEnd] = equal_range(value.first);
-    if (rangeBegin != rangeEnd) {
-        return {rangeBegin, false};
-    } else {
-        auto it = Storage_.insert(rangeBegin, std::forward<TArg>(value));
-        return {it, true};
-    }
-}
-
-template <class K, class V, size_t N>
-template <class TInputIterator>
-void TCompactFlatMap<K, V, N>::insert(TInputIterator begin, TInputIterator end)
-{
-    for (auto it = begin; it != end; ++it) {
-        insert(*it);
-    }
-}
-
-template <class K, class V, size_t N>
-template <class... TArgs>
-auto TCompactFlatMap<K, V, N>::emplace(TArgs&&... args) -> std::pair<iterator, bool>
-{
-    return insert(value_type(std::forward<TArgs>(args)...));
-}
-
-template <class K, class V, size_t N>
-V& TCompactFlatMap<K, V, N>::operator[](const K& k)
-{
-    auto [it, inserted] = insert({k, V()});
-    return it->second;
-}
-
-template <class K, class V, size_t N>
-void TCompactFlatMap<K, V, N>::erase(const K& k)
-{
-    auto [rangeBegin, rangeEnd] = equal_range(k);
-    erase(rangeBegin, rangeEnd);
-}
-
-template <class K, class V, size_t N>
-void TCompactFlatMap<K, V, N>::erase(iterator pos)
-{
-    Storage_.erase(pos);
-
-    // Try to keep the storage inline. This is why erase doesn't return an iterator.
-    Storage_.shrink_to_small();
-}
-
-template <class K, class V, size_t N>
-void TCompactFlatMap<K, V, N>::erase(iterator b, iterator e)
-{
-    Storage_.erase(b, e);
-
-    // Try to keep the storage inline. This is why erase doesn't return an iterator.
-    Storage_.shrink_to_small();
-}
-
-template <class K, class V, size_t N>
-std::pair<typename TCompactFlatMap<K, V, N>::iterator, typename TCompactFlatMap<K, V, N>::iterator>
-TCompactFlatMap<K, V, N>::equal_range(const K& k)
-{
-    auto result = std::equal_range(Storage_.begin(), Storage_.end(), k, TKeyComparer());
-    YT_ASSERT(std::distance(result.first, result.second) <= 1);
-    return result;
-}
-
-template <class K, class V, size_t N>
-std::pair<typename TCompactFlatMap<K, V, N>::const_iterator, typename TCompactFlatMap<K, V, N>::const_iterator>
-TCompactFlatMap<K, V, N>::equal_range(const K& k) const
-{
-    auto result = std::equal_range(Storage_.begin(), Storage_.end(), k, TKeyComparer());
-    YT_ASSERT(std::distance(result.first, result.second) <= 1);
-    return result;
-}
-
-template <class K, class V, size_t N>
-typename TCompactFlatMap<K, V, N>::const_iterator TCompactFlatMap<K, V, N>::lower_bound(const K& k) const
-{
-    return std::lower_bound(Storage_.begin(), Storage_.end(), k, TKeyComparer());
-}
-
-template <class K, class V, size_t N>
-typename TCompactFlatMap<K, V, N>::iterator TCompactFlatMap<K, V, N>::lower_bound(const K& k)
-{
-    return std::lower_bound(Storage_.begin(), Storage_.end(), k, TKeyComparer());
-}
-
-template <class K, class V, size_t N>
-typename TCompactFlatMap<K, V, N>::const_iterator TCompactFlatMap<K, V, N>::upper_bound(const K& k) const
-{
-    return std::upper_bound(Storage_.begin(), Storage_.end(), k, TKeyComparer());
-}
-
-template <class K, class V, size_t N>
-typename TCompactFlatMap<K, V, N>::iterator TCompactFlatMap<K, V, N>::upper_bound(const K& k)
-{
-    return std::upper_bound(Storage_.begin(), Storage_.end(), k, TKeyComparer());
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-} // namespace NYT
diff --git a/library/cpp/yt/string/enum-inl.h b/library/cpp/yt/string/enum-inl.h
index 41f7197d156..922f56d82c6 100644
--- a/library/cpp/yt/string/enum-inl.h
+++ b/library/cpp/yt/string/enum-inl.h
@@ -5,133 +5,152 @@
 #endif
 
 #include "format.h"
+#include "string.h"
+#include "string_builder.h"
 
 #include <library/cpp/yt/exception/exception.h>
 
 #include <util/string/printf.h>
 #include <util/string/strip.h>
 
+#include <span>
+
 namespace NYT {
 
 ////////////////////////////////////////////////////////////////////////////////
 
 namespace NDetail {
 
+////////////////////////////////////////////////////////////////////////////////
+
+using TEnumSuggestionsCalculator = std::string (*)(
+    TStringBuf value,
+    const std::span<const TStringBuf>& domainNames);
+
+extern "C" TEnumSuggestionsCalculator TryGetEnumSuggestionsCalculator();
+
 [[noreturn]]
 void ThrowMalformedEnumValueException(
     TStringBuf typeName,
-    TStringBuf value);
+    TStringBuf value,
+    const std::span<const TStringBuf>& domainNames = {});
 
 void FormatUnknownEnumValue(
-    TStringBuilderBase* builder,
+    auto* builder,
     TStringBuf name,
-    i64 value);
+    auto value)
+{
+    builder->AppendFormat("%v::unknown-%v", name, ToUnderlying(value));
+}
+
+////////////////////////////////////////////////////////////////////////////////
 
 } // namespace NDetail
 
+////////////////////////////////////////////////////////////////////////////////
+
 template <class T>
-std::optional<T> TryParseEnum(TStringBuf value)
+std::optional<T> TryParseEnum(TStringBuf str, bool enableUnknown)
 {
-    auto tryFromString = [] (TStringBuf value) -> std::optional<T> {
-        if (auto decodedValue = TryDecodeEnumValue(value)) {
-            auto enumValue = TEnumTraits<T>::FindValueByLiteral(*decodedValue);
-            return enumValue ? enumValue : TEnumTraits<T>::FindValueByLiteral(value);
-        }
+    auto tryParseToken = [&] (TStringBuf token) -> std::optional<T> {
+        if (auto optionalValue = TEnumTraits<T>::FindValueByLiteral(token)) {
+            return *optionalValue;
 
-        auto reportError = [value] () {
-            throw TSimpleException(Format("Enum value %Qv is neither in a proper underscore case nor in a format \"%v(123)\"",
-                value,
-                TEnumTraits<T>::GetTypeName()));
-        };
-
-        TStringBuf typeName;
-        auto isTypeNameCorrect = value.NextTok('(', typeName) && typeName == TEnumTraits<T>::GetTypeName();
-        if (!isTypeNameCorrect) {
-            reportError();
         }
 
-        TStringBuf enumValue;
-        std::underlying_type_t<T> underlyingValue = 0;
-        auto isEnumValueCorrect = value.NextTok(')', enumValue) && TryFromString(enumValue, underlyingValue);
-        if (!isEnumValueCorrect) {
-            reportError();
+        if (auto optionalDecodedValue = TryDecodeEnumValue(token)) {
+            if (auto optionalValue = TEnumTraits<T>::FindValueByLiteral(*optionalDecodedValue)) {
+                return *optionalValue;
+            }
         }
 
-        auto isParsingComplete = value.empty();
-        if (!isParsingComplete) {
-            reportError();
+        if (enableUnknown) {
+            if constexpr (constexpr auto optionalUnknownValue = TEnumTraits<T>::TryGetUnknownValue()) {
+                return *optionalUnknownValue;
+            }
         }
 
-        return static_cast<T>(underlyingValue);
+        return std::nullopt;
     };
 
     if constexpr (TEnumTraits<T>::IsBitEnum) {
         T result{};
         TStringBuf token;
-        while (value.NextTok('|', token)) {
-            if (auto scalar = tryFromString(StripString(token))) {
-                result |= *scalar;
+        while (str.NextTok('|', token)) {
+            if (auto optionalValue = tryParseToken(StripString(token))) {
+                result |= *optionalValue;
             } else {
                 return {};
             }
         }
         return result;
     } else {
-        return tryFromString(value);
+        return tryParseToken(str);
     }
 }
 
 template <class T>
-T ParseEnum(TStringBuf value)
+T ParseEnum(TStringBuf str)
 {
-    if (auto optionalResult = TryParseEnum<T>(value)) {
+    if (auto optionalResult = TryParseEnum<T>(str, /*enableUnkown*/ true)) {
         return *optionalResult;
     }
-    NYT::NDetail::ThrowMalformedEnumValueException(TEnumTraits<T>::GetTypeName(), value);
+
+    std::span<const TStringBuf> domainNames;
+    if constexpr (requires { TEnumTraits<T>::GetDomainNames(); }) {
+        domainNames = TEnumTraits<T>::GetDomainNames();
+    }
+
+    NYT::NDetail::ThrowMalformedEnumValueException(TEnumTraits<T>::GetTypeName(), str, domainNames);
 }
 
 template <class T>
 void FormatEnum(TStringBuilderBase* builder, T value, bool lowerCase)
 {
-    auto formatScalarValue = [builder, lowerCase] (T value) {
-        auto optionalLiteral = TEnumTraits<T>::FindLiteralByValue(value);
-        if (!optionalLiteral) {
-            NYT::NDetail::FormatUnknownEnumValue(
-                builder,
-                TEnumTraits<T>::GetTypeName(),
-                ToUnderlying(value));
-            return;
-        }
-
+    auto formatLiteral = [&] (auto* builder, TStringBuf literal) {
         if (lowerCase) {
-            CamelCaseToUnderscoreCase(builder, *optionalLiteral);
+            CamelCaseToUnderscoreCase(builder, literal);
         } else {
-            builder->AppendString(*optionalLiteral);
+            builder->AppendString(literal);
         }
     };
 
     if constexpr (TEnumTraits<T>::IsBitEnum) {
-        if (TEnumTraits<T>::FindLiteralByValue(value)) {
-            formatScalarValue(value);
+        if (None(value)) {
+            // Avoid empty string if possible.
+            if (auto optionalLiteral = TEnumTraits<T>::FindLiteralByValue(value)) {
+                formatLiteral(builder, *optionalLiteral);
+            }
             return;
         }
-        auto first = true;
-        for (auto scalarValue : TEnumTraits<T>::GetDomainValues()) {
-            if (Any(value & scalarValue)) {
-                if (!first) {
-                    builder->AppendString(TStringBuf(" | "));
-                }
-                first = false;
-                formatScalarValue(scalarValue);
+
+        TDelimitedStringBuilderWrapper delimitedBuilder(builder, " | ");
+
+        T printedValue{};
+        for (auto currentValue : TEnumTraits<T>::GetDomainValues()) {
+            // Check if currentValue is viable and non-redunant.
+            if ((value & currentValue) == currentValue && (printedValue | currentValue) != printedValue) {
+                formatLiteral(&delimitedBuilder, *TEnumTraits<T>::FindLiteralByValue(currentValue));
+                printedValue |= currentValue;
             }
         }
+
+        // Handle the remainder.
+        if (printedValue != value) {
+            NYT::NDetail::FormatUnknownEnumValue(&delimitedBuilder, TEnumTraits<T>::GetTypeName(), value & ~printedValue);
+        }
     } else {
-        formatScalarValue(value);
+        if (auto optionalLiteral = TEnumTraits<T>::FindLiteralByValue(value)) {
+            formatLiteral(builder, *optionalLiteral);
+            return;
+        }
+
+        NYT::NDetail::FormatUnknownEnumValue(builder, TEnumTraits<T>::GetTypeName(), value);
     }
 }
 
 template <class T>
-TString FormatEnum(T value)
+std::string FormatEnum(T value)
 {
     TStringBuilder builder;
     FormatEnum(&builder, value, /*lowerCase*/ true);
diff --git a/library/cpp/yt/string/enum.cpp b/library/cpp/yt/string/enum.cpp
index e61b813fd21..beeba753daf 100644
--- a/library/cpp/yt/string/enum.cpp
+++ b/library/cpp/yt/string/enum.cpp
@@ -6,13 +6,50 @@ namespace NYT {
 
 ////////////////////////////////////////////////////////////////////////////////
 
-template <bool failOnError>
-std::optional<TString> DecodeEnumValueImpl(TStringBuf value)
+namespace NDetail {
+
+////////////////////////////////////////////////////////////////////////////////
+
+#if defined(_MSC_VER)
+
+extern "C" TEnumSuggestionsCalculator TryGetEnumSuggestionsCalculatorWeak()
+{
+    return nullptr;
+}
+
+__pragma(comment(linker, "/alternatename:TryGetEnumSuggestionsCalculator=TryGetEnumSuggestionsCalculatorWeak"))
+
+#else
+
+extern "C" Y_WEAK TEnumSuggestionsCalculator TryGetEnumSuggestionsCalculator()
+{
+    return nullptr;
+}
+
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
+
+void ThrowMalformedEnumValueException(
+    TStringBuf typeName,
+    TStringBuf value,
+    const std::span<const TStringBuf>& domainNames)
+{
+    auto errorMessage = Format("Error parsing %v value %Qv", typeName, value);
+    auto suggestionsCalculator = TryGetEnumSuggestionsCalculator();
+    if (!domainNames.empty() && suggestionsCalculator) {
+        errorMessage += Format("; closest possible values are %v", suggestionsCalculator(value, domainNames));
+    }
+    throw TSimpleException(errorMessage);
+}
+
+template <bool ThrowOnError>
+std::optional<std::string> DecodeEnumValueImpl(TStringBuf value)
 {
     auto camelValue = UnderscoreCaseToCamelCase(value);
     auto underscoreValue = CamelCaseToUnderscoreCase(camelValue);
     if (value != underscoreValue) {
-        if constexpr (failOnError) {
+        if constexpr (ThrowOnError) {
             throw TSimpleException(Format("Enum value %Qv is not in a proper underscore case; did you mean %Qv?",
                 value,
                 underscoreValue));
@@ -23,39 +60,29 @@ std::optional<TString> DecodeEnumValueImpl(TStringBuf value)
     return camelValue;
 }
 
-std::optional<TString> TryDecodeEnumValue(TStringBuf value)
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace NDetail
+
+////////////////////////////////////////////////////////////////////////////////
+
+std::optional<std::string> TryDecodeEnumValue(TStringBuf value)
 {
-    return DecodeEnumValueImpl<false>(value);
+    return NDetail::DecodeEnumValueImpl<false>(value);
 }
 
-TString DecodeEnumValue(TStringBuf value)
+std::string DecodeEnumValue(TStringBuf value)
 {
-    auto decodedValue = DecodeEnumValueImpl<true>(value);
+    auto decodedValue = NDetail::DecodeEnumValueImpl<true>(value);
     YT_VERIFY(decodedValue);
     return *decodedValue;
 }
 
-TString EncodeEnumValue(TStringBuf value)
+std::string EncodeEnumValue(TStringBuf value)
 {
     return CamelCaseToUnderscoreCase(value);
 }
 
-namespace NDetail {
-
-void ThrowMalformedEnumValueException(TStringBuf typeName, TStringBuf value)
-{
-    throw TSimpleException(Format("Error parsing %v value %Qv",
-        typeName,
-        value));
-}
-
-void FormatUnknownEnumValue(TStringBuilderBase* builder, TStringBuf name, i64 value)
-{
-    builder->AppendFormat("%v(%v)", name, value);
-}
-
-} // namespace NDetail
-
 ////////////////////////////////////////////////////////////////////////////////
 
 } // namespace NYT
diff --git a/library/cpp/yt/string/enum.h b/library/cpp/yt/string/enum.h
index 792e09402d5..322485a560d 100644
--- a/library/cpp/yt/string/enum.h
+++ b/library/cpp/yt/string/enum.h
@@ -10,21 +10,24 @@ namespace NYT {
 
 ////////////////////////////////////////////////////////////////////////////////
 
-std::optional<TString> TryDecodeEnumValue(TStringBuf value);
-TString DecodeEnumValue(TStringBuf value);
-TString EncodeEnumValue(TStringBuf value);
+std::optional<std::string> TryDecodeEnumValue(TStringBuf value);
+std::string DecodeEnumValue(TStringBuf value);
+std::string EncodeEnumValue(TStringBuf value);
 
 template <class T>
-std::optional<T> TryParseEnum(TStringBuf value);
+std::optional<T> TryParseEnum(TStringBuf str, bool enableUnknown = false);
 
+//! Parses an enum value from a string.
+//! Link against library/cpp/yt/string/enable_enum_suggestions_on_enum_parse_error
+//! to include suggestions in the exception message on parse failure.
 template <class T>
-T ParseEnum(TStringBuf value);
+T ParseEnum(TStringBuf str);
 
 template <class T>
 void FormatEnum(TStringBuilderBase* builder, T value, bool lowerCase);
 
 template <class T>
-TString FormatEnum(T value);
+std::string FormatEnum(T value);
 
 ////////////////////////////////////////////////////////////////////////////////
 
diff --git a/library/cpp/yt/string/format-inl.h b/library/cpp/yt/string/format-inl.h
index 4eaa70bef2f..d17d2783dbe 100644
--- a/library/cpp/yt/string/format-inl.h
+++ b/library/cpp/yt/string/format-inl.h
@@ -10,13 +10,11 @@
 
 #include <library/cpp/yt/assert/assert.h>
 
-#include <library/cpp/yt/small_containers/compact_vector.h>
-
 #include <library/cpp/yt/containers/enum_indexed_array.h>
 
 #include <library/cpp/yt/misc/concepts.h>
 #include <library/cpp/yt/misc/enum.h>
-#include <library/cpp/yt/misc/wrapper_traits.h>
+#include <library/cpp/yt/misc/source_location.h>
 
 #include <util/generic/maybe.h>
 
@@ -30,114 +28,14 @@
     #include <filesystem>
 #endif
 
-namespace NYT {
-
-////////////////////////////////////////////////////////////////////////////////
-
-inline char* TStringBuilderBase::Preallocate(size_t size)
-{
-    Reserve(size + GetLength());
-    return Current_;
-}
-
-inline void TStringBuilderBase::Reserve(size_t size)
-{
-    if (Y_UNLIKELY(End_ - Begin_ < static_cast<ssize_t>(size))) {
-        size_t length = GetLength();
-        auto newLength = std::max(size, MinBufferLength);
-        DoReserve(newLength);
-        Current_ = Begin_ + length;
-    }
-}
-
-inline size_t TStringBuilderBase::GetLength() const
-{
-    return Current_ ? Current_ - Begin_ : 0;
-}
-
-inline TStringBuf TStringBuilderBase::GetBuffer() const
-{
-    return TStringBuf(Begin_, Current_);
-}
-
-inline void TStringBuilderBase::Advance(size_t size)
-{
-    Current_ += size;
-    YT_ASSERT(Current_ <= End_);
-}
-
-inline void TStringBuilderBase::AppendChar(char ch)
-{
-    *Preallocate(1) = ch;
-    Advance(1);
-}
-
-inline void TStringBuilderBase::AppendChar(char ch, int n)
-{
-    YT_ASSERT(n >= 0);
-    if (Y_LIKELY(0 != n)) {
-        char* dst = Preallocate(n);
-        ::memset(dst, ch, n);
-        Advance(n);
-    }
-}
+#ifdef __cpp_lib_source_location
+#include <source_location>
+#endif // __cpp_lib_source_location
 
-inline void TStringBuilderBase::AppendString(TStringBuf str)
-{
-    if (Y_LIKELY(str)) {
-        char* dst = Preallocate(str.length());
-        ::memcpy(dst, str.begin(), str.length());
-        Advance(str.length());
-    }
-}
-
-inline void TStringBuilderBase::AppendString(const char* str)
-{
-    AppendString(TStringBuf(str));
-}
-
-inline void TStringBuilderBase::Reset()
-{
-    Begin_ = Current_ = End_ = nullptr;
-    DoReset();
-}
-
-template <class... TArgs>
-void TStringBuilderBase::AppendFormat(TStringBuf format, TArgs&& ... args)
-{
-    Format(this, TRuntimeFormat{format}, std::forward<TArgs>(args)...);
-}
-
-template <size_t Length, class... TArgs>
-void TStringBuilderBase::AppendFormat(const char (&format)[Length], TArgs&& ... args)
-{
-    Format(this, TRuntimeFormat{format}, std::forward<TArgs>(args)...);
-}
+namespace NYT {
 
 ////////////////////////////////////////////////////////////////////////////////
 
-inline TString TStringBuilder::Flush()
-{
-    Buffer_.resize(GetLength());
-    auto result = std::move(Buffer_);
-    Reset();
-    return result;
-}
-
-inline void TStringBuilder::DoReset()
-{
-    Buffer_ = {};
-}
-
-inline void TStringBuilder::DoReserve(size_t newLength)
-{
-    Buffer_.ReserveAndResize(newLength);
-    auto capacity = Buffer_.capacity();
-    Buffer_.ReserveAndResize(capacity);
-    Begin_ = &*Buffer_.begin();
-    End_ = Begin_ + capacity;
-}
-
 inline void FormatValue(TStringBuilderBase* builder, const TStringBuilder& value, TStringBuf /*spec*/)
 {
     builder->AppendString(value.GetBuffer());
@@ -181,6 +79,17 @@ TString ToStringIgnoringFormatValue(const T& t)
     return s;
 }
 
+// Forward declarations to avoid dependencies, that are not needed by all clients.
+
+template <class T, size_t N>
+class TCompactVector;
+
+template <class TValue, size_t N>
+class TCompactFlatSet;
+
+template <class TKey, class TValue, size_t N, class TKeyCompare>
+class TCompactFlatMap;
+
 ////////////////////////////////////////////////////////////////////////////////
 
 // Helper functions for formatting.
@@ -222,24 +131,73 @@ void FormatPointerValue(
 // so that someone doesn't accidentally implement the
 // "SimpleRange" concept and have a non-trivial
 // formatting procedure at the same time.
+// Sadly, clang is bugged and thus we must do implementation by hand
+// if we want to use this concept in class specializations.
 
 template <class R>
-concept CKnownRange =
-    requires (R r) { [] <class... Ts> (std::vector<Ts...>) { } (r); } ||
-    requires (R r) { [] <class T, size_t E> (std::span<T, E>) { } (r); } ||
-    requires (R r) { [] <class T, size_t N> (TCompactVector<T, N>) { } (r); } ||
-    requires (R r) { [] <class... Ts> (std::set<Ts...>) { } (r); } ||
-    requires (R r) { [] <class... Ts> (THashSet<Ts...>) { } (r); } ||
-    requires (R r) { [] <class... Ts> (THashMultiSet<Ts...>) { } (r); };
+constexpr bool CKnownRange = false;
+
+template <class T>
+    requires requires (T* t) { [] <class... Ts> (std::vector<Ts...>*) {} (t); }
+constexpr bool CKnownRange<T> = true;
+template <class T, size_t E>
+constexpr bool CKnownRange<std::span<T, E>> = true;
+template <class T, size_t N>
+constexpr bool CKnownRange<std::array<T, N>> = true;
+template <class T, size_t N>
+constexpr bool CKnownRange<TCompactVector<T, N>> = true;
+template <class T>
+    requires requires (T* t) { [] <class... Ts> (std::set<Ts...>*) {} (t); }
+constexpr bool CKnownRange<T> = true;
+template <class T>
+    requires requires (T* t) { [] <class... Ts> (std::multiset<Ts...>*) {} (t); }
+constexpr bool CKnownRange<T> = true;
+template <class... Ts>
+constexpr bool CKnownRange<THashSet<Ts...>> = true;
+template <class... Ts>
+constexpr bool CKnownRange<THashMultiSet<Ts...>> = true;
+template <class T, size_t N>
+constexpr bool CKnownRange<TCompactFlatSet<T, N>> = true;
 
 ////////////////////////////////////////////////////////////////////////////////
 
 template <class R>
-concept CKnownKVRange =
-    requires (R r) { [] <class... Ts> (std::map<Ts...>) { } (r); } ||
-    requires (R r) { [] <class... Ts> (std::multimap<Ts...>) { } (r); } ||
-    requires (R r) { [] <class... Ts> (THashMap<Ts...>) { } (r); } ||
-    requires (R r) { [] <class... Ts> (THashMultiMap<Ts...>) { } (r); };
+constexpr bool CKnownKVRange = false;
+
+template <class T>
+    requires requires (T* t) { [] <class... Ts> (std::map<Ts...>*) {} (t); }
+constexpr bool CKnownKVRange<T> = true;
+template <class T>
+    requires requires (T* t) { [] <class... Ts> (std::multimap<Ts...>*) {} (t); }
+constexpr bool CKnownKVRange<T> = true;
+template <class... Ts>
+constexpr bool CKnownKVRange<THashMap<Ts...>> = true;
+template <class... Ts>
+constexpr bool CKnownKVRange<THashMultiMap<Ts...>> = true;
+template <class... Ts>
+constexpr bool CKnownKVRange<TCompactFlatMap<Ts...>> = true;
+template <class K, class V, size_t N, class C>
+constexpr bool CKnownKVRange<TCompactFlatMap<K, V, N, C>> = true;
+
+// TODO(arkady-e1ppa): Uncomment me when
+// https://github.com/llvm/llvm-project/issues/58534 is shipped.
+// template <class R>
+// concept CKnownRange =
+//     requires (R r) { [] <class... Ts> (std::vector<Ts...>) { } (r); } ||
+//     requires (R r) { [] <class T, size_t E> (std::span<T, E>) { } (r); } ||
+//     requires (R r) { [] <class T, size_t N> (TCompactVector<T, N>) { } (r); } ||
+//     requires (R r) { [] <class... Ts> (std::set<Ts...>) { } (r); } ||
+//     requires (R r) { [] <class... Ts> (THashSet<Ts...>) { } (r); } ||
+//     requires (R r) { [] <class... Ts> (THashMultiSet<Ts...>) { } (r); };
+
+// ////////////////////////////////////////////////////////////////////////////////
+
+// template <class R>
+// concept CKnownKVRange =
+//     requires (R r) { [] <class... Ts> (std::map<Ts...>) { } (r); } ||
+//     requires (R r) { [] <class... Ts> (std::multimap<Ts...>) { } (r); } ||
+//     requires (R r) { [] <class... Ts> (THashMap<Ts...>) { } (r); } ||
+//     requires (R r) { [] <class... Ts> (THashMultiMap<Ts...>) { } (r); };
 
 } // namespace NDetail
 
@@ -289,6 +247,43 @@ void FormatKeyValueRange(TStringBuilderBase* builder, const TRange& range, const
 
 ////////////////////////////////////////////////////////////////////////////////
 
+template <class TRange, class TValueGetter, class TIntervalFormatter>
+void FormatCompactIntervalRange(
+    TStringBuilderBase* builder,
+    const TRange& range,
+    const TValueGetter& valueGetter,
+    const TIntervalFormatter& intervalFormatter)
+{
+    if (range.begin() == range.end()) {
+        builder->AppendString("[]");
+        return;
+    }
+
+    builder->AppendChar('[');
+
+    auto first = range.begin();
+    auto last = first;
+    auto current = std::next(first);
+
+    while (current != range.end()) {
+        if (valueGetter(current) != valueGetter(last) + 1) {
+            bool firstInterval = first == range.begin();
+            intervalFormatter(builder, first, last, valueGetter, firstInterval);
+            first = current;
+        }
+
+        last = current;
+        ++current;
+    }
+
+    bool firstInterval = first == range.begin();
+    intervalFormatter(builder, first, last, valueGetter, firstInterval);
+
+    builder->AppendChar(']');
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
 template <class R>
 concept CFormattableRange =
     NDetail::CKnownRange<R> &&
@@ -300,6 +295,22 @@ concept CFormattableKVRange =
     CFormattable<typename R::key_type> &&
     CFormattable<typename R::value_type>;
 
+
+////////////////////////////////////////////////////////////////////////////////
+
+// Specializations of TFormatArg for ranges
+template <class R>
+    requires CFormattableRange<std::remove_cvref_t<R>>
+struct TFormatArg<R>
+    : public TFormatArgBase
+{
+    using TUnderlying = typename std::remove_cvref_t<R>::value_type;
+
+    static constexpr auto ConversionSpecifiers = TFormatArg<TUnderlying>::ConversionSpecifiers;
+
+    static constexpr auto FlagSpecifiers = TFormatArg<TUnderlying>::FlagSpecifiers;
+};
+
 ////////////////////////////////////////////////////////////////////////////////
 
 template <class TRange, class TFormatter>
@@ -315,7 +326,7 @@ typename TFormattableView<TRange, TFormatter>::TEnd TFormattableView<TRange, TFo
 }
 
 template <class TRange, class TFormatter>
-TFormattableView<TRange, TFormatter> MakeFormattableView(
+TFormattableView<TRange, std::decay_t<TFormatter>> MakeFormattableView(
     const TRange& range,
     TFormatter&& formatter)
 {
@@ -323,7 +334,7 @@ TFormattableView<TRange, TFormatter> MakeFormattableView(
 }
 
 template <class TRange, class TFormatter>
-TFormattableView<TRange, TFormatter> MakeShrunkFormattableView(
+TFormattableView<TRange, std::decay_t<TFormatter>> MakeShrunkFormattableView(
     const TRange& range,
     TFormatter&& formatter,
     size_t limit)
@@ -340,10 +351,63 @@ TFormatterWrapper<TFormatter> MakeFormatterWrapper(
     TFormatter&& formatter)
 {
     return TFormatterWrapper<TFormatter>{
-        .Formatter = std::move(formatter)
+        .Formatter = std::forward<TFormatter>(formatter)
     };
 }
 
+template <class TRange, class TValueGetter, class TIntervalFormatter>
+auto TCompactIntervalView<TRange, TValueGetter, TIntervalFormatter>::begin() const
+    -> TBegin
+{
+    return RangeBegin;
+}
+
+template <class TRange, class TValueGetter, class TIntervalFormatter>
+auto TCompactIntervalView<TRange, TValueGetter, TIntervalFormatter>::end() const
+    -> TEnd
+{
+    return RangeEnd;
+}
+
+template <class TRange>
+auto TDefaultValueGetter<TRange>::operator()(const TIterator& iterator) const
+    -> typename std::iterator_traits<TIterator>::value_type
+{
+    return *iterator;
+}
+
+template <class TRange, class TValueGetter>
+void TDefaultIntervalFormatter<TRange, TValueGetter>::operator()(
+    TStringBuilderBase* builder,
+    const TIterator& first,
+    const TIterator& last,
+    const TValueGetter& valueGetter,
+    bool firstInterval) const
+{
+    if (!firstInterval) {
+        builder->AppendString(DefaultJoinToStringDelimiter);
+    }
+
+    if (first == last) {
+        builder->AppendFormat("%v", valueGetter(first));
+    } else {
+        builder->AppendFormat("%v-%v", valueGetter(first), valueGetter(last));
+    }
+}
+
+template <class TRange, class TValueGetter, class TIntervalFormatter>
+TCompactIntervalView<TRange, TValueGetter, TIntervalFormatter> MakeCompactIntervalView(
+    const TRange& range,
+    TValueGetter&& valueGetter,
+    TIntervalFormatter&& intervalFormatter)
+{
+    return TCompactIntervalView<TRange, TValueGetter, TIntervalFormatter>{
+        range.begin(),
+        range.end(),
+        std::forward<TValueGetter>(valueGetter),
+        std::forward<TIntervalFormatter>(intervalFormatter)};
+}
+
 template <class... TArgs>
 TLazyMultiValueFormatter<TArgs...>::TLazyMultiValueFormatter(
     TStringBuf format,
@@ -360,49 +424,12 @@ auto MakeLazyMultiValueFormatter(TStringBuf format, TArgs&&... args)
 
 ////////////////////////////////////////////////////////////////////////////////
 
-// Non-container objects.
-
-#define XX(valueType, castType, genericSpec) \
-    inline void FormatValue(TStringBuilderBase* builder, valueType value, TStringBuf spec) \
-    { \
-        NYT::NDetail::FormatIntValue(builder, static_cast<castType>(value), spec, genericSpec); \
-    }
-
-XX(i8,                  i32,      TStringBuf("d"))
-XX(ui8,                 ui32,     TStringBuf("u"))
-XX(i16,                 i32,      TStringBuf("d"))
-XX(ui16,                ui32,     TStringBuf("u"))
-XX(i32,                 i32,      TStringBuf("d"))
-XX(ui32,                ui32,     TStringBuf("u"))
-XX(long,                i64,      TStringBuf(PRIdLEAST64))
-XX(long long,           i64,      TStringBuf(PRIdLEAST64))
-XX(unsigned long,       ui64,     TStringBuf(PRIuLEAST64))
-XX(unsigned long long,  ui64,     TStringBuf(PRIuLEAST64))
-
-#undef XX
-
-#define XX(valueType, castType, genericSpec) \
-    inline void FormatValue(TStringBuilderBase* builder, valueType value, TStringBuf spec) \
-    { \
-        NYT::NDetail::FormatValueViaSprintf(builder, static_cast<castType>(value), spec, genericSpec); \
-    }
-
-XX(double,              double,   TStringBuf("lf"))
-XX(float,               float,    TStringBuf("f"))
-
-#undef XX
-
-// Pointer
-template <class T>
-void FormatValue(TStringBuilderBase* builder, T* value, TStringBuf spec)
-{
-    NYT::NDetail::FormatPointerValue(builder, static_cast<const void*>(value), spec);
-}
-
-// TStringBuf
-inline void FormatValue(TStringBuilderBase* builder, TStringBuf value, TStringBuf spec)
+template <class TStringBuilder>
+void FormatString(TStringBuilder* builder, TStringBuf value, TStringBuf spec)
 {
-    if (!spec) {
+    // Fast path: plain "%v" (the overwhelmingly common case) and empty spec
+    // both mean "emit the string verbatim". Skip alignment/flag parsing.
+    if (spec.empty() || (spec.size() == 1 && spec.front() == NDetail::GenericSpecSymbol)) {
         builder->AppendString(value);
         return;
     }
@@ -489,6 +516,53 @@ inline void FormatValue(TStringBuilderBase* builder, TStringBuf value, TStringBu
     }
 }
 
+////////////////////////////////////////////////////////////////////////////////
+
+// Non-container objects.
+
+#define XX(valueType, castType, genericSpec) \
+    inline void FormatValue(TStringBuilderBase* builder, valueType value, TStringBuf spec) \
+    { \
+        NYT::NDetail::FormatIntValue(builder, static_cast<castType>(value), spec, genericSpec); \
+    }
+
+XX(i8,                  i32,      TStringBuf("d"))
+XX(ui8,                 ui32,     TStringBuf("u"))
+XX(i16,                 i32,      TStringBuf("d"))
+XX(ui16,                ui32,     TStringBuf("u"))
+XX(i32,                 i32,      TStringBuf("d"))
+XX(ui32,                ui32,     TStringBuf("u"))
+XX(long,                i64,      TStringBuf(PRIdLEAST64))
+XX(long long,           i64,      TStringBuf(PRIdLEAST64))
+XX(unsigned long,       ui64,     TStringBuf(PRIuLEAST64))
+XX(unsigned long long,  ui64,     TStringBuf(PRIuLEAST64))
+
+#undef XX
+
+#define XX(valueType, castType, genericSpec) \
+    inline void FormatValue(TStringBuilderBase* builder, valueType value, TStringBuf spec) \
+    { \
+        NYT::NDetail::FormatValueViaSprintf(builder, static_cast<castType>(value), spec, genericSpec); \
+    }
+
+XX(double,              double,   TStringBuf("lf"))
+XX(float,               float,    TStringBuf("f"))
+
+#undef XX
+
+// Pointer
+template <class T>
+void FormatValue(TStringBuilderBase* builder, T* value, TStringBuf spec)
+{
+    NYT::NDetail::FormatPointerValue(builder, static_cast<const void*>(value), spec);
+}
+
+// TStringBuf
+inline void FormatValue(TStringBuilderBase* builder, TStringBuf value, TStringBuf spec)
+{
+    FormatString(builder, value, spec);
+}
+
 // TString
 inline void FormatValue(TStringBuilderBase* builder, const TString& value, TStringBuf spec)
 {
@@ -533,6 +607,58 @@ inline void FormatValue(TStringBuilderBase* builder, const std::filesystem::path
 }
 #endif
 
+#ifdef __cpp_lib_source_location
+// std::source_location
+inline void FormatValue(TStringBuilderBase* builder, const std::source_location& location, TStringBuf /*spec*/)
+{
+    if (location.file_name() != nullptr) {
+        builder->AppendFormat(
+            "%v:%v:%v",
+            location.file_name(),
+            location.line(),
+            location.column());
+    } else {
+        builder->AppendString("<unknown>");
+    }
+}
+#endif // __cpp_lib_source_location
+
+// TSourceLocation
+inline void FormatValue(TStringBuilderBase* builder, const TSourceLocation& location, TStringBuf /*spec*/)
+{
+    if (location.GetFileName() != nullptr) {
+        builder->AppendFormat(
+            "%v:%v",
+            location.GetFileName(),
+            location.GetLine());
+    } else {
+        builder->AppendString("<unknown>");
+    }
+}
+
+// std::monostate
+inline void FormatValue(TStringBuilderBase* builder, const std::monostate&, TStringBuf /*spec*/)
+{
+    builder->AppendString(TStringBuf("<monostate>"));
+}
+
+// std::variant
+template <class... Ts>
+    requires (CFormattable<Ts> && ...)
+void FormatValue(TStringBuilderBase* builder, const std::variant<Ts...>& variant, TStringBuf spec)
+{
+    [&] <size_t... Ids> (std::index_sequence<Ids...>) {
+        ([&] {
+            if (variant.index() == Ids) {
+                FormatValue(builder, std::get<Ids>(variant), spec);
+                return false;
+            }
+
+            return true;
+        } () && ...);
+    } (std::index_sequence_for<Ts...>());
+}
+
 // char
 inline void FormatValue(TStringBuilderBase* builder, char value, TStringBuf spec)
 {
@@ -598,7 +724,9 @@ void FormatValue(TStringBuilderBase* builder, TEnum value, TStringBuf spec)
 }
 
 template <class TArcadiaEnum>
-    requires (std::is_enum_v<TArcadiaEnum> && !TEnumTraits<TArcadiaEnum>::IsEnum)
+concept CArcadiaEnum = (std::is_enum_v<TArcadiaEnum> && !TEnumTraits<TArcadiaEnum>::IsEnum);
+
+template <CArcadiaEnum TArcadiaEnum>
 void FormatValue(TStringBuilderBase* builder, TArcadiaEnum value, TStringBuf /*spec*/)
 {
     // NB(arkady-e1ppa): This can catch normal enums which
@@ -660,6 +788,27 @@ void FormatValue(
     const TFormatterWrapper<TFormatter>& wrapper,
     TStringBuf spec);
 
+// TCompactIntervalView
+
+template <class TRange, class TValueGetter, class TIntervalFormatter>
+concept CCompactIntervalView = requires (
+    TRange range,
+    TValueGetter valueGetter,
+    TIntervalFormatter intervalFormatter)
+{
+    { valueGetter(range.begin()) } -> std::integral;
+    {
+        intervalFormatter(nullptr, range.begin(), range.begin(), valueGetter, true)
+    } -> std::same_as<void>;
+};
+
+template <class TRange, class TValueGetter, class TIntervalFormatter>
+    requires CCompactIntervalView<TRange, TValueGetter, TIntervalFormatter>
+void FormatValue(
+    TStringBuilderBase* builder,
+    const TCompactIntervalView<TRange, TValueGetter, TIntervalFormatter>& compactIntervalView,
+    TStringBuf spec);
+
 // TLazyMultiValueFormatter
 template <class... TArgs>
 void FormatValue(
@@ -711,7 +860,7 @@ void FormatValue(TStringBuilderBase* builder, const std::tuple<Ts...>& value, TS
     [&] <size_t... Idx> (std::index_sequence<Idx...>) {
         ([&] {
             FormatValue(builder, std::get<Idx>(value), spec);
-            if constexpr (Idx != sizeof...(Ts)) {
+            if constexpr (Idx != sizeof...(Ts) - 1) {
                 builder->AppendString(TStringBuf(", "));
             }
         } (), ...);
@@ -740,9 +889,9 @@ void FormatValue(TStringBuilderBase* builder, const TEnumIndexedArray<E, T>& col
 
 // One-valued ranges
 template <CFormattableRange TRange>
-void FormatValue(TStringBuilderBase* builder, const TRange& collection, TStringBuf /*spec*/)
+void FormatValue(TStringBuilderBase* builder, const TRange& collection, TStringBuf spec)
 {
-    NYT::FormatRange(builder, collection, TDefaultFormatter());
+    NYT::FormatRange(builder, collection, TSpecBoundFormatter(spec));
 }
 
 // Two-valued ranges
@@ -762,6 +911,21 @@ void FormatValue(
     NYT::FormatRange(builder, formattableView, formattableView.Formatter, formattableView.Limit);
 }
 
+// TCompactIntervalView
+template <class TRange, class TValueGetter, class TIntervalFormatter>
+    requires CCompactIntervalView<TRange, TValueGetter, TIntervalFormatter>
+void FormatValue(
+    TStringBuilderBase* builder,
+    const TCompactIntervalView<TRange, TValueGetter, TIntervalFormatter>& compactIntervalView,
+    TStringBuf /*spec*/)
+{
+    NYT::FormatCompactIntervalRange(
+        builder,
+        compactIntervalView,
+        compactIntervalView.ValueGetter,
+        compactIntervalView.IntervalFormatter);
+}
+
 // TFormatterWrapper
 template <class TFormatter>
 void FormatValue(
@@ -781,7 +945,7 @@ void FormatValue(
 {
     std::apply(
         [&] <class... TInnerArgs> (TInnerArgs&&... args) {
-            builder->AppendFormat(value.Format_, std::forward<TInnerArgs>(args)...);
+            builder->AppendFormat(TRuntimeFormat{value.Format_}, std::forward<TInnerArgs>(args)...);
         },
         value.Args_);
 }
@@ -859,13 +1023,58 @@ concept CFormatter = CInvocable<T, void(size_t, TStringBuilderBase*, TStringBuf)
 
 ////////////////////////////////////////////////////////////////////////////////
 
+// NB: |spec| is tiny (usually a single char), so an inline scan beats
+// the AVX2 |memchr| that |TStringBuf::Contains| dispatches to.
+Y_FORCE_INLINE bool SpecContains(TStringBuf spec, char symbol)
+{
+    for (char c : spec) {
+        if (c == symbol) {
+            return true;
+        }
+    }
+    return false;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
 template <CFormatter TFormatter>
-void RunFormatter(
+Y_FORCE_INLINE void RunFormatterAt(
+    const TFormatter& formatter,
+    size_t index,
+    TStringBuilderBase* builder,
+    TStringBuf spec,
+    bool singleQuotes,
+    bool doubleQuotes)
+{
+    // 'n' means 'nothing'; skip the argument.
+    if (!SpecContains(spec, 'n')) {
+        if (singleQuotes) {
+            builder->AppendChar('\'');
+        }
+        if (doubleQuotes) {
+            builder->AppendChar('"');
+        }
+
+        formatter(index, builder, spec);
+
+        if (singleQuotes) {
+            builder->AppendChar('\'');
+        }
+        if (doubleQuotes) {
+            builder->AppendChar('"');
+        }
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+template <CFormatter TFormatter>
+void RunFormatterFullScan(
     TStringBuilderBase* builder,
     TStringBuf format,
-    const TFormatter& formatter)
+    const TFormatter& formatter,
+    int argIndex = 0)
 {
-    size_t argIndex = 0;
     auto current = std::begin(format);
     auto end = std::end(format);
     while (true) {
@@ -901,27 +1110,13 @@ void RunFormatter(
         bool singleQuotes = false;
         bool doubleQuotes = false;
 
+        static constexpr TStringBuf conversionSpecifiers =
+            "diuoxXfFeEgGaAcspn";
+
         while (
             argFormatEnd != end &&
-            *argFormatEnd != GenericSpecSymbol &&     // value in generic format
-            *argFormatEnd != 'd' &&                   // others are standard specifiers supported by printf
-            *argFormatEnd != 'i' &&
-            *argFormatEnd != 'u' &&
-            *argFormatEnd != 'o' &&
-            *argFormatEnd != 'x' &&
-            *argFormatEnd != 'X' &&
-            *argFormatEnd != 'f' &&
-            *argFormatEnd != 'F' &&
-            *argFormatEnd != 'e' &&
-            *argFormatEnd != 'E' &&
-            *argFormatEnd != 'g' &&
-            *argFormatEnd != 'G' &&
-            *argFormatEnd != 'a' &&
-            *argFormatEnd != 'A' &&
-            *argFormatEnd != 'c' &&
-            *argFormatEnd != 's' &&
-            *argFormatEnd != 'p' &&
-            *argFormatEnd != 'n')
+            *argFormatEnd != GenericSpecSymbol &&            // value in generic format
+            !conversionSpecifiers.Contains(*argFormatEnd)) // others are standard specifiers supported by printf
         {
             switch (*argFormatEnd) {
                 case 'q':
@@ -941,27 +1136,162 @@ void RunFormatter(
             ++argFormatEnd;
         }
 
-        // 'n' means 'nothing'; skip the argument.
-        if (*argFormatBegin != 'n') {
-            // Format argument.
-            TStringBuf argFormat(argFormatBegin, argFormatEnd);
-            if (singleQuotes) {
-                builder->AppendChar('\'');
-            }
-            if (doubleQuotes) {
-                builder->AppendChar('"');
-            }
-            formatter(argIndex++, builder, argFormat);
-            if (singleQuotes) {
-                builder->AppendChar('\'');
-            }
-            if (doubleQuotes) {
-                builder->AppendChar('"');
+        RunFormatterAt(
+            formatter,
+            argIndex++,
+            builder,
+            TStringBuf{argFormatBegin, argFormatEnd},
+            singleQuotes,
+            doubleQuotes);
+
+        current = argFormatEnd;
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+template <CFormatter TFormatter, class... TArgs>
+void RunFormatter(
+    TStringBuilderBase* builder,
+    TBasicFormatString<TArgs...> formatString,
+    const TFormatter& formatter)
+{
+    auto isValidLocations = [] (const auto& t) {
+        return std::get<0>(t) != std::get<1>(t);
+    };
+    // Generally marker is simply "%v" e.g. 2 symbols.
+    // We assume it is used to insert something for roughly 5 symbols
+    // of size.
+    builder->Preallocate(std::size(formatString.Get()) + sizeof...(TArgs) * (5 - 2));
+
+    // Empty marker positions -- fallback to the normal impl.
+    if constexpr (sizeof...(TArgs) != 0) {
+        if (!isValidLocations(formatString.Markers[0])) {
+            RunFormatterFullScan(builder, formatString.Get(), formatter);
+            return;
+        }
+    } else {
+        if (formatString.Escapes[0] == -2) {
+            RunFormatterFullScan(builder, formatString.Get(), formatter);
+            return;
+        }
+    }
+
+    int escapesFound = 0;
+    int currentPos = 0;
+
+    auto beginIt = formatString.Get().begin();
+    auto size = formatString.Get().size();
+
+    const auto& [markers, escapes] = std::tie(formatString.Markers, formatString.Escapes);
+
+    auto appendVerbatim = [&] (int offsetToEnd) {
+        builder->AppendString(TStringBuf{beginIt + currentPos, beginIt + offsetToEnd});
+    };
+
+    auto processEscape = [&] () mutable {
+        // OpenMP doesn't support structured bindings :(.
+        auto escapePos = formatString.Escapes[escapesFound];
+
+        // Append everything that's present until %%.
+        appendVerbatim(escapePos);
+
+        // Append '%'.
+        builder->AppendChar('%');
+
+        // Advance position to first '%' pos + 2.
+        currentPos = escapePos + 2;
+    };
+
+    int argIndex = 0;
+
+    while(argIndex < std::ssize(markers)) {
+        auto [markerStart, markerEnd] = markers[argIndex];
+
+        if (
+            escapes[escapesFound] != -1 &&
+            escapes[escapesFound] - currentPos < markerStart - currentPos)
+        {
+            // Escape sequence is closer.
+            processEscape();
+            ++escapesFound;
+        } else {
+            // Normal marker is closer.
+
+            // Append everything that's present until marker start.
+            appendVerbatim(markerStart);
+
+            // Parsing format string.
+
+            // We skip '%' here since spec does not contain it.
+            auto spec = TStringBuf{beginIt + markerStart + 1, beginIt + markerEnd};
+            bool singleQuotes = false;
+            bool doubleQuotes = false;
+            for (auto c : spec) {
+                if (c == 'q') {
+                    singleQuotes = true;
+                }
+                if (c == 'Q') {
+                    doubleQuotes = true;
+                }
             }
+            RunFormatterAt(
+                formatter,
+                argIndex,
+                builder,
+                spec,
+                singleQuotes,
+                doubleQuotes);
+
+            // Advance position past marker's end.
+            currentPos = markerEnd;
+            ++argIndex;
+            continue;
         }
 
-        current = argFormatEnd;
+        // Check if the number of escapes we have found has exceeded the recorded limit
+        // e.g. we have to manually scan the rest of the formatString.
+        if (escapesFound == std::ssize(escapes)) {
+            break;
+        }
     }
+
+    // Process remaining escapes.
+    while (escapesFound < std::ssize(escapes)) {
+        if (escapes[escapesFound] == -1) {
+            break;
+        }
+
+        processEscape();
+        ++escapesFound;
+    }
+
+    // We either ran out of markers or reached the limit of allowed
+    // escape sequences.
+
+    // Happy path: no limit on escape sequences.
+    if (escapesFound != std::ssize(escapes)) {
+        // Append whatever's left until the end.
+        appendVerbatim(size);
+        return;
+    }
+
+    // Sad path: we have to fully parse remainder of format.
+    RunFormatterFullScan(builder, TStringBuf{beginIt + currentPos, beginIt + size}, formatter, argIndex);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+// For benchmarking purposes.
+template <class... TArgs>
+TString FormatOld(TFormatString<TArgs...> format, TArgs&&... args)
+{
+    TStringBuilder builder;
+    if constexpr ((CFormattable<TArgs> && ...)) {
+        NYT::NDetail::TValueFormatter<0, TArgs...> formatter(args...);
+        NYT::NDetail::RunFormatterFullScan(&builder, format.Get(), formatter);
+    }
+    return builder.Flush();
 }
 
 } // namespace NDetail
@@ -980,7 +1310,7 @@ void Format(TStringBuilderBase* builder, TFormatString<TArgs...> format, TArgs&&
     // a second error.
     if constexpr ((CFormattable<TArgs> && ...)) {
         NYT::NDetail::TValueFormatter<0, TArgs...> formatter(args...);
-        NYT::NDetail::RunFormatter(builder, format.Get(), formatter);
+        NYT::NDetail::RunFormatter(builder, format, formatter);
     }
 }
 
@@ -1001,7 +1331,7 @@ void FormatVector(
     const TVector& vec)
 {
     NYT::NDetail::TRangeFormatter<typename TVector::value_type> formatter(vec);
-    NYT::NDetail::RunFormatter(builder, format, formatter);
+    NYT::NDetail::RunFormatterFullScan(builder, format, formatter);
 }
 
 template <class TVector>
@@ -1011,7 +1341,7 @@ void FormatVector(
     const TVector& vec)
 {
     NYT::NDetail::TRangeFormatter<typename TVector::value_type> formatter(vec);
-    NYT::NDetail::RunFormatter(builder, format, formatter);
+    NYT::NDetail::RunFormatterFullScan(builder, format, formatter);
 }
 
 template <size_t Length, class TVector>
diff --git a/library/cpp/yt/string/format.cpp b/library/cpp/yt/string/format.cpp
index 47b0c1d712d..07120aae612 100644
--- a/library/cpp/yt/string/format.cpp
+++ b/library/cpp/yt/string/format.cpp
@@ -111,12 +111,13 @@ void FormatPointerValue(
     const void* value,
     TStringBuf format)
 {
-    static_assert(sizeof(value) == sizeof(ui64));
+    static_assert(sizeof(value) == sizeof(uintptr_t));
+
     if (format == TStringBuf("p") || format == TStringBuf("v")) {
         builder->AppendString(TStringBuf("0x"));
-        FormatValue(builder, reinterpret_cast<ui64>(value), TStringBuf("x"));
+        FormatValue(builder, reinterpret_cast<uintptr_t>(value), TStringBuf("x"));
     } else if (format == TStringBuf("x") || format == TStringBuf("X")) {
-        FormatValue(builder, reinterpret_cast<ui64>(value), format);
+        FormatValue(builder, reinterpret_cast<uintptr_t>(value), format);
     } else {
         builder->AppendString("<invalid pointer format>");
     }
diff --git a/library/cpp/yt/string/format.h b/library/cpp/yt/string/format.h
index a6ab1f76f49..fa45f39e5ac 100644
--- a/library/cpp/yt/string/format.h
+++ b/library/cpp/yt/string/format.h
@@ -1,9 +1,12 @@
 #pragma once
 
 #include "format_string.h"
+#include "string_builder.h"
 
 #include <util/generic/string.h>
 
+#include <iterator>
+
 namespace NYT {
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -61,65 +64,6 @@ TString Format(TFormatString<TArgs...> format, TArgs&&... args);
 
 ////////////////////////////////////////////////////////////////////////////////
 
-// StringBuilder(Base) definition.
-
-//! A simple helper for constructing strings by a sequence of appends.
-class TStringBuilderBase
-{
-public:
-    virtual ~TStringBuilderBase() = default;
-
-    char* Preallocate(size_t size);
-
-    void Reserve(size_t size);
-
-    size_t GetLength() const;
-
-    TStringBuf GetBuffer() const;
-
-    void Advance(size_t size);
-
-    void AppendChar(char ch);
-    void AppendChar(char ch, int n);
-
-    void AppendString(TStringBuf str);
-    void AppendString(const char* str);
-
-    template <size_t Length, class... TArgs>
-    void AppendFormat(const char (&format)[Length], TArgs&&... args);
-    template <class... TArgs>
-    void AppendFormat(TStringBuf format, TArgs&&... args);
-
-    void Reset();
-
-protected:
-    char* Begin_ = nullptr;
-    char* Current_ = nullptr;
-    char* End_ = nullptr;
-
-    virtual void DoReset() = 0;
-    virtual void DoReserve(size_t newLength) = 0;
-
-    static constexpr size_t MinBufferLength = 128;
-};
-
-////////////////////////////////////////////////////////////////////////////////
-
-class TStringBuilder
-    : public TStringBuilderBase
-{
-public:
-    TString Flush();
-
-protected:
-    TString Buffer_;
-
-    void DoReset() override;
-    void DoReserve(size_t size) override;
-};
-
-////////////////////////////////////////////////////////////////////////////////
-
 template <class... TArgs>
 void Format(TStringBuilderBase* builder, TFormatString<TArgs...> format, TArgs&&... args);
 
@@ -147,18 +91,75 @@ struct TFormattableView
 
 //! Annotates a given #range with #formatter to be applied to each item.
 template <class TRange, class TFormatter>
-TFormattableView<TRange, TFormatter> MakeFormattableView(
+TFormattableView<TRange, std::decay_t<TFormatter>> MakeFormattableView(
     const TRange& range,
     TFormatter&& formatter);
 
 template <class TRange, class TFormatter>
-TFormattableView<TRange, TFormatter> MakeShrunkFormattableView(
+TFormattableView<TRange, std::decay_t<TFormatter>> MakeShrunkFormattableView(
     const TRange& range,
     TFormatter&& formatter,
     size_t limit);
 
 ////////////////////////////////////////////////////////////////////////////////
 
+template <class TRange, class TValueGetter, class TIntervalFormatter>
+struct TCompactIntervalView
+{
+    using TBegin = std::decay_t<decltype(std::declval<const TRange>().begin())>;
+    using TEnd = std::decay_t<decltype(std::declval<const TRange>().end())>;
+
+    TBegin RangeBegin;
+    TEnd RangeEnd;
+
+    TValueGetter ValueGetter;
+    TIntervalFormatter IntervalFormatter;
+
+    TBegin begin() const;
+    TEnd end() const;
+};
+
+template <class TRange>
+struct TDefaultValueGetter
+{
+    using TIterator = std::decay_t<decltype(std::declval<const TRange>().begin())>;
+
+    auto operator()(const TIterator& iterator) const
+        -> typename std::iterator_traits<TIterator>::value_type;
+};
+
+template <class TRange, class TValueGetter>
+struct TDefaultIntervalFormatter
+{
+    using TIterator = std::decay_t<decltype(std::declval<const TRange>().begin())>;
+
+    void operator()(
+        TStringBuilderBase* builder,
+        const TIterator& first,
+        const TIterator& last,
+        const TValueGetter& valueGetter,
+        bool firstInterval) const;
+};
+
+////////////////////////////////////////////////////////////////////////////////
+
+//! Writes a given integral #range as a sequence of intervals.
+//! Example:
+// MakeCompactIntervalView(std::vector {1, 2, 3, 5, 7, 8})
+// => [1-3,5,7-8]
+
+template <
+    class TRange,
+    class TValueGetter = TDefaultValueGetter<TRange>,
+    class TIntervalFormatter = TDefaultIntervalFormatter<TRange, TValueGetter>
+>
+TCompactIntervalView<TRange, TValueGetter, TIntervalFormatter> MakeCompactIntervalView(
+    const TRange& range,
+    TValueGetter&& valueGetter = {},
+    TIntervalFormatter&& intervalFormatter = {});
+
+////////////////////////////////////////////////////////////////////////////////
+
 template <class TFormatter>
 struct TFormatterWrapper
 {
diff --git a/library/cpp/yt/string/format_analyser-inl.h b/library/cpp/yt/string/format_analyser-inl.h
deleted file mode 100644
index 8a3dd897ffc..00000000000
--- a/library/cpp/yt/string/format_analyser-inl.h
+++ /dev/null
@@ -1,112 +0,0 @@
-#ifndef FORMAT_ANALYSER_INL_H_
-#error "Direct inclusion of this file is not allowed, include format_analyser.h"
-// For the sake of sane code completion.
-#include "format_analyser.h"
-#endif
-
-#include "format_arg.h"
-
-namespace NYT::NDetail {
-
-////////////////////////////////////////////////////////////////////////////////
-
-consteval bool Contains(std::string_view sv, char symbol)
-{
-    return sv.find(symbol) != std::string_view::npos;
-}
-
-template <class... TArgs>
-consteval void TFormatAnalyser::ValidateFormat(std::string_view format)
-{
-    std::array<std::string_view, sizeof...(TArgs)> markers = {};
-    std::array<TSpecifiers, sizeof...(TArgs)> specifiers{GetSpecifiers<TArgs>()...};
-
-    int markerCount = 0;
-    int currentMarkerStart = -1;
-
-    for (int index = 0; index < std::ssize(format); ++index) {
-        auto symbol = format[index];
-
-        // Parse verbatim text.
-        if (currentMarkerStart == -1) {
-            if (symbol == IntroductorySymbol) {
-                // Marker maybe begins.
-                currentMarkerStart = index;
-            }
-            continue;
-        }
-
-        // NB: We check for %% first since
-        // in order to verify if symbol is a specifier
-        // we need markerCount to be within range of our
-        // specifier array.
-        if (symbol == IntroductorySymbol) {
-            if (currentMarkerStart + 1 != index) {
-                // '%a% detected'
-                CrashCompilerWrongTermination("You may not terminate flag sequence other than %% with \'%\' symbol");
-                return;
-            }
-            // '%%' detected --- skip
-            currentMarkerStart = -1;
-            continue;
-        }
-
-        // We are inside of marker.
-        if (markerCount == std::ssize(markers)) {
-            // To many markers
-            CrashCompilerNotEnoughArguments("Number of arguments supplied to format is smaller than the number of flag sequences");
-            return;
-        }
-
-        if (Contains(specifiers[markerCount].Conversion, symbol)) {
-            // Marker has finished.
-
-            markers[markerCount]
-                = std::string_view(format.begin() + currentMarkerStart, index - currentMarkerStart + 1);
-            currentMarkerStart = -1;
-            ++markerCount;
-
-            continue;
-        }
-
-        if (!Contains(specifiers[markerCount].Flags, symbol)) {
-            CrashCompilerWrongFlagSpecifier("Symbol is not a valid flag specifier; See FlagSpecifiers");
-        }
-    }
-
-    if (currentMarkerStart != -1) {
-        // Runaway marker.
-        CrashCompilerMissingTermination("Unterminated flag sequence detected; Use \'%%\' to type plain %");
-        return;
-    }
-
-    if (markerCount < std::ssize(markers)) {
-        // Missing markers.
-        CrashCompilerTooManyArguments("Number of arguments supplied to format is greater than the number of flag sequences");
-        return;
-    }
-
-    // TODO(arkady-e1ppa): Consider per-type verification
-    // of markers.
-}
-
-template <class TArg>
-consteval auto TFormatAnalyser::GetSpecifiers()
-{
-    if constexpr (!CFormattable<TArg>) {
-        CrashCompilerNotFormattable<TArg>("Your specialization of TFormatArg is broken");
-    }
-
-    return TSpecifiers{
-        .Conversion = std::string_view{
-            std::data(TFormatArg<TArg>::ConversionSpecifiers),
-            std::size(TFormatArg<TArg>::ConversionSpecifiers)},
-        .Flags = std::string_view{
-            std::data(TFormatArg<TArg>::FlagSpecifiers),
-            std::size(TFormatArg<TArg>::FlagSpecifiers)},
-    };
-}
-
-////////////////////////////////////////////////////////////////////////////////
-
-} // namespace NYT::NDetail
diff --git a/library/cpp/yt/string/format_analyser.h b/library/cpp/yt/string/format_analyser.h
index 9a05e3eb8cf..9f194144dcb 100644
--- a/library/cpp/yt/string/format_analyser.h
+++ b/library/cpp/yt/string/format_analyser.h
@@ -1,7 +1,10 @@
 #pragma once
 
+#include "format_arg.h"
+
 #include <util/generic/strbuf.h>
 
+#include <algorithm>
 #include <array>
 #include <string_view>
 
@@ -12,36 +15,138 @@ namespace NYT::NDetail {
 struct TFormatAnalyser
 {
 public:
+    using TMarkerLocation = std::tuple<int, int>;
+    // NB(arkady-e1ppa): Location is considered invalid (e.g. not filled)
+    // if get<0> == get<1> == 0.
+    template <class... TArgs>
+    using TMarkerLocations = std::array<TMarkerLocation, sizeof...(TArgs)>;
+    // NB(arkady-e1ppa): We can't cover all of them since that would require
+    // dynamic storage for their coordinates and we do not have
+    // constexpr context large enough to deallocate dynamic memory at the
+    // correct time. Thus we store first 5 position and scanning afterwards
+    // is pessimized. |-1| is for no position at all.
+    // |-2| is used to imply runtime format.
+    using TEscapeLocations = std::array<int, 5>;
+
+    // TODO(arkady-e1ppa): Until clang-19 consteval functions
+    // defined out of line produce symbols in rare cases
+    // causing linker to crash.
     template <class... TArgs>
-    static consteval void ValidateFormat(std::string_view fmt);
+    static consteval auto AnalyzeFormat(std::string_view fmt)
+    {
+        return DoAnalyzeFormat<TArgs...>(fmt);
+    }
 
 private:
-    // Non-constexpr function call will terminate compilation.
-    // Purposefully undefined and non-constexpr/consteval
-    template <class T>
-    static void CrashCompilerNotFormattable(std::string_view /*msg*/)
-    { /*Suppress "internal linkage but undefined" warning*/ }
-    static void CrashCompilerNotEnoughArguments(std::string_view msg);
-    static void CrashCompilerTooManyArguments(std::string_view msg);
-    static void CrashCompilerWrongTermination(std::string_view msg);
-    static void CrashCompilerMissingTermination(std::string_view msg);
-    static void CrashCompilerWrongFlagSpecifier(std::string_view msg);
+    static consteval bool Contains(std::string_view sv, char symbol)
+    {
+        return sv.find(symbol) != std::string_view::npos;
+    }
 
     struct TSpecifiers
     {
         std::string_view Conversion;
         std::string_view Flags;
     };
+
     template <class TArg>
-    static consteval auto GetSpecifiers();
+    static consteval auto GetSpecifiers()
+    {
+        return TSpecifiers{
+            .Conversion = std::string_view{
+                std::data(TFormatArg<TArg>::ConversionSpecifiers),
+                std::size(TFormatArg<TArg>::ConversionSpecifiers)},
+            .Flags = std::string_view{
+                std::data(TFormatArg<TArg>::FlagSpecifiers),
+                std::size(TFormatArg<TArg>::FlagSpecifiers)},
+        };
+    }
 
     static constexpr char IntroductorySymbol = '%';
+
+    template <class... TArgs>
+    static consteval auto DoAnalyzeFormat(std::string_view format)
+    {
+        std::array<TSpecifiers, sizeof...(TArgs)> specifiers{GetSpecifiers<TArgs>()...};
+
+        TMarkerLocations<TArgs...> markerLocations = {};
+        TEscapeLocations escapeLocations = {};
+        std::ranges::fill(escapeLocations, -1);
+
+        int escapesCount = 0;
+
+        int markerCount = 0;
+        int currentMarkerStart = -1;
+
+        for (int index = 0; index < std::ssize(format); ++index) {
+            auto symbol = format[index];
+
+            // Parse verbatim text.
+            if (currentMarkerStart == -1) {
+                if (symbol == IntroductorySymbol) {
+                    // Marker maybe begins.
+                    currentMarkerStart = index;
+                }
+                continue;
+            }
+
+            // NB: We check for %% first since
+            // in order to verify if symbol is a specifier
+            // we need markerCount to be within range of our
+            // specifier array.
+            if (symbol == IntroductorySymbol) {
+                if (currentMarkerStart + 1 != index) {
+                    // '%a% detected'
+                    throw "You may not terminate flag sequence other than %% with \'%\' symbol";
+                }
+                // '%%' detected --- skip
+                if (escapesCount < std::ssize(escapeLocations)) {
+                    escapeLocations[escapesCount] = currentMarkerStart;
+                    ++escapesCount;
+                }
+
+                currentMarkerStart = -1;
+                continue;
+            }
+
+            // We are inside of marker.
+            if (markerCount == std::ssize(markerLocations)) {
+                // Too many markers
+                throw "Number of arguments supplied to format is smaller than the number of flag sequences";
+            }
+
+            if (Contains(specifiers[markerCount].Conversion, symbol)) {
+                // Marker has finished.
+
+                markerLocations[markerCount]
+                    = std::tuple{currentMarkerStart, index + 1};
+                currentMarkerStart = -1;
+                ++markerCount;
+
+                continue;
+            }
+
+            if (!Contains(specifiers[markerCount].Flags, symbol)) {
+                throw "Symbol is not a valid flag specifier; See FlagSpecifiers";
+            }
+        }
+
+        if (currentMarkerStart != -1) {
+            // Runaway marker.
+            throw "Unterminated flag sequence detected; Use \'%%\' to type plain %";
+        }
+
+        if (markerCount < std::ssize(markerLocations)) {
+            // Missing markers.
+            throw "Number of arguments supplied to format is greater than the number of flag sequences";
+        }
+
+        // TODO(arkady-e1ppa): Consider per-type verification
+        // of markers.
+        return std::tuple(markerLocations, escapeLocations);
+    }
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 
 } // namespace NYT::NDetail
-
-#define FORMAT_ANALYSER_INL_H_
-#include "format_analyser-inl.h"
-#undef FORMAT_ANALYSER_INL_H_
diff --git a/library/cpp/yt/string/format_arg.h b/library/cpp/yt/string/format_arg.h
index 544e2657667..4dc7be06e8f 100644
--- a/library/cpp/yt/string/format_arg.h
+++ b/library/cpp/yt/string/format_arg.h
@@ -32,7 +32,7 @@ class TFormatArgBase
 public:
     // TODO(arkady-e1ppa): Consider more strict formatting rules.
     static constexpr std::array ConversionSpecifiers = {
-        'v', '1', 'c', 's', 'd', 'i', 'o',
+        'v', 'c', 's', 'd', 'i', 'o',
         'x', 'X', 'u', 'f', 'F', 'e', 'E',
         'a', 'A', 'g', 'G', 'n', 'p'
     };
diff --git a/library/cpp/yt/string/format_string-inl.h b/library/cpp/yt/string/format_string-inl.h
index a692d9648d0..67f9bad45c9 100644
--- a/library/cpp/yt/string/format_string-inl.h
+++ b/library/cpp/yt/string/format_string-inl.h
@@ -4,6 +4,8 @@
 #include "format_string.h"
 #endif
 
+#include <algorithm>
+
 namespace NYT {
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -15,8 +17,13 @@ consteval TBasicFormatString<TArgs...>::TBasicFormatString(const T& fmt)
     : Format_(fmt)
 {
     CheckFormattability();
-#if !defined(NDEBUG) && !defined(YT_DISABLE_FORMAT_STATIC_ANALYSIS)
-    NDetail::TFormatAnalyser::ValidateFormat<std::remove_cvref_t<TArgs>...>(Format_);
+#if !defined(YT_DISABLE_FORMAT_STATIC_ANALYSIS)
+    std::tie(Markers, Escapes) = NDetail::TFormatAnalyser::AnalyzeFormat<std::remove_cvref_t<TArgs>...>(Format_);
+#else
+    std::ranges::fill_n(std::ranges::begin(Escapes), 1, -1);
+    if constexpr (sizeof...(TArgs) != 0) {
+        std::ranges::fill_n(std::ranges::begin(Markers), 1, std::tuple{0, 0});
+    }
 #endif
 }
 
@@ -46,6 +53,11 @@ template <class... TArgs>
 TBasicFormatString<TArgs...>::TBasicFormatString(TRuntimeFormat fmt)
     : Format_(fmt.Get())
 {
+    std::ranges::fill_n(std::ranges::begin(Escapes), 1, -1);
+    if constexpr (sizeof...(TArgs) != 0) {
+        std::ranges::fill_n(std::ranges::begin(Markers), 1, std::tuple{0, 0});
+    }
+
     // NB(arkady-e1ppa): StaticFormat performs the
     // formattability check of the args in a way
     // that provides more useful information
diff --git a/library/cpp/yt/string/format_string.h b/library/cpp/yt/string/format_string.h
index 0c347637732..1008ccb4533 100644
--- a/library/cpp/yt/string/format_string.h
+++ b/library/cpp/yt/string/format_string.h
@@ -27,7 +27,7 @@ class TRuntimeFormat
 
 // This class used to properly bind to
 // string literals and allow compile-time parsing/checking
-// of those. If you need a runtime format, use TRuntimeFormat
+// of those. If you need a runtime format, use TRuntimeFormat.
 template <class... TArgs>
 class TBasicFormatString
 {
@@ -43,6 +43,10 @@ class TBasicFormatString
 
     static consteval void CheckFormattability();
 
+    // Data used for compile-time slicing of the format string.
+    NDetail::TFormatAnalyser::TMarkerLocations<TArgs...> Markers = {};
+    NDetail::TFormatAnalyser::TEscapeLocations Escapes = {};
+
 private:
     std::string_view Format_;
 
@@ -50,12 +54,19 @@ class TBasicFormatString
     static void CrashCompilerClassIsNotFormattable();
 };
 
-// Used to properly infer template arguments if Format.
+// Used to properly infer template arguments in Format.
 template <class... TArgs>
 using TFormatString = TBasicFormatString<std::type_identity_t<TArgs>...>;
 
 ////////////////////////////////////////////////////////////////////////////////
 
+template <class T>
+concept CStringLiteral = requires (T& t) {
+    [] (const char*) { } (t);
+};
+
+////////////////////////////////////////////////////////////////////////////////
+
 } // namespace NYT
 
 #define FORMAT_STRING_INL_H_
diff --git a/library/cpp/yt/string/raw_formatter.h b/library/cpp/yt/string/raw_formatter.h
index 6956330883b..23ea7f9af08 100644
--- a/library/cpp/yt/string/raw_formatter.h
+++ b/library/cpp/yt/string/raw_formatter.h
@@ -84,11 +84,12 @@ class TBaseFormatter
         }
     }
 
-    //! Appends a single character and updates the internal cursor.
-    void AppendChar(char ch)
+    //! Appends a single character given number of times and updates the internal cursor.
+    void AppendChar(char ch, int count = 1)
     {
-        if (Cursor_ < End_) {
+        while (Cursor_ < End_ && count > 0) {
             *Cursor_++ = ch;
+            count--;
         }
     }
 
@@ -97,6 +98,8 @@ class TBaseFormatter
     {
         int digits = 0;
 
+        width = std::min(width, GetBytesRemaining());
+
         if (radix == 16) {
             // Optimize output of hex numbers.
 
@@ -140,22 +143,6 @@ class TBaseFormatter
         }
     }
 
-    //! Formats |number| as hexadecimal number and updates the internal cursor.
-    //! Padding will be added in front if needed.
-    void AppendNumberAsHexWithPadding(uintptr_t number, int width)
-    {
-        char* begin = Cursor_;
-        AppendString("0x");
-        AppendNumber(number, 16);
-        // Move to right and add padding in front if needed.
-        if (Cursor_ < begin + width) {
-            auto delta = begin + width - Cursor_;
-            std::copy(begin, Cursor_, begin + delta);
-            std::fill(begin, begin + delta, ' ');
-            Cursor_ = begin + width;
-        }
-    }
-
     //! Formats |guid| and updates the internal cursor.
     void AppendGuid(TGuid guid)
     {
@@ -185,7 +172,6 @@ class TBaseFormatter
     char* const Begin_;
     char* Cursor_;
     char* const End_;
-
 };
 
 template <size_t N>
@@ -203,7 +189,6 @@ class TRawFormatter
 
 private:
     char Buffer_[N];
-
 };
 
 ////////////////////////////////////////////////////////////////////////////////
diff --git a/library/cpp/yt/string/stream.cpp b/library/cpp/yt/string/stream.cpp
new file mode 100644
index 00000000000..4bf8dcd599c
--- /dev/null
+++ b/library/cpp/yt/string/stream.cpp
@@ -0,0 +1,144 @@
+#include "stream.h"
+
+#include <util/generic/bitops.h>
+#include <util/generic/string.h>
+#include <util/generic/utility.h>
+#include <util/system/yassert.h>
+
+namespace NYT {
+
+////////////////////////////////////////////////////////////////////////////////
+
+static constexpr size_t MinBufferGrowSize = 16;
+
+////////////////////////////////////////////////////////////////////////////////
+
+TStdStringOutput::TStdStringOutput(std::string& string) noexcept
+    : String_(&string)
+{ }
+
+TStdStringOutput::~TStdStringOutput() = default;
+
+void TStdStringOutput::Reserve(size_t size)
+{
+    String_->reserve(String_->size() + size);
+}
+
+void TStdStringOutput::Swap(TStdStringOutput& other) noexcept
+{
+    DoSwap(String_, other.String_);
+}
+
+size_t TStdStringOutput::DoNext(void** ptr)
+{
+    if (String_->size() == String_->capacity()) {
+        String_->reserve(FastClp2(String_->capacity() + MinBufferGrowSize));
+    }
+    size_t previousSize = String_->size();
+    ResizeUninitialized(*String_, String_->capacity());
+    *ptr = String_->data() + previousSize;
+    return String_->size() - previousSize;
+}
+
+void TStdStringOutput::DoUndo(size_t len)
+{
+    Y_ABORT_UNLESS(len <= String_->size(), "trying to undo more bytes than actually written");
+    String_->resize(String_->size() - len);
+}
+
+void TStdStringOutput::DoWrite(const void* buf, size_t len)
+{
+    String_->append(static_cast<const char*>(buf), len);
+}
+
+void TStdStringOutput::DoWriteC(char c)
+{
+    String_->push_back(c);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+TStdStringStream::TStdStringStream()
+    : TEmbeddedString()
+    , TStdStringOutput(*TEmbeddedString::Ptr())
+{ }
+
+TStdStringStream::TStdStringStream(const std::string& string)
+    : TEmbeddedString(string)
+    , TStdStringOutput(*TEmbeddedString::Ptr())
+{ }
+
+TStdStringStream::TStdStringStream(std::string&& string)
+    : TEmbeddedString(std::move(string))
+    , TStdStringOutput(*TEmbeddedString::Ptr())
+{ }
+
+TStdStringStream::TStdStringStream(const TStdStringStream& other)
+    : TEmbeddedString(other.Str())
+    , TStdStringOutput(*TEmbeddedString::Ptr())
+{ }
+
+TStdStringStream::TStdStringStream(TStdStringStream&& other) noexcept
+    : TEmbeddedString(std::move(other).Str())
+    , TStdStringOutput(*TEmbeddedString::Ptr())
+{ }
+
+TStdStringStream& TStdStringStream::operator=(const TStdStringStream& other)
+{
+    // The embedded string reference remains valid; only its contents change.
+    Str() = other.Str();
+    return *this;
+}
+
+TStdStringStream& TStdStringStream::operator=(TStdStringStream&& other) noexcept
+{
+    // The embedded string reference remains valid; only its contents change.
+    Str() = std::move(other).Str();
+    return *this;
+}
+
+TStdStringStream::~TStdStringStream() = default;
+
+TStdStringStream::operator bool() const noexcept
+{
+    return !Empty();
+}
+
+std::string& TStdStringStream::Str() & noexcept
+{
+    return *Ptr();
+}
+
+const std::string& TStdStringStream::Str() const& noexcept
+{
+    return *Ptr();
+}
+
+std::string&& TStdStringStream::Str() && noexcept
+{
+    return std::move(*Ptr());
+}
+
+const char* TStdStringStream::Data() const noexcept
+{
+    return Ptr()->data();
+}
+
+size_t TStdStringStream::Size() const noexcept
+{
+    return Ptr()->size();
+}
+
+bool TStdStringStream::Empty() const noexcept
+{
+    return Ptr()->empty();
+}
+
+void TStdStringStream::Clear()
+{
+    Str().clear();
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace NYT
diff --git a/library/cpp/yt/string/stream.h b/library/cpp/yt/string/stream.h
new file mode 100644
index 00000000000..b041a5e0e49
--- /dev/null
+++ b/library/cpp/yt/string/stream.h
@@ -0,0 +1,107 @@
+#pragma once
+
+#include <util/generic/store_policy.h>
+
+#include <util/stream/zerocopy_output.h>
+
+#include <util/system/compiler.h>
+
+#include <string>
+
+namespace NYT {
+
+////////////////////////////////////////////////////////////////////////////////
+
+//! Drop-in, |std::string|-backed replacements for util's |TStringOutput| /
+//! |TStringStream| (util/stream/str.h).
+//!
+//! The util adapters are hard-wired to |TString| (they take a |TString&| / own
+//! a |TString|), which forces any string they touch to stay |TString|. These
+//! mirror the same |IOutputStream| / zero-copy interfaces over |std::string|,
+//! so a buffer that previously had to be |TString| solely to feed one of those
+//! streams can become |std::string|.
+//!
+//! Only the output/owning variants live here: for *reading* from a
+//! |std::string| / |TStringBuf|, util's |TMemoryInput| already works (it views
+//! raw bytes and involves no |TString|).
+
+//! An output stream that appends to a referenced |std::string|.
+class TStdStringOutput
+    : public IZeroCopyOutput
+{
+public:
+    //! Constructs an output stream appending to \p string.
+    /*!
+     *  As with |TStringOutput|, the stream keeps a reference to \p string, so
+     *  the caller must keep it alive while the stream is in use.
+     */
+    explicit TStdStringOutput(std::string& string Y_LIFETIME_BOUND) noexcept;
+
+    TStdStringOutput(TStdStringOutput&&) noexcept = default;
+
+    ~TStdStringOutput() override;
+
+    //! Reserves \p size additional characters in the output string.
+    void Reserve(size_t size);
+
+    void Swap(TStdStringOutput& other) noexcept;
+
+protected:
+    size_t DoNext(void** ptr) override;
+    void DoUndo(size_t len) override;
+    void DoWrite(const void* buf, size_t len) override;
+    void DoWriteC(char c) override;
+
+private:
+    std::string* String_;
+};
+
+////////////////////////////////////////////////////////////////////////////////
+
+//! An output stream that owns a |std::string| (the writing half of util's
+//! |TStringStream|). Read the accumulated bytes back via |Str()|, or wrap it in
+//! a |TMemoryInput|.
+class TStdStringStream
+    : private TEmbedPolicy<std::string>
+    , public TStdStringOutput
+{
+    using TEmbeddedString = TEmbedPolicy<std::string>;
+
+public:
+    TStdStringStream();
+    explicit TStdStringStream(const std::string& string);
+    explicit TStdStringStream(std::string&& string);
+    TStdStringStream(const TStdStringStream& other);
+    TStdStringStream(TStdStringStream&& other) noexcept;
+
+    TStdStringStream& operator=(const TStdStringStream& other);
+    TStdStringStream& operator=(TStdStringStream&& other) noexcept;
+
+    ~TStdStringStream() override;
+
+    //! Returns whether this stream contains any data.
+    explicit operator bool() const noexcept;
+
+    //! Returns the string this stream is writing into.
+    std::string& Str() & noexcept;
+    const std::string& Str() const& noexcept;
+    std::string&& Str() && noexcept;
+
+    //! Returns a pointer to the (null-terminated) character data.
+    const char* Data() const noexcept;
+
+    //! Returns the total number of characters in the stream.
+    size_t Size() const noexcept;
+
+    //! Returns whether the underlying string is empty.
+    Y_PURE_FUNCTION bool Empty() const noexcept;
+
+    using TStdStringOutput::Reserve;
+
+    //! Clears the underlying string.
+    void Clear();
+};
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace NYT
diff --git a/library/cpp/yt/string/string-inl.h b/library/cpp/yt/string/string-inl.h
index baf789b4f1f..fc9e49779f3 100644
--- a/library/cpp/yt/string/string-inl.h
+++ b/library/cpp/yt/string/string-inl.h
@@ -4,7 +4,7 @@
 #include "string.h"
 #endif
 
-#include "format.h"
+#include "string_builder.h"
 
 namespace NYT {
 
@@ -19,7 +19,7 @@ namespace NYT {
  *  \param delimiter A delimiter to be inserted between items: ", " by default.
  *  \return The resulting combined string.
  */
-template <class TIterator, class TFormatter>
+template <std::forward_iterator TIterator, class TFormatter>
 void JoinToString(
     TStringBuilderBase* builder,
     const TIterator& begin,
@@ -35,8 +35,8 @@ void JoinToString(
     }
 }
 
-template <class TIterator, class TFormatter>
-TString JoinToString(
+template <std::forward_iterator TIterator, class TFormatter>
+std::string JoinToString(
     const TIterator& begin,
     const TIterator& end,
     const TFormatter& formatter,
@@ -48,8 +48,8 @@ TString JoinToString(
 }
 
 //! A handy shortcut with default formatter.
-template <class TIterator>
-TString JoinToString(
+template <std::forward_iterator TIterator>
+std::string JoinToString(
     const TIterator& begin,
     const TIterator& end,
     TStringBuf delimiter)
@@ -63,9 +63,9 @@ TString JoinToString(
  *  \param formatter Formatter to apply to the items.
  *  \param delimiter A delimiter to be inserted between items; ", " by default.
  */
-template <class TCollection, class TFormatter>
-TString JoinToString(
-    const TCollection& collection,
+template <std::ranges::range TCollection, class TFormatter>
+std::string JoinToString(
+    TCollection&& collection,
     const TFormatter& formatter,
     TStringBuf delimiter)
 {
@@ -75,22 +75,22 @@ TString JoinToString(
 }
 
 //! A handy shortcut with the default formatter.
-template <class TCollection>
-TString JoinToString(
-    const TCollection& collection,
+template <std::ranges::range TCollection>
+std::string JoinToString(
+    TCollection&& collection,
     TStringBuf delimiter)
 {
-    return JoinToString(collection, TDefaultFormatter(), delimiter);
+    return JoinToString(std::forward<TCollection>(collection), TDefaultFormatter(), delimiter);
 }
 
 //! Concatenates a bunch of TStringBuf-like instances into TString.
 template <class... Ts>
-TString ConcatToString(Ts... args)
+std::string ConcatToString(Ts... args)
 {
     size_t length = 0;
     ((length += args.length()), ...);
 
-    TString result;
+    std::string result;
     result.reserve(length);
     (result.append(args), ...);
 
@@ -98,14 +98,14 @@ TString ConcatToString(Ts... args)
 }
 
 //! Converts a range of items into strings.
-template <class TIter, class TFormatter>
-std::vector<TString> ConvertToStrings(
+template <std::forward_iterator TIter, class TFormatter>
+std::vector<std::string> ConvertToStrings(
     const TIter& begin,
     const TIter& end,
     const TFormatter& formatter,
     size_t maxSize)
 {
-    std::vector<TString> result;
+    std::vector<std::string> result;
     for (auto it = begin; it != end; ++it) {
         TStringBuilder builder;
         formatter(&builder, *it);
@@ -118,8 +118,8 @@ std::vector<TString> ConvertToStrings(
 }
 
 //! A handy shortcut with the default formatter.
-template <class TIter>
-std::vector<TString> ConvertToStrings(
+template <std::forward_iterator TIter>
+std::vector<std::string> ConvertToStrings(
     const TIter& begin,
     const TIter& end,
     size_t maxSize)
@@ -133,9 +133,9 @@ std::vector<TString> ConvertToStrings(
  *  \param formatter Formatter to apply to the items.
  *  \param maxSize Size limit for the resulting vector.
  */
-template <class TCollection, class TFormatter>
-std::vector<TString> ConvertToStrings(
-    const TCollection& collection,
+template <std::ranges::range TCollection, class TFormatter>
+std::vector<std::string> ConvertToStrings(
+    TCollection&& collection,
     const TFormatter& formatter,
     size_t maxSize)
 {
@@ -145,12 +145,12 @@ std::vector<TString> ConvertToStrings(
 }
 
 //! A handy shortcut with default formatter.
-template <class TCollection>
-std::vector<TString> ConvertToStrings(
-    const TCollection& collection,
+template <std::ranges::range TCollection>
+std::vector<std::string> ConvertToStrings(
+    TCollection&& collection,
     size_t maxSize)
 {
-    return ConvertToStrings(collection, TDefaultFormatter(), maxSize);
+    return ConvertToStrings(std::forward<TCollection>(collection), TDefaultFormatter(), maxSize);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
diff --git a/library/cpp/yt/string/string.cpp b/library/cpp/yt/string/string.cpp
index c4bd98b66c0..e4a2afeca5e 100644
--- a/library/cpp/yt/string/string.cpp
+++ b/library/cpp/yt/string/string.cpp
@@ -65,42 +65,46 @@ TString CamelCaseToUnderscoreCase(TStringBuf str)
 
 ////////////////////////////////////////////////////////////////////////////////
 
-TString TrimLeadingWhitespaces(const TString& str)
+std::string AsciiStringToLower(TStringBuf value)
 {
-    for (int i = 0; i < static_cast<int>(str.size()); ++i) {
-        if (str[i] != ' ') {
-            return str.substr(i);
-        }
+    std::string result(value.size(), '\0');
+    for (size_t index = 0; index < value.size(); ++index) {
+        result[index] = ::AsciiToLower(value[index]);
     }
-    return "";
+    return result;
 }
 
-TString Trim(const TString& str, const TString& whitespaces)
+std::string AsciiStringToUpper(TStringBuf value)
 {
-    size_t end = str.size();
-    while (end > 0) {
-        size_t i = end - 1;
-        bool isWhitespace = false;
-        for (auto c : whitespaces) {
-            if (str[i] == c) {
-                isWhitespace = true;
-                break;
-            }
-        }
-        if (!isWhitespace) {
-            break;
-        }
-        --end;
+    std::string result(value.size(), '\0');
+    for (size_t index = 0; index < value.size(); ++index) {
+        result[index] = ::AsciiToUpper(value[index]);
+    }
+    return result;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+[[nodiscard]] TStringBuf TrimLeadingWhitespaces(TStringBuf str Y_LIFETIME_BOUND)
+{
+    auto begin = str.find_first_not_of(' ');
+    return begin == TStringBuf::npos ? "" : str.substr(begin);
+}
+
+[[nodiscard]] TStringBuf Trim(TStringBuf str Y_LIFETIME_BOUND, TStringBuf whitespaces)
+{
+    if (whitespaces.empty()) {
+        return str;
     }
+    auto end = str.find_last_not_of(whitespaces);
 
-    if (end == 0) {
+    if (end == TStringBuf::npos) {
         return "";
     }
 
-    size_t begin = str.find_first_not_of(whitespaces);
-    YT_VERIFY(begin != TString::npos);
-    YT_VERIFY(begin < end);
-    return str.substr(begin, end - begin);
+    auto begin = str.find_first_not_of(whitespaces);
+    YT_VERIFY(begin != TStringBuf::npos);
+    return str.substr(begin, end - begin + 1);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -308,7 +312,7 @@ size_t TCaseInsensitiveStringHasher::operator()(TStringBuf arg) const
 {
     auto compute = [&] (char* buffer) {
         for (size_t index = 0; index < arg.length(); ++index) {
-            buffer[index] = AsciiToLower(arg[index]);
+            buffer[index] = ::AsciiToLower(arg[index]);
         }
         return ComputeHash(TStringBuf(buffer, arg.length()));
     };
@@ -322,11 +326,16 @@ size_t TCaseInsensitiveStringHasher::operator()(TStringBuf arg) const
     }
 }
 
-bool TCaseInsensitiveStringEqualityComparer::operator()(TStringBuf lhs, TStringBuf rhs) const
+bool TCaseInsensitiveStringEqualComparer::operator()(TStringBuf lhs, TStringBuf rhs) const
 {
     return AsciiEqualsIgnoreCase(lhs, rhs);
 }
 
+bool TCaseInsensitiveStringLessComparer::operator()(TStringBuf lhs, TStringBuf rhs) const
+{
+    return AsciiCompareIgnoreCase(lhs, rhs) < 0;
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 
 bool TryParseBool(TStringBuf value, bool* result)
@@ -359,4 +368,45 @@ TStringBuf FormatBool(bool value)
 
 ////////////////////////////////////////////////////////////////////////////////
 
+void TruncateStringInplace(std::string* string, int lengthLimit, TStringBuf truncatedSuffix)
+{
+    if (std::ssize(*string) > lengthLimit) {
+        string->resize(lengthLimit);
+        string->append(truncatedSuffix);
+    }
+}
+
+std::string TruncateString(std::string string, int lengthLimit, TStringBuf truncatedSuffix)
+{
+    TruncateStringInplace(&string, lengthLimit, truncatedSuffix);
+    return string;
+}
+
+TTruncatedStringView::TTruncatedStringView(const std::string& value, int limit)
+    : Value_(value)
+    , Limit_(std::max(limit, 0))
+{ }
+
+void TTruncatedStringView::WriteToBuilder(TStringBuilderBase* builder, TStringBuf /* spec */) const
+{
+    i64 valueSize = std::ssize(Value_);
+    i64 maxSize = Limit_ + std::ssize(DefaultTruncatedMessage);
+    if (valueSize <= maxSize) {
+        builder->AppendString(Value_);
+        return;
+    }
+
+    char* begin = builder->Preallocate(maxSize);
+    memcpy(begin, Value_.data(), Limit_);
+    memcpy(begin + Limit_, DefaultTruncatedMessage.data(), DefaultTruncatedMessage.size());
+    builder->Advance(maxSize);
+}
+
+void FormatValue(TStringBuilderBase* builder, TTruncatedStringView value, TStringBuf spec)
+{
+    value.WriteToBuilder(builder, spec);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
 } // namespace NYT
diff --git a/library/cpp/yt/string/string.h b/library/cpp/yt/string/string.h
index 8257c1a5ead..968ac3a0554 100644
--- a/library/cpp/yt/string/string.h
+++ b/library/cpp/yt/string/string.h
@@ -9,8 +9,6 @@
 #include <util/string/strip.h>
 
 #include <vector>
-#include <set>
-#include <map>
 
 namespace NYT {
 
@@ -27,6 +25,25 @@ struct TDefaultFormatter
     }
 };
 
+//! Bind spec to a formatter.
+//! Used in ranges processing.
+class TSpecBoundFormatter
+{
+public:
+    explicit TSpecBoundFormatter(TStringBuf spec)
+        : Spec_(spec)
+    { }
+
+    template <class T>
+    void operator()(TStringBuilderBase* builder, const T& obj) const
+    {
+        FormatValue(builder, obj, Spec_);
+    }
+
+private:
+    TStringBuf Spec_;
+};
+
 static constexpr TStringBuf DefaultJoinToStringDelimiter = ", ";
 static constexpr TStringBuf DefaultKeyValueDelimiter = ": ";
 static constexpr TStringBuf DefaultRangeEllipsisFormat = "...";
@@ -46,7 +63,7 @@ static constexpr TStringBuf IntToHexUppercase = "0123456789ABCDEF";
  *  \param delimiter A delimiter to be inserted between items: ", " by default.
  *  \return The resulting combined string.
  */
-template <class TIterator, class TFormatter>
+template <std::forward_iterator TIterator, class TFormatter>
 void JoinToString(
     TStringBuilderBase* builder,
     const TIterator& begin,
@@ -54,16 +71,16 @@ void JoinToString(
     const TFormatter& formatter,
     TStringBuf delimiter = DefaultJoinToStringDelimiter);
 
-template <class TIterator, class TFormatter>
-TString JoinToString(
+template <std::forward_iterator TIterator, class TFormatter>
+std::string JoinToString(
     const TIterator& begin,
     const TIterator& end,
     const TFormatter& formatter,
     TStringBuf delimiter = DefaultJoinToStringDelimiter);
 
 //! A handy shortcut with default formatter.
-template <class TIterator>
-TString JoinToString(
+template <std::forward_iterator TIterator>
+std::string JoinToString(
     const TIterator& begin,
     const TIterator& end,
     TStringBuf delimiter = DefaultJoinToStringDelimiter);
@@ -74,33 +91,33 @@ TString JoinToString(
  *  \param formatter Formatter to apply to the items.
  *  \param delimiter A delimiter to be inserted between items; ", " by default.
  */
-template <class TCollection, class TFormatter>
-TString JoinToString(
-    const TCollection& collection,
+template <std::ranges::range TCollection, class TFormatter>
+std::string JoinToString(
+    TCollection&& collection,
     const TFormatter& formatter,
     TStringBuf delimiter = DefaultJoinToStringDelimiter);
 
 //! A handy shortcut with the default formatter.
-template <class TCollection>
-TString JoinToString(
-    const TCollection& collection,
+template <std::ranges::range TCollection>
+std::string JoinToString(
+    TCollection&& collection,
     TStringBuf delimiter = DefaultJoinToStringDelimiter);
 
 //! Concatenates a bunch of TStringBuf-like instances into TString.
 template <class... Ts>
-TString ConcatToString(Ts... args);
+std::string ConcatToString(Ts... args);
 
 //! Converts a range of items into strings.
-template <class TIter, class TFormatter>
-std::vector<TString> ConvertToStrings(
+template <std::forward_iterator TIter, class TFormatter>
+std::vector<std::string> ConvertToStrings(
     const TIter& begin,
     const TIter& end,
     const TFormatter& formatter,
     size_t maxSize = std::numeric_limits<size_t>::max());
 
 //! A handy shortcut with the default formatter.
-template <class TIter>
-std::vector<TString> ConvertToStrings(
+template <std::forward_iterator TIter>
+std::vector<std::string> ConvertToStrings(
     const TIter& begin,
     const TIter& end,
     size_t maxSize = std::numeric_limits<size_t>::max());
@@ -111,16 +128,16 @@ std::vector<TString> ConvertToStrings(
  *  \param formatter Formatter to apply to the items.
  *  \param maxSize Size limit for the resulting vector.
  */
-template <class TCollection, class TFormatter>
-std::vector<TString> ConvertToStrings(
-    const TCollection& collection,
+template <std::ranges::range TCollection, class TFormatter>
+std::vector<std::string> ConvertToStrings(
+    TCollection&& collection,
     const TFormatter& formatter,
     size_t maxSize = std::numeric_limits<size_t>::max());
 
 //! A handy shortcut with default formatter.
-template <class TCollection>
-std::vector<TString> ConvertToStrings(
-    const TCollection& collection,
+template <std::ranges::range TCollection>
+std::vector<std::string> ConvertToStrings(
+    TCollection&& collection,
     size_t maxSize = std::numeric_limits<size_t>::max());
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -131,8 +148,17 @@ TString UnderscoreCaseToCamelCase(TStringBuf str);
 void CamelCaseToUnderscoreCase(TStringBuilderBase* builder, TStringBuf str);
 TString CamelCaseToUnderscoreCase(TStringBuf str);
 
-TString TrimLeadingWhitespaces(const TString& str);
-TString Trim(const TString& str, const TString& whitespaces);
+//! ASCII case conversion returning |std::string|.
+//! TODO(babenko): likely a temporary workaround; these exist only because util's
+//! |to_lower|/|to_upper| are |TString|-based (forcing a |TString| round-trip for
+//! |std::string| callers). Drop once util gains |std::string| support.
+//! Returns a copy of |value| with every ASCII letter lowercased; non-ASCII bytes are left intact.
+std::string AsciiStringToLower(TStringBuf value);
+//! Returns a copy of |value| with every ASCII letter uppercased; non-ASCII bytes are left intact.
+std::string AsciiStringToUpper(TStringBuf value);
+
+[[nodiscard]] TStringBuf TrimLeadingWhitespaces(TStringBuf str Y_LIFETIME_BOUND);
+[[nodiscard]] TStringBuf Trim(TStringBuf str Y_LIFETIME_BOUND, TStringBuf whitespaces = " ");
 
 ////////////////////////////////////////////////////////////////////////////////
 
@@ -151,8 +177,15 @@ struct TCaseInsensitiveStringHasher
     size_t operator()(TStringBuf arg) const;
 };
 
-struct TCaseInsensitiveStringEqualityComparer
+struct TCaseInsensitiveStringEqualComparer
 {
+    using is_transparent = void;
+    bool operator()(TStringBuf lhs, TStringBuf rhs) const;
+};
+
+struct TCaseInsensitiveStringLessComparer
+{
+    using is_transparent = void;
     bool operator()(TStringBuf lhs, TStringBuf rhs) const;
 };
 
@@ -164,6 +197,26 @@ TStringBuf FormatBool(bool value);
 
 ////////////////////////////////////////////////////////////////////////////////
 
+inline constexpr TStringBuf DefaultTruncatedMessage = "...<truncated>";
+
+void TruncateStringInplace(std::string* string, int lengthLimit, TStringBuf truncatedSuffix = DefaultTruncatedMessage);
+std::string TruncateString(std::string string, int lengthLimit, TStringBuf truncatedSuffix = DefaultTruncatedMessage);
+
+class TTruncatedStringView
+{
+public:
+    TTruncatedStringView(const std::string& value, int limit);
+    void WriteToBuilder(TStringBuilderBase* builder, TStringBuf spec) const;
+
+private:
+    const std::string& Value_;
+    const int Limit_;
+};
+
+void FormatValue(TStringBuilderBase* builder, TTruncatedStringView value, TStringBuf spec);
+
+////////////////////////////////////////////////////////////////////////////////
+
 } // namespace NYT
 
 #define STRING_INL_H_
diff --git a/library/cpp/yt/string/string_builder-inl.h b/library/cpp/yt/string/string_builder-inl.h
new file mode 100644
index 00000000000..ad1958d1e85
--- /dev/null
+++ b/library/cpp/yt/string/string_builder-inl.h
@@ -0,0 +1,115 @@
+#ifndef STRING_BUILDER_INL_H_
+#error "Direct inclusion of this file is not allowed, include string_builder.h"
+// For the sake of sane code completion.
+#include "string_builder.h"
+#endif
+
+#include "format_string.h"
+
+#include <library/cpp/yt/assert/assert.h>
+
+namespace NYT {
+
+////////////////////////////////////////////////////////////////////////////////
+
+inline char* TStringBuilderBase::Preallocate(size_t size)
+{
+    Reserve(size + GetLength());
+    return Current_;
+}
+
+inline void TStringBuilderBase::Reserve(size_t size)
+{
+    if (Y_UNLIKELY(End_ - Begin_ < static_cast<ssize_t>(size))) {
+        size_t length = GetLength();
+        auto newLength = std::max(size, MinBufferLength);
+        DoReserve(newLength);
+        Current_ = Begin_ + length;
+    }
+}
+
+inline size_t TStringBuilderBase::GetLength() const
+{
+    return Current_ ? Current_ - Begin_ : 0;
+}
+
+inline TStringBuf TStringBuilderBase::GetBuffer() const
+{
+    return TStringBuf(Begin_, Current_);
+}
+
+inline void TStringBuilderBase::Advance(size_t size)
+{
+    Current_ += size;
+    YT_ASSERT(Current_ <= End_);
+}
+
+inline void TStringBuilderBase::AppendChar(char ch)
+{
+    *Preallocate(1) = ch;
+    Advance(1);
+}
+
+inline void TStringBuilderBase::AppendChar(char ch, int n)
+{
+    YT_ASSERT(n >= 0);
+    if (Y_LIKELY(0 != n)) {
+        char* dst = Preallocate(n);
+        ::memset(dst, ch, n);
+        Advance(n);
+    }
+}
+
+inline void TStringBuilderBase::AppendString(TStringBuf str)
+{
+    if (Y_LIKELY(str)) {
+        char* dst = Preallocate(str.length());
+        ::memcpy(dst, str.begin(), str.length());
+        Advance(str.length());
+    }
+}
+
+inline void TStringBuilderBase::AppendString(const char* str)
+{
+    AppendString(TStringBuf(str));
+}
+
+inline void TStringBuilderBase::Reset()
+{
+    Begin_ = Current_ = End_ = nullptr;
+    DoReset();
+}
+
+template <class... TArgs>
+void TStringBuilderBase::AppendFormat(TFormatString<TArgs...> format, TArgs&&... args)
+{
+    Format(this, format, std::forward<TArgs>(args)...);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+inline std::string TStringBuilder::Flush()
+{
+    Buffer_.resize(GetLength());
+    auto result = std::move(Buffer_);
+    Reset();
+    return result;
+}
+
+inline void TStringBuilder::DoReset()
+{
+    Buffer_.clear();
+}
+
+inline void TStringBuilder::DoReserve(size_t newLength)
+{
+    ResizeUninitialized(Buffer_, newLength);
+    auto capacity = Buffer_.capacity();
+    ResizeUninitialized(Buffer_, capacity);
+    Begin_ = &*Buffer_.begin();
+    End_ = Begin_ + capacity;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace NYT
diff --git a/library/cpp/yt/string/string_builder.cpp b/library/cpp/yt/string/string_builder.cpp
new file mode 100644
index 00000000000..bca493fa325
--- /dev/null
+++ b/library/cpp/yt/string/string_builder.cpp
@@ -0,0 +1,30 @@
+#include "string_builder.h"
+
+namespace NYT {
+
+////////////////////////////////////////////////////////////////////////////////
+
+TDelimitedStringBuilderWrapper::TDelimitedStringBuilderWrapper(
+    TStringBuilderBase* builder,
+    TStringBuf delimiter)
+    : Builder_(builder)
+    , Delimiter_(delimiter)
+{ }
+
+TStringBuilderBase* TDelimitedStringBuilderWrapper::operator->()
+{
+    return operator&();
+}
+
+TStringBuilderBase* TDelimitedStringBuilderWrapper::operator&()
+{
+    if (!FirstCall_) {
+        Builder_->AppendString(Delimiter_);
+    }
+    FirstCall_ = false;
+    return Builder_;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace NYT
diff --git a/library/cpp/yt/string/string_builder.h b/library/cpp/yt/string/string_builder.h
index de1c1abb1ee..ad2e3280857 100644
--- a/library/cpp/yt/string/string_builder.h
+++ b/library/cpp/yt/string/string_builder.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include "format.h"
+#include "format_string.h"
 
 #include <util/generic/string.h>
 
@@ -8,6 +8,61 @@ namespace NYT {
 
 ////////////////////////////////////////////////////////////////////////////////
 
+//! A simple helper for constructing strings by a sequence of appends.
+class TStringBuilderBase
+{
+public:
+    virtual ~TStringBuilderBase() = default;
+
+    char* Preallocate(size_t size);
+
+    void Reserve(size_t size);
+
+    size_t GetLength() const;
+
+    TStringBuf GetBuffer() const;
+
+    void Advance(size_t size);
+
+    void AppendChar(char ch);
+    void AppendChar(char ch, int n);
+
+    void AppendString(TStringBuf str);
+    void AppendString(const char* str);
+
+    template <class... TArgs>
+    void AppendFormat(TFormatString<TArgs...> format, TArgs&&... args);
+
+    void Reset();
+
+protected:
+    char* Begin_ = nullptr;
+    char* Current_ = nullptr;
+    char* End_ = nullptr;
+
+    virtual void DoReset() = 0;
+    virtual void DoReserve(size_t newLength) = 0;
+
+    static constexpr size_t MinBufferLength = 128;
+};
+
+////////////////////////////////////////////////////////////////////////////////
+
+class TStringBuilder
+    : public TStringBuilderBase
+{
+public:
+    std::string Flush();
+
+protected:
+    std::string Buffer_;
+
+    void DoReset() override;
+    void DoReserve(size_t size) override;
+};
+
+////////////////////////////////////////////////////////////////////////////////
+
 //! Appends a certain delimiter starting from the second call.
 class TDelimitedStringBuilderWrapper
     : private TNonCopyable
@@ -15,19 +70,10 @@ class TDelimitedStringBuilderWrapper
 public:
     TDelimitedStringBuilderWrapper(
         TStringBuilderBase* builder,
-        TStringBuf delimiter = TStringBuf(", "))
-        : Builder_(builder)
-        , Delimiter_(delimiter)
-    { }
-
-    TStringBuilderBase* operator->()
-    {
-        if (!FirstCall_) {
-            Builder_->AppendString(Delimiter_);
-        }
-        FirstCall_ = false;
-        return Builder_;
-    }
+        TStringBuf delimiter = TStringBuf(", "));
+
+    TStringBuilderBase* operator->();
+    TStringBuilderBase* operator&();
 
 private:
     TStringBuilderBase* const Builder_;
@@ -39,3 +85,7 @@ class TDelimitedStringBuilderWrapper
 ////////////////////////////////////////////////////////////////////////////////
 
 } // namespace NYT
+
+#define STRING_BUILDER_INL_H_
+#include "string_builder-inl.h"
+#undef STRING_BUILDER_INL_H_
diff --git a/library/cpp/yt/string/unittests/enum_ut.cpp b/library/cpp/yt/string/unittests/enum_ut.cpp
index be5387151a0..b262568565c 100644
--- a/library/cpp/yt/string/unittests/enum_ut.cpp
+++ b/library/cpp/yt/string/unittests/enum_ut.cpp
@@ -27,13 +27,39 @@ DEFINE_BIT_ENUM(ELangs,
     ((Rust)       (0x04))
     ((Python)     (0x08))
     ((JavaScript) (0x10))
+    ((CppGo)      (0x03))
+    ((All)        (0x1f))
 );
 
+DEFINE_BIT_ENUM(ELangsWithUnknown,
+    ((None)       (0x00))
+    ((Cpp)        (0x01))
+    ((Go)         (0x02))
+    ((Rust)       (0x04))
+    ((Python)     (0x08))
+    ((JavaScript) (0x10))
+    ((CppGo)      (0x03))
+    ((All)        (0x1f))
+    ((Unknown)    (0x20))
+);
+DEFINE_ENUM_UNKNOWN_VALUE(ELangsWithUnknown, Unknown);
+
 DEFINE_ENUM(ECustomDomainName,
     ((A) (1) ("value_a"))
     ((B) (2) ("value_b"))
 );
 
+DEFINE_ENUM(EColorWithUnknown,
+    (Red)
+    (Green)
+    (Unknown)
+);
+DEFINE_ENUM_UNKNOWN_VALUE(EColorWithUnknown, Unknown);
+
+DEFINE_BIT_ENUM(EBitEnumWithoutNone,
+    ((Some)(1))
+);
+
 TEST(TFormatTest, Enum)
 {
     EXPECT_EQ("Red", Format("%v", EColor::Red));
@@ -42,7 +68,8 @@ TEST(TFormatTest, Enum)
     EXPECT_EQ("BlackAndWhite", Format("%v", EColor::BlackAndWhite));
     EXPECT_EQ("black_and_white", Format("%lv", EColor::BlackAndWhite));
 
-    EXPECT_EQ("EColor(100)", Format("%v", EColor(100)));
+    EXPECT_EQ("EColor::unknown-100", Format("%v", EColor(100)));
+    EXPECT_EQ("Cpp | ELangs::unknown-32", Format("%v", ELangs(0x21)));
 
     EXPECT_EQ("JavaScript", Format("%v", ELangs::JavaScript));
     EXPECT_EQ("java_script", Format("%lv", ELangs::JavaScript));
@@ -50,6 +77,8 @@ TEST(TFormatTest, Enum)
     EXPECT_EQ("None", Format("%v", ELangs::None));
     EXPECT_EQ("none", Format("%lv", ELangs::None));
 
+    EXPECT_EQ("", Format("%v", EBitEnumWithoutNone()));
+
     EXPECT_EQ("Cpp | Go", Format("%v", ELangs::Cpp | ELangs::Go));
     EXPECT_EQ("cpp | go", Format("%lv", ELangs::Cpp | ELangs::Go));
 
@@ -64,6 +93,19 @@ TEST(TFormatEnumTest, FormatEnumWithCustomDomainName)
     EXPECT_EQ("value_b", FormatEnum(ECustomDomainName::B));
 }
 
+TEST(TParseEnumTest, ParseUnknown)
+{
+    EXPECT_EQ(std::nullopt, TryParseEnum<EColor>("yellow"));
+    EXPECT_THROW(ParseEnum<EColor>("yellow"), TSimpleException);
+    EXPECT_EQ(std::nullopt, TryParseEnum<EColorWithUnknown>("yellow"));
+    EXPECT_EQ(EColorWithUnknown::Unknown, TryParseEnum<EColorWithUnknown>("yellow", /*enableUnknown*/ true));
+    EXPECT_EQ(EColorWithUnknown::Unknown, ParseEnum<EColorWithUnknown>("yellow"));
+    EXPECT_EQ(std::nullopt, TryParseEnum<ELangs>("cpp | haskell"));
+    EXPECT_THROW(ParseEnum<ELangs>("cpp | haskell"), TSimpleException);
+    EXPECT_EQ(ELangsWithUnknown::Cpp | ELangsWithUnknown::Unknown, TryParseEnum<ELangsWithUnknown>("cpp | haskell", /*enableUnknown*/ true));
+    EXPECT_EQ(ELangsWithUnknown::Cpp | ELangsWithUnknown::Unknown, ParseEnum<ELangsWithUnknown>("cpp | haskell"));
+}
+
 TEST(TParseEnumTest, ParseEnumWithCustomDomainName)
 {
     EXPECT_EQ(ECustomDomainName::A, TryParseEnum<ECustomDomainName>("value_a"));
@@ -77,12 +119,10 @@ TEST(TParseEnumTest, ParseBitEnum)
     EXPECT_EQ(ELangs::Cpp, TryParseEnum<ELangs>("cpp"));
     EXPECT_EQ(ELangs::Cpp | ELangs::Rust, TryParseEnum<ELangs>("cpp|rust"));
     EXPECT_EQ(ELangs::Cpp | ELangs::Rust, TryParseEnum<ELangs>("cpp | rust"));
-    EXPECT_EQ(std::nullopt, TryParseEnum<ELangs>("unk | rust"));
+    EXPECT_EQ(std::nullopt, TryParseEnum<ELangs>("haskell | rust"));
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 } // namespace
 } // namespace NYT
-
-
diff --git a/library/cpp/yt/string/unittests/format_ut.cpp b/library/cpp/yt/string/unittests/format_ut.cpp
index 4083338c44a..a2d324799cd 100644
--- a/library/cpp/yt/string/unittests/format_ut.cpp
+++ b/library/cpp/yt/string/unittests/format_ut.cpp
@@ -2,7 +2,9 @@
 
 #include <library/cpp/yt/string/format.h>
 
-#include <library/cpp/yt/small_containers/compact_vector.h>
+#include <library/cpp/yt/compact_containers/compact_flat_map.h>
+#include <library/cpp/yt/compact_containers/compact_flat_set.h>
+#include <library/cpp/yt/compact_containers/compact_vector.h>
 
 #include <util/generic/hash_set.h>
 
@@ -13,6 +15,44 @@ namespace {
 
 ////////////////////////////////////////////////////////////////////////////////
 
+struct TWithCustomFlags
+{
+    [[maybe_unused]]
+    friend void FormatValue(TStringBuilderBase* builder, const TWithCustomFlags&, TStringBuf spec)
+    {
+        if (spec.Contains('R')) {
+            builder->AppendString("R");
+        }
+        if (spec.Contains('N')) {
+            builder->AppendString("N");
+        }
+
+        builder->AppendString("P");
+    }
+};
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace
+
+////////////////////////////////////////////////////////////////////////////////
+
+template <>
+struct TFormatArg<TWithCustomFlags>
+{
+    [[maybe_unused]] static constexpr std::array ConversionSpecifiers = {
+        'v',
+    };
+
+    [[maybe_unused]] static constexpr std::array FlagSpecifiers = {
+        'R', 'N',
+    };
+};
+
+////////////////////////////////////////////////////////////////////////////////
+
+namespace {
+
 // Some compile-time sanity checks.
 static_assert(CFormattable<int>);
 static_assert(CFormattable<double>);
@@ -22,6 +62,7 @@ static_assert(CFormattable<TStringBuf>);
 static_assert(CFormattable<TString>);
 static_assert(CFormattable<std::span<int>>);
 static_assert(CFormattable<std::vector<int>>);
+static_assert(CFormattable<std::array<int, 5>>);
 
 // N.B. TCompactVector<int, 1> is not buildable on Windows
 static_assert(CFormattable<TCompactVector<int, 2>>);
@@ -29,8 +70,10 @@ static_assert(CFormattable<std::set<int>>);
 static_assert(CFormattable<std::map<int, int>>);
 static_assert(CFormattable<std::multimap<int, int>>);
 static_assert(CFormattable<THashSet<int>>);
+static_assert(CFormattable<TCompactFlatSet<int, 2>>);
 static_assert(CFormattable<THashMap<int, int>>);
 static_assert(CFormattable<THashMultiSet<int>>);
+static_assert(CFormattable<TCompactFlatMap<int, int, 2>>);
 static_assert(CFormattable<std::pair<int, int>>);
 static_assert(CFormattable<std::optional<int>>);
 static_assert(CFormattable<TDuration>);
@@ -39,6 +82,9 @@ static_assert(CFormattable<TInstant>);
 struct TUnformattable
 { };
 static_assert(!CFormattable<TUnformattable>);
+static_assert(!CFormattable<std::variant<TUnformattable>>);
+
+static_assert(CFormattable<TWithCustomFlags>);
 
 ////////////////////////////////////////////////////////////////////////////////
 
@@ -197,6 +243,20 @@ TEST(TFormatTest, Pointers)
     }
 }
 
+TEST(TFormatTest, Tuples)
+{
+    EXPECT_EQ("{}", Format("%v", std::tuple()));
+    EXPECT_EQ("{1, 2, 3}", Format("%v", std::tuple(1, 2, 3)));
+    EXPECT_EQ("{1, 2}", Format("%v", std::pair(1, 2)));
+}
+
+TEST(TFormatTest, CompactIntervalView)
+{
+    EXPECT_EQ("[]", Format("%v", MakeCompactIntervalView(std::vector<int>{})));
+    EXPECT_EQ("[1]", Format("%v", MakeCompactIntervalView(std::vector<int>{1})));
+    EXPECT_EQ("[0, 2-4, 7]", Format("%v", MakeCompactIntervalView(std::vector<int>{0, 2, 3, 4, 7})));
+}
+
 TEST(TFormatTest, LazyMultiValueFormatter)
 {
     int i = 1;
@@ -210,6 +270,19 @@ TEST(TFormatTest, LazyMultiValueFormatter)
     EXPECT_EQ("int: 1, string: hello, range: [1, 2, 3]", Format("%v", lazyFormatter));
 }
 
+TEST(TFormatTest, ReusableLambdaFormatter)
+{
+    auto formatter = [&] (auto* builder, int value) {
+        builder->AppendFormat("%v", value);
+    };
+
+    std::vector<int> range1{1, 2, 3};
+    EXPECT_EQ("[1, 2, 3]", Format("%v", MakeFormattableView(range1, formatter)));
+
+    std::vector<int> range2{4, 5, 6};
+    EXPECT_EQ("[4, 5, 6]", Format("%v", MakeFormattableView(range2, formatter)));
+}
+
 TEST(TFormatTest, VectorArg)
 {
     std::vector<TString> params = {"a", "b", "c"};
@@ -223,6 +296,84 @@ TEST(TFormatTest, RuntimeFormat)
     EXPECT_EQ(Format(TRuntimeFormat(format), "World"), "Hello World");
 }
 
+TEST(TFormatTest, CustomFlagsSimple)
+{
+    EXPECT_EQ(Format("%v", TWithCustomFlags{}), TString("P"));
+    EXPECT_EQ(Format("%Rv", TWithCustomFlags{}), TString("RP"));
+    EXPECT_EQ(Format("%Nv", TWithCustomFlags{}), TString("NP"));
+    EXPECT_EQ(Format("%RNv", TWithCustomFlags{}), TString("RNP"));
+    EXPECT_EQ(Format("%NRv", TWithCustomFlags{}), TString("RNP"));
+}
+
+TEST(TFormatTest, CustomFlagsCollection)
+{
+    constexpr int elementCount = 5;
+    auto toCollection = [] (TString pattern) {
+        TString ret = "[";
+        for (int i = 0; i < elementCount - 1; ++i) {
+            ret += pattern + ", ";
+        }
+
+        ret += pattern + "]";
+
+        return ret;
+    };
+
+    std::vector vec(elementCount, TWithCustomFlags{});
+
+    EXPECT_EQ(Format("%v", vec), toCollection("P"));
+    EXPECT_EQ(Format("%Rv", vec), toCollection("RP"));
+    EXPECT_EQ(Format("%Nv", vec), toCollection("NP"));
+    EXPECT_EQ(Format("%RNv", vec), toCollection("RNP"));
+    EXPECT_EQ(Format("%NRv", vec), toCollection("RNP"));
+}
+
+TEST(TFormatTest, CustomFlagsCollectionTwoLevels)
+{
+    constexpr int elementCount1 = 5;
+    constexpr int elementCount2 = 3;
+    auto toCollection = [] (int count, TString pattern) {
+        TString ret = "[";
+        for (int i = 0; i < count - 1; ++i) {
+            ret += pattern + ", ";
+        }
+
+        ret += pattern + "]";
+
+        return ret;
+    };
+    auto toCollectionD2 = [&] (TString pattern) {
+        return toCollection(elementCount2, toCollection(elementCount1, std::move(pattern)));
+    };
+
+    std::vector vec(elementCount1, TWithCustomFlags{});
+    std::array<decltype(vec), elementCount2> arr;
+    std::ranges::fill(arr, vec);
+
+    EXPECT_EQ(Format("%v", arr), toCollectionD2("P"));
+    EXPECT_EQ(Format("%Rv", arr), toCollectionD2("RP"));
+    EXPECT_EQ(Format("%Nv", arr), toCollectionD2("NP"));
+    EXPECT_EQ(Format("%RNv", arr), toCollectionD2("RNP"));
+    EXPECT_EQ(Format("%NRv", arr), toCollectionD2("RNP"));
+}
+
+TEST(TFormatTest, ManyEscapes)
+{
+    EXPECT_EQ("a%b%c%d%e%f%g", Format("%v%%%v%%%v%%%v%%%v%%%v%%%g", "a", "b", "c", "d", "e", "f", "g"));
+}
+
+TEST(TFormatTest, TTruncatedString)
+{
+    EXPECT_EQ("", Format("%v", TTruncatedStringView("", 3)));
+    EXPECT_EQ("abc", Format("%v", TTruncatedStringView("abc", 3)));
+    EXPECT_EQ("abcd", Format("%v", TTruncatedStringView("abcd", 3)));
+    EXPECT_EQ("abcdefghijklmnopq", Format("%v", TTruncatedStringView("abcdefghijklmnopq", 3)));
+    EXPECT_EQ("abc...<truncated>", Format("%v", TTruncatedStringView("abcdefghijklmnopqr", 3)));
+    EXPECT_EQ("a: \"abc...<truncated>\",", Format("a: %Qv,", TTruncatedStringView("abcdefghijklmnopqr", 3)));
+    EXPECT_EQ("a: \'abc...<truncated>\',", Format("a: %qv,", TTruncatedStringView("abcdefghijklmnopqr", 3)));
+    EXPECT_EQ("aQ: \'abc...<truncated>\',", Format("aQ: %qv,", TTruncatedStringView("abcdefghijklmnopqr", 3)));
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 
 } // namespace
diff --git a/library/cpp/yt/string/unittests/guid_ut.cpp b/library/cpp/yt/string/unittests/guid_ut.cpp
index ed02b873917..9cff37c380f 100644
--- a/library/cpp/yt/string/unittests/guid_ut.cpp
+++ b/library/cpp/yt/string/unittests/guid_ut.cpp
@@ -12,7 +12,7 @@ namespace {
 
 static_assert(CFormattable<TGuid>);
 
-TString CanonicalToString(TGuid value)
+std::string CanonicalToString(TGuid value)
 {
    return Sprintf("%x-%x-%x-%x",
         value.Parts32[3],
@@ -48,7 +48,7 @@ TEST(TGuidTest, FormatAllSymbols)
 TEST(TGuidTest, ByteOrder)
 {
     auto guid = TGuid::FromStringHex32("12345678ABCDEF0112345678ABCDEF01");
-    TString bytes{reinterpret_cast<const char*>(&(guid.Parts32[0])), 16};
+    std::string bytes{reinterpret_cast<const char*>(&(guid.Parts32[0])), 16};
     EXPECT_EQ(HexEncode(bytes), "01EFCDAB7856341201EFCDAB78563412");
 }
 
diff --git a/library/cpp/yt/string/unittests/stream_ut.cpp b/library/cpp/yt/string/unittests/stream_ut.cpp
new file mode 100644
index 00000000000..5f46105373c
--- /dev/null
+++ b/library/cpp/yt/string/unittests/stream_ut.cpp
@@ -0,0 +1,66 @@
+#include <library/cpp/testing/gtest/gtest.h>
+
+#include <library/cpp/yt/string/stream.h>
+
+#include <util/stream/str.h>
+
+namespace NYT {
+namespace {
+
+////////////////////////////////////////////////////////////////////////////////
+
+TEST(TStdStringOutputTest, AppendsToReferencedString)
+{
+    std::string buffer = "abc";
+    {
+        TStdStringOutput output(buffer);
+        output << "de" << 'f' << 42;
+    }
+    EXPECT_EQ(buffer, "abcdef42");
+}
+
+TEST(TStdStringOutputTest, MatchesTStringOutput)
+{
+    std::string stdBuffer;
+    TString utilBuffer;
+    TStdStringOutput stdOutput(stdBuffer);
+    TStringOutput utilOutput(utilBuffer);
+    for (int i = 0; i < 1000; ++i) {
+        stdOutput << i << ',';
+        utilOutput << i << ',';
+    }
+    EXPECT_EQ(stdBuffer, std::string(utilBuffer));
+}
+
+TEST(TStdStringStreamTest, WriteAndStr)
+{
+    TStdStringStream stream;
+    EXPECT_FALSE(static_cast<bool>(stream));
+    stream << "value=" << 123;
+    EXPECT_TRUE(static_cast<bool>(stream));
+    EXPECT_EQ(stream.Str(), "value=123");
+    EXPECT_EQ(stream.Size(), 9u);
+}
+
+TEST(TStdStringStreamTest, ClearAndReuse)
+{
+    TStdStringStream stream("seed");
+    EXPECT_EQ(stream.Str(), "seed");
+    stream.Clear();
+    EXPECT_TRUE(stream.Empty());
+    stream << "again";
+    EXPECT_EQ(stream.Str(), "again");
+}
+
+TEST(TStdStringStreamTest, MoveOutBuffer)
+{
+    TStdStringStream stream;
+    stream << "movable";
+    std::string extracted = std::move(stream).Str();
+    EXPECT_EQ(extracted, "movable");
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace
+} // namespace NYT
diff --git a/library/cpp/yt/string/unittests/string_ut.cpp b/library/cpp/yt/string/unittests/string_ut.cpp
index 3e12312af0b..073516006fb 100644
--- a/library/cpp/yt/string/unittests/string_ut.cpp
+++ b/library/cpp/yt/string/unittests/string_ut.cpp
@@ -45,8 +45,23 @@ TEST(TStringTest, CamelCaseToUnderscoreCase)
     }
 }
 
+TEST(TStringTest, TrimWhitespaces)
+{
+    EXPECT_EQ("", TrimLeadingWhitespaces(""));
+    EXPECT_EQ("", TrimLeadingWhitespaces("   "));
+    EXPECT_EQ("foo", TrimLeadingWhitespaces("   foo"));
+    EXPECT_EQ("foo ", TrimLeadingWhitespaces("   foo "));
+    EXPECT_EQ("f oo ", TrimLeadingWhitespaces("   f oo "));
+
+    EXPECT_EQ("", Trim("", ""));
+    EXPECT_EQ("", Trim(" ", " "));
+    EXPECT_EQ(" ", Trim(" ", "\t"));
+    EXPECT_EQ("", Trim(" \t", " \t"));
+    EXPECT_EQ("foo", Trim(" foo ", " "));
+    EXPECT_EQ("f", Trim(" f ", " "));
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 
 } // namespace
 } // namespace NYT
-
diff --git a/library/cpp/yt/system/benchmarks/cpu_id.cpp b/library/cpp/yt/system/benchmarks/cpu_id.cpp
new file mode 100644
index 00000000000..2bb36eb4657
--- /dev/null
+++ b/library/cpp/yt/system/benchmarks/cpu_id.cpp
@@ -0,0 +1,33 @@
+#include <library/cpp/yt/system/cpu_id.h>
+
+#include <benchmark/benchmark.h>
+
+#include <sched.h>
+
+namespace NYT {
+namespace {
+
+////////////////////////////////////////////////////////////////////////////////
+
+// rseq: a single thread-local read.
+void BM_GetCurrentCpuId(benchmark::State& state)
+{
+    for (auto _ : state) {
+        benchmark::DoNotOptimize(GetCurrentCpuId());
+    }
+}
+BENCHMARK(BM_GetCurrentCpuId);
+
+// The fallback path: sched_getcpu() (vDSO getcpu).
+void BM_SchedGetCpu(benchmark::State& state)
+{
+    for (auto _ : state) {
+        benchmark::DoNotOptimize(sched_getcpu());
+    }
+}
+BENCHMARK(BM_SchedGetCpu);
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace
+} // namespace NYT
diff --git a/library/cpp/yt/system/benchmarks/process.cpp b/library/cpp/yt/system/benchmarks/process.cpp
new file mode 100644
index 00000000000..74b4b6b1e13
--- /dev/null
+++ b/library/cpp/yt/system/benchmarks/process.cpp
@@ -0,0 +1,35 @@
+#include <benchmark/benchmark.h>
+
+#include <library/cpp/yt/system/process_id.h>
+
+#include <util/system/getpid.h>
+
+namespace NYT {
+namespace {
+
+////////////////////////////////////////////////////////////////////////////////
+
+void BM_GetProcessId(benchmark::State& state)
+{
+    // Cached getpid: only the first call hits the kernel.
+    for (auto _ : state) {
+        benchmark::DoNotOptimize(GetProcessId());
+    }
+}
+
+BENCHMARK(BM_GetProcessId);
+
+void BM_RawGetPid(benchmark::State& state)
+{
+    // Uncached getpid syscall (uncached on glibc >= 2.25), for comparison.
+    for (auto _ : state) {
+        benchmark::DoNotOptimize(::GetPID());
+    }
+}
+
+BENCHMARK(BM_RawGetPid);
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace
+} // namespace NYT
diff --git a/library/cpp/yt/system/benchmarks/thread.cpp b/library/cpp/yt/system/benchmarks/thread.cpp
new file mode 100644
index 00000000000..5aa5f7dc2d9
--- /dev/null
+++ b/library/cpp/yt/system/benchmarks/thread.cpp
@@ -0,0 +1,55 @@
+#include <benchmark/benchmark.h>
+
+#include <library/cpp/yt/system/thread_id.h>
+#include <library/cpp/yt/system/thread_name.h>
+
+#include <util/system/thread.h>
+
+namespace NYT {
+namespace {
+
+////////////////////////////////////////////////////////////////////////////////
+
+void BM_GetSystemThreadId(benchmark::State& state)
+{
+    // Cached gettid: only the first call per thread hits the kernel.
+    for (auto _ : state) {
+        benchmark::DoNotOptimize(GetSystemThreadId());
+    }
+}
+
+BENCHMARK(BM_GetSystemThreadId);
+
+void BM_GetSequentialThreadId(benchmark::State& state)
+{
+    for (auto _ : state) {
+        benchmark::DoNotOptimize(GetSequentialThreadId());
+    }
+}
+
+BENCHMARK(BM_GetSequentialThreadId);
+
+void BM_RawGetTid(benchmark::State& state)
+{
+    // Uncached gettid syscall, for comparison.
+    for (auto _ : state) {
+        benchmark::DoNotOptimize(::TThread::CurrentThreadNumericId());
+    }
+}
+
+BENCHMARK(BM_RawGetTid);
+
+void BM_GetCurrentThreadName(benchmark::State& state)
+{
+    // TLS-cached thread name (also read by TOriginAttributes::Capture).
+    for (auto _ : state) {
+        benchmark::DoNotOptimize(GetCurrentThreadName());
+    }
+}
+
+BENCHMARK(BM_GetCurrentThreadName);
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace
+} // namespace NYT
diff --git a/library/cpp/yt/system/benchmarks/tscp.cpp b/library/cpp/yt/system/benchmarks/tscp.cpp
new file mode 100644
index 00000000000..067584a3198
--- /dev/null
+++ b/library/cpp/yt/system/benchmarks/tscp.cpp
@@ -0,0 +1,31 @@
+#include <benchmark/benchmark.h>
+
+#include <library/cpp/yt/system/tscp.h>
+
+namespace NYT::NProfiling {
+namespace {
+
+////////////////////////////////////////////////////////////////////////////////
+
+// Timestamp counter and processor id via a single serializing rdtscp.
+void BM_TscpGet(benchmark::State& state)
+{
+    for (auto _ : state) {
+        benchmark::DoNotOptimize(TTscp::Get());
+    }
+}
+BENCHMARK(BM_TscpGet);
+
+// Cheaper, lower-precision counterpart: rseq fast path + non-serializing rdtsc.
+void BM_TscpGetApproximate(benchmark::State& state)
+{
+    for (auto _ : state) {
+        benchmark::DoNotOptimize(TTscp::GetApproximate());
+    }
+}
+BENCHMARK(BM_TscpGetApproximate);
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace
+} // namespace NYT::NProfiling
diff --git a/library/cpp/yt/system/cpu_id-inl.h b/library/cpp/yt/system/cpu_id-inl.h
new file mode 100644
index 00000000000..804995f5973
--- /dev/null
+++ b/library/cpp/yt/system/cpu_id-inl.h
@@ -0,0 +1,41 @@
+#ifndef CPU_ID_INL_H_
+#error "Direct inclusion of this file is not allowed, include cpu_id.h"
+// For the sake of sane code completion.
+#include "cpu_id.h"
+#endif
+
+#ifdef __linux__
+#include <library/cpp/yt/rseq/rseq.h>
+#endif
+
+#include <util/system/compiler.h>
+
+namespace NYT {
+
+////////////////////////////////////////////////////////////////////////////////
+
+namespace NDetail {
+
+int GetCurrentCpuIdSlow();
+
+} // namespace NDetail
+
+Y_FORCE_INLINE int GetCurrentCpuId()
+{
+#ifdef YT_RSEQ_AVAILABLE
+    // Branch-free read of the rseq cpu_id: the offset always points at a readable
+    // field. A data-dependent branch on the offset here would defeat load pipelining.
+    auto cpuId = NRseq::ReadField<int>(NRseq::CpuIdFieldOffset);
+    // Negative means this thread is not registered yet or rseq is unavailable.
+    if (cpuId < 0) [[unlikely]] {
+        return NDetail::GetCurrentCpuIdSlow();
+    }
+    return cpuId;
+#else
+    return NDetail::GetCurrentCpuIdSlow();
+#endif
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace NYT
diff --git a/library/cpp/yt/system/cpu_id.cpp b/library/cpp/yt/system/cpu_id.cpp
new file mode 100644
index 00000000000..9f6e46c9fc9
--- /dev/null
+++ b/library/cpp/yt/system/cpu_id.cpp
@@ -0,0 +1,44 @@
+#include "cpu_id.h"
+
+#include <library/cpp/yt/misc/tls.h>
+
+#ifdef __linux__
+#include <library/cpp/yt/rseq/rseq.h>
+
+#include <sched.h>
+#endif
+
+namespace NYT::NDetail {
+
+////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __linux__
+
+YT_PREVENT_TLS_CACHING int GetCurrentCpuIdSlow()
+{
+#ifdef YT_RSEQ_AVAILABLE
+    if (NRseq::EnsureCurrentThreadRegistered()) {
+        auto cpuId = NRseq::ReadField<int>(NRseq::CpuIdFieldOffset);
+        if (cpuId >= 0) {
+            return cpuId;
+        }
+    }
+#endif
+    // No rseq fast path (unsupported arch, or thread not registered): sched_getcpu.
+    auto cpuId = ::sched_getcpu();
+    return cpuId >= 0 ? cpuId : 0;
+}
+
+#else
+
+// No sched_getcpu (darwin / windows): sharding degenerates to one shard.
+int GetCurrentCpuIdSlow()
+{
+    return 0;
+}
+
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace NYT::NDetail
diff --git a/library/cpp/yt/system/cpu_id.h b/library/cpp/yt/system/cpu_id.h
new file mode 100644
index 00000000000..751183479b8
--- /dev/null
+++ b/library/cpp/yt/system/cpu_id.h
@@ -0,0 +1,31 @@
+#pragma once
+
+namespace NYT {
+
+////////////////////////////////////////////////////////////////////////////////
+
+/*!
+ * Index of the CPU the calling thread currently runs on, in [0, NumberOfCpus).
+ * On Linux/x86-64 and Linux/arm64 the fast path is a single thread-local read of
+ * the kernel's rseq area; the first call per thread lazily registers rseq, and
+ * reads fall back to sched_getcpu() when rseq is unavailable. On other platforms
+ * it is sched_getcpu() (Linux) or 0.
+ * It is a hint (the thread may migrate right after) -- for sharding, not correctness.
+ *
+ * The rseq backend lives in library/cpp/yt/rseq, with no third-party dependency.
+ *
+ * Fiber-TLS: the fast path is inlined and reads the thread pointer, so it must be
+ * reached only through a non-inlinable, fiber-switch-free frame (a virtual call or
+ * YT_PREVENT_TLS_CACHING; see library/cpp/yt/misc/tls.h). Otherwise the thread base
+ * may be cached and reused after the fiber resumes on another OS thread, reading a
+ * different -- possibly already-freed -- thread's area.
+ */
+int GetCurrentCpuId();
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace NYT
+
+#define CPU_ID_INL_H_
+#include "cpu_id-inl.h"
+#undef CPU_ID_INL_H_
diff --git a/library/cpp/yt/system/env-inl.h b/library/cpp/yt/system/env-inl.h
new file mode 100644
index 00000000000..22fbab46922
--- /dev/null
+++ b/library/cpp/yt/system/env-inl.h
@@ -0,0 +1,32 @@
+#ifndef ENV_INL_H_
+#error "Direct inclusion of this file is not allowed, include env.h"
+// For the sake of sane code completion.
+#include "env.h"
+#endif
+
+#include <util/string/cast.h>
+
+namespace NYT {
+
+////////////////////////////////////////////////////////////////////////////////
+
+namespace NDetail {
+
+[[noreturn]] void ThrowFailedToParseEnvValueError(TStringBuf name, TStringBuf value);
+
+} // namespace NDetail
+
+template <class T>
+T GetEnvValueOrThrow(TStringBuf name)
+{
+    auto value = GetEnvValueOrThrow(name);
+    T result;
+    if (!TryFromString<T>(value, result)) {
+        NDetail::ThrowFailedToParseEnvValueError(name, value);
+    }
+    return result;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace NYT
diff --git a/library/cpp/yt/system/env.cpp b/library/cpp/yt/system/env.cpp
new file mode 100644
index 00000000000..78a8b5887e3
--- /dev/null
+++ b/library/cpp/yt/system/env.cpp
@@ -0,0 +1,76 @@
+#include "env.h"
+
+#include <library/cpp/yt/exception/exception.h>
+
+#include <util/string/printf.h>
+
+#include <util/system/platform.h>
+#include <util/system/env.h>
+
+#include <util/generic/maybe.h>
+
+#ifdef _darwin_
+    #include <crt_externs.h>
+    #define environ (*_NSGetEnviron())
+#endif
+
+#ifdef _linux_
+    #include <unistd.h>
+#endif
+
+namespace NYT {
+
+////////////////////////////////////////////////////////////////////////////////
+
+#if defined(_linux_) || defined(_darwin_)
+
+std::vector<std::string> GetEnvironNameValuePairs()
+{
+    std::vector<std::string> result;
+    for (char** envIt = environ; *envIt; ++envIt) {
+        result.emplace_back(*envIt);
+    }
+    return result;
+}
+
+#endif
+
+std::pair<TStringBuf, std::optional<TStringBuf>> ParseEnvironNameValuePair(TStringBuf pair)
+{
+    if (auto pos = pair.find('='); pos != std::string::npos) {
+        return {pair.substr(0, pos), pair.substr(pos + 1)};
+    } else {
+        return {pair, std::nullopt};
+    }
+}
+
+std::optional<std::string> TryGetEnvValue(TStringBuf name)
+{
+    auto result = TryGetEnv(TString(name));
+    return result ? std::optional<std::string>(*result) : std::nullopt;
+}
+
+std::string GetEnvValueOrThrow(TStringBuf name)
+{
+    auto value = TryGetEnvValue(name);
+    if (!value) {
+        throw TSimpleException(Sprintf("Environment variable \"%s\" is not set", name.data()));
+    }
+    return *value;
+}
+
+namespace NDetail {
+
+void ThrowFailedToParseEnvValueError(TStringBuf name, TStringBuf value)
+{
+    throw TSimpleException(Sprintf(
+        "Failed to parse value \"%s\" of environment variable \"%s\"",
+        TString(value).c_str(),
+        TString(name).c_str()));
+}
+
+} // namespace NDetail
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace NYT
diff --git a/library/cpp/yt/system/env.h b/library/cpp/yt/system/env.h
new file mode 100644
index 00000000000..ed27ceeff89
--- /dev/null
+++ b/library/cpp/yt/system/env.h
@@ -0,0 +1,34 @@
+#pragma once
+
+#include <util/generic/strbuf.h>
+
+#include <optional>
+#include <string>
+#include <vector>
+
+namespace NYT {
+
+////////////////////////////////////////////////////////////////////////////////
+
+// NB: Currently not supported on other platforms.
+#if defined(_linux_) || defined(_darwin_)
+std::vector<std::string> GetEnvironNameValuePairs();
+#endif
+
+std::pair<TStringBuf, std::optional<TStringBuf>> ParseEnvironNameValuePair(TStringBuf pair);
+
+std::optional<std::string> TryGetEnvValue(TStringBuf name);
+std::string GetEnvValueOrThrow(TStringBuf name);
+
+//! Returns the value of the environment variable #name parsed as #T (via |FromString|).
+//! Throws if the variable is not set or its value cannot be parsed.
+template <class T>
+T GetEnvValueOrThrow(TStringBuf name);
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace NYT
+
+#define ENV_INL_H_
+#include "env-inl.h"
+#undef ENV_INL_H_
diff --git a/library/cpp/yt/system/exit-inl.h b/library/cpp/yt/system/exit-inl.h
new file mode 100644
index 00000000000..e4fe8ea5940
--- /dev/null
+++ b/library/cpp/yt/system/exit-inl.h
@@ -0,0 +1,32 @@
+#ifndef EXIT_INL_H_
+#error "Direct inclusion of this file is not allowed, include exit.h"
+// For the sake of sane code completion.
+#include "exit.h"
+#endif
+
+namespace NYT {
+
+////////////////////////////////////////////////////////////////////////////////
+
+template <class E>
+    requires std::is_enum_v<E>
+[[noreturn]] void AbortProcessSilently(E exitCode)
+{
+    AbortProcessSilently(ToUnderlying(exitCode));
+}
+
+template <class E>
+    requires std::is_enum_v<E>
+[[noreturn]] void AbortProcessDramatically(
+    E exitCode,
+    TStringBuf message)
+{
+    AbortProcessDramatically(
+        ToUnderlying(exitCode),
+        TEnumTraits<E>::FindLiteralByValue(exitCode).value_or("<unknown>"),
+        message);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace NYT
diff --git a/library/cpp/yt/system/exit.cpp b/library/cpp/yt/system/exit.cpp
new file mode 100644
index 00000000000..e4088fe4da2
--- /dev/null
+++ b/library/cpp/yt/system/exit.cpp
@@ -0,0 +1,28 @@
+#include "exit.h"
+
+namespace NYT {
+
+////////////////////////////////////////////////////////////////////////////////
+
+void AbortProcessSilently(int exitCode)
+{
+    _exit(exitCode);
+}
+
+void AbortProcessDramatically(int exitCode, TStringBuf exitCodeStr, TStringBuf message)
+{
+    fprintf(stderr, "\n");
+    if (message) {
+        fprintf(stderr, "*** %s\n", message.data());
+    }
+    fprintf(stderr, "*** Aborting process with exit code %d", exitCode);
+    if (exitCodeStr) {
+        fprintf(stderr, " (%s)", exitCodeStr.data());
+    }
+    fprintf(stderr, "\n");
+    _exit(exitCode);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace NYT
diff --git a/library/cpp/yt/system/exit.h b/library/cpp/yt/system/exit.h
new file mode 100644
index 00000000000..15261d63342
--- /dev/null
+++ b/library/cpp/yt/system/exit.h
@@ -0,0 +1,49 @@
+#pragma once
+
+#include <library/cpp/yt/misc/enum.h>
+
+#include <type_traits>
+
+namespace NYT {
+
+////////////////////////////////////////////////////////////////////////////////
+
+DEFINE_ENUM(EProcessExitCode,
+    ((OK)                  (0))
+    ((ArgumentsError)      (1))
+    ((GenericError)        (2))
+    ((IOError)             (3))
+    ((InternalError)       (4))
+    ((OutOfMemory)         (9))
+);
+
+//! Invokes _exit to abort the process immediately without calling any cleanup code
+//! and without printing any details to stderr.
+[[noreturn]] void AbortProcessSilently(int exitCode);
+
+//! A typed version of #AbortProcessSilently.
+template <class E>
+    requires std::is_enum_v<E>
+[[noreturn]] void AbortProcessSilently(E exitCode);
+
+//! Invokes _exit to abort the process immediately
+//! without calling any cleanup code but printing error message to stderr.
+[[noreturn]] void AbortProcessDramatically(
+    int exitCode,
+    TStringBuf exitCodeStr,
+    TStringBuf message);
+
+//! A typed version of #AbortProcessDramatically.
+template <class E>
+    requires std::is_enum_v<E>
+[[noreturn]] void AbortProcessDramatically(
+    E exitCode,
+    TStringBuf message);
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace NYT
+
+#define EXIT_INL_H_
+#include "exit-inl.h"
+#undef EXIT_INL_H_
diff --git a/library/cpp/yt/system/handle_eintr-inl.h b/library/cpp/yt/system/handle_eintr-inl.h
new file mode 100644
index 00000000000..d98c160c6e2
--- /dev/null
+++ b/library/cpp/yt/system/handle_eintr-inl.h
@@ -0,0 +1,34 @@
+#ifndef HANDLE_EINTR_INL_H_
+#error "Direct inclusion of this file is not allowed, include handle_eintr.h"
+// For the sake of sane code completion.
+#include "handle_eintr.h"
+#endif
+
+#include <errno.h>
+
+namespace NYT {
+
+////////////////////////////////////////////////////////////////////////////////
+
+#ifndef _win_
+template <class F,  class... Args>
+auto HandleEintr(F f, Args&&... args) -> decltype(f(args...))
+{
+    while (true) {
+        auto x = f(args...);
+        if (x != -1 || errno != EINTR) {
+            return x;
+        }
+    }
+}
+#else
+template <class F,  class... Args>
+auto HandleEintr(F f, Args&&... args) -> decltype(f(args...))
+{
+     return f(args...);
+}
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace NYT
diff --git a/library/cpp/yt/system/handle_eintr.h b/library/cpp/yt/system/handle_eintr.h
new file mode 100644
index 00000000000..4821c21a26a
--- /dev/null
+++ b/library/cpp/yt/system/handle_eintr.h
@@ -0,0 +1,16 @@
+#pragma once
+
+namespace NYT {
+
+////////////////////////////////////////////////////////////////////////////////
+
+template <class F,  class... Args>
+auto HandleEintr(F f, Args&&... args) -> decltype(f(args...));
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace NYT
+
+#define HANDLE_EINTR_INL_H_
+#include "handle_eintr-inl.h"
+#undef HANDLE_EINTR_INL_H_
diff --git a/library/cpp/yt/system/proc.h b/library/cpp/yt/system/proc.h
new file mode 100644
index 00000000000..b1b65608e3f
--- /dev/null
+++ b/library/cpp/yt/system/proc.h
@@ -0,0 +1,32 @@
+#pragma once
+
+#include <library/cpp/yt/misc/enum.h>
+
+#include <errno.h>
+
+namespace NYT {
+
+////////////////////////////////////////////////////////////////////////////////
+
+//! NYT::TError::FromSystem adds this value to a system errno. The enum
+//! below lists several errno's that are used in our code.
+constexpr int LinuxErrorCodeBase = 4200;
+constexpr int LinuxErrorCodeCount = 2000;
+
+DEFINE_ENUM(ELinuxErrorCode,
+    ((NOENT)              ((LinuxErrorCodeBase + ENOENT)))
+    ((IO)                 ((LinuxErrorCodeBase + EIO)))
+    ((ACCESS)             ((LinuxErrorCodeBase + EACCES)))
+    ((NFILE)              ((LinuxErrorCodeBase + ENFILE)))
+    ((MFILE)              ((LinuxErrorCodeBase + EMFILE)))
+    ((NOSPC)              ((LinuxErrorCodeBase + ENOSPC)))
+    ((PIPE)               ((LinuxErrorCodeBase + EPIPE)))
+    ((CONNRESET)          ((LinuxErrorCodeBase + ECONNRESET)))
+    ((TIMEDOUT)           ((LinuxErrorCodeBase + ETIMEDOUT)))
+    ((CONNREFUSED)        ((LinuxErrorCodeBase + ECONNREFUSED)))
+    ((DQUOT)              ((LinuxErrorCodeBase + EDQUOT)))
+);
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace NYT
diff --git a/library/cpp/yt/system/process_id-inl.h b/library/cpp/yt/system/process_id-inl.h
new file mode 100644
index 00000000000..9f0ef98100e
--- /dev/null
+++ b/library/cpp/yt/system/process_id-inl.h
@@ -0,0 +1,35 @@
+#ifndef PROCESS_ID_INL_H_
+#error "Direct inclusion of this file is not allowed, include process_id.h"
+// For the sake of sane code completion.
+#include "process_id.h"
+#endif
+
+#include <atomic>
+
+#include <util/system/compiler.h>
+
+namespace NYT {
+
+////////////////////////////////////////////////////////////////////////////////
+
+namespace NDetail {
+
+TProcessId GetProcessIdImpl();
+
+} // namespace NDetail
+
+extern std::atomic<TProcessId> CachedProcessId;
+
+inline TProcessId GetProcessId()
+{
+    auto cachedProcessId = CachedProcessId.load(std::memory_order::relaxed);
+    if (cachedProcessId == InvalidProcessId) [[unlikely]] {
+        cachedProcessId = NDetail::GetProcessIdImpl();
+        CachedProcessId.store(cachedProcessId, std::memory_order::relaxed);
+    }
+    return cachedProcessId;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace NYT
diff --git a/library/cpp/yt/system/process_id.cpp b/library/cpp/yt/system/process_id.cpp
new file mode 100644
index 00000000000..0be6dfd2913
--- /dev/null
+++ b/library/cpp/yt/system/process_id.cpp
@@ -0,0 +1,37 @@
+#include "process_id.h"
+
+#ifdef _unix_
+#include <library/cpp/yt/misc/static_initializer.h>
+
+#include <pthread.h>
+#endif
+
+namespace NYT {
+
+////////////////////////////////////////////////////////////////////////////////
+
+std::atomic<TProcessId> CachedProcessId = InvalidProcessId;
+
+namespace NDetail {
+
+TProcessId GetProcessIdImpl()
+{
+    return ::GetPID();
+}
+
+} // namespace NDetail
+
+#ifdef _unix_
+// The pid is stable for the lifetime of a process, so we cache it to avoid the
+// |getpid| syscall on each call. After a |fork|, however, the child runs with a
+// fresh pid, so the cache must be invalidated there.
+YT_STATIC_INITIALIZER(
+    ::pthread_atfork(
+        /*prepare*/ nullptr,
+        /*parent*/  nullptr,
+        /*child*/   [] { CachedProcessId.store(InvalidProcessId, std::memory_order::relaxed); }));
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace NYT
diff --git a/library/cpp/yt/system/process_id.h b/library/cpp/yt/system/process_id.h
new file mode 100644
index 00000000000..4dcc89b13ab
--- /dev/null
+++ b/library/cpp/yt/system/process_id.h
@@ -0,0 +1,22 @@
+#pragma once
+
+#include <util/system/getpid.h>
+
+namespace NYT {
+
+////////////////////////////////////////////////////////////////////////////////
+
+constexpr TProcessId InvalidProcessId = TProcessId(-1);
+
+//! Returns the OS process id (|getpid|).
+//! The value is cached process-wide, so only the first call hits the kernel.
+//! The cache is reset in the child after |fork|.
+TProcessId GetProcessId();
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace NYT
+
+#define PROCESS_ID_INL_H_
+#include "process_id-inl.h"
+#undef PROCESS_ID_INL_H_
diff --git a/library/cpp/yt/system/thread_id-inl.h b/library/cpp/yt/system/thread_id-inl.h
new file mode 100644
index 00000000000..6139ff863c2
--- /dev/null
+++ b/library/cpp/yt/system/thread_id-inl.h
@@ -0,0 +1,50 @@
+#ifndef THREAD_ID_INL_H_
+#error "Direct inclusion of this file is not allowed, include thread_id.h"
+// For the sake of sane code completion.
+#include "thread_id.h"
+#endif
+
+#include <library/cpp/yt/misc/tls.h>
+
+#include <atomic>
+
+#include <util/system/compiler.h>
+
+namespace NYT {
+
+////////////////////////////////////////////////////////////////////////////////
+
+namespace NDetail {
+
+TSystemThreadId GetSystemThreadIdImpl();
+
+} // namespace NDetail
+
+YT_DECLARE_THREAD_LOCAL(TSystemThreadId, CachedSystemThreadId);
+
+inline TSystemThreadId GetSystemThreadId()
+{
+    auto& cachedSystemThreadId = CachedSystemThreadId();
+    if (Y_UNLIKELY(cachedSystemThreadId == InvalidSystemThreadId)) {
+        cachedSystemThreadId = NDetail::GetSystemThreadIdImpl();
+    }
+    return cachedSystemThreadId;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+YT_DECLARE_THREAD_LOCAL(TSequentialThreadId, CachedSequentialThreadId);
+extern std::atomic<TSequentialThreadId> SequentialThreadIdGenerator;
+
+inline TSequentialThreadId GetSequentialThreadId()
+{
+    auto& cachedSequentialThreadId = CachedSequentialThreadId();
+    if (Y_UNLIKELY(cachedSequentialThreadId == InvalidSequentialThreadId)) {
+        cachedSequentialThreadId = ++SequentialThreadIdGenerator;
+    }
+    return cachedSequentialThreadId;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace NYT
diff --git a/library/cpp/yt/system/thread_id.cpp b/library/cpp/yt/system/thread_id.cpp
new file mode 100644
index 00000000000..978c735df25
--- /dev/null
+++ b/library/cpp/yt/system/thread_id.cpp
@@ -0,0 +1,44 @@
+#include "thread_id.h"
+
+#include <util/system/thread.h>
+
+#ifdef _unix_
+#include <library/cpp/yt/misc/static_initializer.h>
+
+#include <pthread.h>
+#endif
+
+namespace NYT {
+
+////////////////////////////////////////////////////////////////////////////////
+
+YT_DEFINE_THREAD_LOCAL(TSystemThreadId, CachedSystemThreadId, InvalidSystemThreadId);
+
+YT_DEFINE_THREAD_LOCAL(TSequentialThreadId, CachedSequentialThreadId, InvalidSequentialThreadId);
+std::atomic<TSequentialThreadId> SequentialThreadIdGenerator = InvalidSequentialThreadId;
+
+namespace NDetail {
+
+TSystemThreadId GetSystemThreadIdImpl()
+{
+    static_assert(std::is_same_v<TSystemThreadId, ::TThread::TId>);
+    return ::TThread::CurrentThreadNumericId();
+}
+
+} // namespace NDetail
+
+#ifdef _unix_
+// The kernel tid is stable for the lifetime of a thread, so we cache it to
+// avoid the |gettid| syscall on each call. After a |fork|, however, the
+// surviving (calling) thread of the child gets a fresh kernel tid, so the
+// cache must be invalidated there.
+YT_STATIC_INITIALIZER(
+    ::pthread_atfork(
+        /*prepare*/ nullptr,
+        /*parent*/  nullptr,
+        /*child*/   [] { CachedSystemThreadId() = InvalidSystemThreadId; }));
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace NYT
diff --git a/library/cpp/yt/system/thread_id.h b/library/cpp/yt/system/thread_id.h
new file mode 100644
index 00000000000..75960d036e1
--- /dev/null
+++ b/library/cpp/yt/system/thread_id.h
@@ -0,0 +1,28 @@
+#pragma once
+
+#include <util/generic/ylimits.h>
+
+#include <util/system/types.h>
+
+namespace NYT {
+
+////////////////////////////////////////////////////////////////////////////////
+
+using TSystemThreadId = size_t;
+constexpr TSystemThreadId InvalidSystemThreadId = Max<TSystemThreadId>();
+//! Returns the OS thread id (e.g. |gettid| on Linux).
+//! The value is cached in TLS, so only the first call per thread hits the kernel.
+//! The cache is reset in the child after |fork|.
+TSystemThreadId GetSystemThreadId();
+
+using TSequentialThreadId = ui32;
+constexpr TSequentialThreadId InvalidSequentialThreadId = Max<TSequentialThreadId>();
+TSequentialThreadId GetSequentialThreadId();
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace NYT
+
+#define THREAD_ID_INL_H_
+#include "thread_id-inl.h"
+#undef THREAD_ID_INL_H_
diff --git a/library/cpp/yt/misc/thread_name.cpp b/library/cpp/yt/system/thread_name.cpp
similarity index 96%
rename from library/cpp/yt/misc/thread_name.cpp
rename to library/cpp/yt/system/thread_name.cpp
index bb1737b08ad..11e20abcf5c 100644
--- a/library/cpp/yt/misc/thread_name.cpp
+++ b/library/cpp/yt/system/thread_name.cpp
@@ -20,7 +20,7 @@ TStringBuf TThreadName::ToStringBuf() const
 
 ////////////////////////////////////////////////////////////////////////////////
 
-TThreadName::TThreadName(const TString& name)
+TThreadName::TThreadName(TStringBuf name)
 {
     Length = std::min<int>(TThreadName::BufferCapacity - 1, name.length());
     ::memcpy(Buffer.data(), name.data(), Length);
diff --git a/library/cpp/yt/misc/thread_name.h b/library/cpp/yt/system/thread_name.h
similarity index 93%
rename from library/cpp/yt/misc/thread_name.h
rename to library/cpp/yt/system/thread_name.h
index 233808f99f4..35153880831 100644
--- a/library/cpp/yt/misc/thread_name.h
+++ b/library/cpp/yt/system/thread_name.h
@@ -11,7 +11,7 @@ namespace NYT {
 struct TThreadName
 {
     TThreadName() = default;
-    TThreadName(const TString& name);
+    TThreadName(TStringBuf name);
 
     TStringBuf ToStringBuf() const;
 
diff --git a/library/cpp/yt/system/tscp-inl.h b/library/cpp/yt/system/tscp-inl.h
new file mode 100644
index 00000000000..9a068166b6c
--- /dev/null
+++ b/library/cpp/yt/system/tscp-inl.h
@@ -0,0 +1,71 @@
+#ifndef TSCP_INL_H_
+#error "Direct inclusion of this file is not allowed, include tscp.h"
+// For the sake of sane code completion.
+#include "tscp.h"
+#endif
+
+#include "cpu_id.h"
+
+#include <util/system/cpu_id.h>
+
+namespace NYT::NProfiling {
+
+////////////////////////////////////////////////////////////////////////////////
+
+namespace {
+
+////////////////////////////////////////////////////////////////////////////////
+
+#if defined(__x86_64__)
+
+const bool SupportsRdtscp = NX86::HaveRDTSCP();
+
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace
+
+inline TTscp TTscp::Get()
+{
+#if defined(__x86_64__)
+    ui64 t;
+    ui64 c;
+    if (SupportsRdtscp) {
+        ui64 rax, rcx, rdx;
+        asm volatile ( "rdtscp\n" : "=a" (rax), "=c" (rcx), "=d" (rdx) : : );
+        t = (rdx << 32) + rax;
+        c = rcx;
+    } else {
+        ui64 rax, rdx;
+        asm volatile ( "rdtsc\n" : "=a" (rax), "=d" (rdx) : : );
+        t = (rdx << 32) + rax;
+
+        // cpuId[1] >> 24 is an APIC id.
+        ui32 cpuId[4];
+        NX86::CpuId(1, 0, cpuId);
+        c = cpuId[1] >> 24;
+    }
+#elif defined(__arm64__) || defined(__aarch64__)
+    ui64 c;
+    __asm__ volatile("mrs %x0, tpidrro_el0" : "=r"(c));
+    c = c & 0x07u;
+    TCpuInstant t = GetCpuInstant();
+#endif
+    return TTscp{
+        .Instant = static_cast<TCpuInstant>(t),
+        .ProcessorId = static_cast<int>(c) & (MaxProcessorId - 1)
+    };
+}
+
+inline TTscp TTscp::GetApproximate()
+{
+    return TTscp{
+        .Instant = GetApproximateCpuInstant(),
+        .ProcessorId = NYT::GetCurrentCpuId() & (MaxProcessorId - 1),
+    };
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace NYT::NProfiling
diff --git a/library/cpp/yt/system/tscp.h b/library/cpp/yt/system/tscp.h
new file mode 100644
index 00000000000..f90d60d73b3
--- /dev/null
+++ b/library/cpp/yt/system/tscp.h
@@ -0,0 +1,45 @@
+#pragma once
+
+#include <library/cpp/yt/cpu_clock/clock.h>
+
+#include <util/generic/bitops.h>
+
+namespace NYT::NProfiling {
+
+////////////////////////////////////////////////////////////////////////////////
+
+//! Timestamp counter + processor id.
+struct TTscp
+{
+    //! Defines the range for TTscp::ProcessorId.
+    //! Always a power of 2.
+    static constexpr int MaxProcessorId = 64;
+    static_assert(IsPowerOf2(MaxProcessorId), "MaxProcessorId must be a power of 2.");
+
+    //! The moment this TTscp instance was created.
+    TCpuInstant Instant;
+
+    //! "Processor id", always taken modulo #MaxProcessorId.
+    //! There's no guarantee that same value indicates the same phisycal core.
+    int ProcessorId;
+
+    //! Returns the current timestamp counter and processor id, both obtained from a single serializing rdtscp.
+    static TTscp Get();
+
+    //! A cheaper, lower-precision counterpart of #Get: the processor id comes from the
+    //! rseq fast path (GetCurrentCpuId) and the instant from a non-serializing rdtsc
+    //! (GetApproximateCpuInstant), instead of a single serializing rdtscp.
+    //!
+    //! WARNING (fiber TLS): inlined and reads the thread pointer (via GetCurrentCpuId),
+    //! so it must be reached only through a non-inlinable, fiber-switch-free frame (a
+    //! virtual call or YT_PREVENT_TLS_CACHING; see library/cpp/yt/misc/tls.h).
+    static TTscp GetApproximate();
+};
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace NYT::NProfiling
+
+#define TSCP_INL_H_
+#include "tscp-inl.h"
+#undef TSCP_INL_H_
diff --git a/library/cpp/yt/system/unittests/cpu_id_ut.cpp b/library/cpp/yt/system/unittests/cpu_id_ut.cpp
new file mode 100644
index 00000000000..cfdd999b111
--- /dev/null
+++ b/library/cpp/yt/system/unittests/cpu_id_ut.cpp
@@ -0,0 +1,62 @@
+#include <library/cpp/testing/gtest/gtest.h>
+
+#include <library/cpp/yt/system/cpu_id.h>
+
+#include <sched.h>
+
+#include <vector>
+
+namespace NYT {
+namespace {
+
+////////////////////////////////////////////////////////////////////////////////
+
+std::vector<int> GetAllowedCpus()
+{
+    cpu_set_t set;
+    CPU_ZERO(&set);
+    if (sched_getaffinity(0, sizeof(set), &set) != 0) {
+        return {};
+    }
+    std::vector<int> cpus;
+    for (int cpu = 0; cpu < CPU_SETSIZE; ++cpu) {
+        if (CPU_ISSET(cpu, &set)) {
+            cpus.push_back(cpu);
+        }
+    }
+    return cpus;
+}
+
+bool TryPinToCpu(int cpu)
+{
+    cpu_set_t set;
+    CPU_ZERO(&set);
+    CPU_SET(cpu, &set);
+    // Pinning the current thread to a single allowed CPU: the kernel migrates us
+    // onto it before sched_setaffinity returns, and keeps us there (it is the only
+    // permitted CPU), so there is no migration race afterwards.
+    return sched_setaffinity(0, sizeof(set), &set) == 0;
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+// When pinned to a CPU, GetCurrentCpuId must report exactly that CPU -- this checks
+// the actual contract (the real running CPU), not just a range, and is independent
+// of how many CPUs are online or how they are numbered.
+TEST(TGetCurrentCpuIdTest, MatchesPinnedCpu)
+{
+    auto allowedCpus = GetAllowedCpus();
+    if (allowedCpus.empty() || !TryPinToCpu(allowedCpus.front())) {
+        GTEST_SKIP() << "Cannot control CPU affinity in this environment";
+    }
+
+    for (int cpu : allowedCpus) {
+        ASSERT_TRUE(TryPinToCpu(cpu));
+        EXPECT_EQ(GetCurrentCpuId(), cpu);
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace
+} // namespace NYT
diff --git a/library/cpp/yt/system/unittests/env_ut.cpp b/library/cpp/yt/system/unittests/env_ut.cpp
new file mode 100644
index 00000000000..55cfa86c835
--- /dev/null
+++ b/library/cpp/yt/system/unittests/env_ut.cpp
@@ -0,0 +1,81 @@
+#include <library/cpp/testing/gtest/gtest.h>
+
+#include <library/cpp/yt/system/env.h>
+
+#include <library/cpp/yt/misc/guid.h>
+
+#include <library/cpp/yt/string/format.h>
+
+#include <util/generic/scope.h>
+
+#include <util/system/env.h>
+
+namespace NYT {
+namespace {
+
+////////////////////////////////////////////////////////////////////////////////
+
+TEST(TParseEnvironNameValuePairTest, NonNull)
+{
+    auto pair = ParseEnvironNameValuePair("var=value");
+    EXPECT_EQ(pair.first, "var");
+    EXPECT_EQ(pair.second, "value");
+}
+
+TEST(TParseEnvironNameValuePairTest, Null)
+{
+    auto pair = ParseEnvironNameValuePair("some");
+    EXPECT_EQ(pair.first, "some");
+    EXPECT_EQ(pair.second, std::nullopt);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+#if defined(_linux_) || defined(_darwin_)
+
+TEST(TGetEnvironNameValuePairsTest, Simple)
+{
+    auto key = Format("var%v", TGuid::Create());
+    auto value = TString("value");
+    auto pair = Format("%v=%v", key, value);
+    SetEnv(key, value);
+    auto pairs = GetEnvironNameValuePairs();
+    EXPECT_TRUE(std::ranges::find(pairs, pair) != pairs.end());
+    UnsetEnv(key);
+}
+
+TEST(TGetEnvValueOrThrowTest, Typed)
+{
+    auto key = Format("var%v", TGuid::Create());
+    SetEnv(key, "42");
+    Y_DEFER {
+        UnsetEnv(key);
+    };
+    EXPECT_EQ(GetEnvValueOrThrow<int>(key), 42);
+    EXPECT_EQ(GetEnvValueOrThrow(key), "42");
+}
+
+TEST(TGetEnvValueOrThrowTest, Missing)
+{
+    auto key = Format("var%v", TGuid::Create());
+    EXPECT_THROW(GetEnvValueOrThrow<int>(key), std::exception);
+}
+
+TEST(TGetEnvValueOrThrowTest, Unparseable)
+{
+    auto key = Format("var%v", TGuid::Create());
+    SetEnv(key, "not-a-number");
+    Y_DEFER {
+        UnsetEnv(key);
+    };
+    EXPECT_THROW(GetEnvValueOrThrow<int>(key), std::exception);
+}
+
+#endif
+
+////////////////////////////////////////////////////////////////////////////////
+
+} // namespace
+} // namespace NYT
+
+
diff --git a/library/cpp/yt/ya_cpp.make.inc b/library/cpp/yt/ya_cpp.make.inc
index cfd07909ebe..f062ffcf137 100644
--- a/library/cpp/yt/ya_cpp.make.inc
+++ b/library/cpp/yt/ya_cpp.make.inc
@@ -1,7 +1,20 @@
 # This file should be included in all YT projects (including YT ORM installations).
 
-IF (NOT MSVC)
+IF (CLANG)
     CXXFLAGS(
         -Wdeprecated-this-capture
+        -Wimplicit-fallthrough
+        -Wparentheses
+        -Wno-logical-op-parentheses
+        -Wno-bitwise-op-parentheses
+        -Wswitch
+        -Wreturn-type
     )
+
+    IF (MUSL)
+        CXXFLAGS(
+            --system-header-prefix=endian.h
+            --system-header-prefix=byteswap.h
+        )
+    ENDIF()
 ENDIF()
diff --git a/library/cpp/yt/yson_string/convert.cpp b/library/cpp/yt/yson_string/convert.cpp
index 6d78ea6c9db..51094255ae7 100644
--- a/library/cpp/yt/yson_string/convert.cpp
+++ b/library/cpp/yt/yson_string/convert.cpp
@@ -11,6 +11,8 @@
 
 #include <array>
 
+#include <util/string/escape.h>
+
 #include <util/stream/mem.h>
 
 namespace NYT::NYson {
@@ -67,6 +69,12 @@ TYsonString ConvertToYsonString<TString>(const TString& value)
     return ConvertToYsonString(static_cast<TStringBuf>(value));
 }
 
+template <>
+TYsonString ConvertToYsonString<std::string>(const std::string& value)
+{
+    return ConvertToYsonString(static_cast<TStringBuf>(value));
+}
+
 struct TConvertStringToYsonStringTag
 { };
 
@@ -306,6 +314,17 @@ TString ConvertFromYsonString<TString>(const TYsonStringBuf& str)
     }
 }
 
+template <>
+std::string ConvertFromYsonString<std::string>(const TYsonStringBuf& str)
+{
+    try {
+        // TODO(sabdenovch): Avoid copying.
+        return ParseStringFromYsonString(str);
+    } catch (const std::exception& ex) {
+        throw TYsonLiteralParseException(ex, "Error parsing \"string\" value from YSON");
+    }
+}
+
 template <>
 float ConvertFromYsonString<float>(const TYsonStringBuf& str)
 {
diff --git a/library/cpp/yt/yson_string/convert.h b/library/cpp/yt/yson_string/convert.h
index 06de28d2f9d..02cbe15654c 100644
--- a/library/cpp/yt/yson_string/convert.h
+++ b/library/cpp/yt/yson_string/convert.h
@@ -13,6 +13,7 @@
 namespace NYT::NYson {
 
 ////////////////////////////////////////////////////////////////////////////////
+
 // Generic forward declarations.
 
 template <class T>
@@ -44,6 +45,8 @@ TYsonString ConvertToYsonString<ui64>(const ui64& value);
 template <>
 TYsonString ConvertToYsonString<TString>(const TString& value);
 template <>
+TYsonString ConvertToYsonString<std::string>(const std::string& value);
+template <>
 TYsonString ConvertToYsonString<TStringBuf>(const TStringBuf& value);
 TYsonString ConvertToYsonString(const char* value);
 
@@ -91,6 +94,8 @@ ui64 ConvertFromYsonString<ui64>(const TYsonStringBuf& str);
 
 template <>
 TString ConvertFromYsonString<TString>(const TYsonStringBuf& str);
+template <>
+std::string ConvertFromYsonString<std::string>(const TYsonStringBuf& str);
 
 template <>
 float ConvertFromYsonString<float>(const TYsonStringBuf& str);
diff --git a/library/cpp/yt/yson_string/string-inl.h b/library/cpp/yt/yson_string/string-inl.h
index 09db98881f0..bc8d3ed0c63 100644
--- a/library/cpp/yt/yson_string/string-inl.h
+++ b/library/cpp/yt/yson_string/string-inl.h
@@ -99,6 +99,22 @@ inline bool operator != (const TYsonStringBuf& lhs, const TYsonStringBuf& rhs)
 
 ////////////////////////////////////////////////////////////////////////////////
 
+//! Abseil hash support for TYsonString.
+template <class THash>
+THash AbslHashValue(THash hash, const TYsonString& str)
+{
+    return THash::combine(std::move(hash), str.AsStringBuf());
+}
+
+//! Abseil hash support for TYsonStringBuf.
+template <class THash>
+THash AbslHashValue(THash hash, const TYsonStringBuf& str)
+{
+    return THash::combine(std::move(hash), str.AsStringBuf());
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
 } // namespace NYT::NYson
 
 //! A hasher for TYsonString
diff --git a/library/cpp/yt/yson_string/string.cpp b/library/cpp/yt/yson_string/string.cpp
index ed2990a51b0..7c7713b0d9a 100644
--- a/library/cpp/yt/yson_string/string.cpp
+++ b/library/cpp/yt/yson_string/string.cpp
@@ -61,13 +61,6 @@ EYsonType TYsonStringBuf::GetType() const
 
 ////////////////////////////////////////////////////////////////////////////////
 
-TYsonString::TYsonString()
-{
-    Begin_ = nullptr;
-    Size_ = 0;
-    Type_ = EYsonType::Node; // fake
-}
-
 TYsonString::TYsonString(const TYsonStringBuf& ysonStringBuf)
 {
     if (ysonStringBuf) {
@@ -75,7 +68,7 @@ TYsonString::TYsonString(const TYsonStringBuf& ysonStringBuf)
         auto holder = NDetail::TYsonStringHolder::Allocate(data.length());
         ::memcpy(holder->GetData(), data.data(), data.length());
         Begin_ = holder->GetData();
-        Size_ = data.Size();
+        Size_ = data.size();
         Type_ = ysonStringBuf.GetType();
         Payload_ = std::move(holder);
     } else {
@@ -91,35 +84,35 @@ TYsonString::TYsonString(
     : TYsonString(TYsonStringBuf(data, type))
 { }
 
-#ifdef TSTRING_IS_STD_STRING
 TYsonString::TYsonString(
     const TString& data,
     EYsonType type)
-    : TYsonString(TYsonStringBuf(data, type))
+    : TYsonString(TCowString(data), type)
 { }
-#else
+
 TYsonString::TYsonString(
-    const TString& data,
+    TCowString data,
     EYsonType type)
-{
-    // NOTE: CoW TString implementation is assumed
-    // Moving the payload MUST NOT invalidate its internal pointers
-    Payload_ = data;
-    Begin_ = data.data();
-    Size_ = data.length();
-    Type_ = type;
-}
-#endif
+    : Payload_(std::move(data))
+    , Begin_(std::get<TCowString>(Payload_).data())
+    , Size_(std::get<TCowString>(Payload_).length())
+    , Type_(type)
+{ }
+
+TYsonString::TYsonString(
+    std::string data,
+    EYsonType type)
+    : TYsonString(TCowString(std::move(data)), type)
+{ }
 
 TYsonString::TYsonString(
     const TSharedRef& data,
     EYsonType type)
-{
-    Payload_ = data.GetHolder();
-    Begin_ = data.Begin();
-    Size_ = data.Size();
-    Type_ = type;
-}
+    : Payload_(data.GetHolder())
+    , Begin_(data.Begin())
+    , Size_(data.Size())
+    , Type_(type)
+{ }
 
 TYsonString::operator bool() const
 {
@@ -148,8 +141,8 @@ TString TYsonString::ToString() const
         [&] (const TSharedRangeHolderPtr&) {
             return TString(AsStringBuf());
         },
-        [] (const TString& payload) {
-            return payload;
+        [] (const TCowString& payload) {
+            return TString(payload);
         });
 }
 
@@ -163,8 +156,8 @@ TSharedRef TYsonString::ToSharedRef() const
         [&] (const TSharedRangeHolderPtr& holder) {
             return TSharedRef(Begin_, Size_, holder);
         },
-        [] (const TString& payload) {
-            return TSharedRef::FromString(payload);
+        [&] (const TCowString& payload) {
+            return TSharedRef(Begin_, Size_, MakeSharedRangeHolder(payload));
         });
 }
 
diff --git a/library/cpp/yt/yson_string/string.h b/library/cpp/yt/yson_string/string.h
index e310405ebcb..c93240ebade 100644
--- a/library/cpp/yt/yson_string/string.h
+++ b/library/cpp/yt/yson_string/string.h
@@ -6,6 +6,8 @@
 
 #include <library/cpp/yt/string/format.h>
 
+#include <library/cpp/containers/cow_string/cow_string.h>
+
 #include <variant>
 
 namespace NYT::NYson {
@@ -21,11 +23,11 @@ class TYsonStringBuf
     TYsonStringBuf();
 
     //! Constructs an instance from TYsonString.
-    TYsonStringBuf(const TYsonString& ysonString);
+    TYsonStringBuf(const TYsonString& ysonString Y_LIFETIME_BOUND);
 
     //! Constructs a non-null instance with given type and content.
     explicit TYsonStringBuf(
-        const TString& data,
+        const TString& data Y_LIFETIME_BOUND,
         EYsonType type = EYsonType::Node);
 
     //! Constructs a non-null instance with given type and content.
@@ -37,7 +39,7 @@ class TYsonStringBuf
     //! (without this overload there is no way to construct TYsonStringBuf from
     //! string literal).
     explicit TYsonStringBuf(
-        const char* data,
+        const char* data Y_LIFETIME_BOUND,
         EYsonType type = EYsonType::Node);
 
     //! Returns |true| if the instance is not null.
@@ -59,13 +61,13 @@ class TYsonStringBuf
 
 //! An owning version of TYsonStringBuf.
 /*!
- *  Internally captures the data either via TString or a polymorphic ref-counted holder.
+ *  Internally captures the data either via TCowString or a polymorphic ref-counted holder.
  */
 class TYsonString
 {
 public:
     //! Constructs a null instance.
-    TYsonString();
+    TYsonString() = default;
 
     //! Constructs an instance from TYsonStringBuf.
     //! Copies the data into a ref-counted payload.
@@ -83,6 +85,18 @@ class TYsonString
         const TString& data,
         EYsonType type = EYsonType::Node);
 
+    //! Constructs an instance from TCowString.
+    //! Zero-copy: retains the reference to TCowString in payload.
+    explicit TYsonString(
+        TCowString data,
+        EYsonType type = EYsonType::Node);
+
+    //! Constructs an instance from std::string.
+    //! Moves #data into a ref-counted payload.
+    explicit TYsonString(
+        std::string data,
+        EYsonType type = EYsonType::Node);
+
     //! Constructs an instance from TSharedRef.
     //! Zero-copy; retains the reference to TSharedRef holder in payload.
     explicit TYsonString(
@@ -117,11 +131,11 @@ class TYsonString
     struct TNullPayload
     { };
 
-    std::variant<TNullPayload, TSharedRangeHolderPtr, TString> Payload_;
+    std::variant<TNullPayload, TSharedRangeHolderPtr, TCowString> Payload_;
 
-    const char* Begin_;
-    ui64 Size_ : 56;
-    EYsonType Type_ : 8;
+    const char* Begin_ = nullptr;
+    ui64 Size_ : 56 = 0;
+    EYsonType Type_ : 8 = EYsonType::Node;
 };
 
 ////////////////////////////////////////////////////////////////////////////////
diff --git a/library/cpp/yt/yson_string/unittests/saveload_ut.cpp b/library/cpp/yt/yson_string/unittests/saveload_ut.cpp
index 33a98a30ea4..bcb1bfa196b 100644
--- a/library/cpp/yt/yson_string/unittests/saveload_ut.cpp
+++ b/library/cpp/yt/yson_string/unittests/saveload_ut.cpp
@@ -31,7 +31,7 @@ TEST(TYsonStringTest, SaveLoadString)
 
 TEST(TYsonStringTest, SaveLoadSharedRef)
 {
-    TSharedRef ref = TSharedRef::FromString("My tests data");
+    auto ref = TSharedRef::FromString(std::string("My tests data"));
     const TYsonString expected(ref);
     TStringStream s;
     ::Save(&s, expected);
diff --git a/scripts/check_peerdirs.py b/scripts/check_peerdirs.py
new file mode 100644
index 00000000000..0ec91d0b4c6
--- /dev/null
+++ b/scripts/check_peerdirs.py
@@ -0,0 +1,85 @@
+#!/usr/bin/env python3
+import sys
+from pathlib import Path
+
+SDK = Path(__file__).resolve().parent.parent
+PREFIX = Path("ydb/public/sdk/cpp")
+ALLOWLIST = SDK / "allowed_peerdirs.txt"
+ALLOWED = [
+    line.split("#", 1)[0].strip()
+    for line in ALLOWLIST.read_text(encoding="utf-8").splitlines()
+    if line.split("#", 1)[0].strip()
+]
+IN_SCOPE = {"src", "include", "plugins", "examples"}
+
+
+def ok(rel):
+    parts = Path(rel).parts
+    return (
+        parts
+        and parts[0] in IN_SCOPE
+        and "ut" not in parts
+        and "ut_utils" not in parts
+    )
+
+
+def peerdirs(text):
+    in_block = False
+    for i, line in enumerate(text.splitlines(), 1):
+        s = line.split("#", 1)[0].strip()
+        if s.startswith("PEERDIR("):
+            if s.endswith(")"):
+                dep = s[len("PEERDIR("):-1].strip()
+                if dep:
+                    yield i, dep
+            else:
+                in_block = True
+            continue
+        if in_block:
+            if s == ")":
+                in_block = False
+            elif s:
+                yield i, s
+
+
+def targets(changed_path):
+    all_targets = [
+        p for p in sorted(SDK.rglob("ya.make")) if ok(p.relative_to(SDK))
+    ]
+    if not changed_path:
+        return all_targets
+    changed = [
+        Path(line.strip())
+        for line in Path(changed_path).read_text(encoding="utf-8").splitlines()
+        if line.strip()
+    ]
+    if PREFIX / "allowed_peerdirs.txt" in changed or PREFIX / "scripts/check_peerdirs.py" in changed:
+        return all_targets
+    out = []
+    for path in changed:
+        try:
+            rel = path.relative_to(PREFIX)
+        except ValueError:
+            continue
+        if path.name != "ya.make" or not ok(rel):
+            continue
+        out.append(SDK / rel)
+    return out
+
+
+def main():
+    files = targets(sys.argv[1] if len(sys.argv) > 1 else None)
+    bad = []
+    for ya_make in files:
+        for line_no, dep in peerdirs(ya_make.read_text(encoding="utf-8")):
+            if not any(dep.startswith(p) for p in ALLOWED):
+                rel = PREFIX / ya_make.relative_to(SDK)
+                bad.append(f"{rel}:{line_no}: forbidden PEERDIR {dep!r}")
+    if bad:
+        print("\n".join(bad), file=sys.stderr)
+        raise SystemExit(1)
+    print(f"ok ({len(files)} ya.make)")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/scripts/test_copy_sources_plugins.sh b/scripts/test_copy_sources_plugins.sh
index ddf4804800a..010e18de7cc 100755
--- a/scripts/test_copy_sources_plugins.sh
+++ b/scripts/test_copy_sources_plugins.sh
@@ -31,15 +31,36 @@ mkdir -p "$MONOREPO/ydb/public/api/client/yc_public/common"
 mkdir -p "$MONOREPO/ydb/public/api/client/yc_public/iam"
 mkdir -p "$MONOREPO/ydb/public/api/grpc"
 mkdir -p "$MONOREPO/ydb/public/api/protos/out"
+mkdir -p "$MONOREPO/util"
+mkdir -p "$MONOREPO/library/cpp/example"
+mkdir -p "$MONOREPO/contrib/libs/libc_compat"
+mkdir -p "$MONOREPO/tools/enum_parser"
 
 echo "MONOREPO_TRACE" > "$MONOREPO/ydb/public/sdk/cpp/plugins/trace/otel/trace.cpp"
 echo "MONOREPO_METRICS" > "$MONOREPO/ydb/public/sdk/cpp/plugins/metrics/otel/metrics.cpp"
 echo "# MONOREPO_PLUGINS_CMAKE" > "$MONOREPO/ydb/public/sdk/cpp/plugins/CMakeLists.txt"
 echo "// monorepo type_switcher" > "$MONOREPO/ydb/public/sdk/cpp/include/ydb-cpp-sdk/type_switcher.h"
+echo "// monorepo stlfwd" > "$MONOREPO/ydb/public/sdk/cpp/include/ydb-cpp-sdk/stlfwd.h"
 echo "// monorepo version" > "$MONOREPO/ydb/public/sdk/cpp/src/version.h"
 touch "$MONOREPO/ydb/public/api/client/yc_private/accessservice/sensitive.proto"
+printf 'upstream=old\nseparator=unchanged\nstandalone=old\n' > "$MONOREPO/util/merged.txt"
+printf 'upstream=old\nseparator=unchanged\nstandalone=old\n' > "$MONOREPO/util/renamed-old.txt"
+echo "remove upstream" > "$MONOREPO/util/deleted.txt"
+printf 'upstream=old\nseparator=unchanged\nstandalone=old\n' > "$MONOREPO/library/cpp/example/merged.txt"
+printf 'upstream=old\nseparator=unchanged\nstandalone=old\n' > "$MONOREPO/contrib/libs/libc_compat/merged.txt"
+printf 'upstream=old\nseparator=unchanged\nstandalone=old\n' > "$MONOREPO/tools/enum_parser/merged.txt"
+
+git -C "$MONOREPO" init -q
+git -C "$MONOREPO" config user.name "Import Test"
+git -C "$MONOREPO" config user.email "import-test@example.com"
+git -C "$MONOREPO" add .
+git -C "$MONOREPO" commit -q -m "base"
+BASE_COMMIT=$(git -C "$MONOREPO" rev-parse HEAD)
 
 mkdir -p "$OSS"/{util,library,contrib,cmake,third_party,tools,.devcontainer,.github,scripts,examples}
+mkdir -p "$OSS/library/cpp/example"
+mkdir -p "$OSS/contrib/libs/libc_compat"
+mkdir -p "$OSS/tools/enum_parser"
 mkdir -p "$OSS/.git"
 mkdir -p "$OSS/plugins/trace/otel"
 mkdir -p "$OSS/plugins/metrics/otel"
@@ -63,7 +84,29 @@ echo "OSS_SLO_WORKLOAD" > "$OSS/tests/slo_workloads/key_value/main.cpp"
 echo "OSS_DEB_PACKAGE" > "$OSS/tests/deb_package/Dockerfile"
 echo "OSS_DEB_PACKAGE" > "$OSS/tests/deb_package/test_project/main.cpp"
 echo "// oss type_switcher" > "$OSS/include/ydb-cpp-sdk/type_switcher.h"
+echo "// oss stlfwd" > "$OSS/include/ydb-cpp-sdk/stlfwd.h"
 echo "// oss version" > "$OSS/src/version.h"
+echo "$BASE_COMMIT" > "$OSS/.github/last_commit.txt"
+printf 'upstream=old\nseparator=unchanged\nstandalone=custom\n' > "$OSS/util/merged.txt"
+printf 'upstream=old\nseparator=unchanged\nstandalone=custom\n' > "$OSS/util/renamed-old.txt"
+echo "remove upstream" > "$OSS/util/deleted.txt"
+echo "standalone only" > "$OSS/util/local.txt"
+printf 'upstream=old\nseparator=unchanged\nstandalone=custom\n' > "$OSS/library/cpp/example/merged.txt"
+printf 'upstream=old\nseparator=unchanged\nstandalone=custom\n' > "$OSS/contrib/libs/libc_compat/merged.txt"
+printf 'upstream=old\nseparator=unchanged\nstandalone=custom\n' > "$OSS/tools/enum_parser/merged.txt"
+
+printf 'upstream=new\nseparator=unchanged\nstandalone=old\n' > "$MONOREPO/util/merged.txt"
+git -C "$MONOREPO" mv util/renamed-old.txt util/renamed-new.txt
+printf 'upstream=new\nseparator=unchanged\nstandalone=old\n' > "$MONOREPO/util/renamed-new.txt"
+echo "added upstream" > "$MONOREPO/util/added.txt"
+rm "$MONOREPO/util/deleted.txt"
+printf 'upstream=new\nseparator=unchanged\nstandalone=old\n' > "$MONOREPO/library/cpp/example/merged.txt"
+printf 'upstream=new\nseparator=unchanged\nstandalone=old\n' > "$MONOREPO/contrib/libs/libc_compat/merged.txt"
+printf 'upstream=new\nseparator=unchanged\nstandalone=old\n' > "$MONOREPO/tools/enum_parser/merged.txt"
+mkdir -p "$MONOREPO/library/cpp/not_vendored"
+echo "must stay unvendored" > "$MONOREPO/library/cpp/not_vendored/file.txt"
+git -C "$MONOREPO" add -A
+git -C "$MONOREPO" commit -q -m "update util"
 
 "$COPY_SOURCES" "$MONOREPO" "$OSS"
 
@@ -96,6 +139,31 @@ assert_contains "$OSS/plugins/metrics/otel/metrics.cpp" "MONOREPO_METRICS" "OSS_
 assert_contains "$OSS/tests/slo_workloads/key_value/main.cpp" "OSS_SLO_WORKLOAD" ""
 assert_contains "$OSS/tests/deb_package/Dockerfile" "OSS_DEB_PACKAGE" ""
 assert_contains "$OSS/tests/deb_package/test_project/main.cpp" "OSS_DEB_PACKAGE" ""
+assert_contains "$OSS/include/ydb-cpp-sdk/stlfwd.h" "oss stlfwd" "monorepo stlfwd"
+assert_contains "$OSS/util/merged.txt" "upstream=new" ""
+assert_contains "$OSS/util/merged.txt" "standalone=custom" ""
+assert_contains "$OSS/util/added.txt" "added upstream" ""
+assert_contains "$OSS/util/local.txt" "standalone only" ""
+assert_contains "$OSS/util/renamed-new.txt" "upstream=new" ""
+assert_contains "$OSS/util/renamed-new.txt" "standalone=custom" ""
+assert_contains "$OSS/library/cpp/example/merged.txt" "upstream=new" ""
+assert_contains "$OSS/library/cpp/example/merged.txt" "standalone=custom" ""
+assert_contains "$OSS/contrib/libs/libc_compat/merged.txt" "upstream=new" ""
+assert_contains "$OSS/contrib/libs/libc_compat/merged.txt" "standalone=custom" ""
+assert_contains "$OSS/tools/enum_parser/merged.txt" "upstream=new" ""
+assert_contains "$OSS/tools/enum_parser/merged.txt" "standalone=custom" ""
+if [ -e "$OSS/util/deleted.txt" ]; then
+    echo "FAIL: upstream-deleted util file was retained" >&2
+    failures=$((failures + 1))
+fi
+if [ -e "$OSS/util/renamed-old.txt" ]; then
+    echo "FAIL: old path of upstream-renamed util file was retained" >&2
+    failures=$((failures + 1))
+fi
+if [ -e "$OSS/library/cpp/not_vendored/file.txt" ]; then
+    echo "FAIL: unvendored library component was imported" >&2
+    failures=$((failures + 1))
+fi
 
 while IFS= read -r cmake_file; do
     assert_contains "$cmake_file" "OSS_CMAKE" "MONOREPO_PLUGINS_CMAKE"
diff --git a/src/api/grpc/draft/ydb_test_shard_v1.proto b/src/api/grpc/draft/ydb_test_shard_v1.proto
deleted file mode 100644
index 02d61d01af4..00000000000
--- a/src/api/grpc/draft/ydb_test_shard_v1.proto
+++ /dev/null
@@ -1,15 +0,0 @@
-syntax = "proto3";
-
-package Ydb.TestShard.V1;
-
-import "src/api/protos/draft/ydb_test_shard.proto";
-
-service TestShardService {
-    // Creates TestShard tablet(s)
-    rpc CreateTestShard(Ydb.TestShard.CreateTestShardRequest) 
-        returns (Ydb.TestShard.CreateTestShardResponse);
-
-    // Deletes TestShard tablet(s)
-    rpc DeleteTestShard(Ydb.TestShard.DeleteTestShardRequest)
-        returns (Ydb.TestShard.DeleteTestShardResponse);
-}
diff --git a/src/api/grpc/ydb_topic_deferred_publish_v1.proto b/src/api/grpc/draft/ydb_topic_deferred_publish_v1.proto
similarity index 94%
rename from src/api/grpc/ydb_topic_deferred_publish_v1.proto
rename to src/api/grpc/draft/ydb_topic_deferred_publish_v1.proto
index 45bc9805985..52e44db651c 100644
--- a/src/api/grpc/ydb_topic_deferred_publish_v1.proto
+++ b/src/api/grpc/draft/ydb_topic_deferred_publish_v1.proto
@@ -5,7 +5,7 @@ package Ydb.Topic.DeferredPublish.V1;
 
 option java_package = "com.yandex.ydb.topic.deferredpublish.v1";
 
-import "src/api/protos/ydb_topic_deferred_publish.proto";
+import "src/api/protos/draft/ydb_topic_deferred_publish.proto";
 
 service TopicDeferredPublishService {
     // Starts a deferred topic publication.
diff --git a/src/api/grpc/ydb_test_shard_v1.proto b/src/api/grpc/ydb_test_shard_v1.proto
new file mode 100644
index 00000000000..8cda7263dc0
--- /dev/null
+++ b/src/api/grpc/ydb_test_shard_v1.proto
@@ -0,0 +1,15 @@
+syntax = "proto3";
+
+package Ydb.TestShardSet.V1;
+
+import "src/api/protos/ydb_test_shard.proto";
+
+service TestShardSetService {
+    // Creates TestShardSet tablet(s)
+    rpc CreateTestShardSet(Ydb.TestShardSet.CreateTestShardSetRequest) 
+        returns (Ydb.TestShardSet.CreateTestShardSetResponse);
+
+    // Deletes TestShardSet tablet(s)
+    rpc DeleteTestShardSet(Ydb.TestShardSet.DeleteTestShardSetRequest)
+        returns (Ydb.TestShardSet.DeleteTestShardSetResponse);
+}
diff --git a/src/api/protos/draft/fq.proto b/src/api/protos/draft/fq.proto
index 1864a04d815..20f48783977 100644
--- a/src/api/protos/draft/fq.proto
+++ b/src/api/protos/draft/fq.proto
@@ -118,7 +118,7 @@ message QueryContent {
     string name = 2 [(Ydb.length).le = 1024];
     Acl acl = 3;
     Limits limits = 4;
-    string text = 5 [(Ydb.length).range = {min: 1, max: 102400}]; // The text of the query itself
+    string text = 5 [(Ydb.length).range = {min: 1, max: 1024000}]; // The text of the query itself
     bool automatic = 6; // Is used for queries that are created by automatic systems (robots, jdbc driver, ...)
     string description = 7 [(Ydb.length).le = 10240]; // Description of the query, there can be any text
     // Specified settings for query's executor
diff --git a/src/api/protos/draft/ydb_maintenance.proto b/src/api/protos/draft/ydb_maintenance.proto
index 3b629b77052..be2f73550f9 100644
--- a/src/api/protos/draft/ydb_maintenance.proto
+++ b/src/api/protos/draft/ydb_maintenance.proto
@@ -24,6 +24,28 @@ enum ItemState {
     ITEM_STATE_DOWN = 3;
 }
 
+// NodeRole is an additional cluster responsibility a node carries on top of its
+// type, hosting a fault-tolerance-sensitive subsystem that maintenance must respect.
+message NodeRole {
+    // Node hosts a state storage replica.
+    message StateStorage {
+    }
+
+    // Node hosts VDisks of a static blobstorage group.
+    message StaticGroup {
+    }
+
+    // Node is configured to host system tablets.
+    message SystemTablet {
+    }
+
+    oneof role {
+        StateStorage state_storage = 1;
+        StaticGroup static_group = 2;
+        SystemTablet system_tablet = 3;
+    }
+}
+
 message Node {
     message StorageNode {
     }
@@ -37,6 +59,10 @@ message Node {
     uint32 port = 3;
     Ydb.Discovery.NodeLocation location = 4;
     ItemState state = 5;
+    // Type is the node's base kind:
+    // - a static storage node;
+    // - or a dynamic (compute) node serving a tenant.
+    // Exactly one is set.
     oneof type {
         StorageNode storage = 6;
         DynamicNode dynamic = 7;
@@ -46,6 +72,9 @@ message Node {
     // version defines YDB version for current Node.
     // For example, 'ydb-stable-24-1'.
     string version = 9;
+    // roles lists extra cluster responsibilities the node carries beyond its type;
+    // empty when the node hosts none of them.
+    repeated NodeRole roles = 10;
 }
 
 message ListClusterNodesRequest {
diff --git a/src/api/protos/ydb_topic_deferred_publish.proto b/src/api/protos/draft/ydb_topic_deferred_publish.proto
similarity index 100%
rename from src/api/protos/ydb_topic_deferred_publish.proto
rename to src/api/protos/draft/ydb_topic_deferred_publish.proto
diff --git a/src/api/protos/ydb_cms.proto b/src/api/protos/ydb_cms.proto
index fe90f5b1def..f72bb967a9e 100644
--- a/src/api/protos/ydb_cms.proto
+++ b/src/api/protos/ydb_cms.proto
@@ -101,7 +101,7 @@ message DatabaseQuotas {
     // A minimum value of `TtlSettings.run_interval_seconds` that can be specified.
     // Default is 1800 (15 minutes).
     uint32 ttl_min_run_internal_seconds = 4;
-    
+
     message StorageQuotas {
         // in theory an arbitrary string, but in practice "hdd" or "ssd"
         string unit_kind = 1;
@@ -120,7 +120,7 @@ message ScaleRecommenderPolicies {
         message TargetTrackingPolicy {
             oneof target {
                 // A percentage of compute resources' average CPU utilization.
-                uint32 average_cpu_utilization_percent = 1 [(Ydb.value) = "[10; 90]"]; 
+                uint32 average_cpu_utilization_percent = 1 [(Ydb.value) = "[10; 90]"];
             }
         }
 
@@ -216,6 +216,8 @@ message GetDatabaseStatusResult {
     // Outstanding problems related to database resources
     // (e.g. storage pool allocation failures).
     repeated Ydb.Issue.IssueMessage issues = 12;
+    // Current database attributes
+    map<string, string> attributes = 13;
 }
 
 // Change resources allocated for database.
diff --git a/src/api/protos/ydb_export.proto b/src/api/protos/ydb_export.proto
index 95822a81daf..1514e3822b7 100644
--- a/src/api/protos/ydb_export.proto
+++ b/src/api/protos/ydb_export.proto
@@ -75,7 +75,7 @@ message YdbDumpFormat {
 }
 
 message ParquetFormat {
-    uint32 row_group_size = 1;
+    uint32 row_group_size = 1 [(value) = "[1; 10000000]"];
 }
 
 /// S3
diff --git a/src/api/protos/ydb_query.proto b/src/api/protos/ydb_query.proto
index ecce71efb12..6263cbfe612 100644
--- a/src/api/protos/ydb_query.proto
+++ b/src/api/protos/ydb_query.proto
@@ -142,6 +142,10 @@ message CommitTransactionRequest {
 message CommitTransactionResponse {
     StatusIds.StatusCode status = 1;
     repeated Ydb.Issue.IssueMessage issues = 2;
+
+    // Commit timestamp (PlanStep, TxId) for StrictSerializableRW write transactions.
+    // Present only on SUCCESS and when the transaction had write effects.
+    Ydb.VirtualTimestamp commit_timestamp = 3;
 }
 
 message RollbackTransactionRequest {
@@ -159,7 +163,7 @@ message RollbackTransactionResponse {
 enum Syntax {
     SYNTAX_UNSPECIFIED = 0;
     SYNTAX_YQL_V1 = 1; // YQL
-    SYNTAX_PG = 2; // PostgresQL
+    SYNTAX_PG = 2 [deprecated = true]; // Removed: PostgreSQL syntax is no longer supported
 }
 
 message QueryContent {
@@ -255,6 +259,10 @@ message ExecuteQueryResponsePart {
 
     TransactionMeta tx_meta = 6;
     VirtualTimestamp snapshot_timestamp = 7;
+
+    // Commit timestamp (PlanStep, TxId) for StrictSerializableRW write transactions.
+    // Present only in the final (trailing) part on SUCCESS and when the transaction had write effects.
+    VirtualTimestamp commit_timestamp = 8;
 }
 
 message ExecuteScriptRequest {
diff --git a/src/api/protos/ydb_table.proto b/src/api/protos/ydb_table.proto
index b7ced0a0bd5..5a40929e7ff 100644
--- a/src/api/protos/ydb_table.proto
+++ b/src/api/protos/ydb_table.proto
@@ -137,12 +137,11 @@ message FulltextIndexSettings {
         //   Tokens: ["foo-bar", "baz_lorem", "ipsum"]
         WHITESPACE = 1;
 
-        // Applies general language-aware tokenization
-        // Splits text on whitespace and punctuation
+        // Splits text into sequences of alphabetic and numeric characters
         // Example:
         //   Text: "foo-bar baz_lorem ipsum"
         //   Tokens: ["foo", "bar", "baz", "lorem", "ipsum"]
-        STANDARD = 2;
+        ALPHANUMERIC = 2;
 
         // Treats the entire input as a single token
         // No splitting is performed
@@ -150,6 +149,13 @@ message FulltextIndexSettings {
         //   Text: "Hello World!"
         //   Tokens: ["Hello World!"]
         KEYWORD = 3;
+
+        // Applies general language-aware tokenization
+        // According to a simplified Unicode UAX#29 standard
+        // Example:
+        //   Text: "The 24.18 Brown-Foxes jumped over the lazy dog's bone!"
+        //   Tokens: ["The", "24.18", "Brown", "Foxes", "jumped", "over", "the", "lazy", "dog's", "bone"]
+        STANDARD = 4;
     }
 
     // Represents text analyzers settings
@@ -434,6 +440,30 @@ message TableIndexDescription {
     uint64 size_bytes = 7;
 }
 
+// Represent multi-column table statistics
+message TableMultiColumnStatistics {
+    enum MultiColumnStatisticsType {
+        STATISTIC_TYPE_UNSPECIFIED = 0;
+        COUNT_MIN_SKETCH = 1;
+    }
+    // Name of statistics
+    string name = 1;
+    // List of columns the statistics is built on
+    repeated string columns = 2;
+    // Types of statistics to build
+    repeated MultiColumnStatisticsType types = 3;
+}
+
+// Represent multi-column table statistics description
+message TableMultiColumnStatisticsDescription {
+    // Name of statistics
+    string name = 1;
+    // List of columns the statistics is built on
+    repeated string columns = 2;
+    // Types of statistics to build
+    repeated TableMultiColumnStatistics.MultiColumnStatisticsType types = 3;
+}
+
 // State of index building operation
 message IndexBuildState {
     enum State {
@@ -449,8 +479,8 @@ message IndexBuildState {
     }
 }
 
-// State of set column constraint operation
-message SetColumnConstraintState {
+// State of set not null operation
+message SetNotNullState {
     enum State {
         STATE_UNSPECIFIED = 0;
         STATE_PREPARING = 1;
@@ -458,9 +488,21 @@ message SetColumnConstraintState {
         STATE_APPLYING = 3;
         STATE_DONE = 4;
         STATE_CANCELLED = 5;
+        STATE_REJECTED = 6;
     }
 }
 
+message SetNotNullItem {
+    optional string column_name = 1;
+}
+
+message SetNotNullMetadata {
+    string path = 1;
+    repeated string columns = 2;
+    SetNotNullState.State state = 3;
+    float progress = 4;
+}
+
 // Description of index building operation
 message IndexBuildDescription {
     string path = 1;
@@ -1054,6 +1096,8 @@ message CreateTableRequest {
      * The metrics configuration for the given table.
      */
     optional MetricsSettings metrics_settings = 21;
+    // List of multi-column table statistics
+    repeated TableMultiColumnStatistics statistics = 22;
 }
 
 message CreateTableResponse {
@@ -1187,6 +1231,13 @@ message AlterTableRequest {
         MetricsSettings set_metrics_settings = 25;
         google.protobuf.Empty drop_metrics_settings = 26;
     }
+
+    // Start set not null for table
+    repeated SetNotNullItem set_not_null = 27;
+    // Add multi-column table statistics
+    repeated TableMultiColumnStatistics add_statistics = 28;
+    // Remove multi-column table statistics (by its names)
+    repeated string drop_statistics = 29;
 }
 
 message AlterTableResponse {
@@ -1318,6 +1369,8 @@ message DescribeTableResult {
      * The metrics configuration for the given table.
      */
     optional MetricsSettings metrics_settings = 19;
+    // List of multi-column table statistics
+    repeated TableMultiColumnStatisticsDescription statistics = 20;
 }
 
 message Query {
diff --git a/src/api/protos/draft/ydb_test_shard.proto b/src/api/protos/ydb_test_shard.proto
similarity index 73%
rename from src/api/protos/draft/ydb_test_shard.proto
rename to src/api/protos/ydb_test_shard.proto
index 1ef8a662c42..314f48b8baf 100644
--- a/src/api/protos/draft/ydb_test_shard.proto
+++ b/src/api/protos/ydb_test_shard.proto
@@ -1,27 +1,23 @@
 syntax = "proto3";
 
-package Ydb.TestShard;
+package Ydb.TestShardSet;
 
-option java_package = "com.yandex.ydb.test_shard";
+option java_package = "com.yandex.ydb.test_shard_set";
 
 import "src/api/protos/ydb_operation.proto";
 
-message CreateTestShardRequest {
+message CreateTestShardSetRequest {
     Ydb.Operations.OperationParams operation_params = 1;
 
-    // Database path
-    string database = 2;
+    // Path to the TestShardSet object to create
+    string path = 2;
 
-    // Base index for tablet ID generation
-    // Same owner_idx = same tablets (idempotent duplicate detection)
-    uint64 owner_idx = 3;
-
-    // Storage pool names for tablet channels (optional)
+    // Storage pool kinds for tablet channels (optional)
     // If not provided, uses first 3 storage pools from the database domain
-    repeated string channels = 4;
+    repeated string channels = 3;
 
     // Number of tablets to create
-    uint32 count = 5;
+    uint32 count = 4;
 
     // TestShard initialization config in YAML format
     //
@@ -59,41 +55,34 @@ message CreateTestShardRequest {
     //   stall_counter: 1000       # Barrier sync every N requests
     //
     // validation:                 # Optional external validation
-    //   server: "host:9999"       # Validation server address
+    //   server: "host:port"       # Validation server address
     //   after_bytes: 1000000      # Start validation after N bytes
     //
     // tracing:                    # Optional request tracing
     //   put_fraction_ppm: 1000    # Trace fraction (parts per million)
     //   verbosity: 15             # Trace detail level (0-15)
     // ```
-    string config = 6;
+    string config = 5;
 }
 
-message CreateTestShardResponse {
+message CreateTestShardSetResponse {
     Ydb.Operations.Operation operation = 1;
 }
 
-message CreateTestShardResult {
+message CreateTestShardSetResult {
     // Created tablet IDs
     repeated uint64 tablet_ids = 1;
 }
 
-message DeleteTestShardRequest {
+message DeleteTestShardSetRequest {
     Ydb.Operations.OperationParams operation_params = 1;
 
-    // Database path
-    string database = 2;
-
-    // Owner index identifying tablets to delete
-    uint64 owner_idx = 3;
-
-    // Number of consecutive tablets to delete starting from owner_idx
-    // If not specified, deletes all tablets with this owner_idx
-    uint32 count = 4;
+    // Path to the TestShardSet object to delete
+    string path = 2;
 }
 
-message DeleteTestShardResponse {
+message DeleteTestShardSetResponse {
     Ydb.Operations.Operation operation = 1;
 }
 
-message DeleteTestShardResult {}
+message DeleteTestShardSetResult {}
diff --git a/src/api/protos/ydb_topic.proto b/src/api/protos/ydb_topic.proto
index 08aa58f643a..bd2fdb56522 100644
--- a/src/api/protos/ydb_topic.proto
+++ b/src/api/protos/ydb_topic.proto
@@ -722,12 +722,14 @@ message TransactionIdentity {
 }
 
 // Identity of a deferred topic publication for StreamWrite.
-// int_publication_id is assigned by the server in BeginPublication.
-// ext_publication_id is repeated from BeginPublication on each write batch.
+// int_publication_id is assigned by the server in BeginPublication and is authoritative.
+// ext_publication_id is optional and informational only (diagnostics / TWriteId display).
+// When set, the server does not require a non-empty value and does not check that it
+// matches BeginPublication. Omitting the field and setting an empty string are both allowed.
 message DeferredPublishIdentity {
     uint64 int_publication_id = 1;
 
-    string ext_publication_id = 2 [(Ydb.length).le = 2048];
+    optional string ext_publication_id = 2 [(Ydb.length).le = 2048];
 }
 
 // Add offsets to transaction request sent from client to server.
diff --git a/src/client/CMakeLists.txt b/src/client/CMakeLists.txt
index e9b85f044ea..fcf0a1b81c6 100644
--- a/src/client/CMakeLists.txt
+++ b/src/client/CMakeLists.txt
@@ -27,6 +27,7 @@ add_subdirectory(scheme)
 add_subdirectory(secret)
 add_subdirectory(ss_tasks)
 add_subdirectory(table)
+add_subdirectory(test_shard)
 add_subdirectory(topic)
 add_subdirectory(trace)
 add_subdirectory(types)
diff --git a/src/client/coordination/CMakeLists.txt b/src/client/coordination/CMakeLists.txt
index e8152b6dd7c..04c32795133 100644
--- a/src/client/coordination/CMakeLists.txt
+++ b/src/client/coordination/CMakeLists.txt
@@ -15,6 +15,7 @@ target_link_libraries(client-ydb_coordination PUBLIC
 
 target_sources(client-ydb_coordination PRIVATE
   coordination.cpp
+  distributed_lock.cpp
   proto_accessor.cpp
 )
 
diff --git a/src/client/coordination/coordination.cpp b/src/client/coordination/coordination.cpp
index 4c3cacfb689..02a967f965a 100644
--- a/src/client/coordination/coordination.cpp
+++ b/src/client/coordination/coordination.cpp
@@ -172,16 +172,17 @@ class TSessionContext : public TThrRefBase {
     using TResponse = Ydb::Coordination::SessionResponse;
     using TGrpcStatus = NYdbGrpc::TGrpcStatus;
     using IProcessor = NYdbGrpc::IStreamRequestReadWriteProcessor<TRequest, TResponse>;
+    using TSessionLostCallback = std::function<void()>;
 
     friend class TSession::TImpl;
 
 public:
     TSessionContext(
-            TGRpcConnectionsImpl* connections,
+            std::shared_ptr<TGRpcConnectionsImpl> connections,
             TDbDriverStatePtr dbState,
             const std::string& path,
             const TSessionSettings& settings)
-        : Connections_(connections)
+        : Connections_(std::move(connections))
         , DbDriverState_(dbState)
         , Path_(path)
         , Settings_(settings)
@@ -197,8 +198,8 @@ class TSessionContext : public TThrRefBase {
         return result;
     }
 
-    void Start(IQueueClientContextProvider* provider) {
-        auto context = provider->CreateContext();
+    void Start() {
+        auto context = Connections_->CreateContext();
         if (!context) {
             auto status = MakeStatus(EStatus::CLIENT_CANCELLED, "Client is stopped");
             auto promise = std::move(SessionPromise);
@@ -333,11 +334,16 @@ class TSessionContext : public TThrRefBase {
     struct TDescribeSemaphoreOp : public TSimpleOp {
         const std::string Name;
         TDescribeSemaphoreSettings Settings;
+        NYdbGrpc::TQueueClientCallbackGuardFactory CallbackGuardFactory;
         TPromise<TDescribeSemaphoreResult> Promise = NewPromise<TDescribeSemaphoreResult>();
 
-        TDescribeSemaphoreOp(const std::string& name, const TDescribeSemaphoreSettings& settings)
+        TDescribeSemaphoreOp(
+                const std::string& name,
+                const TDescribeSemaphoreSettings& settings,
+                NYdbGrpc::TQueueClientCallbackGuardFactory callbackGuardFactory)
             : Name(name)
             , Settings(settings)
+            , CallbackGuardFactory(std::move(callbackGuardFactory))
         {}
 
         void FillRequest(TRequest& req, uint64_t reqId) const override {
@@ -356,7 +362,9 @@ class TSessionContext : public TThrRefBase {
             } else if (Settings.OnChanged_) {
                 std::function<void(bool)> callback;
                 callback.swap(Settings.OnChanged_);
-                callback(false);
+                NYdbGrpc::RunQueueClientCallback(CallbackGuardFactory, [&] {
+                    callback(false);
+                });
             }
         }
     };
@@ -527,7 +535,10 @@ class TSessionContext : public TThrRefBase {
         if (IsClosed()) {
             return MakeClosedResult<TSemaphoreDescription>();
         }
-        auto op = std::make_unique<TDescribeSemaphoreOp>(name, settings);
+        auto op = std::make_unique<TDescribeSemaphoreOp>(
+            name,
+            settings,
+            Connections_->GetCallbackGuardFactory());
         auto future = op->Promise.GetFuture();
         if (IsWriteAllowed()) {
             DoSendSimpleOp(std::move(op));
@@ -582,6 +593,32 @@ class TSessionContext : public TThrRefBase {
         return future;
     }
 
+    std::shared_ptr<void> DoSubscribeSessionLost(TSessionLostCallback callback) {
+        TSessionLostCallback callbackToCall;
+        uint64_t callbackId = 0;
+        {
+            std::lock_guard guard(Lock);
+            if (SessionLossNotified || IsClosed() || SessionState == ESessionState::EXPIRED || ConnectionState == EConnectionState::STOPPED) {
+                callbackToCall = std::move(callback);
+            } else {
+                callbackId = NextSessionLostCallbackId++;
+                SessionLostCallbacks.emplace(callbackId, std::move(callback));
+            }
+        }
+
+        if (callbackToCall) {
+            callbackToCall();
+            return {};
+        }
+
+        return std::shared_ptr<void>(
+            new uint64_t(callbackId),
+            [self = TPtr(this), callbackId](void* ptr) {
+                delete static_cast<uint64_t*>(ptr);
+                self->DoUnsubscribeSessionLost(callbackId);
+            });
+    }
+
     TDuration GetConnectTimeout() {
         // Use a separate connect timeout if available
         if (Settings_.ConnectTimeout_) {
@@ -855,7 +892,34 @@ class TSessionContext : public TThrRefBase {
         return dynamic_cast<TOperation*>(it->second.get());
     }
 
+    void DoUnsubscribeSessionLost(uint64_t callbackId) {
+        std::lock_guard guard(Lock);
+        SessionLostCallbacks.erase(callbackId);
+    }
+
+    std::vector<TSessionLostCallback> TakeSessionLostCallbacksLocked() {
+        std::vector<TSessionLostCallback> callbacks;
+        if (SessionLossNotified) {
+            return callbacks;
+        }
+
+        SessionLossNotified = true;
+        callbacks.reserve(SessionLostCallbacks.size());
+        for (auto& [_, callback] : SessionLostCallbacks) {
+            callbacks.emplace_back(std::move(callback));
+        }
+        SessionLostCallbacks.clear();
+        return callbacks;
+    }
+
 private:
+    template<class TCallback>
+    void RunUserCallback(TCallback&& callback) {
+        NYdbGrpc::RunQueueClientCallback(
+            Connections_->GetCallbackGuardFactory(),
+            std::forward<TCallback>(callback));
+    }
+
     void OnProcessorStatus(TStatus status) {
         std::shared_ptr<IQueueClientContext> context;
         TDbDriverStatePtr dbDriverState;
@@ -869,6 +933,7 @@ class TSessionContext : public TThrRefBase {
         std::deque<TResultPromise<bool>> failedSemaphoreOps;
         std::deque<std::unique_ptr<TSimpleOp>> failedSimpleOps;
         TResultPromise<void> closePromise;
+        std::vector<TSessionLostCallback> sessionLostCallbacks;
 
         {
             std::lock_guard guard(Lock);
@@ -925,6 +990,7 @@ class TSessionContext : public TThrRefBase {
                     SessionState = ESessionState::EXPIRED;
                     notifyExpired = true;
                 }
+                sessionLostCallbacks = TakeSessionLostCallbacksLocked();
             } else {
                 context = LocalContext;
                 ConnectionState = EConnectionState::DISCONNECTED;
@@ -1017,16 +1083,24 @@ class TSessionContext : public TThrRefBase {
             op->SetFailure(status);
         }
 
+        for (auto& callback : sessionLostCallbacks) {
+            callback();
+        }
+
         if (closePromise.Initialized()) {
             closePromise.SetValue(TResult<void>(expired ? MakeStatus() : status));
         }
 
         if (stopped) {
             if (notifyExpired && Settings_.OnStateChanged_) {
-                Settings_.OnStateChanged_(ESessionState::EXPIRED);
+                RunUserCallback([this] {
+                    Settings_.OnStateChanged_(ESessionState::EXPIRED);
+                });
             }
             if (Settings_.OnStopped_) {
-                Settings_.OnStopped_();
+                RunUserCallback([this] {
+                    Settings_.OnStopped_();
+                });
             }
             return;
         }
@@ -1228,7 +1302,9 @@ class TSessionContext : public TThrRefBase {
         }
 
         if (detached && Settings_.OnStateChanged_) {
-            Settings_.OnStateChanged_(ESessionState::DETACHED);
+            RunUserCallback([this] {
+                Settings_.OnStateChanged_(ESessionState::DETACHED);
+            });
         }
 
         if (sessionStartTimeoutContext) {
@@ -1442,9 +1518,13 @@ class TSessionContext : public TThrRefBase {
                     }
                 }
                 if (expired && Settings_.OnStateChanged_) {
-                    Settings_.OnStateChanged_(ESessionState::EXPIRED);
+                    RunUserCallback([this] {
+                        Settings_.OnStateChanged_(ESessionState::EXPIRED);
+                    });
                 } else if (detached && Settings_.OnStateChanged_) {
-                    Settings_.OnStateChanged_(ESessionState::DETACHED);
+                    RunUserCallback([this] {
+                        Settings_.OnStateChanged_(ESessionState::DETACHED);
+                    });
                 }
                 return false;
             }
@@ -1475,7 +1555,9 @@ class TSessionContext : public TThrRefBase {
                     }
                 }
                 if (Settings_.OnStateChanged_) {
-                    Settings_.OnStateChanged_(ESessionState::ATTACHED);
+                    RunUserCallback([this] {
+                        Settings_.OnStateChanged_(ESessionState::ATTACHED);
+                    });
                 }
                 if (replyPromise.Initialized()) {
                     // If there are no listeners session destructor will be immediately called outside of the lock
@@ -1518,7 +1600,9 @@ class TSessionContext : public TThrRefBase {
                     Y_ABORT_UNLESS(SessionState != ESessionState::ATTACHED);
                 }
                 if (expired && Settings_.OnStateChanged_) {
-                    Settings_.OnStateChanged_(ESessionState::EXPIRED);
+                    RunUserCallback([this] {
+                        Settings_.OnStateChanged_(ESessionState::EXPIRED);
+                    });
                 }
                 return false;
             }
@@ -1555,7 +1639,9 @@ class TSessionContext : public TThrRefBase {
                     supersededPromise.SetValue(TResult<bool>(std::move(status), false));
                 }
                 if (acceptedCallback) {
-                    acceptedCallback();
+                    RunUserCallback([callback = std::move(acceptedCallback)] {
+                        callback();
+                    });
                 }
                 return true;
             }
@@ -1636,7 +1722,9 @@ class TSessionContext : public TThrRefBase {
                     }
                 }
                 if (callback) {
-                    callback(triggered);
+                    RunUserCallback([callback = std::move(callback), triggered] {
+                        callback(triggered);
+                    });
                 }
                 return true;
             }
@@ -1730,7 +1818,7 @@ class TSessionContext : public TThrRefBase {
     }
 
 private:
-    TGRpcConnectionsImpl* const Connections_;
+    std::shared_ptr<TGRpcConnectionsImpl> Connections_;
     TDbDriverStatePtr DbDriverState_;
     const std::string Path_;
     const TSessionSettings Settings_;
@@ -1760,6 +1848,9 @@ class TSessionContext : public TThrRefBase {
     std::deque<std::unique_ptr<TSimpleOp>> PendingRequests;
     std::unordered_map<uint64_t, std::unique_ptr<TSimpleOp>> SentRequests;
     TResultPromise<void> ReconnectPromise;
+    std::unordered_map<uint64_t, TSessionLostCallback> SessionLostCallbacks;
+    uint64_t NextSessionLostCallbackId = 1;
+    bool SessionLossNotified = false;
 
     // These are used to manage session timeout
     IQueueClientContextPtr SessionStartTimeoutContext;
@@ -1850,14 +1941,14 @@ class TClient::TImpl : public TClientImplCommon<TClient::TImpl> {
         const TSessionSettings& settings)
     {
         auto session = MakeIntrusive<TSessionContext>(
-            Connections_.get(),
+            Connections_,
             DbDriverState_,
             path,
             settings);
 
         auto result = session->TakeStartResult();
 
-        session->Start(Connections_.get());
+        session->Start();
 
         return result;
     }
@@ -2049,6 +2140,10 @@ class TSession::TImpl {
         return Context->DoDeleteSemaphore(name, force);
     }
 
+    std::shared_ptr<void> SubscribeSessionLost(std::function<void()> callback) {
+        return Context->DoSubscribeSessionLost(std::move(callback));
+    }
+
 private:
     const TIntrusivePtr<TSessionContext> Context;
 };
@@ -2123,5 +2218,9 @@ TAsyncResult<void> TSession::DeleteSemaphore(
     return Impl_->DeleteSemaphore(name, force);
 }
 
+std::shared_ptr<void> TSession::SubscribeSessionLost(std::function<void()> callback) {
+    return Impl_->SubscribeSessionLost(std::move(callback));
+}
+
 }
 }
diff --git a/src/client/coordination/distributed_lock.cpp b/src/client/coordination/distributed_lock.cpp
new file mode 100644
index 00000000000..a0f5149df89
--- /dev/null
+++ b/src/client/coordination/distributed_lock.cpp
@@ -0,0 +1,206 @@
+#include <ydb-cpp-sdk/client/coordination/distributed_lock.h>
+
+#include <util/system/hostname.h>
+
+#include <mutex>
+
+namespace NYdb {
+namespace NCoordination {
+    struct TDistributedLock::TImpl {
+        struct TLockState {
+            std::stop_token GetStopToken() const {
+                std::lock_guard guard(Mutex);
+                return StopSource.get_token();
+            }
+
+            bool TryBeginHold() {
+                std::lock_guard guard(Mutex);
+                if (SessionLost) {
+                    return false;
+                }
+                StopSource = std::stop_source{};
+                Holding = true;
+                return true;
+            }
+
+            void EndHold() {
+                std::lock_guard guard(Mutex);
+                Holding = false;
+            }
+
+            void RequestStopIfHolding() {
+                std::lock_guard guard(Mutex);
+                if (Holding) {
+                    StopSource.request_stop();
+                }
+            }
+
+            void NotifySessionLost() {
+                std::lock_guard guard(Mutex);
+                SessionLost = true;
+                if (Holding) {
+                    StopSource.request_stop();
+                }
+            }
+
+            mutable std::mutex Mutex;
+            std::stop_source StopSource;
+            bool Holding = false;
+            bool SessionLost = false;
+        };
+
+        TSession Session;
+        TAcquireSemaphoreSettings Settings;
+        std::string Name;
+        TDuration Timeout;
+        std::shared_ptr<TLockState> LockState;
+        std::shared_ptr<void> SessionLostSubscription;
+
+        bool CancelAcquire() noexcept try {
+            auto releaseFuture = Session.ReleaseSemaphore(Name);
+            if (!releaseFuture.Wait(Timeout)) {
+                return false;
+            }
+            const auto result = releaseFuture.GetValue();
+            return result.IsSuccess();
+        } catch (...) {
+            return false;
+        }
+
+        bool IsSessionLost() {
+            return Session.GetSessionState() == ESessionState::EXPIRED ||
+                Session.GetConnectionState() == EConnectionState::STOPPED;
+        }
+
+        bool TryBeginHold() {
+            if (IsSessionLost()) {
+                LockState->NotifySessionLost();
+                return false;
+            }
+            if (!LockState->TryBeginHold()) {
+                return false;
+            }
+            if (IsSessionLost()) {
+                LockState->NotifySessionLost();
+                LockState->EndHold();
+                return false;
+            }
+            return true;
+        }
+
+        TImpl(TSession session, const TDistributedLockSettings& lockSettings)
+            : Session(std::move(session))
+            , Name(lockSettings.Name_)
+            , Timeout(lockSettings.Timeout_)
+            , LockState(std::make_shared<TLockState>())
+        {
+            if (!Session) {
+                throw TYdbLockException("Session is not initialized");
+            }
+
+            Settings = TAcquireSemaphoreSettings()
+                .Exclusive()
+                .Data(FQDNHostName())
+                .Ephemeral()
+                .Timeout(Timeout);
+
+            std::weak_ptr<TLockState> weakLockState = LockState;
+            SessionLostSubscription = Session.SubscribeSessionLost([weakLockState] {
+                if (auto lockState = weakLockState.lock()) {
+                    lockState->NotifySessionLost();
+                }
+            });
+        }
+
+        bool try_lock() noexcept try {
+            auto acquireFuture = Session.AcquireSemaphore(Name, Settings);
+            if (!acquireFuture.Wait(Timeout)) {
+                CancelAcquire();
+                return false;
+            }
+            const auto result = acquireFuture.GetValue();
+            if (!result.IsSuccess()) {
+                return false;
+            }
+            if (!result.GetResult()) {
+                return false;
+            }
+            if (!TryBeginHold()) {
+                return false;
+            }
+            return true;
+        } catch (...) {
+            return false;
+        }
+
+        void lock() {
+            auto acquireFuture = Session.AcquireSemaphore(Name, Settings);
+            if (!acquireFuture.Wait(Timeout)) {
+                CancelAcquire();
+                throw TYdbLockException("Failed to acquire semaphore");
+            }
+            const auto result = acquireFuture.GetValue();
+            if (!result.IsSuccess()) {
+                throw TYdbLockException("Failed to acquire semaphore");
+            }
+            if (!result.GetResult()) {
+                throw TYdbLockException("Failed to acquire semaphore");
+            }
+            if (!TryBeginHold()) {
+                throw TYdbLockException("Failed to acquire semaphore");
+            }
+        }
+
+        void unlock() noexcept try {
+            auto releaseFuture = Session.ReleaseSemaphore(Name);
+            if (releaseFuture.Wait(Timeout)) {
+                const auto result = releaseFuture.GetValue();
+                if (result.IsSuccess() && result.GetResult()) {
+                    LockState->EndHold();
+                    return;
+                }
+            }
+
+            LockState->RequestStopIfHolding();
+            LockState->EndHold();
+        } catch (...) {
+            LockState->RequestStopIfHolding();
+            LockState->EndHold();
+        }
+    };
+
+    TDistributedLock::TDistributedLock(TSession session, const TDistributedLockSettings& settings) {
+        impl_ = std::make_unique<TImpl>(std::move(session), settings);
+    }
+
+    TDistributedLock TSession::CreateDistributedLock(const TDistributedLockSettings& settings) {
+        return TDistributedLock(*this, settings);
+    }
+
+    TDistributedLock::~TDistributedLock() = default;
+
+    void TDistributedLock::lock() {
+        impl_->lock();
+    }
+
+    void TDistributedLock::unlock() noexcept {
+        impl_->unlock();
+    }
+
+    void TDistributedLock::Acquire() {
+        impl_->lock();
+    }
+
+    void TDistributedLock::Release() noexcept {
+        impl_->unlock();
+    }
+
+    bool TDistributedLock::try_lock() noexcept {
+        return impl_->try_lock();
+    }
+
+    std::stop_token TDistributedLock::getStopToken() const {
+        return impl_->LockState->GetStopToken();
+    }
+}
+}
diff --git a/src/client/driver/driver.cpp b/src/client/driver/driver.cpp
index 4dfdb88477f..2cd004faa54 100644
--- a/src/client/driver/driver.cpp
+++ b/src/client/driver/driver.cpp
@@ -13,7 +13,7 @@
 #include <ydb-cpp-sdk/client/common_client/ssl_credentials.h>
 #include <util/stream/file.h>
 #include <ydb-cpp-sdk/client/resources/ydb_ca.h>
-
+#include <thread>
 namespace NYdb::inline V3 {
 
 using NYdbGrpc::TGRpcClientLow;
@@ -23,6 +23,7 @@ using NYdbGrpc::TGRpcClientConfig;
 using NYdbGrpc::TResponseCallback;
 using NYdbGrpc::TGrpcStatus;
 using NYdbGrpc::TTcpKeepAliveSettings;
+using NYdbGrpc::IsGRpcCompletionThread;
 
 using Ydb::StatusIds;
 
@@ -361,11 +362,14 @@ TDriver::TDriver(const TDriverConfig& config) {
         ythrow yexception() << "Invalid config object";
     }
 
-    Impl_.reset(new TGRpcConnectionsImpl(config.Impl_));
+    Impl_.reset(new TGRpcConnectionsImpl(config.Impl_), TGRpcConnectionsDeleter());
 }
 
 void TDriver::Stop(bool wait) {
-    Impl_->Stop(wait);
+    auto impl = Impl_;
+    TGRpcConnectionsImpl::DeferOrRunNow(impl->StopState_, [impl, wait]() mutable {
+        impl->Stop(wait);
+    });
 }
 
 TDriverConfig TDriver::GetConfig() const {
diff --git a/src/client/export/export.cpp b/src/client/export/export.cpp
index 6ac28469894..0cdcf9e88c6 100644
--- a/src/client/export/export.cpp
+++ b/src/client/export/export.cpp
@@ -28,6 +28,10 @@ const std::string TEncryptionAlgorithm::CHACHA_20_POLY_1305 = "ChaCha20-Poly1305
 /// Common
 namespace {
 
+// helper type for the visitor
+template <typename... Ts>
+struct overloads : Ts... { using Ts::operator()...; };
+
 std::vector<TExportItemProgress> ItemsProgressFromProto(const google::protobuf::RepeatedPtrField<ExportItemProgress>& proto) {
     std::vector<TExportItemProgress> result;
     result.reserve(proto.size());
@@ -101,6 +105,16 @@ TExportToS3Response::TExportToS3Response(TStatus&& status, Ydb::Operations::Oper
         Metadata_.Settings.Compression(metadata.settings().compression());
     }
 
+    switch (metadata.settings().format_case()) {
+    case Ydb::Export::ExportToS3Settings::FORMAT_NOT_SET:
+    case Ydb::Export::ExportToS3Settings::kYdbDump:
+        Metadata_.Settings.Format(TProtoAccessor::FromProto(metadata.settings().ydb_dump()));
+        break;
+    case Ydb::Export::ExportToS3Settings::kParquet:
+        Metadata_.Settings.Format(TProtoAccessor::FromProto(metadata.settings().parquet()));
+        break;
+    }
+
     // progress
     Metadata_.Progress = TProtoAccessor::FromProto(metadata.progress());
     Metadata_.ItemsProgress = ItemsProgressFromProto(metadata.items_progress());
@@ -226,6 +240,17 @@ TFuture<TExportToS3Response> TExportClient::ExportToS3(const TExportToS3Settings
     request.mutable_settings()->set_access_key(TStringType{settings.AccessKey_});
     request.mutable_settings()->set_secret_key(TStringType{settings.SecretKey_});
 
+    // Set format based on the Format_ field
+    std::visit(overloads{
+        [&request](const TYdbDumpFormat&) {
+            request.mutable_settings()->mutable_ydb_dump();
+        },
+        [&request](const TParquetFormat& format) {
+            auto parquet = request.mutable_settings()->mutable_parquet();
+            parquet->set_row_group_size(format.RowGroupSize_);
+        }
+    }, settings.Format_);
+
     for (const auto& item : settings.Item_) {
         auto& protoItem = *request.mutable_settings()->mutable_items()->Add();
         protoItem.set_source_path(TStringType{item.Src});
diff --git a/src/client/iam/iam.cpp b/src/client/iam/iam.cpp
index 9a152b85561..c8a294a5448 100644
--- a/src/client/iam/iam.cpp
+++ b/src/client/iam/iam.cpp
@@ -8,102 +8,163 @@
 #include <library/cpp/json/json_reader.h>
 #include <library/cpp/http/simple/http_client.h>
 
+#include <exception>
 #include <mutex>
 
 using namespace yandex::cloud::iam::v1;
 
 namespace NYdb::inline V3 {
 
-class TIAMCredentialsProvider : public ICredentialsProvider {
+class TIAMCredentialsProvider : public ICredentialsProvider, public std::enable_shared_from_this<TIAMCredentialsProvider> {
 public:
-    TIAMCredentialsProvider(const TIamHost& params)
+    TIAMCredentialsProvider(const TIamHost& params, std::weak_ptr<ICoreFacility> facility)
         : HttpClient_(TSimpleHttpClient(TString(params.Host), params.Port))
         , Request_("/computeMetadata/v1/instance/service-accounts/default/token")
         , NextTicketUpdate_(TInstant::Zero())
         , RefreshPeriod_(params.RefreshPeriod)
-    {
-        GetTicket();
+        , Facility_(std::move(facility))
+        , AuthInfo_(NThreading::NewPromise<std::string>())
+    {}
+
+    void Start() {
+        auto facility = Facility_.lock();
+        if (!facility) {
+            Fail("IAM-token provider response facility is not available");
+            return;
+        }
+        try {
+            facility->AddPeriodicTask([weak = weak_from_this()](NYdb::NIssue::TIssues&&, EStatus status) {
+                if (auto self = weak.lock()) {
+                    return self->OnPeriodicTick(status);
+                }
+                return false;
+            }, PERIODIC_TICK);
+        } catch (...) {
+            Fail(CurrentExceptionMessage());
+        }
     }
 
     std::string GetAuthInfo() const override {
-        std::string ticket;
-        TInstant nextTicketUpdate;
-        {
-            std::lock_guard lock(Lock_);
-            ticket = Ticket_;
-            nextTicketUpdate = NextTicketUpdate_;
-        }
-        if (TInstant::Now() >= nextTicketUpdate) {
-            GetTicket();
-            {
-                std::lock_guard lock(Lock_);
-                ticket = Ticket_;
-            }
-        }
-        return ticket;
+        return GetAuthInfoAsync().GetValueSync();
+    }
+
+    NThreading::TFuture<std::string> GetAuthInfoAsync() const override {
+        std::lock_guard lock(Lock_);
+        return AuthInfo_.GetFuture();
     }
 
     bool IsValid() const override {
         return true;
     }
 
+    ~TIAMCredentialsProvider() { Fail("IAM-token provider stopped"); }
+
 private:
     TSimpleHttpClient HttpClient_;
     std::string Request_;
     mutable std::mutex Lock_;
-    mutable std::string Ticket_;
     mutable TInstant NextTicketUpdate_;
     TDuration RefreshPeriod_;
+    std::weak_ptr<ICoreFacility> Facility_;
+    mutable NThreading::TPromise<std::string> AuthInfo_;
+    mutable bool Stopped_ = false;
 
-    void GetTicket() const {
-        try {
-            TStringStream out;
-            TSimpleHttpClient::THeaders headers;
-            headers["Metadata-Flavor"] = "Google";
-            HttpClient_.DoGet(Request_, &out, headers);
-            NJson::TJsonValue resp;
-            NJson::ReadJsonTree(&out, &resp, true);
-
-            auto respMap = resp.GetMap();
-
-            std::string ticket;
-            if (auto it = respMap.find("access_token"); it == respMap.end())
-                ythrow yexception() << "Result doesn't contain access_token";
-            else if (ticket = it->second.GetStringSafe(); ticket.empty())
-                ythrow yexception() << "Got empty ticket";
-
-            const auto now = TInstant::Now();
-            TInstant nextUpdate;
-            TDuration expiresIn;
-            if (auto it = respMap.find("expires_in"); it != respMap.end()) {
-                auto seconds = it->second.GetUInteger();
-                if (seconds > 0) {
-                    expiresIn = TDuration::Seconds(seconds);
-                }
-            } else if (auto it = respMap.find("expiry"); it != respMap.end()) {
-                try {
-                    TInstant expiry;
-                    if (TInstant::TryParseIso8601(it->second.GetStringSafe(), expiry) && expiry > now) {
-                        expiresIn = expiry - now;
-                    }
-                } catch (...) {
-                }
+    void Fail(std::string error) const {
+        NThreading::TPromise<std::string> promise;
+        {
+            std::lock_guard lock(Lock_);
+            Stopped_ = true;
+            promise = AuthInfo_;
+        }
+        promise.TrySetException(std::make_exception_ptr(yexception() << error));
+    }
+
+    bool OnPeriodicTick(EStatus status) const {
+        if (status != EStatus::SUCCESS) {
+            Fail("IAM-token provider periodic task failed");
+            return false;
+        }
+
+        NThreading::TPromise<std::string> promise;
+        {
+            std::lock_guard lock(Lock_);
+            if (Stopped_) {
+                return false;
+            }
+            if (TInstant::Now() < NextTicketUpdate_) {
+                return true;
             }
-            if (expiresIn > TDuration::Zero()) {
-                const auto halfLife = expiresIn / 2;
-                const auto interval = std::max(std::min(halfLife, RefreshPeriod_), TDuration::MilliSeconds(100));
-                nextUpdate = now + interval;
-            } else {
-                nextUpdate = now + std::min(RefreshPeriod_, TDuration::Minutes(30));
+            if (AuthInfo_.GetFuture().IsReady()) {
+                AuthInfo_ = NThreading::NewPromise<std::string>();
             }
+            promise = AuthInfo_;
+        }
 
+        try {
+            auto [ticket, nextUpdate] = GetTicket();
             {
                 std::lock_guard lock(Lock_);
-                Ticket_ = std::move(ticket);
                 NextTicketUpdate_ = nextUpdate;
             }
+            promise.TrySetValue(std::move(ticket));
         } catch (...) {
+            const auto error = std::current_exception();
+            if (!IsRetryable(error)) {
+                Fail(CurrentExceptionMessage());
+                return false;
+            }
+            std::lock_guard lock(Lock_);
+            NextTicketUpdate_ = TInstant::Now() + std::min(RefreshPeriod_, TDuration::Seconds(10));
         }
+        return true;
+    }
+
+    static bool IsRetryable(const std::exception_ptr& error) {
+        try {
+            std::rethrow_exception(error);
+        } catch (const THttpRequestException& e) {
+            const int code = e.GetStatusCode();
+            return code == 0 || code == HTTP_REQUEST_TIME_OUT || code == HTTP_AUTHENTICATION_TIMEOUT ||
+                code == HTTP_TOO_MANY_REQUESTS || (code >= 500 && code < 600);
+        } catch (const TSystemError&) {
+            return true;
+        } catch (...) {
+            return false;
+        }
+    }
+
+    std::pair<std::string, TInstant> GetTicket() const {
+        TStringStream out;
+        TSimpleHttpClient::THeaders headers;
+        headers["Metadata-Flavor"] = "Google";
+        HttpClient_.DoGet(Request_, &out, headers);
+        NJson::TJsonValue resp;
+        NJson::ReadJsonTree(&out, &resp, true);
+
+        auto respMap = resp.GetMap();
+        std::string ticket;
+        if (auto it = respMap.find("access_token"); it == respMap.end())
+            ythrow yexception() << "Result doesn't contain access_token";
+        else if (ticket = it->second.GetStringSafe(); ticket.empty())
+            ythrow yexception() << "Got empty ticket";
+
+        const auto now = TInstant::Now();
+        TDuration expiresIn;
+        if (auto it = respMap.find("expires_in"); it != respMap.end()) {
+            const auto seconds = it->second.GetUInteger();
+            if (seconds > 0) {
+                expiresIn = TDuration::Seconds(seconds);
+            }
+        } else if (auto it = respMap.find("expiry"); it != respMap.end()) {
+            TInstant expiry;
+            if (TInstant::TryParseIso8601(it->second.GetStringSafe(), expiry) && expiry > now) {
+                expiresIn = expiry - now;
+            }
+        }
+        const auto interval = expiresIn > TDuration::Zero()
+            ? std::max(std::min(expiresIn / 2, RefreshPeriod_), TDuration::MilliSeconds(100))
+            : std::min(RefreshPeriod_, TDuration::Minutes(30));
+        return {std::move(ticket), now + interval};
     }
 };
 
@@ -112,7 +173,26 @@ class TIamCredentialsProviderFactory : public ICredentialsProviderFactory {
     TIamCredentialsProviderFactory(const TIamHost& params): Params_(params) {}
 
     TCredentialsProviderPtr CreateProvider() const final {
-        return std::make_shared<TIAMCredentialsProvider>(Params_);
+        return NCredentials::NDetail::GetOrCreateCachedProvider(
+            GetClientIdentity(),
+            [this] {
+                auto facility = CreateSimpleCoreFacility();
+                auto provider = CreateProvider(facility);
+                return std::make_shared<TOwningFacilityCredentialsProvider>(
+                    std::move(facility), std::move(provider));
+            });
+    }
+
+    TCredentialsProviderPtr CreateProvider(std::weak_ptr<ICoreFacility> facility) const final {
+        auto provider = std::make_shared<TIAMCredentialsProvider>(Params_, std::move(facility));
+        provider->Start();
+        return provider;
+    }
+
+    std::string GetClientIdentity() const final {
+        return TStringBuilder() <<
+                "TIamCredentialsProviderFactory" << '\t' <<
+                Params_.Host << ':' << Params_.Port << '@' << Params_.RefreshPeriod;
     }
 
 private:
diff --git a/src/client/iam_private/common/iam.h b/src/client/iam_private/common/iam.h
index 21e8354abc8..9fe1a84233c 100644
--- a/src/client/iam_private/common/iam.h
+++ b/src/client/iam_private/common/iam.h
@@ -25,27 +25,15 @@ class TIamServiceCredentialsProviderFactory : public ICredentialsProviderFactory
 
     class TCredentialsProvider : public TGrpcIamCredentialsProvider<TRequest, TResponse, TService> {
     public:
-        // TDriver path: a shared facility (TGRpcConnectionsImpl) supports multiple periodic tasks,
-        // so we can hand the same weak_ptr to the nested auth provider here.
-        TCredentialsProvider(const TIamServiceParams& params, std::weak_ptr<ICoreFacility> responseFacility)
-            : TGrpcIamCredentialsProvider<TRequest, TResponse, TService>(params,
-                MakeRequestFiller(params),
-                MakeRpc(),
-                responseFacility,
-                params.SystemServiceAccountCredentials->CreateProvider(responseFacility))
-        {}
-
-        // Standalone (no-arg) path: the caller has already built a self-owning auth provider
-        // backed by its OWN facility. We must not share `outerFacility` with the auth provider
-        // because TSimpleCoreFacility allows only one periodic task.
         TCredentialsProvider(const TIamServiceParams& params,
-                             std::weak_ptr<ICoreFacility> outerFacility,
-                             TCredentialsProviderPtr authProvider)
+                             std::weak_ptr<ICoreFacility> responseFacility,
+                             TCredentialsProviderPtr authProvider = {})
             : TGrpcIamCredentialsProvider<TRequest, TResponse, TService>(params,
                 MakeRequestFiller(params),
                 MakeRpc(),
-                std::move(outerFacility),
-                std::move(authProvider))
+                responseFacility,
+                authProvider ? std::move(authProvider) :
+                    params.SystemServiceAccountCredentials->CreateProvider(responseFacility))
         {}
     };
 
@@ -54,23 +42,41 @@ class TIamServiceCredentialsProviderFactory : public ICredentialsProviderFactory
         : Params_(params)
     {}
 
-    // Deprecated. Kept for backward compatibility — see comment on TIamJwtCredentialsProviderFactory.
-    // The nested auth provider gets its own facility (via a recursive no-arg CreateProvider() that
-    // returns a TOwningFacilityCredentialsProvider). Sharing a TSimpleCoreFacility between two gRPC
-    // IAM providers would abort: each one registers a periodic task and the facility allows only one.
     TCredentialsProviderPtr CreateProvider() const override final {
-        auto authProvider = Params_.SystemServiceAccountCredentials->CreateProvider();
-        auto outerFacility = CreateSimpleCoreFacility();
-        auto serviceProvider = std::make_shared<TCredentialsProvider>(
-            Params_, std::weak_ptr<ICoreFacility>(outerFacility), std::move(authProvider));
-        return std::make_shared<TOwningFacilityCredentialsProvider>(
-            std::move(outerFacility), std::move(serviceProvider));
+        return NCredentials::NDetail::GetOrCreateCachedProvider(
+            GetClientIdentity(),
+            [this] {
+                auto authProvider = NCredentials::NDetail::GetOrCreateCachedProvider(
+                    "async:" + Params_.SystemServiceAccountCredentials->GetClientIdentity(), [this] {
+                        auto facility = CreateSimpleCoreFacility();
+                        return std::make_shared<TOwningFacilityCredentialsProvider>(facility,
+                            Params_.SystemServiceAccountCredentials->CreateProvider(facility), true);
+                    });
+                auto facility = CreateSimpleCoreFacility();
+                auto serviceProvider = std::make_shared<TCredentialsProvider>(
+                    Params_, facility, std::move(authProvider));
+                return std::make_shared<TOwningFacilityCredentialsProvider>(
+                    std::move(facility), std::move(serviceProvider));
+            });
     }
 
     TCredentialsProviderPtr CreateProvider(std::weak_ptr<ICoreFacility> facility) const override {
         return std::make_shared<TCredentialsProvider>(Params_, std::move(facility));
     }
 
+    std::string GetClientIdentity() const override final {
+        return NIam::NDetail::MakeClientIdentity(
+            "TIamServiceCredentialsProviderFactory",
+            Params_,
+            TService::service_full_name(),
+            Params_.ServiceId,
+            Params_.MicroserviceId,
+            Params_.ResourceId,
+            Params_.ResourceType,
+            Params_.TargetServiceAccountId,
+            Params_.SystemServiceAccountCredentials->GetClientIdentity());
+    }
+
 private:
     TIamServiceParams Params_;
 };
diff --git a/src/client/impl/internal/db_driver_state/state.cpp b/src/client/impl/internal/db_driver_state/state.cpp
index 2c87fd71952..9ad2ad2e8c5 100644
--- a/src/client/impl/internal/db_driver_state/state.cpp
+++ b/src/client/impl/internal/db_driver_state/state.cpp
@@ -17,6 +17,7 @@ namespace {
 
         url.assign(to, Quote(to, TStringBuf(url), safe));
     }
+
 }
 
 namespace NYdb::inline V3 {
@@ -58,14 +59,30 @@ TDbDriverState::TDbDriverState(
     Log.SetFormatter(GetPrefixLogFormatter(GetDatabaseLogPrefix(Database)));
 }
 
-void TDbDriverState::SetCredentialsProvider(std::shared_ptr<ICredentialsProvider> credentialsProvider) {
-    CredentialsProvider = std::move(credentialsProvider);
+void TDbDriverState::InitCredentials(
+    std::shared_ptr<ICredentialsProviderFactory> credentialsProviderFactory
+) {
+    Credentials.Provider = credentialsProviderFactory->CreateProvider(weak_from_this());
 #ifndef YDB_GRPC_UNSECURE_AUTH
-    CallCredentials = grpc::MetadataCredentialsFromPlugin(
-        std::unique_ptr<grpc::MetadataCredentialsPlugin>(new TYdbAuthenticator(CredentialsProvider)));
+    Credentials.CallCredentials = grpc::MetadataCredentialsFromPlugin(
+        std::unique_ptr<grpc::MetadataCredentialsPlugin>(new TYdbAuthenticator(Credentials.Provider)));
 #endif
 }
 
+NThreading::TFuture<void> TDbDriverState::GetCredentialsReady() const {
+    return Credentials.Provider->GetAuthInfoAsync().IgnoreResult();
+}
+
+std::shared_ptr<ICredentialsProvider> TDbDriverState::GetCredentialsProvider() const {
+    return Credentials.Provider;
+}
+
+#ifndef YDB_GRPC_UNSECURE_AUTH
+std::shared_ptr<grpc::CallCredentials> TDbDriverState::GetCallCredentials() const {
+    return Credentials.CallCredentials;
+}
+#endif
+
 bool TDbDriverState::AreClientTlsCredentialsValid() const {
     std::call_once(ClientTlsValidationOnceFlag_, [this]() {
         ClientTlsValidationDetail_.clear();
@@ -189,53 +206,67 @@ TDbDriverStatePtr TDbDriverStateTracker::GetDriverState(
         }
     }
     TDbDriverStatePtr strongState;
-    for (;;) {
+    {
         std::unique_lock lock(Lock_);
-        {
+        Notify_.wait(lock, [&]() {
             auto state = States_.find(key);
-            if (state != States_.end()) {
-                auto strong = state->second.lock();
-                if (strong) {
-                    return strong;
-                } else {
-                    // We could find state record, but couldn't promote weak to shared
-                    // this means weak ptr already expired but dtor hasn't been
-                    // called yet. Likely other thread now is waiting on mutex to
-                    // remove expired record from hashmap. So give him chance
-                    // to do it after that we will be able to create new state
-                    lock.unlock();
-                    std::this_thread::yield();
-                    continue;
-                }
+            if (state == States_.end()) {
+                return true;
+            }
+            strongState = state->second.lock();
+            if (strongState) {
+                return true;
             }
+            return false;
+        });
+        if (strongState) {
+            return strongState;
         }
         {
             auto deleter = [this, key](TDbDriverState* p) {
                 {
                     std::unique_lock lock(Lock_);
                     States_.erase(key);
+                    Notify_.notify_all();
                 }
                 delete p;
             };
-            strongState = std::shared_ptr<TDbDriverState>(
-                new TDbDriverState(
-                    quotedDatabase,
-                    discoveryEndpoint,
-                    discoveryMode,
-                    sslCredentials,
-                    DiscoveryClient_),
-                deleter);
-
-            strongState->SetCredentialsProvider(
-                credentialsProviderFactory
-                    ? credentialsProviderFactory->CreateProvider(strongState)
-                    : CreateInsecureCredentialsProviderFactory()->CreateProvider(strongState));
-
-            if (discoveryMode != EDiscoveryMode::Off) {
-                DiscoveryClient_->AddPeriodicTask(CreatePeriodicDiscoveryTask(strongState), DISCOVERY_RECHECK_PERIOD);
+
+            auto [it, inserted] = States_.try_emplace(key); // creates empty weak_ptr
+            auto& weakState = it->second;
+            lock.unlock(); // temporarily release lock
+
+            try {
+                Y_ABORT_UNLESS(inserted);
+                strongState = std::shared_ptr<TDbDriverState>(
+                    new TDbDriverState(
+                        quotedDatabase,
+                        discoveryEndpoint,
+                        discoveryMode,
+                        sslCredentials,
+                        DiscoveryClient_),
+                    deleter);
+
+                strongState->InitCredentials(
+                    credentialsProviderFactory
+                        ? std::move(credentialsProviderFactory)
+                        : CreateInsecureCredentialsProviderFactory());
+
+                if (discoveryMode != EDiscoveryMode::Off) {
+                    DiscoveryClient_->AddPeriodicTask(CreatePeriodicDiscoveryTask(strongState), DISCOVERY_RECHECK_PERIOD);
+                }
+            } catch (...) {
+                lock.lock();
+                Y_ABORT_UNLESS(weakState.expired());
+                Y_ABORT_UNLESS(States_.erase(key));
+                Notify_.notify_all();
+                throw;
             }
-            Y_ABORT_UNLESS(States_.emplace(key, strongState).second);
-            break;
+
+            lock.lock(); // re-acquire lock
+            Y_ABORT_UNLESS(weakState.expired());
+            weakState = strongState; // reference remains valid
+            Notify_.notify_all();
         }
     }
 
@@ -272,7 +303,8 @@ void TDbDriverState::PostToResponseQueue(TPostTaskCb&& f) {
 }
 
 NThreading::TFuture<void> TDbDriverStateTracker::SendNotification(
-    TDbDriverState::ENotifyType type
+    TDbDriverState::ENotifyType type,
+    TNotificationCbRunner cbRunner
 ) {
     std::vector<std::weak_ptr<TDbDriverState>> states;
     {
@@ -289,7 +321,7 @@ NThreading::TFuture<void> TDbDriverStateTracker::SendNotification(
             std::lock_guard lock(strong->NotifyCbsLock);
             for (auto& cb : strong->NotifyCbs[static_cast<size_t>(type)]) {
                 if (cb) {
-                    auto future = cb();
+                    auto future = cbRunner ? cbRunner(cb) : cb();
                     if (!future.HasException()) {
                         results.push_back(future);
                     }
@@ -298,6 +330,14 @@ NThreading::TFuture<void> TDbDriverStateTracker::SendNotification(
             }
         }
     }
+    if (results.empty()) {
+        // MakeFuture<void>() uses a process-wide singleton that may already be
+        // destroyed when driver shutdown is triggered by another singleton.
+        auto promise = NThreading::NewPromise<void>();
+        auto future = promise.GetFuture();
+        promise.SetValue();
+        return future;
+    }
     return NThreading::WaitExceptionOrAll(results);
 }
 
diff --git a/src/client/impl/internal/db_driver_state/state.h b/src/client/impl/internal/db_driver_state/state.h
index c975aaaf315..e719eebafee 100644
--- a/src/client/impl/internal/db_driver_state/state.h
+++ b/src/client/impl/internal/db_driver_state/state.h
@@ -8,6 +8,7 @@
 #include <ydb-cpp-sdk/client/common_client/ssl_credentials.h>
 #include <ydb-cpp-sdk/client/types/core_facility/core_facility.h>
 
+#include <memory>
 #include <mutex>
 
 namespace NYdb::inline V3 {
@@ -40,6 +41,12 @@ class TDbDriverState
     NThreading::TFuture<void> DiscoveryCompleted() const;
 
     void SignalDiscoveryCompleted();
+    void InitCredentials(std::shared_ptr<ICredentialsProviderFactory> credentialsProviderFactory);
+    NThreading::TFuture<void> GetCredentialsReady() const;
+    std::shared_ptr<ICredentialsProvider> GetCredentialsProvider() const;
+#ifndef YDB_GRPC_UNSECURE_AUTH
+    std::shared_ptr<grpc::CallCredentials> GetCallCredentials() const;
+#endif
 
     void AddPeriodicTask(TPeriodicCb&& cb, TDeadline::Duration period) override;
     void PostToResponseQueue(TPostTaskCb&& f) override;
@@ -50,7 +57,6 @@ class TDbDriverState
     void ForEachForeignEndpoint(const TEndpointElectorSafe::THandleCb& cb, const void* tag) const;
     TBalancingPolicy::TImpl::EPolicyType GetBalancingPolicyType() const;
     std::string GetEndpoint() const;
-    void SetCredentialsProvider(std::shared_ptr<ICredentialsProvider> credentialsProvider);
     bool AreClientTlsCredentialsValid() const;
     const std::string& GetClientTlsValidationDetail() const;
 
@@ -58,15 +64,11 @@ class TDbDriverState
     const std::string DiscoveryEndpoint;
     const EDiscoveryMode DiscoveryMode;
     const TSslCredentials SslCredentials;
-    std::shared_ptr<ICredentialsProvider> CredentialsProvider;
     IInternalClient* Client;
     TEndpointPool EndpointPool;
     // StopCb allow client to subscribe for notifications from lower layer
     std::mutex NotifyCbsLock;
     std::array<std::vector<TCb>, static_cast<size_t>(ENotifyType::COUNT)> NotifyCbs;
-#ifndef YDB_GRPC_UNSECURE_AUTH
-    std::shared_ptr<grpc::CallCredentials> CallCredentials;
-#endif
     // Status of last discovery call, used in sync mode, coresponding mutex
     std::shared_mutex LastDiscoveryStatusRWLock;
     TPlainStatus LastDiscoveryStatus;
@@ -75,6 +77,14 @@ class TDbDriverState
     NThreading::TPromise<void> DiscoveryCompletedPromise;
 
 private:
+    struct TCredentials {
+        std::shared_ptr<ICredentialsProvider> Provider;
+#ifndef YDB_GRPC_UNSECURE_AUTH
+        std::shared_ptr<grpc::CallCredentials> CallCredentials;
+#endif
+    };
+
+    TCredentials Credentials;
     mutable std::once_flag ClientTlsValidationOnceFlag_;
     mutable bool ClientTlsCredentialsValid_ = true;
     mutable std::string ClientTlsValidationDetail_;
@@ -98,6 +108,8 @@ class TDbDriverStateTracker {
     };
 public:
     TDbDriverStateTracker(IInternalClient* client);
+    using TNotificationCbRunner = std::function<NThreading::TFuture<void>(TDbDriverState::TCb& cb)>;
+
     TDbDriverState::TPtr GetDriverState(
         const std::string& database,
         const std::string& discoveryEndpoint,
@@ -106,12 +118,14 @@ class TDbDriverStateTracker {
         std::shared_ptr<ICredentialsProviderFactory> credentialsProviderFactory
     );
     NThreading::TFuture<void> SendNotification(
-        TDbDriverState::ENotifyType type);
+        TDbDriverState::ENotifyType type,
+        TNotificationCbRunner cbRunner = {});
     void SetMetricRegistry(::NMonitoring::TMetricRegistry *sensorsRegistry);
 private:
     IInternalClient* DiscoveryClient_;
     std::unordered_map<TStateKey, std::weak_ptr<TDbDriverState>, TStateKeyHash> States_;
     std::shared_mutex Lock_;
+    std::condition_variable_any Notify_;
 };
 
 using TDbDriverStatePtr = TDbDriverState::TPtr;
diff --git a/src/client/impl/internal/grpc_connections/actions.h b/src/client/impl/internal/grpc_connections/actions.h
index 4c64a32d7ba..0f67b7cbd2d 100644
--- a/src/client/impl/internal/grpc_connections/actions.h
+++ b/src/client/impl/internal/grpc_connections/actions.h
@@ -14,6 +14,8 @@
 
 #include <grpcpp/alarm.h>
 
+#include <memory>
+
 namespace NYdb::inline V3 {
 
 using NYdbGrpc::IQueueClientContext;
@@ -28,6 +30,15 @@ using TResponseCb = std::function<void(TResponse*, TPlainStatus status)>;
 using TDeferredOperationCb = std::function<void(Ydb::Operations::Operation*, TPlainStatus status)>;
 using TDelayedCb = std::function<void(bool ok)>;
 
+inline TPlainStatus MakeClientStoppedStatus() {
+    return TPlainStatus(EStatus::CLIENT_CANCELLED, "Client is stopped");
+}
+
+class TQueueResponse : public IObjectInQueue {
+public:
+    virtual void Cancel() = 0;
+};
+
 template<typename TCb>
 class TGenericCbHolder {
 protected:
@@ -87,11 +98,16 @@ class TAlarmActionBase
             LocalContext_.reset();
         }
 
-        if (ok) {
-            OnAlarm();
-        } else {
-            OnError();
-        }
+        auto guardFactory = this->Context_
+            ? this->Context_->GetCallbackGuardFactory()
+            : NYdbGrpc::TQueueClientCallbackGuardFactory();
+        NYdbGrpc::RunQueueClientCallback(guardFactory, [&] {
+            if (ok) {
+                OnAlarm();
+            } else {
+                OnError();
+            }
+        });
 
         return false;
     }
@@ -112,7 +128,7 @@ class TAlarmActionBase
 template<typename TResponse>
 class TGRpcErrorResponse
     : public TGenericCbHolder<TResponseCb<TResponse>>
-    , public IObjectInQueue
+    , public TQueueResponse
 {
 public:
     TGRpcErrorResponse(
@@ -135,10 +151,17 @@ class TGRpcErrorResponse
             status.Issues.AddIssue(NYdb::NIssue::TIssue(msg));
         }
 
+        this->Context_.reset();
         this->UserResponseCb_(nullptr, status);
         delete this;
     }
 
+    void Cancel() override {
+        this->Context_.reset();
+        this->UserResponseCb_(nullptr, MakeClientStoppedStatus());
+        delete this;
+    }
+
 private:
     NYdbGrpc::TGrpcStatus GRpcStatus_;
     std::string Endpoint_;
@@ -147,7 +170,7 @@ class TGRpcErrorResponse
 template<typename TResponse>
 class TResult
     : public TGenericCbHolder<TResponseCb<TResponse>>
-    , public IObjectInQueue
+    , public TQueueResponse
 {
 public:
     TResult(
@@ -165,10 +188,17 @@ class TResult
         , Metadata_(std::move(metadata)) {}
 
     void Process(void*) override {
+        this->Context_.reset();
         this->UserResponseCb_(&Response_, TPlainStatus{GRpcStatus_, Endpoint_, std::move(Metadata_)});
         delete this;
     }
 
+    void Cancel() override {
+        this->Context_.reset();
+        this->UserResponseCb_(nullptr, MakeClientStoppedStatus());
+        delete this;
+    }
+
 private:
     TResponse Response_;
     NYdbGrpc::TGrpcStatus GRpcStatus_;
diff --git a/src/client/impl/internal/grpc_connections/grpc_connections.cpp b/src/client/impl/internal/grpc_connections/grpc_connections.cpp
index f739bf20aa6..7e56f5e31ec 100644
--- a/src/client/impl/internal/grpc_connections/grpc_connections.cpp
+++ b/src/client/impl/internal/grpc_connections/grpc_connections.cpp
@@ -5,10 +5,276 @@
 #include <src/client/impl/observability/constants.h>
 
 #include <string>
+#include <thread>
+#include <utility>
 
 
 namespace NYdb::inline V3 {
 
+namespace {
+    thread_local ui32 SdkResponseCallbackDepth = 0;
+
+    template<class TCallback>
+    void RunAfterCurrentSdkCallback(std::shared_ptr<TDriverStopState> stopState, TCallback&& callback) {
+        // A fresh detached thread that runs to completion and exits: deferring onto a single
+        // long-lived worker instead was tried and regressed (a permanently-blocked worker
+        // faults at process teardown). Teardown-from-callback is rare, so on-demand is fine.
+        try {
+            std::thread([stopState = std::move(stopState), callback = std::forward<TCallback>(callback)]() mutable {
+                // Wait until every in-flight SDK callback (including the one that scheduled
+                // us) has returned before touching the driver, so we never free it or join
+                // its threads from under a live callback frame.
+                if (stopState) {
+                    stopState->WaitCallbacksDrained();
+                }
+                callback();
+            }).detach();
+        } catch (...) {
+            Y_ABORT("Failed to defer YDB driver action from SDK callback thread");
+        }
+    }
+
+    TQueueClientCallbackGuardFactory MakeSdkCallbackGuardFactory(std::shared_ptr<TDriverStopState> stopState) {
+        return [stopState = std::move(stopState)] {
+            return std::make_unique<TSdkCallbackGuard>(stopState);
+        };
+    }
+
+    class TSdkQueueClientContext final : public NYdbGrpc::IQueueClientContext {
+    public:
+        TSdkQueueClientContext(IQueueClientContextPtr underlying, std::shared_ptr<TDriverStopState> stopState)
+            : Underlying_(std::move(underlying))
+            , StopState_(std::move(stopState))
+        {
+            Y_ABORT_UNLESS(Underlying_);
+            Y_ABORT_UNLESS(StopState_);
+        }
+
+        IQueueClientContextPtr CreateContext() override {
+            auto child = Underlying_->CreateContext();
+            if (!child) {
+                return nullptr;
+            }
+            return std::make_shared<TSdkQueueClientContext>(std::move(child), StopState_);
+        }
+
+        TQueueClientCallbackGuardFactory GetCallbackGuardFactory() override {
+            return MakeSdkCallbackGuardFactory(StopState_);
+        }
+
+        grpc::CompletionQueue* CompletionQueue() override {
+            return Underlying_->CompletionQueue();
+        }
+
+        bool IsCancelled() const override {
+            return Underlying_->IsCancelled();
+        }
+
+        bool Cancel() override {
+            return Underlying_->Cancel();
+        }
+
+        void SubscribeCancel(std::function<void()> callback) override {
+            Underlying_->SubscribeCancel(std::move(callback));
+        }
+
+    private:
+        IQueueClientContextPtr Underlying_;
+        std::shared_ptr<TDriverStopState> StopState_;
+    };
+}
+
+namespace {
+
+using TCredentialsWaitResult = TGRpcConnectionsImpl::TCredentialsWaitResult;
+
+TPlainStatus InitFailedStatus(const std::exception* e = nullptr) {
+    TStringBuilder message;
+    message << "Credentials provider initialization failed";
+    if (e) {
+        message << ". " << e->what();
+    }
+    return TPlainStatus(EStatus::CLIENT_UNAUTHENTICATED, message);
+}
+
+TPlainStatus InitCancelledStatus() {
+    return TPlainStatus(EStatus::CLIENT_CANCELLED, "Client is stopped");
+}
+
+TCredentialsWaitResult ReadyResult(const NThreading::TFuture<void>& future) {
+    try {
+        future.GetValue();
+        return {};
+    } catch (const std::exception& e) {
+        return InitFailedStatus(&e);
+    } catch (...) {
+        return InitFailedStatus();
+    }
+}
+
+bool ScheduledSuccessfully(const NThreading::TFuture<bool>& future) {
+    try {
+        return future.GetValue();
+    } catch (...) {
+        return false;
+    }
+}
+
+} // anonymous namespace
+
+bool TDriverStopState::TryEnterCallback() noexcept {
+    std::unique_lock lock(Mutex_);
+    if (Stopped_) {
+        return false;
+    }
+    ++InFlightCallbacks_;
+    return true;
+}
+
+void TDriverStopState::LeaveCallback() noexcept {
+    std::unique_lock lock(Mutex_);
+    Y_ABORT_UNLESS(InFlightCallbacks_ > 0);
+    if (--InFlightCallbacks_ == 0) {
+        Drained_.notify_all();
+    }
+}
+
+void TDriverStopState::WaitCallbacksDrained() {
+    std::unique_lock lock(Mutex_);
+    Drained_.wait(lock, [this] {
+        return InFlightCallbacks_ == 0;
+    });
+}
+
+void TDriverStopState::MarkStopped() noexcept {
+    std::unique_lock lock(Mutex_);
+    Stopped_ = true;
+    if (InFlightCallbacks_ == 0) {
+        Drained_.notify_all();
+    }
+}
+
+TSdkCallbackGuard::TSdkCallbackGuard(std::shared_ptr<TDriverStopState> stopState)
+    : StopState_(std::move(stopState))
+{
+    Entered_ = !StopState_ || StopState_->TryEnterCallback();
+    if (Entered_) {
+        ++SdkResponseCallbackDepth;
+    }
+}
+
+TSdkCallbackGuard::~TSdkCallbackGuard() {
+    if (!Entered_) {
+        return;
+    }
+
+    --SdkResponseCallbackDepth;
+
+    if (StopState_) {
+        StopState_->LeaveCallback();
+    }
+}
+
+bool TSdkCallbackGuard::IsEntered() const noexcept {
+    return Entered_;
+}
+
+NThreading::TFuture<void> TGRpcConnectionsImpl::CredentialsReadyToWaitFor(
+    const TDbDriverStatePtr& dbState,
+    const TRpcRequestSettings& requestSettings,
+    const IQueueClientContextPtr& context) const
+{
+    if (!requestSettings.UseAuth) {
+        return {};
+    }
+    auto ready = dbState->GetCredentialsReady();
+    return ready.HasValue() && !(context && context->IsCancelled())
+        ? NThreading::TFuture<void>{}
+        : ready;
+}
+
+void TGRpcConnectionsImpl::DeferUntilCredentialsReady(
+    const TRpcRequestSettings& requestSettings,
+    IQueueClientContextPtr& context,
+    NThreading::TFuture<void> credentialsReady,
+    TCredentialsCallback callback)
+{
+    auto cancelled = NThreading::NewPromise<void>();
+    if (!credentialsReady.IsReady()) {
+        TryCreateContext(context);
+        if (context) {
+            context->SubscribeCancel([cancelled]() mutable {
+                cancelled.TrySetValue();
+            });
+        } else {
+            cancelled.SetValue();
+        }
+    } else if (context && context->IsCancelled()) {
+        cancelled.SetValue();
+    }
+
+    auto scheduleContext = context;
+    auto schedule = [this, scheduleContext, stopState = StopState_](TDeadline deadline) {
+        TSdkCallbackGuard guard(stopState);
+        if (!guard.IsEntered()) {
+            return NThreading::MakeFuture(false);
+        }
+        const auto now = TDeadline::Clock::now();
+        const auto timeout = deadline.GetTimePoint() <= now
+            ? TDuration::Zero()
+            : TDuration::MicroSeconds(std::chrono::duration_cast<std::chrono::microseconds>(
+                deadline.GetTimePoint() - now).count());
+        return ScheduleFuture(timeout, scheduleContext);
+    };
+
+    NThreading::TFuture<TCredentialsWaitResult> wait;
+    if (credentialsReady.IsReady()) {
+        auto status = ReadyResult(credentialsReady);
+        wait = NThreading::MakeFuture(status || !cancelled.HasValue()
+            ? std::move(status)
+            : TCredentialsWaitResult(InitCancelledStatus()));
+    } else {
+        auto result = NThreading::NewPromise<TCredentialsWaitResult>();
+        wait = result.GetFuture();
+        credentialsReady.Subscribe([result](const NThreading::TFuture<void>& future) mutable {
+            result.TrySetValue(ReadyResult(future));
+        });
+        cancelled.GetFuture().Subscribe([result](const NThreading::TFuture<void>&) mutable {
+            result.TrySetValue(InitCancelledStatus());
+        });
+        if (requestSettings.Deadline != TDeadline::Max()) {
+            try {
+                schedule(requestSettings.Deadline).Subscribe(
+                    [result](const NThreading::TFuture<bool>& future) mutable {
+                        result.TrySetValue(ScheduledSuccessfully(future)
+                            ? TPlainStatus(EStatus::CLIENT_DEADLINE_EXCEEDED,
+                                "Request deadline exceeded while waiting for credentials")
+                            : InitCancelledStatus());
+                    });
+            } catch (...) {
+                result.TrySetValue(InitCancelledStatus());
+            }
+        }
+    }
+
+    wait.Subscribe([callback = std::move(callback), schedule = std::move(schedule)]
+        (const NThreading::TFuture<TCredentialsWaitResult>& future) mutable {
+        NThreading::TFuture<bool> scheduled;
+        try {
+            scheduled = schedule(TDeadline::Now());
+        } catch (...) {
+            callback(InitCancelledStatus());
+            return;
+        }
+        scheduled.Subscribe([callback = std::move(callback), status = future.GetValue()]
+            (const NThreading::TFuture<bool>& future) mutable {
+            callback(ScheduledSuccessfully(future)
+                ? std::move(status)
+                : TCredentialsWaitResult(InitCancelledStatus()));
+        });
+    });
+}
+
 bool IsTokenCorrect(const std::string& in) {
     for (char c : in) {
         if (!(IsAsciiAlnum(c) || IsAsciiPunct(c) || c == ' ')) {
@@ -20,7 +286,11 @@ bool IsTokenCorrect(const std::string& in) {
 
 std::string GetAuthInfo(TDbDriverStatePtr p) {
     try {
-        auto token = p->CredentialsProvider->GetAuthInfo();
+        auto credentialsProvider = p->GetCredentialsProvider();
+        if (!credentialsProvider) {
+            throw TAuthenticationError("Credentials provider is not initialized");
+        }
+        auto token = credentialsProvider->GetAuthInfo();
         if (!IsTokenCorrect(token)) {
             throw TAuthenticationError("token is incorrect, illegal characters found");
         }
@@ -43,8 +313,16 @@ std::string CreateSDKBuildInfo() {
     return std::string("ydb-cpp-sdk/") + GetSdkSemver();
 }
 
-std::string BuildFullBuildInfo(const IConnectionsParams& params) {
+std::string BuildFullBuildInfo(const IConnectionsParams& params, bool includeObservability) {
     auto result = CreateSDKBuildInfo();
+    if (includeObservability && params.GetTraceProvider()) {
+        result += " ydb-sdk-tracing/";
+        result += NObservability::kTracingChainVersion;
+    }
+    if (includeObservability && params.GetExternalMetricRegistry()) {
+        result += " ydb-sdk-metrics/";
+        result += NObservability::kMetricsChainVersion;
+    }
     auto extra = params.GetBuildInfoExtra();
     if (!extra.empty()) {
         result += ';';
@@ -62,13 +340,24 @@ class TScheduledObject : public TThrRefBase {
         return static_cast<TDerived*>(this);
     }
 
+    void Complete(bool ok) {
+        bool entered = true;
+        std::unique_ptr<NYdbGrpc::IQueueClientCallbackGuard> guard;
+        if (CallbackGuardFactory) {
+            guard = CallbackGuardFactory();
+            entered = !guard || guard->IsEntered();
+        }
+        Derived()->OnComplete(entered ? ok : false);
+    }
+
 protected:
     TScheduledObject() { }
 
     void Start(TDuration timeout, IQueueClientContextProvider* provider) {
+        CallbackGuardFactory = provider->GetCallbackGuardFactory();
         auto context = provider->CreateContext();
         if (!context) {
-            Derived()->OnComplete(false);
+            Complete(false);
             return;
         }
 
@@ -95,13 +384,14 @@ class TScheduledObject : public TThrRefBase {
             Context.reset();
         }
 
-        Derived()->OnComplete(ok);
+        Complete(ok);
     }
 
 private:
     std::mutex Mutex;
     IQueueClientContextPtr Context;
     grpc::Alarm Alarm;
+    TQueueClientCallbackGuardFactory CallbackGuardFactory;
 
 private:
     using TFixedEvent = NYdbGrpc::TQueueClientFixedEvent<TSelf>;
@@ -124,8 +414,8 @@ class TScheduledCallback : public TScheduledObject<TScheduledCallback> {
     }
 
     void OnComplete(bool ok) {
-        Callback(ok);
-        Callback = { };
+        auto callback = std::move(Callback);
+        callback(ok);
     }
 
 private:
@@ -160,6 +450,7 @@ class TScheduledFuture : public TScheduledObject<TScheduledFuture> {
 TGRpcConnectionsImpl::TGRpcConnectionsImpl(std::shared_ptr<IConnectionsParams> params)
     : MetricRegistryPtr_(nullptr)
     , ClientThreadsNum_(params->GetClientThreadsNum())
+    , StopState_(std::make_shared<TDriverStopState>())
     , DefaultDiscoveryEndpoint_(params->GetEndpoint())
     , SslCredentials_(params->GetSslCredentials())
     , DefaultDatabase_(params->GetDatabase())
@@ -187,7 +478,8 @@ TGRpcConnectionsImpl::TGRpcConnectionsImpl(std::shared_ptr<IConnectionsParams> p
 #endif
     , MetricRegistry_(params->GetExternalMetricRegistry())
     , TraceProvider_(params->GetTraceProvider())
-    , BuildInfo_(BuildFullBuildInfo(*params))
+    , BuildInfoWithoutObservability_(BuildFullBuildInfo(*params, false))
+    , BuildInfo_(BuildFullBuildInfo(*params, true))
     , NetworkThreadsNum_(params->GetNetworkThreadsNum())
     , UsePerChannelTcpConnection_(params->GetUsePerChannelTcpConnection())
     , GRpcClientLow_(NetworkThreadsNum_)
@@ -228,15 +520,41 @@ TGRpcConnectionsImpl::TGRpcConnectionsImpl(std::shared_ptr<IConnectionsParams> p
 }
 
 TGRpcConnectionsImpl::~TGRpcConnectionsImpl() {
-    GRpcClientLow_.Stop(true);
-    ResponseQueue_->Stop();
+    Stop(true);
+    StopState_->MarkStopped();
+    StopState_->WaitCallbacksDrained();
+}
+
+bool TGRpcConnectionsImpl::IsCurrentThreadInSdkCallback() noexcept {
+    return SdkResponseCallbackDepth != 0;
+}
+
+void TGRpcConnectionsImpl::DeferOrRunNow(std::shared_ptr<TDriverStopState> stopState, std::function<void()> action) {
+    if (!IsCurrentThreadInSdkCallback() && !NYdbGrpc::IsGRpcCompletionThread()) {
+        action();
+        return;
+    }
+
+    RunAfterCurrentSdkCallback(std::move(stopState), std::move(action));
+}
+
+void TGRpcConnectionsDeleter::operator()(TGRpcConnectionsImpl* connections) const noexcept {
+    if (!connections) {
+        return;
+    }
+
+    TGRpcConnectionsImpl::DeferOrRunNow(connections->StopState_, [connections] {
+        delete connections;
+    });
 }
 
 void TGRpcConnectionsImpl::AddPeriodicTask(TPeriodicCb&& cb, TDeadline::Duration period) {
     std::shared_ptr<IQueueClientContext> context;
     if (!TryCreateContext(context)) {
         NYdb::NIssue::TIssues issues;
-        cb(std::move(issues), EStatus::CLIENT_INTERNAL_ERROR);
+        RunGuarded(StopState_,
+            [&] { cb(std::move(issues), EStatus::CLIENT_INTERNAL_ERROR); },
+            [&] { cb(std::move(issues), EStatus::CLIENT_CANCELLED); });
     } else {
         auto action = MakeIntrusive<TPeriodicAction>(
             std::move(cb),
@@ -248,7 +566,12 @@ void TGRpcConnectionsImpl::AddPeriodicTask(TPeriodicCb&& cb, TDeadline::Duration
 }
 
 void TGRpcConnectionsImpl::PostToResponseQueue(std::function<void()>&& f) {
-    ResponseQueue_->Post(std::move(f));
+    auto stopState = StopState_;
+    ResponseQueue_->Post([f = std::move(f), stopState = std::move(stopState)]() mutable {
+        RunGuarded(stopState,
+            [&] { auto callback = std::move(f); callback(); },
+            [] {});
+    });
 }
 
 void TGRpcConnectionsImpl::ScheduleDelayedTask(TSimpleCb&& fn, TDeadline deadline) {
@@ -291,7 +614,7 @@ NThreading::TFuture<bool> TGRpcConnectionsImpl::ScheduleFuture(
 {
     IQueueClientContextProvider* provider = context.get();
     if (!provider) {
-        provider = &GRpcClientLow_;
+        provider = this;
     }
 
     return MakeIntrusive<TScheduledFuture>()
@@ -305,7 +628,7 @@ void TGRpcConnectionsImpl::ScheduleCallback(
 {
     IQueueClientContextProvider* provider = context.get();
     if (!provider) {
-        provider = &GRpcClientLow_;
+        provider = this;
     }
 
     return MakeIntrusive<TScheduledCallback>(std::move(callback))
@@ -328,7 +651,15 @@ TDbDriverStatePtr TGRpcConnectionsImpl::GetDriverState(
 }
 
 IQueueClientContextPtr TGRpcConnectionsImpl::CreateContext() {
-    return GRpcClientLow_.CreateContext();
+    auto context = GRpcClientLow_.CreateContext();
+    if (!context) {
+        return nullptr;
+    }
+    return std::make_shared<TSdkQueueClientContext>(std::move(context), StopState_);
+}
+
+TQueueClientCallbackGuardFactory TGRpcConnectionsImpl::GetCallbackGuardFactory() {
+    return MakeSdkCallbackGuardFactory(StopState_);
 }
 
 bool TGRpcConnectionsImpl::TryCreateContext(IQueueClientContextPtr& context) {
@@ -347,8 +678,22 @@ void TGRpcConnectionsImpl::WaitIdle() {
 }
 
 void TGRpcConnectionsImpl::Stop(bool wait) {
-    StateTracker_.SendNotification(TDbDriverState::ENotifyType::STOP).Wait();
+    auto stopState = StopState_;
+    StateTracker_.SendNotification(
+        TDbDriverState::ENotifyType::STOP,
+        [stopState = std::move(stopState)](TDbDriverState::TCb& cb) {
+            TSdkCallbackGuard guard(stopState);
+            if (guard.IsEntered()) {
+                return cb();
+            }
+
+            return NThreading::MakeFuture();
+        }).Wait();
     GRpcClientLow_.Stop(wait);
+    if (wait) {
+        StopResponseQueue();
+        StopState_->WaitCallbacksDrained();
+    }
 }
 
 void TGRpcConnectionsImpl::SetGrpcKeepAlive(NYdbGrpc::TGRpcClientConfig& config, const TDeadline::Duration& timeout, bool permitWithoutCalls) {
@@ -391,6 +736,7 @@ TAsyncListEndpointsResult TGRpcConnectionsImpl::GetEndpoints(TDbDriverStatePtr d
 
     TRpcRequestSettings rpcSettings;
     rpcSettings.Deadline = TDeadline::AfterDuration(GET_ENDPOINTS_TIMEOUT);
+    rpcSettings.IncludeObservabilityInBuildInfo = true;
 
     RunDeferred<Ydb::Discovery::V1::DiscoveryService, Ydb::Discovery::ListEndpointsRequest, Ydb::Discovery::ListEndpointsResponse>(
         std::move(request),
@@ -402,9 +748,14 @@ TAsyncListEndpointsResult TGRpcConnectionsImpl::GetEndpoints(TDbDriverStatePtr d
 
     std::weak_ptr<TDbDriverState> weakState = dbState;
 
-    return promise.GetFuture().Apply([this, weakState](NThreading::TFuture<TListEndpointsResult> future){
+    auto stopState = StopState_;
+    return promise.GetFuture().Apply([this, weakState, stopState = std::move(stopState)](NThreading::TFuture<TListEndpointsResult> future){
         auto strong = weakState.lock();
         auto result = future.ExtractValue();
+        TSdkCallbackGuard guard(stopState);
+        if (!guard.IsEntered()) {
+            return NThreading::MakeFuture<TListEndpointsResult>(std::move(result));
+        }
         if (strong && result.DiscoveryStatus.IsTransportError()) {
             strong->StatCollector.IncDiscoveryFailDueTransportError();
         }
@@ -492,8 +843,23 @@ const TLog& TGRpcConnectionsImpl::GetLog() const {
 }
 
 void TGRpcConnectionsImpl::EnqueueResponse(IObjectInQueue* action) {
-    ResponseQueue_->Post([action]() {
-        action->Process(nullptr);
+    auto stopState = StopState_;
+    ResponseQueue_->Post([action, stopState = std::move(stopState)]() {
+        RunGuarded(stopState,
+            [&] { action->Process(nullptr); },
+            [&] {
+                if (auto* response = dynamic_cast<TQueueResponse*>(action)) {
+                    response->Cancel();
+                } else {
+                    delete action;
+                }
+            });
+    });
+}
+
+void TGRpcConnectionsImpl::StopResponseQueue() {
+    std::call_once(ResponseQueueStopOnce_, [this] {
+        ResponseQueue_->Stop();
     });
 }
 
@@ -501,9 +867,12 @@ TCallMeta TGRpcConnectionsImpl::MakeCallMeta(const TRpcRequestSettings& requestS
     TCallMeta meta;
     meta.Timeout = requestSettings.Deadline;
 #ifndef YDB_GRPC_UNSECURE_AUTH
-    meta.CallCredentials = dbState->CallCredentials;
+    if (requestSettings.UseAuth) {
+        meta.CallCredentials = dbState->GetCallCredentials();
+    }
 #else
-    if (requestSettings.UseAuth && dbState->CredentialsProvider && dbState->CredentialsProvider->IsValid()) {
+    auto credentialsProvider = dbState->GetCredentialsProvider();
+    if (requestSettings.UseAuth && credentialsProvider && credentialsProvider->IsValid()) {
         meta.Aux.push_back({YDB_AUTH_TICKET_HEADER, GetAuthInfo(dbState)});
     }
 #endif
@@ -533,7 +902,9 @@ TCallMeta TGRpcConnectionsImpl::MakeCallMeta(const TRpcRequestSettings& requestS
 
     static const std::string clientPid = GetClientPIDHeaderValue();
 
-    meta.Aux.push_back({YDB_SDK_BUILD_INFO_HEADER, BuildInfo_});
+    meta.Aux.push_back({
+        YDB_SDK_BUILD_INFO_HEADER,
+        requestSettings.IncludeObservabilityInBuildInfo ? BuildInfo_ : BuildInfoWithoutObservability_});
     meta.Aux.push_back({YDB_CLIENT_PID, clientPid});
     meta.Aux.insert(meta.Aux.end(), requestSettings.Header.begin(), requestSettings.Header.end());
 
diff --git a/src/client/impl/internal/grpc_connections/grpc_connections.h b/src/client/impl/internal/grpc_connections/grpc_connections.h
index 329cec719e1..f31b8d4f54f 100644
--- a/src/client/impl/internal/grpc_connections/grpc_connections.h
+++ b/src/client/impl/internal/grpc_connections/grpc_connections.h
@@ -15,8 +15,17 @@
 
 #include <src/library/issue/yql_issue_message.h>
 
+#include <atomic>
+#include <condition_variable>
+#include <mutex>
 #include <optional>
 
+#if defined(_asan_enabled_)
+#define YDB_ASAN_SIZE_ATTRIBUTES __attribute__((nodebug))
+#else
+#define YDB_ASAN_SIZE_ATTRIBUTES
+#endif
+
 namespace NYdb::inline V3 {
 
 namespace NMetrics {
@@ -34,12 +43,54 @@ constexpr TDeadline::Duration GET_ENDPOINTS_TIMEOUT = std::chrono::seconds(10);
 using NYdbGrpc::TCallMeta;
 using NYdbGrpc::IQueueClientContextPtr;
 using NYdbGrpc::IQueueClientContextProvider;
+using NYdbGrpc::IQueueClientCallbackGuard;
+using NYdbGrpc::TQueueClientCallbackGuardFactory;
 
 class ICredentialsProvider;
 
 // Deferred callbacks
 using TDeferredResultCb = std::function<void(google::protobuf::Any*, TPlainStatus status)>;
 
+class TDriverStopState {
+public:
+    bool TryEnterCallback() noexcept;
+    void LeaveCallback() noexcept;
+
+    void WaitCallbacksDrained();
+    void MarkStopped() noexcept;
+
+private:
+    std::mutex Mutex_;
+    std::condition_variable Drained_;
+    ui64 InFlightCallbacks_ = 0;
+    bool Stopped_ = false;
+};
+
+class TSdkCallbackGuard final : public IQueueClientCallbackGuard {
+public:
+    explicit TSdkCallbackGuard(std::shared_ptr<TDriverStopState> stopState = {});
+    ~TSdkCallbackGuard();
+
+    bool IsEntered() const noexcept override;
+
+private:
+    std::shared_ptr<TDriverStopState> StopState_;
+    bool Entered_ = false;
+};
+
+// Runs onEntered() while the driver is not stopping, otherwise onStopped().
+// The single choke point behind every SDK-level guarded callback: it decides
+// run-vs-substitute and keeps the in-flight-callback drain counter correct.
+template<class TOnEntered, class TOnStopped>
+void RunGuarded(const std::shared_ptr<TDriverStopState>& stopState, TOnEntered&& onEntered, TOnStopped&& onStopped) {
+    TSdkCallbackGuard guard(stopState);
+    if (guard.IsEntered()) {
+        std::forward<TOnEntered>(onEntered)();
+    } else {
+        std::forward<TOnStopped>(onStopped)();
+    }
+}
+
 std::string GetAuthInfo(TDbDriverStatePtr p);
 std::string CreateSDKBuildInfo();
 
@@ -49,10 +100,20 @@ class TGRpcConnectionsImpl
 {
     friend class TDeferredAction;
     friend class TDriver;
+    friend struct TGRpcConnectionsDeleter;
 public:
     TGRpcConnectionsImpl(std::shared_ptr<IConnectionsParams> params);
     ~TGRpcConnectionsImpl();
 
+    static bool IsCurrentThreadInSdkCallback() noexcept;
+
+    // Runs action() now if the caller is on a normal thread, otherwise defers it to a
+    // fresh thread that first waits for all in-flight callbacks to drain. Used for
+    // Stop()/delete triggered from within a callback, where running inline would
+    // deadlock (self-join) or free the driver under a live callback frame.
+    static void DeferOrRunNow(std::shared_ptr<TDriverStopState> stopState, std::function<void()> action);
+
+public:
     void AddPeriodicTask(TPeriodicCb&& cb, TDeadline::Duration period) override;
     void PostToResponseQueue(std::function<void()>&& f) override;
 
@@ -79,6 +140,7 @@ class TGRpcConnectionsImpl
         const std::optional<std::shared_ptr<ICredentialsProviderFactory>>& credentialsProviderFactory
     );
     IQueueClientContextPtr CreateContext() override;
+    TQueueClientCallbackGuardFactory GetCallbackGuardFactory() override;
     bool TryCreateContext(IQueueClientContextPtr& context);
     void WaitIdle();
     void Stop(bool wait = false);
@@ -90,6 +152,20 @@ class TGRpcConnectionsImpl
 
     static void SetGrpcCompressionAlgorithm(NYdbGrpc::TGRpcClientConfig& config, EGrpcCompressionAlgorithm algorithm);
 
+    using TCredentialsWaitResult = std::optional<TPlainStatus>;
+    using TCredentialsCallback = std::function<void(TCredentialsWaitResult)>;
+
+    NThreading::TFuture<void> CredentialsReadyToWaitFor(
+        const TDbDriverStatePtr& dbState,
+        const TRpcRequestSettings& requestSettings,
+        const IQueueClientContextPtr& context) const;
+
+    void DeferUntilCredentialsReady(
+        const TRpcRequestSettings& requestSettings,
+        IQueueClientContextPtr& context,
+        NThreading::TFuture<void> credentialsReady,
+        TCredentialsCallback callback);
+
     template<typename TService>
     std::pair<std::unique_ptr<TServiceConnection<TService>>, TEndpointKey> GetServiceConnection(
         TDbDriverStatePtr dbState, const TEndpointKey& preferredEndpoint,
@@ -158,6 +234,43 @@ class TGRpcConnectionsImpl
             TRequest,
             TResponse>::TAsyncRequest;
 
+    template<typename TResponse>
+    void RunResponseCallback(
+        TResponseCb<TResponse>& callback,
+        TResponse* response,
+        TPlainStatus status,
+        const std::shared_ptr<TDriverStopState>& stopState)
+    {
+        RunGuarded(stopState,
+            [&] { callback(response, std::move(status)); },
+            [&] { callback(nullptr, MakeClientStoppedStatus()); });
+    }
+
+    template<typename TCallback, typename TProcessor>
+    void RunStreamCallback(
+        TCallback& callback,
+        TPlainStatus status,
+        TProcessor processor,
+        const std::shared_ptr<TDriverStopState>& stopState)
+    {
+        RunGuarded(stopState,
+            [&] { callback(std::move(status), std::move(processor)); },
+            [&] { callback(MakeClientStoppedStatus(), nullptr); });
+    }
+
+    template<typename TService, typename TCallback>
+    void RunServiceConnectionCallback(
+        TCallback& callback,
+        TPlainStatus status,
+        std::unique_ptr<TServiceConnection<TService>> serviceConnection,
+        TEndpointKey endpoint,
+        const std::shared_ptr<TDriverStopState>& stopState)
+    {
+        RunGuarded(stopState,
+            [&] { callback(std::move(status), std::move(serviceConnection), std::move(endpoint)); },
+            [&] { callback(MakeClientStoppedStatus(), std::unique_ptr<TServiceConnection<TService>>{nullptr}, TEndpointKey{}); });
+    }
+
     template<typename TRequest>
     class TRequestWrapper {
     public:
@@ -184,6 +297,7 @@ class TGRpcConnectionsImpl
         TRequestWrapper& operator=(TRequestWrapper&& other) = default;
 
         template<typename TService, typename TResponse>
+        YDB_ASAN_SIZE_ATTRIBUTES
         void DoRequest(
             std::unique_ptr<TServiceConnection<TService>>& serviceConnection,
             NYdbGrpc::TAdvancedResponseCallback<TResponse>&& responseCbLow,
@@ -205,6 +319,7 @@ class TGRpcConnectionsImpl
     };
 
     template<typename TService, typename TRequest, typename TResponse>
+    YDB_ASAN_SIZE_ATTRIBUTES
     void Run(
         TRequestWrapper<TRequest>&& requestWrapper,
         TResponseCb<TResponse>&& userResponseCb,
@@ -217,14 +332,33 @@ class TGRpcConnectionsImpl
         using TConnection = std::unique_ptr<TServiceConnection<TService>>;
         Y_ABORT_UNLESS(dbState);
 
+        if (auto ready = CredentialsReadyToWaitFor(dbState, requestSettings, context); ready.Initialized()) {
+            DeferUntilCredentialsReady(requestSettings, context, std::move(ready),
+                [this, requestWrapper = std::move(requestWrapper), userResponseCb = std::move(userResponseCb),
+                 rpc, dbState, requestSettings, context]
+                (std::optional<TPlainStatus> status) YDB_ASAN_SIZE_ATTRIBUTES mutable {
+                    if (status) {
+                        userResponseCb(nullptr, std::move(*status));
+                        return;
+                    }
+                    Run<TService, TRequest, TResponse>(
+                        std::move(requestWrapper),
+                        std::move(userResponseCb),
+                        rpc,
+                        std::move(dbState),
+                        requestSettings,
+                        std::move(context));
+                });
+            return;
+        }
+
         if (auto tlsValidationStatus = ValidateClientTlsCredentials(dbState)) {
-            userResponseCb(nullptr, std::move(*tlsValidationStatus));
+            RunResponseCallback<TResponse>(userResponseCb, nullptr, std::move(*tlsValidationStatus), StopState_);
             return;
         }
 
         if (!TryCreateContext(context)) {
-            TPlainStatus status(EStatus::CLIENT_CANCELLED, "Client is stopped");
-            userResponseCb(nullptr, TPlainStatus{status.Status, std::move(status.Issues)});
+            RunResponseCallback<TResponse>(userResponseCb, nullptr, MakeClientStoppedStatus(), StopState_);
             return;
         }
 
@@ -246,79 +380,80 @@ class TGRpcConnectionsImpl
         WithServiceConnection<TService>(
             [this, requestWrapper = std::move(requestWrapper), userResponseCb = std::move(userResponseCb), rpc, 
              requestSettings, context = std::move(context), dbState]
-            (TPlainStatus status, TConnection serviceConnection, TEndpointKey endpoint) mutable -> void {
-                if (!status.Ok()) {
-                    userResponseCb(
-                        nullptr,
-                        std::move(status));
-                    return;
-                }
-
-                Y_ABORT_UNLESS(serviceConnection != nullptr);
-
-                TCallMeta meta;
+                (TPlainStatus status, TConnection serviceConnection, TEndpointKey endpoint) mutable -> void {
+                    if (!status.Ok()) {
+                        context.reset();
+                        RunResponseCallback<TResponse>(userResponseCb, nullptr, std::move(status), StopState_);
+                        return;
+                    }
 
-                try {
-                    meta = MakeCallMeta(requestSettings, dbState);
-                } catch (const TYdbException& e) {
-                    userResponseCb(
-                        nullptr,
-                        TPlainStatus(dynamic_cast<const TAuthenticationError*>(&e) ? EStatus::CLIENT_UNAUTHENTICATED : EStatus::UNAVAILABLE, e.what())
-                    );
-                    return;
-                }
+                    Y_ABORT_UNLESS(serviceConnection != nullptr);
 
-                dbState->StatCollector.IncGRpcInFlight();
-                dbState->StatCollector.IncGRpcInFlightByHost(endpoint.GetEndpoint());
+                    TCallMeta meta;
 
-                NYdbGrpc::TAdvancedResponseCallback<TResponse> responseCbLow =
-                    [this, context, userResponseCb = std::move(userResponseCb), endpoint, dbState]
-                    (const grpc::ClientContext& ctx, TGrpcStatus&& grpcStatus, TResponse&& response) mutable -> void {
-                        dbState->StatCollector.DecGRpcInFlight();
-                        dbState->StatCollector.DecGRpcInFlightByHost(endpoint.GetEndpoint());
+                    try {
+                        meta = MakeCallMeta(requestSettings, dbState);
+                    } catch (const TYdbException& e) {
+                        context.reset();
+                        RunResponseCallback<TResponse>(
+                            userResponseCb,
+                            nullptr,
+                            TPlainStatus(dynamic_cast<const TAuthenticationError*>(&e) ? EStatus::CLIENT_UNAUTHENTICATED : EStatus::UNAVAILABLE, e.what()),
+                            StopState_);
+                        return;
+                    }
 
-                        if (NYdbGrpc::IsGRpcStatusGood(grpcStatus)) {
-                            std::multimap<std::string, std::string> metadata;
+                    dbState->StatCollector.IncGRpcInFlight();
+                    dbState->StatCollector.IncGRpcInFlightByHost(endpoint.GetEndpoint());
 
-                            for (const auto& [name, value] : ctx.GetServerInitialMetadata()) {
-                                metadata.emplace(
-                                    std::string(name.begin(), name.end()),
-                                    std::string(value.begin(), value.end()));
-                            }
-                            for (const auto& [name, value] : ctx.GetServerTrailingMetadata()) {
-                                metadata.emplace(
-                                    std::string(name.begin(), name.end()),
-                                    std::string(value.begin(), value.end()));
-                            }
+                    NYdbGrpc::TAdvancedResponseCallback<TResponse> responseCbLow =
+                        [this, context, userResponseCb = std::move(userResponseCb), endpoint, dbState]
+                        (const grpc::ClientContext& ctx, TGrpcStatus&& grpcStatus, TResponse&& response) mutable -> void {
+                            dbState->StatCollector.DecGRpcInFlight();
+                            dbState->StatCollector.DecGRpcInFlightByHost(endpoint.GetEndpoint());
 
-                            auto resp = new TResult<TResponse>(
-                                std::move(response),
-                                std::move(grpcStatus),
-                                std::move(userResponseCb),
-                                this,
-                                std::move(context),
-                                endpoint.GetEndpoint(),
-                                std::move(metadata));
+                            if (NYdbGrpc::IsGRpcStatusGood(grpcStatus)) {
+                                std::multimap<std::string, std::string> metadata;
 
-                            EnqueueResponse(resp);
-                        } else {
-                            dbState->StatCollector.IncReqFailDueTransportError();
-                            dbState->StatCollector.IncTransportErrorsByHost(endpoint.GetEndpoint());
+                                for (const auto& [name, value] : ctx.GetServerInitialMetadata()) {
+                                    metadata.emplace(
+                                        std::string(name.begin(), name.end()),
+                                        std::string(value.begin(), value.end()));
+                                }
+                                for (const auto& [name, value] : ctx.GetServerTrailingMetadata()) {
+                                    metadata.emplace(
+                                        std::string(name.begin(), name.end()),
+                                        std::string(value.begin(), value.end()));
+                                }
 
-                            auto resp = new TGRpcErrorResponse<TResponse>(
-                                std::move(grpcStatus),
-                                std::move(userResponseCb),
-                                this,
-                                std::move(context),
-                                endpoint.GetEndpoint());
+                                auto resp = new TResult<TResponse>(
+                                    std::move(response),
+                                    std::move(grpcStatus),
+                                    std::move(userResponseCb),
+                                    this,
+                                    std::move(context),
+                                    endpoint.GetEndpoint(),
+                                    std::move(metadata));
+
+                                EnqueueResponse(resp);
+                            } else {
+                                dbState->StatCollector.IncReqFailDueTransportError();
+                                dbState->StatCollector.IncTransportErrorsByHost(endpoint.GetEndpoint());
+
+                                auto resp = new TGRpcErrorResponse<TResponse>(
+                                    std::move(grpcStatus),
+                                    std::move(userResponseCb),
+                                    this,
+                                    std::move(context),
+                                    endpoint.GetEndpoint());
 
-                            dbState->EndpointPool.BanEndpoint(endpoint.GetEndpoint());
+                                dbState->EndpointPool.BanEndpoint(endpoint.GetEndpoint());
 
-                            EnqueueResponse(resp);
-                        }
-                    };
+                                EnqueueResponse(resp);
+                            }
+                        };
 
-                requestWrapper.DoRequest(serviceConnection, std::move(responseCbLow), rpc, meta, context.get());
+                    requestWrapper.DoRequest(serviceConnection, std::move(responseCbLow), rpc, meta, context.get());
             }, dbState, requestSettings.PreferredEndpoint, requestSettings.EndpointPolicy);
     }
 
@@ -334,8 +469,7 @@ class TGRpcConnectionsImpl
         std::shared_ptr<IQueueClientContext> context = nullptr)
     {
         if (!TryCreateContext(context)) {
-            TPlainStatus status(EStatus::CLIENT_CANCELLED, "Client is stopped");
-            userResponseCb(nullptr, status);
+            userResponseCb(nullptr, MakeClientStoppedStatus());
             return;
         }
 
@@ -360,10 +494,12 @@ class TGRpcConnectionsImpl
                 } else {
                     NYdb::NIssue::TIssues opIssues;
                     NYdb::NIssue::IssuesFromMessage(operation->issues(), opIssues);
+                    context.reset();
                     userResponseCb(operation, TPlainStatus{static_cast<EStatus>(operation->status()), std::move(opIssues),
                         status.Endpoint, std::move(status.Metadata)});
                 }
             } else {
+                context.reset();
                 userResponseCb(nullptr, status);
             }
         };
@@ -441,6 +577,7 @@ class TGRpcConnectionsImpl
             TResponse>::TAsyncRequest;
 
     template<class TService, class TRequest, class TResponse, class TCallback>
+    YDB_ASAN_SIZE_ATTRIBUTES
     void StartReadStream(
         const TRequest& request,
         TCallback responseCb,
@@ -453,20 +590,40 @@ class TGRpcConnectionsImpl
         using TConnection = std::unique_ptr<TServiceConnection<TService>>;
         using TProcessor = typename NYdbGrpc::IStreamRequestReadProcessor<TResponse>::TPtr;
 
+        if (auto ready = CredentialsReadyToWaitFor(dbState, requestSettings, context); ready.Initialized()) {
+            DeferUntilCredentialsReady(requestSettings, context, std::move(ready),
+                [this, request, responseCb = std::move(responseCb), rpc, dbState, requestSettings, context]
+                (std::optional<TPlainStatus> status) YDB_ASAN_SIZE_ATTRIBUTES mutable {
+                    if (status) {
+                        responseCb(std::move(*status), nullptr);
+                        return;
+                    }
+                    StartReadStream<TService, TRequest, TResponse>(
+                        request,
+                        std::move(responseCb),
+                        rpc,
+                        std::move(dbState),
+                        requestSettings,
+                        std::move(context));
+                });
+            return;
+        }
+
         if (auto tlsValidationStatus = ValidateClientTlsCredentials(dbState)) {
-            responseCb(std::move(*tlsValidationStatus), nullptr);
+            RunStreamCallback(responseCb, std::move(*tlsValidationStatus), nullptr, StopState_);
             return;
         }
 
         if (!TryCreateContext(context)) {
-            responseCb(TPlainStatus(EStatus::CLIENT_CANCELLED, "Client is stopped"), nullptr);
+            RunStreamCallback(responseCb, MakeClientStoppedStatus(), nullptr, StopState_);
             return;
         }
 
         WithServiceConnection<TService>(
             [this, request, responseCb = std::move(responseCb), rpc, requestSettings, context = std::move(context), dbState](TPlainStatus status, TConnection serviceConnection, TEndpointKey endpoint) mutable {
                 if (!status.Ok()) {
-                    responseCb(std::move(status), nullptr);
+                    context.reset();
+                    RunStreamCallback(responseCb, std::move(status), nullptr, StopState_);
                     return;
                 }
 
@@ -476,17 +633,19 @@ class TGRpcConnectionsImpl
                 try {
                     meta = MakeCallMeta(requestSettings, dbState);
                 } catch (const TYdbException& e) {
-                    responseCb(
+                    context.reset();
+                    RunStreamCallback(
+                        responseCb,
                         TPlainStatus(dynamic_cast<const TAuthenticationError*>(&e) ? EStatus::CLIENT_UNAUTHENTICATED : EStatus::UNAVAILABLE, e.what()),
-                        nullptr
-                    );
+                        nullptr,
+                        StopState_);
                     return;
                 }
 
                 dbState->StatCollector.IncGRpcInFlight();
                 dbState->StatCollector.IncGRpcInFlightByHost(endpoint.GetEndpoint());
 
-                auto lowCallback = [responseCb = std::move(responseCb), dbState, endpoint]
+                auto lowCallback = [responseCb = std::move(responseCb), dbState, endpoint, stopState = StopState_]
                     (TGrpcStatus grpcStatus, TProcessor processor) mutable {
                         dbState->StatCollector.DecGRpcInFlight();
                         dbState->StatCollector.DecGRpcInFlightByHost(endpoint.GetEndpoint());
@@ -500,7 +659,9 @@ class TGRpcConnectionsImpl
                             };
                             processor->AddFinishedCallback(std::move(finishedCallback));
                             TPlainStatus status(std::move(grpcStatus), endpoint.GetEndpoint(), {});
-                            responseCb(std::move(status), std::move(processor));
+                            RunGuarded(stopState,
+                                [&] { responseCb(std::move(status), std::move(processor)); },
+                                [&] { responseCb(MakeClientStoppedStatus(), nullptr); });
                         } else {
                             dbState->StatCollector.IncReqFailDueTransportError();
                             dbState->StatCollector.IncTransportErrorsByHost(endpoint.GetEndpoint());
@@ -508,7 +669,9 @@ class TGRpcConnectionsImpl
                                 dbState->EndpointPool.BanEndpoint(endpoint.GetEndpoint());
                             }
                             TPlainStatus status(std::move(grpcStatus), endpoint.GetEndpoint(), {});
-                            responseCb(std::move(status), nullptr);
+                            RunGuarded(stopState,
+                                [&] { responseCb(std::move(status), nullptr); },
+                                [&] { responseCb(MakeClientStoppedStatus(), nullptr); });
                         }
                     };
 
@@ -522,6 +685,7 @@ class TGRpcConnectionsImpl
     }
 
     template<class TService, class TRequest, class TResponse, class TCallback>
+    YDB_ASAN_SIZE_ATTRIBUTES
     void StartBidirectionalStream(
         TCallback connectedCallback,
         TStreamRpc<TService, TRequest, TResponse, NYdbGrpc::TStreamRequestReadWriteProcessor> rpc,
@@ -533,71 +697,96 @@ class TGRpcConnectionsImpl
         using TConnection = std::unique_ptr<TServiceConnection<TService>>;
         using TProcessor = typename NYdbGrpc::IStreamRequestReadWriteProcessor<TRequest, TResponse>::TPtr;
 
+        if (auto ready = CredentialsReadyToWaitFor(dbState, requestSettings, context); ready.Initialized()) {
+            DeferUntilCredentialsReady(requestSettings, context, std::move(ready),
+                [this, connectedCallback = std::move(connectedCallback), rpc, dbState, requestSettings, context]
+                (std::optional<TPlainStatus> status) YDB_ASAN_SIZE_ATTRIBUTES mutable {
+                    if (status) {
+                        connectedCallback(std::move(*status), nullptr);
+                        return;
+                    }
+                    StartBidirectionalStream<TService, TRequest, TResponse>(
+                        std::move(connectedCallback),
+                        rpc,
+                        std::move(dbState),
+                        requestSettings,
+                        std::move(context));
+                });
+            return;
+        }
+
         if (auto tlsValidationStatus = ValidateClientTlsCredentials(dbState)) {
-            connectedCallback(std::move(*tlsValidationStatus), nullptr);
+            RunStreamCallback(connectedCallback, std::move(*tlsValidationStatus), nullptr, StopState_);
             return;
         }
 
         if (!TryCreateContext(context)) {
-            connectedCallback(TPlainStatus(EStatus::CLIENT_CANCELLED, "Client is stopped"), nullptr);
+            RunStreamCallback(connectedCallback, MakeClientStoppedStatus(), nullptr, StopState_);
             return;
         }
 
         WithServiceConnection<TService>(
             [this, connectedCallback = std::move(connectedCallback), rpc, requestSettings, context = std::move(context), dbState]
-            (TPlainStatus status, TConnection serviceConnection, TEndpointKey endpoint) mutable {
-                if (!status.Ok()) {
-                    connectedCallback(std::move(status), nullptr);
-                    return;
-                }
-
-                Y_ABORT_UNLESS(serviceConnection != nullptr);
-
-                TCallMeta meta;
-                try {
-                    meta = MakeCallMeta(requestSettings, dbState);
-                } catch (const TYdbException& e) {
-                    connectedCallback(
-                        TPlainStatus(dynamic_cast<const TAuthenticationError*>(&e) ? EStatus::CLIENT_UNAUTHENTICATED : EStatus::UNAVAILABLE, e.what()),
-                        nullptr
-                    );
-                    return;
-                }
-
-                dbState->StatCollector.IncGRpcInFlight();
-                dbState->StatCollector.IncGRpcInFlightByHost(endpoint.GetEndpoint());
+                (TPlainStatus status, TConnection serviceConnection, TEndpointKey endpoint) mutable {
+                    if (!status.Ok()) {
+                        context.reset();
+                        RunStreamCallback(connectedCallback, std::move(status), nullptr, StopState_);
+                        return;
+                    }
 
-                auto lowCallback = [connectedCallback = std::move(connectedCallback), dbState, endpoint]
-                    (TGrpcStatus grpcStatus, TProcessor processor) {
-                        dbState->StatCollector.DecGRpcInFlight();
-                        dbState->StatCollector.DecGRpcInFlightByHost(endpoint.GetEndpoint());
+                    Y_ABORT_UNLESS(serviceConnection != nullptr);
+
+                    TCallMeta meta;
+                    try {
+                        meta = MakeCallMeta(requestSettings, dbState);
+                    } catch (const TYdbException& e) {
+                        context.reset();
+                        RunStreamCallback(
+                            connectedCallback,
+                            TPlainStatus(dynamic_cast<const TAuthenticationError*>(&e) ? EStatus::CLIENT_UNAUTHENTICATED : EStatus::UNAVAILABLE, e.what()),
+                            nullptr,
+                            StopState_);
+                        return;
+                    }
 
-                        if (grpcStatus.Ok()) {
-                            Y_ABORT_UNLESS(processor);
-                            auto finishedCallback = [dbState, endpoint] (TGrpcStatus grpcStatus) {
-                                if (!grpcStatus.Ok() && grpcStatus.GRpcStatusCode != grpc::StatusCode::CANCELLED) {
+                    dbState->StatCollector.IncGRpcInFlight();
+                    dbState->StatCollector.IncGRpcInFlightByHost(endpoint.GetEndpoint());
+
+                    auto lowCallback = [connectedCallback = std::move(connectedCallback), dbState, endpoint, stopState = StopState_]
+                        (TGrpcStatus grpcStatus, TProcessor processor) {
+                            dbState->StatCollector.DecGRpcInFlight();
+                            dbState->StatCollector.DecGRpcInFlightByHost(endpoint.GetEndpoint());
+
+                            if (grpcStatus.Ok()) {
+                                Y_ABORT_UNLESS(processor);
+                                auto finishedCallback = [dbState, endpoint] (TGrpcStatus grpcStatus) {
+                                    if (!grpcStatus.Ok() && grpcStatus.GRpcStatusCode != grpc::StatusCode::CANCELLED) {
+                                        dbState->EndpointPool.BanEndpoint(endpoint.GetEndpoint());
+                                    }
+                                };
+                                processor->AddFinishedCallback(std::move(finishedCallback));
+                                TPlainStatus status(std::move(grpcStatus), endpoint.GetEndpoint(), {});
+                                RunGuarded(stopState,
+                                    [&] { connectedCallback(std::move(status), std::move(processor)); },
+                                    [&] { connectedCallback(MakeClientStoppedStatus(), nullptr); });
+                            } else {
+                                dbState->StatCollector.IncReqFailDueTransportError();
+                                dbState->StatCollector.IncTransportErrorsByHost(endpoint.GetEndpoint());
+                                if (grpcStatus.GRpcStatusCode != grpc::StatusCode::CANCELLED) {
                                     dbState->EndpointPool.BanEndpoint(endpoint.GetEndpoint());
                                 }
-                            };
-                            processor->AddFinishedCallback(std::move(finishedCallback));
-                            TPlainStatus status(std::move(grpcStatus), endpoint.GetEndpoint(), {});
-                            connectedCallback(std::move(status), std::move(processor));
-                        } else {
-                            dbState->StatCollector.IncReqFailDueTransportError();
-                            dbState->StatCollector.IncTransportErrorsByHost(endpoint.GetEndpoint());
-                            if (grpcStatus.GRpcStatusCode != grpc::StatusCode::CANCELLED) {
-                                dbState->EndpointPool.BanEndpoint(endpoint.GetEndpoint());
+                                TPlainStatus status(std::move(grpcStatus), endpoint.GetEndpoint(), {});
+                                RunGuarded(stopState,
+                                    [&] { connectedCallback(std::move(status), nullptr); },
+                                    [&] { connectedCallback(MakeClientStoppedStatus(), nullptr); });
                             }
-                            TPlainStatus status(std::move(grpcStatus), endpoint.GetEndpoint(), {});
-                            connectedCallback(std::move(status), nullptr);
-                        }
-                    };
+                        };
 
-                serviceConnection->template DoStreamRequest<TRequest, TResponse>(
-                    std::move(lowCallback),
-                    std::move(rpc),
-                    std::move(meta),
-                    context.get());
+                    serviceConnection->template DoStreamRequest<TRequest, TResponse>(
+                        std::move(lowCallback),
+                        std::move(rpc),
+                        std::move(meta),
+                        context.get());
             }, dbState, requestSettings.PreferredEndpoint, requestSettings.EndpointPolicy);
     }
 
@@ -640,6 +829,7 @@ class TGRpcConnectionsImpl
     }
 
     template <typename TService, typename TCallback>
+    YDB_ASAN_SIZE_ATTRIBUTES
     void WithServiceConnection(TCallback callback, TDbDriverStatePtr dbState,
         const TEndpointKey& preferredEndpoint, TRpcRequestSettings::TEndpointPolicy endpointPolicy)
     {
@@ -653,11 +843,12 @@ class TGRpcConnectionsImpl
                 errString << "No endpoint for database " << dbState->Database;
                 errString << ", cluster endpoint " << dbState->DiscoveryEndpoint;
                 dbState->StatCollector.IncReqFailNoEndpoint();
-                callback(
+                RunServiceConnectionCallback<TService>(
+                    callback,
                     TPlainStatus(EStatus::UNAVAILABLE, errString.Str()),
                     TConnection{nullptr},
-                    TEndpointKey{ });
-
+                    TEndpointKey{},
+                    StopState_);
             } else if (dbState->DiscoveryMode == EDiscoveryMode::Sync) {
                 TStringStream errString;
                 errString << "Endpoint list is empty for database " << dbState->Database;
@@ -673,14 +864,16 @@ class TGRpcConnectionsImpl
                     errString << " while last discovery returned success status. Unable to continue processing.";
                     discoveryStatus = TPlainStatus(EStatus::UNAVAILABLE, errString.Str());
                 } else {
-                    errString <<".";
+                    errString << ".";
                     discoveryStatus.Issues.AddIssues({NYdb::NIssue::TIssue(errString.Str())});
                 }
                 dbState->StatCollector.IncReqFailNoEndpoint();
-                callback(
-                    discoveryStatus,
+                RunServiceConnectionCallback<TService>(
+                    callback,
+                    std::move(discoveryStatus),
                     TConnection{nullptr},
-                    TEndpointKey{ });
+                    TEndpointKey{},
+                    StopState_);
             } else {
                 int64_t newVal;
                 int64_t val;
@@ -688,48 +881,58 @@ class TGRpcConnectionsImpl
                     val = QueuedRequests_.load();
                     if (val >= MaxQueuedRequests_) {
                         dbState->StatCollector.IncReqFailQueueOverflow();
-                        callback(
+                        RunServiceConnectionCallback<TService>(
+                            callback,
                             TPlainStatus(EStatus::CLIENT_LIMITS_REACHED, "Requests queue limit reached"),
                             TConnection{nullptr},
-                            TEndpointKey{ });
+                            TEndpointKey{},
+                            StopState_);
                         return;
                     }
                     newVal = val + 1;
                 } while (!QueuedRequests_.compare_exchange_weak(val, newVal));
 
-                // UpdateAsync guarantee one update in progress for state
+                // UpdateAsync guarantees one update in progress for state.
                 auto asyncResult = dbState->EndpointPool.UpdateAsync();
                 const bool needUpdateChannels = asyncResult.second;
-                asyncResult.first.Subscribe([this, callback = std::move(callback), needUpdateChannels, dbState, preferredEndpoint, endpointPolicy]
+                auto stopState = StopState_;
+                asyncResult.first.Subscribe([this, callback = std::move(callback), needUpdateChannels, dbState, preferredEndpoint, endpointPolicy, stopState = std::move(stopState)]
                     (const NThreading::TFuture<TEndpointUpdateResult>& future) mutable {
                     --QueuedRequests_;
-                    const auto& updateResult = future.GetValue();
-                    if (needUpdateChannels) {
+                    RunGuarded(stopState,
+                        [&] {
+                            const auto& updateResult = future.GetValue();
+                            if (needUpdateChannels) {
 #ifndef YDB_GRPC_BYPASS_CHANNEL_POOL
-                        DeleteChannels(updateResult.Removed);
+                                DeleteChannels(updateResult.Removed);
 #endif
-                    }
-                    auto discoveryStatus = updateResult.DiscoveryStatus;
-                    if (discoveryStatus.Status == EStatus::SUCCESS) {
-                        WithServiceConnection<TService>(std::move(callback), dbState, preferredEndpoint, endpointPolicy);
-                    } else {
-                        callback(
-                            TPlainStatus(discoveryStatus.Status, std::move(discoveryStatus.Issues)),
-                            TConnection{nullptr},
-                            TEndpointKey{ });
-                    }
+                            }
+                            auto discoveryStatus = updateResult.DiscoveryStatus;
+                            if (discoveryStatus.Status == EStatus::SUCCESS) {
+                                WithServiceConnection<TService>(std::move(callback), dbState, preferredEndpoint, endpointPolicy);
+                            } else {
+                                callback(
+                                    TPlainStatus(discoveryStatus.Status, std::move(discoveryStatus.Issues)),
+                                    TConnection{nullptr},
+                                    TEndpointKey{});
+                            }
+                        },
+                        [&] { callback(MakeClientStoppedStatus(), TConnection{nullptr}, TEndpointKey{}); });
                 });
             }
             return;
         }
 
-        callback(
-            TPlainStatus{ },
+        RunServiceConnectionCallback<TService>(
+            callback,
+            TPlainStatus{},
             std::move(serviceConnection),
-            std::move(endpoint));
+            std::move(endpoint),
+            StopState_);
     }
 
     void EnqueueResponse(IObjectInQueue* action);
+    void StopResponseQueue();
 
 private:
     TCallMeta MakeCallMeta(const TRpcRequestSettings& requestSettings, const TDbDriverStatePtr& dbState) const;
@@ -739,6 +942,8 @@ class TGRpcConnectionsImpl
 
     const std::size_t ClientThreadsNum_;
     std::shared_ptr<IExecutor> ResponseQueue_;
+    std::once_flag ResponseQueueStopOnce_;
+    std::shared_ptr<TDriverStopState> StopState_;
 
     const std::string DefaultDiscoveryEndpoint_;
     const TSslCredentials SslCredentials_;
@@ -776,6 +981,7 @@ class TGRpcConnectionsImpl
 
     IDiscoveryMutatorApi::TMutatorCb DiscoveryMutatorCb;
 
+    const std::string BuildInfoWithoutObservability_;
     const std::string BuildInfo_;
 
     const std::size_t NetworkThreadsNum_;
@@ -785,4 +991,10 @@ class TGRpcConnectionsImpl
     TLog Log;
 };
 
+struct TGRpcConnectionsDeleter {
+    void operator()(TGRpcConnectionsImpl* connections) const noexcept;
+};
+
 } // namespace NYdb
+
+#undef YDB_ASAN_SIZE_ATTRIBUTES
diff --git a/src/client/impl/internal/rpc_request_settings/settings.h b/src/client/impl/internal/rpc_request_settings/settings.h
index a63ddf65329..58ee117bf3f 100644
--- a/src/client/impl/internal/rpc_request_settings/settings.h
+++ b/src/client/impl/internal/rpc_request_settings/settings.h
@@ -18,6 +18,7 @@ struct TRpcRequestSettings {
         UseDiscoveryEndpoint            // Use single discovery endpoint
     } EndpointPolicy = TEndpointPolicy::UsePreferredEndpointOptionally;
     bool UseAuth = true;
+    bool IncludeObservabilityInBuildInfo = false;
     NYdb::TDeadline Deadline = NYdb::TDeadline::Max();
     std::string TraceParent;
 
diff --git a/src/client/impl/observability/constants.h b/src/client/impl/observability/constants.h
index 0a16fb3bc83..26a4a99c936 100644
--- a/src/client/impl/observability/constants.h
+++ b/src/client/impl/observability/constants.h
@@ -11,6 +11,11 @@
 
 namespace NYdb::inline V3::NObservability {
 
+// SDK build-info chain versions. Bump these when the corresponding
+// observability integration changes incompatibly.
+inline constexpr std::string_view kTracingChainVersion = "0.1.0";
+inline constexpr std::string_view kMetricsChainVersion = "0.1.0";
+
 // ---------------------------------------------------------------------------
 // OTel Semconv attribute keys shared between span attributes and metric labels.
 // ---------------------------------------------------------------------------
diff --git a/src/client/impl/observability/metric_buffer.cpp b/src/client/impl/observability/metric_buffer.cpp
index 6c2c5ab2ca8..8ed1ca6068a 100644
--- a/src/client/impl/observability/metric_buffer.cpp
+++ b/src/client/impl/observability/metric_buffer.cpp
@@ -59,7 +59,7 @@ class TMetricBufferCore : public std::enable_shared_from_this<TMetricBufferCore>
         std::mutex Mutex;
         std::vector<std::uint64_t> CounterDeltas;
         std::vector<std::vector<double>> HistogramSamples;
-        std::atomic<std::size_t> PendingOps{0};
+        std::size_t PendingOps = 0;
         std::atomic<bool> Active{true}; // becomes false when owning thread exits
     };
 
@@ -142,23 +142,26 @@ class TMetricBufferCore : public std::enable_shared_from_this<TMetricBufferCore>
             return;
         }
         TThreadState& state = AcquireThreadState();
-        if (ShouldDropUpdate(state, 1)) {
-            ReportDroppedCounter(delta);
-            TriggerFlush(EFlushTrigger::Threshold);
-            return;
-        }
+        bool dropped = false;
         bool overThreshold = false;
         {
             std::lock_guard<std::mutex> lock(state.Mutex);
-            if (state.CounterDeltas.size() <= handle) {
-                state.CounterDeltas.resize(handle + 1, 0);
+            if (ShouldDropUpdate(state.PendingOps, 1)) {
+                dropped = true;
+            } else {
+                if (state.CounterDeltas.size() <= handle) {
+                    state.CounterDeltas.resize(handle + 1, 0);
+                }
+                state.CounterDeltas[handle] += delta;
+                ++state.PendingOps;
+                overThreshold = Settings_.ThreadPendingThreshold != 0
+                    && state.PendingOps >= Settings_.ThreadPendingThreshold;
             }
-            state.CounterDeltas[handle] += delta;
         }
-        const auto pending = state.PendingOps.fetch_add(1, std::memory_order_relaxed) + 1;
-        if (Settings_.ThreadPendingThreshold != 0
-            && pending >= Settings_.ThreadPendingThreshold) {
-            overThreshold = true;
+        if (dropped) {
+            ReportDroppedCounter(delta);
+            TriggerFlush(EFlushTrigger::Threshold);
+            return;
         }
         if (overThreshold) {
             TriggerFlush(EFlushTrigger::Threshold);
@@ -180,27 +183,30 @@ class TMetricBufferCore : public std::enable_shared_from_this<TMetricBufferCore>
             return;
         }
         TThreadState& state = AcquireThreadState();
-        if (ShouldDropUpdate(state, 1)) {
-            ReportDroppedHistogram(1);
-            TriggerFlush(EFlushTrigger::Threshold);
-            return;
-        }
+        bool dropped = false;
         bool overThreshold = false;
         {
             std::lock_guard<std::mutex> lock(state.Mutex);
-            if (state.HistogramSamples.size() <= handle) {
-                state.HistogramSamples.resize(handle + 1);
-            }
-            auto& bucket = state.HistogramSamples[handle];
-            if (bucket.capacity() == 0 && Settings_.HistogramReserveSamples > 0) {
-                bucket.reserve(Settings_.HistogramReserveSamples);
+            if (ShouldDropUpdate(state.PendingOps, 1)) {
+                dropped = true;
+            } else {
+                if (state.HistogramSamples.size() <= handle) {
+                    state.HistogramSamples.resize(handle + 1);
+                }
+                auto& bucket = state.HistogramSamples[handle];
+                if (bucket.capacity() == 0 && Settings_.HistogramReserveSamples > 0) {
+                    bucket.reserve(Settings_.HistogramReserveSamples);
+                }
+                bucket.push_back(value);
+                ++state.PendingOps;
+                overThreshold = Settings_.ThreadPendingThreshold != 0
+                    && state.PendingOps >= Settings_.ThreadPendingThreshold;
             }
-            bucket.push_back(value);
         }
-        const auto pending = state.PendingOps.fetch_add(1, std::memory_order_relaxed) + 1;
-        if (Settings_.ThreadPendingThreshold != 0
-            && pending >= Settings_.ThreadPendingThreshold) {
-            overThreshold = true;
+        if (dropped) {
+            ReportDroppedHistogram(1);
+            TriggerFlush(EFlushTrigger::Threshold);
+            return;
         }
         if (overThreshold) {
             TriggerFlush(EFlushTrigger::Threshold);
@@ -225,24 +231,27 @@ class TMetricBufferCore : public std::enable_shared_from_this<TMetricBufferCore>
             return;
         }
         TThreadState& state = AcquireThreadState();
-        if (ShouldDropUpdate(state, values.size())) {
-            ReportDroppedHistogram(values.size());
-            TriggerFlush(EFlushTrigger::Threshold);
-            return;
-        }
+        bool dropped = false;
         bool overThreshold = false;
         {
             std::lock_guard<std::mutex> lock(state.Mutex);
-            if (state.HistogramSamples.size() <= handle) {
-                state.HistogramSamples.resize(handle + 1);
+            if (ShouldDropUpdate(state.PendingOps, values.size())) {
+                dropped = true;
+            } else {
+                if (state.HistogramSamples.size() <= handle) {
+                    state.HistogramSamples.resize(handle + 1);
+                }
+                auto& bucket = state.HistogramSamples[handle];
+                bucket.insert(bucket.end(), values.begin(), values.end());
+                state.PendingOps += values.size();
+                overThreshold = Settings_.ThreadPendingThreshold != 0
+                    && state.PendingOps >= Settings_.ThreadPendingThreshold;
             }
-            auto& bucket = state.HistogramSamples[handle];
-            bucket.insert(bucket.end(), values.begin(), values.end());
         }
-        const auto pending = state.PendingOps.fetch_add(values.size(), std::memory_order_relaxed) + values.size();
-        if (Settings_.ThreadPendingThreshold != 0
-            && pending >= Settings_.ThreadPendingThreshold) {
-            overThreshold = true;
+        if (dropped) {
+            ReportDroppedHistogram(values.size());
+            TriggerFlush(EFlushTrigger::Threshold);
+            return;
         }
         if (overThreshold) {
             TriggerFlush(EFlushTrigger::Threshold);
@@ -320,11 +329,10 @@ class TMetricBufferCore : public std::enable_shared_from_this<TMetricBufferCore>
         Wakeup_.notify_all();
     }
 
-    bool ShouldDropUpdate(const TThreadState& state, std::size_t incomingOps) const noexcept {
+    bool ShouldDropUpdate(std::size_t pending, std::size_t incomingOps) const noexcept {
         if (Settings_.ThreadPendingLimit == 0) {
             return false;
         }
-        const std::size_t pending = state.PendingOps.load(std::memory_order_relaxed);
         if (pending >= Settings_.ThreadPendingLimit) {
             return true;
         }
@@ -460,7 +468,7 @@ class TMetricBufferCore : public std::enable_shared_from_this<TMetricBufferCore>
             for (const auto& samples : state->HistogramSamples) {
                 remainingOps += samples.size();
             }
-            state->PendingOps.store(remainingOps, std::memory_order_release);
+            state->PendingOps = remainingOps;
         }
 
         std::uint64_t addCalls = 0;
diff --git a/src/client/operation/operation.cpp b/src/client/operation/operation.cpp
index e1354864242..eb7c486fbf5 100644
--- a/src/client/operation/operation.cpp
+++ b/src/client/operation/operation.cpp
@@ -97,4 +97,10 @@ NThreading::TFuture<TOperationsList<NTable::TAnalyzeOperation>> TOperationClient
     return List<NTable::TAnalyzeOperation>("analyze", pageSize, pageToken);
 }
 
+template NThreading::TFuture<NTable::TSetNotNullOperation> TOperationClient::Get(const TOperation::TOperationId& id);
+template <>
+NThreading::TFuture<TOperationsList<NTable::TSetNotNullOperation>> TOperationClient::List(std::uint64_t pageSize, const std::string& pageToken) {
+    return List<NTable::TSetNotNullOperation>("setnotnull", pageSize, pageToken);
+}
+
 } // namespace NYdb::NOperation
diff --git a/src/client/persqueue_public/impl/read_session.cpp b/src/client/persqueue_public/impl/read_session.cpp
index 9323a353e12..88572657355 100644
--- a/src/client/persqueue_public/impl/read_session.cpp
+++ b/src/client/persqueue_public/impl/read_session.cpp
@@ -59,7 +59,28 @@ TReadSession::~TReadSession() {
     }
 
     Abort();
+
+    std::vector<TSingleClusterReadSessionImpl::TPtr> sessions;
+    {
+        std::lock_guard guard(Lock);
+        sessions.reserve(ClusterSessions.size());
+        for (auto& [_, sessionInfo] : ClusterSessions) {
+            if (sessionInfo.Session) {
+                sessions.push_back(sessionInfo.Session);
+            }
+        }
+    }
+
+    const TInstant closeDeadline = TInstant::Now() + TDuration::Seconds(5);
+    for (const auto& session : sessions) {
+        if (!session->WaitAllDecompressionTasks(closeDeadline)) {
+            LOG_LAZY(Log, TLOG_WARNING, GetLogPrefix() << "Some decompression tasks are still running after read session destroy timeout");
+        }
+    }
     ClearAllEvents();
+    for (const auto& session : sessions) {
+        session->ClearAllPartitionStreamEvents();
+    }
 
     for (const auto& ctx : CbContexts) {
         ctx->Cancel();
@@ -352,6 +373,12 @@ bool TReadSession::Close(TDuration timeout) {
         // Log final counters.
         CountersLogger->Stop();
     }
+    {
+        std::lock_guard guard(Lock);
+        if (DumpCountersContext) {
+            DumpCountersContext->Cancel();
+        }
+    }
 
     std::vector<TSingleClusterReadSessionImpl::TPtr> sessions;
     NThreading::TPromise<bool> promise = NThreading::NewPromise<bool>();
@@ -362,6 +389,8 @@ bool TReadSession::Close(TDuration timeout) {
         }
     };
 
+    std::vector<TCallbackContextPtr> cbContextsToCancel;
+    std::shared_ptr<TCallbackContext<TCountersLogger>> dumpCountersContextToCancel;
     TDeferredActions deferred;
     {
         std::lock_guard guard(Lock);
@@ -395,9 +424,11 @@ bool TReadSession::Close(TDuration timeout) {
 
     auto timeoutContext = Connections->CreateContext();
     if (!timeoutContext) {
+        std::lock_guard guard(Lock);
         AbortImpl(EStatus::ABORTED, DRIVER_IS_STOPPING_DESCRIPTION, deferred);
         return false;
     }
+    const TInstant closeDeadline = TInstant::Now() + timeout;
     Connections->ScheduleCallback(timeout,
                                   std::move(timeoutCallback),
                                   timeoutContext);
@@ -422,8 +453,30 @@ bool TReadSession::Close(TDuration timeout) {
         EventsQueue->Close(TSessionClosedEvent(EStatus::TIMEOUT, std::move(issues)), deferred);
     }
 
-    std::lock_guard guard(Lock);
-    Aborting = true; // Set abort flag for doing nothing on destructor.
+    {
+        std::lock_guard guard(Lock);
+        Aborting = true; // Set abort flag for doing nothing on destructor.
+        cbContextsToCancel = CbContexts;
+        dumpCountersContextToCancel = DumpCountersContext;
+    }
+
+    for (const auto& session : sessions) {
+        if (!session->WaitAllDecompressionTasks(closeDeadline)) {
+            LOG_LAZY(Log, TLOG_WARNING, GetLogPrefix() << "Some decompression tasks are still running after read session close timeout");
+        }
+    }
+    ClearAllEvents();
+    for (const auto& session : sessions) {
+        session->ClearAllPartitionStreamEvents();
+    }
+
+    for (const auto& ctx : cbContextsToCancel) {
+        ctx->Cancel();
+    }
+    if (dumpCountersContextToCancel) {
+        dumpCountersContextToCancel->Cancel();
+    }
+
     return result;
 }
 
diff --git a/src/client/persqueue_public/impl/write_session_impl.cpp b/src/client/persqueue_public/impl/write_session_impl.cpp
index 2029893d34e..d7e4fa71970 100644
--- a/src/client/persqueue_public/impl/write_session_impl.cpp
+++ b/src/client/persqueue_public/impl/write_session_impl.cpp
@@ -29,7 +29,6 @@ TWriteSessionImpl::TWriteSessionImpl(
     , Client(std::move(client))
     , Connections(std::move(connections))
     , DbDriverState(std::move(dbDriverState))
-    , PrevToken(DbDriverState->CredentialsProvider ? DbDriverState->CredentialsProvider->GetAuthInfo() : "")
     , InitSeqNoPromise(NThreading::NewPromise<ui64>())
     , WakeupInterval(
             Settings.BatchFlushInterval_ != TDuration::Zero() ?
@@ -1183,19 +1182,63 @@ void TWriteSessionImpl::UpdateTokenIfNeededImpl() {
 
     LOG_LAZY(DbDriverState->Log, TLOG_DEBUG, LogPrefix() << "Write session: try to update token");
 
-    if (!DbDriverState->CredentialsProvider || UpdateTokenInProgress || !SessionEstablished)
+    auto credentialsProvider = DbDriverState->GetCredentialsProvider();
+    if (!credentialsProvider || UpdateTokenInProgress || !SessionEstablished || Aborting)
         return;
-    TClientMessage clientMessage;
-    auto* updateRequest = clientMessage.mutable_update_token_request();
-    auto token = DbDriverState->CredentialsProvider->GetAuthInfo();
-    if (token == PrevToken)
+    auto authInfo = credentialsProvider->GetAuthInfoAsync();
+    if (authInfo.IsReady()) {
+        UpdateTokenImpl(authInfo);
         return;
+    }
+    UpdateTokenInProgress = true;
+    try {
+        authInfo.Subscribe([cbContext = SelfContext](const auto& future) {
+            if (auto self = cbContext->LockShared()) try {
+                self->Connections->ScheduleCallback(TDuration::Zero(), [cbContext, future](bool ok) {
+                    if (auto self = cbContext->LockShared()) {
+                        if (!ok) {
+                            self->UpdateTokenInProgress = false;
+                            return;
+                        }
+                        std::lock_guard guard(self->Lock);
+                        self->UpdateTokenImpl(future);
+                    }
+                });
+            } catch (...) {
+                self->UpdateTokenInProgress = false;
+            }
+        });
+    } catch (...) {
+        UpdateTokenInProgress = false;
+    }
+}
+
+void TWriteSessionImpl::UpdateTokenImpl(const NThreading::TFuture<std::string>& future) {
+    Y_ABORT_UNLESS(Lock.IsLocked());
+
+    UpdateTokenInProgress = false;
+    if (!SessionEstablished || Aborting) {
+        return;
+    }
+
+    std::string token;
+    try {
+        token = future.GetValue();
+    } catch (...) {
+        CloseImpl(EStatus::CLIENT_UNAUTHENTICATED, CurrentExceptionMessage());
+        return;
+    }
+    if (token == PrevToken) {
+        return;
+    }
+
     UpdateTokenInProgress = true;
-    updateRequest->set_token(TStringType{token});
     PrevToken = token;
 
     LOG_LAZY(DbDriverState->Log, TLOG_DEBUG, LogPrefix() << "Write session: updating token");
 
+    TClientMessage clientMessage;
+    clientMessage.mutable_update_token_request()->set_token(TStringType{token});
     Processor->Write(std::move(clientMessage));
 }
 
diff --git a/src/client/persqueue_public/impl/write_session_impl.h b/src/client/persqueue_public/impl/write_session_impl.h
index 86be4fc8d3a..aeff9e0c969 100644
--- a/src/client/persqueue_public/impl/write_session_impl.h
+++ b/src/client/persqueue_public/impl/write_session_impl.h
@@ -325,6 +325,7 @@ class TWriteSessionImpl : public TContinuationTokenIssuer,
     TStringBuilder LogPrefix() const;
 
     void UpdateTokenIfNeededImpl();
+    void UpdateTokenImpl(const NThreading::TFuture<std::string>& future);
 
     void WriteInternal(TContinuationToken&& continuationToken, std::string_view data, std::optional<ECodec> codec, ui32 originalSize,
                std::optional<ui64> seqNo = std::nullopt, std::optional<TInstant> createTimestamp = std::nullopt);
@@ -387,7 +388,7 @@ class TWriteSessionImpl : public TContinuationTokenIssuer,
     std::shared_ptr<IWriteSessionConnectionProcessorFactory> ConnectionFactory;
     TDbDriverStatePtr DbDriverState;
     std::string PrevToken;
-    bool UpdateTokenInProgress = false;
+    std::atomic_bool UpdateTokenInProgress = false;
     TInstant LastTokenUpdate = TInstant::Zero();
     std::shared_ptr<TWriteSessionEventsQueue> EventsQueue;
     NYdbGrpc::IQueueClientContextPtr ClientContext; // Common client context.
diff --git a/src/client/proto/accessor.cpp b/src/client/proto/accessor.cpp
index 8a5cbd79c78..5fbdd858ba6 100644
--- a/src/client/proto/accessor.cpp
+++ b/src/client/proto/accessor.cpp
@@ -164,4 +164,16 @@ NImport::EIndexPopulationMode TProtoAccessor::FromProto(Ydb::Import::ImportFromS
     }
 }
 
+NExport::TYdbDumpFormat TProtoAccessor::FromProto(const Ydb::Export::YdbDumpFormat&) {
+    return NExport::TYdbDumpFormat();
+}
+
+NExport::TParquetFormat TProtoAccessor::FromProto(const Ydb::Export::ParquetFormat& value) {
+    NExport::TParquetFormat result;
+    if (value.row_group_size()) {
+        result.RowGroupSize(value.row_group_size());
+    }
+    return result;
+}
+
 } // namespace NYdb
diff --git a/src/client/query/client.cpp b/src/client/query/client.cpp
index 4ff31745aa0..4a8b378f1df 100644
--- a/src/client/query/client.cpp
+++ b/src/client/query/client.cpp
@@ -260,7 +260,12 @@ class TQueryClient::TImpl: public TClientImplCommon<TQueryClient::TImpl>, public
 
                         obs->End(commitTxStatus.GetStatus(), commitTxStatus.GetEndpoint());
 
-                        TCommitTransactionResult commitTxResult(std::move(commitTxStatus));
+                        std::optional<NScheme::TVirtualTimestamp> commitTimestamp;
+                        if (response->has_commit_timestamp()) {
+                            commitTimestamp = NScheme::TVirtualTimestamp(response->commit_timestamp());
+                        }
+
+                        TCommitTransactionResult commitTxResult(std::move(commitTxStatus), std::move(commitTimestamp));
                         promise.SetValue(std::move(commitTxResult));
                     } else {
                         obs->End(status.Status, status.Endpoint);
@@ -377,6 +382,49 @@ class TQueryClient::TImpl: public TClientImplCommon<TQueryClient::TImpl>, public
         return promise.GetFuture();
     }
 
+    TAsyncStatus DeleteSession(const std::string& sessionId, const NYdb::NQuery::TDeleteSessionSettings& settings) {
+        auto request = MakeRequest<Ydb::Query::DeleteSessionRequest>();
+        request.set_session_id(TStringType{sessionId});
+
+        auto promise = NThreading::NewPromise<TStatus>();
+
+        auto obs = MakeObservation("DeleteSession");
+
+        auto responseCb = [promise, obs]
+            (Ydb::Query::DeleteSessionResponse* response, TPlainStatus status) mutable {
+                try {
+                    if (response) {
+                        NYdb::NIssue::TIssues opIssues;
+                        NYdb::NIssue::IssuesFromMessage(response->issues(), opIssues);
+                        TStatus deleteSessionStatus(TPlainStatus{static_cast<EStatus>(response->status()), std::move(opIssues),
+                            status.Endpoint, std::move(status.Metadata)});
+
+                        obs->End(deleteSessionStatus.GetStatus(), deleteSessionStatus.GetEndpoint());
+
+                        promise.SetValue(std::move(deleteSessionStatus));
+                    } else {
+                        obs->End(status.Status, status.Endpoint);
+                        promise.SetValue(TStatus(std::move(status)));
+                    }
+                } catch (...) {
+                    obs->EndWithClientInternalError();
+                    promise.SetException(std::current_exception());
+                }
+            };
+
+        auto rpcSettings = TRpcRequestSettings::Make(settings);
+        rpcSettings.PreferredEndpoint = TEndpointKey(GetNodeIdFromSession(sessionId));
+
+        Connections_->Run<Ydb::Query::V1::QueryService, Ydb::Query::DeleteSessionRequest, Ydb::Query::DeleteSessionResponse>(
+            std::move(request),
+            responseCb,
+            &Ydb::Query::V1::QueryService::Stub::AsyncDeleteSession,
+            DbDriverState_,
+            rpcSettings);
+
+        return promise.GetFuture();
+    }
+
     void DeleteSession(TKqpSessionCommon* sessionImpl) override {
         if (sessionImpl->IsOwnedBySessionPool()) {
             if (SessionPool_.CheckAndFeedWaiterNewSession(sessionImpl->NeedUpdateActiveCounter())) {
@@ -487,12 +535,10 @@ class TQueryClient::TImpl: public TClientImplCommon<TQueryClient::TImpl>, public
     TAsyncCreateSessionResult GetSession(const TCreateSessionSettings& settings) {
         class TQueryClientGetSessionCtx : public NSessionPool::IGetSessionCtx {
         public:
-            TQueryClientGetSessionCtx(std::shared_ptr<TQueryClient::TImpl> client, const TCreateSessionSettings& settings,
-                std::shared_ptr<TQueryObservation> observation)
+            TQueryClientGetSessionCtx(std::shared_ptr<TQueryClient::TImpl> client, const TCreateSessionSettings& settings)
                 : Promise(NThreading::NewPromise<TCreateSessionResult>())
                 , Client(client)
                 , RpcSettings(TRpcRequestSettings::Make(settings))
-                , Observation(std::move(observation))
             {}
 
             TAsyncCreateSessionResult GetFuture() {
@@ -501,9 +547,6 @@ class TQueryClient::TImpl: public TClientImplCommon<TQueryClient::TImpl>, public
 
             void ReplyError(TStatus status) override {
                 TSession session;
-                if (Observation) {
-                    Observation->End(status.GetStatus(), status.GetEndpoint());
-                }
                 ScheduleReply(TCreateSessionResult(std::move(status), std::move(session)));
             }
 
@@ -516,22 +559,37 @@ class TQueryClient::TImpl: public TClientImplCommon<TQueryClient::TImpl>, public
                     )
                 );
 
-                if (Observation) {
-                    Observation->End(EStatus::SUCCESS, session->GetEndpoint());
-                }
                 ScheduleReply(std::move(val));
             }
 
             void ReplyNewSession() override {
-                Client->CreateAttachedSession(RpcSettings).Subscribe(
-                    [promise{std::move(Promise)}, obs = Observation](TAsyncCreateSessionResult future) mutable
+                auto obs = Client->MakeObservation("CreateSession");
+                TRpcRequestSettings deferredRpcSettings = RpcSettings;
+                deferredRpcSettings.Deadline = TDeadline::Max();
+                Client->CreateAttachedSession(
+                    this->Client->Settings_.SessionPoolSettings_.UseDeferredSessionCreation_ ? 
+                    deferredRpcSettings :
+                    RpcSettings).Subscribe(
+                    [promise = Promise, obs](TAsyncCreateSessionResult future) mutable
                 {
                     auto val = future.ExtractValue();
                     if (obs) {
                         obs->End(val.GetStatus(), val.GetEndpoint());
                     }
-                    promise.SetValue(std::move(val));
+                    promise.TrySetValue(std::move(val));
                 });
+                if (Client->Settings_.SessionPoolSettings_.UseDeferredSessionCreation_) {
+                    Client->Connections_->ScheduleDelayedTask(
+                        [promise = Promise, obs, client = Client]() mutable {
+                            TSession session;
+                            promise.TrySetValue(TCreateSessionResult(TStatus(TPlainStatus(EStatus::CLIENT_DEADLINE_EXCEEDED, "GetSession deadline exceeded")), std::move(session)));
+                            if (obs) {
+                                obs->End(EStatus::CLIENT_DEADLINE_EXCEEDED, "GetSession deadline exceeded");
+                            }
+                        },
+                        GetDeadline()
+                    );
+                }
             }
 
             void ScheduleOnDeadlineWaiterCleanup() override {
@@ -555,11 +613,9 @@ class TQueryClient::TImpl: public TClientImplCommon<TQueryClient::TImpl>, public
             NThreading::TPromise<TCreateSessionResult> Promise;
             std::shared_ptr<TQueryClient::TImpl> Client;
             const TRpcRequestSettings RpcSettings;
-            std::shared_ptr<TQueryObservation> Observation;
         };
 
-        auto obs = MakeObservation("CreateSession");
-        auto ctx = std::make_unique<TQueryClientGetSessionCtx>(shared_from_this(), settings, obs);
+        auto ctx = std::make_unique<TQueryClientGetSessionCtx>(shared_from_this(), settings);
         auto future = ctx->GetFuture();
         SessionPool_.GetSession(std::move(ctx));
 
@@ -796,6 +852,24 @@ TAsyncCreateSessionResult TQueryClient::GetSession(const TCreateSessionSettings&
     return Impl_->GetSession(settings);
 }
 
+TAsyncStatus TQueryClient::DeleteSession(const std::string& sessionId, const TDeleteSessionSettings& settings)
+{
+    const auto resolvedRetrySettings = NRetry::ResolveRetrySettings(
+        Impl_->Settings_.RetrySettings_,
+        settings.RetrySettings_,
+        settings.ClientTimeout_,
+        NRetry::ERetryIdempotentDefault::True);
+
+    return NRetry::RunUnaryWithRetry(*this, resolvedRetrySettings,
+        [this, sessionId, settings](TDuration timeout) {
+            auto opSettings = settings;
+            if (timeout != TDuration::Max()) {
+                opSettings.ClientTimeout(timeout);
+            }
+            return Impl_->DeleteSession(sessionId, opSettings);
+        });
+}
+
 int64_t TQueryClient::GetActiveSessionCount() const {
     return Impl_->GetActiveSessionCount();
 }
diff --git a/src/client/query/impl/exec_query.cpp b/src/client/query/impl/exec_query.cpp
index 0a7814b73d4..3654d396dce 100644
--- a/src/client/query/impl/exec_query.cpp
+++ b/src/client/query/impl/exec_query.cpp
@@ -88,6 +88,7 @@ class TExecuteQueryIterator::TReaderImpl {
 
                 std::optional<TExecStats> stats;
                 std::optional<TTransaction> tx;
+                std::optional<NScheme::TVirtualTimestamp> commitTimestamp;
                 if (self->Response_.has_exec_stats()) {
                     stats = TExecStats(std::move(*self->Response_.mutable_exec_stats()));
                 }
@@ -96,16 +97,21 @@ class TExecuteQueryIterator::TReaderImpl {
                     tx = TTransaction(self->Session_.value(), self->Response_.tx_meta().id());
                 }
 
+                if (self->Response_.has_commit_timestamp()) {
+                    commitTimestamp = NScheme::TVirtualTimestamp(self->Response_.commit_timestamp());
+                }
+
                 if (self->Response_.has_result_set()) {
                     promise.SetValue({
                         std::move(status),
                         TResultSet(std::move(*self->Response_.mutable_result_set())),
                         self->Response_.result_set_index(),
                         std::move(stats),
-                        std::move(tx)
+                        std::move(tx),
+                        std::move(commitTimestamp)
                     });
                 } else {
-                    promise.SetValue({std::move(status), std::move(stats), std::move(tx)});
+                    promise.SetValue({std::move(status), std::move(stats), std::move(tx), std::move(commitTimestamp)});
                 }
             }
         };
@@ -160,8 +166,10 @@ struct TExecuteQueryBuffer : public TThrRefBase, TNonCopyable {
     std::vector<Ydb::ResultSet> ResultSets_;
     std::optional<TExecStats> Stats_;
     std::optional<TTransaction> Tx_;
+    std::optional<NScheme::TVirtualTimestamp> CommitTimestamp_;
     std::vector<std::string> ArrowSchemas_;
     std::vector<std::vector<std::string>> BytesData_;
+    std::vector<bool> ResultSetSeen_;
 
     void Next() {
         TPtr self(this);
@@ -173,6 +181,10 @@ struct TExecuteQueryBuffer : public TThrRefBase, TNonCopyable {
                 self->Stats_ = st;
             }
 
+            if (const auto& ct = part.GetCommitTimestamp()) {
+                self->CommitTimestamp_ = ct;
+            }
+
             if (!part.IsSuccess()) {
                 std::optional<TExecStats> stats;
                 std::swap(self->Stats_, stats);
@@ -181,12 +193,14 @@ struct TExecuteQueryBuffer : public TThrRefBase, TNonCopyable {
                     std::vector<NYdb::NIssue::TIssue> issues;
                     std::vector<Ydb::ResultSet> resultProtos;
                     std::optional<TTransaction> tx;
+                    std::optional<NScheme::TVirtualTimestamp> commitTimestamp;
                     std::vector<std::string> arrowSchemas;
                     std::vector<std::vector<std::string>> bytesData;
 
                     std::swap(self->Issues_, issues);
                     std::swap(self->ResultSets_, resultProtos);
                     std::swap(self->Tx_, tx);
+                    std::swap(self->CommitTimestamp_, commitTimestamp);
                     std::swap(self->ArrowSchemas_, arrowSchemas);
                     std::swap(self->BytesData_, bytesData);
 
@@ -203,10 +217,11 @@ struct TExecuteQueryBuffer : public TThrRefBase, TNonCopyable {
                         TStatus(EStatus::SUCCESS, NYdb::NIssue::TIssues(std::move(issues))),
                         std::move(resultSets),
                         std::move(stats),
-                        std::move(tx)
+                        std::move(tx),
+                        std::move(commitTimestamp)
                     ));
                 } else {
-                    self->Promise_.SetValue(TExecuteQueryResult(std::move(part), {}, std::move(stats), {}));
+                    self->Promise_.SetValue(TExecuteQueryResult(std::move(part), {}, std::move(stats), {}));  // No commit timestamp on error
                 }
 
                 return;
@@ -216,29 +231,36 @@ struct TExecuteQueryBuffer : public TThrRefBase, TNonCopyable {
 
             if (part.HasResultSet()) {
                 auto inRs = part.ExtractResultSet();
-                auto& inRsProto = TProtoAccessor::GetProto(inRs);
+                auto& inRsProto = inRs.MutableProto();
 
                 // TODO: Use result sets metadata
                 if (self->ResultSets_.size() <= part.GetResultSetIndex()) {
                     self->ResultSets_.resize(part.GetResultSetIndex() + 1);
+                    self->ResultSetSeen_.resize(part.GetResultSetIndex() + 1);
                 }
 
                 auto& resultSet = self->ResultSets_[part.GetResultSetIndex()];
-                resultSet.set_format(inRsProto.format());
+                const auto resultSetIndex = part.GetResultSetIndex();
 
-                switch (resultSet.format()) {
+                switch (inRsProto.format()) {
                     case Ydb::ResultSet::FORMAT_UNSPECIFIED:
                     case Ydb::ResultSet::FORMAT_VALUE: {
-                        self->CollectYdbValues(resultSet, inRsProto);
+                        if (!self->ResultSetSeen_[resultSetIndex]) {
+                            resultSet = std::move(inRsProto);
+                        } else {
+                            self->CollectYdbValues(resultSet, inRsProto);
+                        }
                         break;
                     }
                     case Ydb::ResultSet::FORMAT_ARROW: {
-                        self->CollectArrowBytes(resultSet, inRs.MutableProto(), part.GetResultSetIndex());
+                        resultSet.set_format(inRsProto.format());
+                        self->CollectArrowBytes(resultSet, inRsProto, part.GetResultSetIndex());
                         break;
                     }
                     default:
                         break;
                 }
+                self->ResultSetSeen_[resultSetIndex] = true;
             }
 
             if (const auto& tx = part.GetTransaction()) {
diff --git a/src/client/query/query.cpp b/src/client/query/query.cpp
index 72c036b5f07..fef7e7877ce 100644
--- a/src/client/query/query.cpp
+++ b/src/client/query/query.cpp
@@ -66,4 +66,9 @@ TCommitTransactionResult::TCommitTransactionResult(TStatus&& status)
     : TStatus(std::move(status))
 {}
 
+TCommitTransactionResult::TCommitTransactionResult(TStatus&& status, std::optional<NScheme::TVirtualTimestamp>&& commitTimestamp)
+    : TStatus(std::move(status))
+    , CommitTimestamp_(std::move(commitTimestamp))
+{}
+
 } // namespace NYdb::NQuery
diff --git a/src/client/scheme/scheme.cpp b/src/client/scheme/scheme.cpp
index 32d30251571..5666717f4b4 100644
--- a/src/client/scheme/scheme.cpp
+++ b/src/client/scheme/scheme.cpp
@@ -29,52 +29,6 @@ void TPermissions::SerializeTo(::Ydb::Scheme::Permissions& proto) const {
     }
 }
 
-TVirtualTimestamp::TVirtualTimestamp(uint64_t planStep, uint64_t txId)
-    : PlanStep(planStep)
-    , TxId(txId)
-{}
-
-TVirtualTimestamp::TVirtualTimestamp(const ::Ydb::VirtualTimestamp& proto)
-    : TVirtualTimestamp(proto.plan_step(), proto.tx_id())
-{}
-
-std::string TVirtualTimestamp::ToString() const {
-    TString result;
-    TStringOutput out(result);
-    Out(out);
-    return result;
-}
-
-void TVirtualTimestamp::Out(IOutputStream& out) const {
-    out << "{ plan_step: " << PlanStep
-      << ", tx_id: " << TxId
-      << " }";
-}
-
-bool TVirtualTimestamp::operator<(const TVirtualTimestamp& rhs) const {
-    return PlanStep < rhs.PlanStep && TxId < rhs.TxId;
-}
-
-bool TVirtualTimestamp::operator<=(const TVirtualTimestamp& rhs) const {
-    return PlanStep <= rhs.PlanStep && TxId <= rhs.TxId;
-}
-
-bool TVirtualTimestamp::operator>(const TVirtualTimestamp& rhs) const {
-    return PlanStep > rhs.PlanStep && TxId > rhs.TxId;
-}
-
-bool TVirtualTimestamp::operator>=(const TVirtualTimestamp& rhs) const {
-    return PlanStep >= rhs.PlanStep && TxId >= rhs.TxId;
-}
-
-bool TVirtualTimestamp::operator==(const TVirtualTimestamp& rhs) const {
-    return PlanStep == rhs.PlanStep && TxId == rhs.TxId;
-}
-
-bool TVirtualTimestamp::operator!=(const TVirtualTimestamp& rhs) const {
-    return !(*this == rhs);
-}
-
 static ESchemeEntryType ConvertProtoEntryType(::Ydb::Scheme::Entry::Type entry) {
     switch (entry) {
     case ::Ydb::Scheme::Entry::DIRECTORY:
diff --git a/src/client/table/impl/table_client.cpp b/src/client/table/impl/table_client.cpp
index 9a6970699f8..dd0d9af184b 100644
--- a/src/client/table/impl/table_client.cpp
+++ b/src/client/table/impl/table_client.cpp
@@ -11,6 +11,14 @@ using namespace NThreading;
 
 const TKeepAliveSettings TTableClient::TImpl::KeepAliveSettings = TKeepAliveSettings().ClientTimeout(KEEP_ALIVE_CLIENT_TIMEOUT);
 
+namespace {
+    NThreading::TFuture<void> MakeReadyFuture() {
+        auto promise = NThreading::NewPromise<void>();
+        auto future = promise.GetFuture();
+        promise.SetValue();
+        return future;
+    }
+}
 
 TDuration GetMinTimeToTouch(const TSessionPoolSettings& settings) {
     return Min(settings.CloseIdleThreshold_, settings.KeepAliveIdleThreshold_);
@@ -73,7 +81,11 @@ std::shared_ptr<NObservability::TRequestSpan> TTableClient::TImpl::CreateRetryAt
 
 TTableClient::TImpl::~TImpl() {
     if (Connections_->GetDrainOnDtors()) {
-        Drain().Wait(DRAIN_TIMEOUT);
+        const bool waitForDrain = !TGRpcConnectionsImpl::IsCurrentThreadInSdkCallback();
+        auto drainFuture = Drain();
+        if (waitForDrain) {
+            drainFuture.Wait(DRAIN_TIMEOUT);
+        }
     }
 }
 
@@ -86,9 +98,7 @@ void TTableClient::TImpl::InitStopper() {
     auto cb = [weak]() mutable {
         auto strong = weak.lock();
         if (!strong) {
-            auto promise = NThreading::NewPromise<void>();
-            promise.SetException("no more client");
-            return promise.GetFuture();
+            return MakeReadyFuture();
         }
         return strong->Drain();
     };
@@ -109,9 +119,13 @@ NThreading::TFuture<void> TTableClient::TImpl::Drain() {
     for (auto& s : sessions) {
         if (!s->GetId().empty()) {
             closeResults.push_back(CloseInternal(s.get()));
+            DbDriverState_->StatCollector.DecSessionsOnHost(s->GetEndpoint());
         }
     }
     sessions.clear();
+    if (closeResults.empty()) {
+        return MakeReadyFuture();
+    }
     return NThreading::WaitExceptionOrAll(closeResults);
 }
 
@@ -1104,8 +1118,7 @@ TAsyncStatus TTableClient::TImpl::Close(const TKqpSessionCommon* sessionImpl, co
 }
 
 TAsyncStatus TTableClient::TImpl::CloseInternal(const TKqpSessionCommon* sessionImpl) {
-    static const auto internalCloseSessionSettings = TCloseSessionSettings()
-            .ClientTimeout(TDuration::Seconds(2));
+    const auto internalCloseSessionSettings = TCloseSessionSettings().ClientTimeout(TDuration::Seconds(2));
 
     auto driver = Connections_;
     return Close(sessionImpl, internalCloseSessionSettings)
diff --git a/src/client/table/impl/table_client.h b/src/client/table/impl/table_client.h
index c9d77b9afc6..38e7237ae12 100644
--- a/src/client/table/impl/table_client.h
+++ b/src/client/table/impl/table_client.h
@@ -21,7 +21,6 @@
 
 #include <library/cpp/threading/future/core/coroutine_traits.h>
 
-
 namespace NYdb::inline V3 {
 namespace NTable {
 
diff --git a/src/client/table/out.cpp b/src/client/table/out.cpp
index 7d29674d4f2..59ac9b11881 100644
--- a/src/client/table/out.cpp
+++ b/src/client/table/out.cpp
@@ -97,6 +97,9 @@ Y_DECLARE_OUT_SPEC(, NYdb::NTable::TFulltextIndexSettings::ETokenizer, stream, v
         case NYdb::NTable::TFulltextIndexSettings::ETokenizer::Keyword:
             stream << "keyword";
             break;
+        case NYdb::NTable::TFulltextIndexSettings::ETokenizer::Alphanumeric:
+            stream << "alphanumeric";
+            break;
         case NYdb::NTable::TFulltextIndexSettings::ETokenizer::Unspecified:
             stream << "unspecified";
             break;
diff --git a/src/client/table/proto_accessor.cpp b/src/client/table/proto_accessor.cpp
index d4e69ccfd16..f10a6285037 100644
--- a/src/client/table/proto_accessor.cpp
+++ b/src/client/table/proto_accessor.cpp
@@ -40,6 +40,14 @@ NTable::TIndexDescription TProtoAccessor::FromProto(const Ydb::Table::TableIndex
     return NTable::TIndexDescription(tableIndexDesc);
 }
 
+NTable::TMultiColumnStatisticsDescription TProtoAccessor::FromProto(const Ydb::Table::TableMultiColumnStatistics& tableMultiColumnStatistics) {
+    return NTable::TMultiColumnStatisticsDescription(tableMultiColumnStatistics);
+}
+
+NTable::TMultiColumnStatisticsDescription TProtoAccessor::FromProto(const Ydb::Table::TableMultiColumnStatisticsDescription& tableMultiColumnStatisticsDesc) {
+    return NTable::TMultiColumnStatisticsDescription(tableMultiColumnStatisticsDesc);
+}
+
 NTable::TChangefeedDescription TProtoAccessor::FromProto(const Ydb::Table::Changefeed& changefeed) {
     return NTable::TChangefeedDescription(changefeed);
 }
diff --git a/src/client/table/table.cpp b/src/client/table/table.cpp
index ff46e22adda..3233f943059 100644
--- a/src/client/table/table.cpp
+++ b/src/client/table/table.cpp
@@ -244,6 +244,21 @@ const TAnalyzeOperation::TMetadata& TAnalyzeOperation::Metadata() const {
     return Metadata_;
 }
 
+TSetNotNullOperation::TSetNotNullOperation(TStatus &&status, Ydb::Operations::Operation &&operation)
+    : TOperation(std::move(status), std::move(operation))
+{
+    Ydb::Table::SetNotNullMetadata metadata;
+    GetProto().metadata().UnpackTo(&metadata);
+    Metadata_.State = static_cast<ESetNotNullState>(metadata.state());
+    Metadata_.Progress = metadata.progress();
+    Metadata_.Path = metadata.path();
+    Metadata_.Columns.assign(metadata.columns().begin(), metadata.columns().end());
+}
+
+const TSetNotNullOperation::TMetadata& TSetNotNullOperation::Metadata() const {
+    return Metadata_;
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 
 class TPartitioningSettings::TImpl {
@@ -390,6 +405,12 @@ class TTableDescription::TImpl {
             Indexes_.emplace_back(TProtoAccessor::FromProto(index));
         }
 
+        // statistics
+        MultiColumnStatistics_.reserve(proto.statistics_size());
+        for (const auto& statistics : proto.statistics()) {
+            MultiColumnStatistics_.emplace_back(TProtoAccessor::FromProto(statistics));
+        }
+
         if constexpr (std::is_same_v<TProto, Ydb::Table::DescribeTableResult>) {
             // changefeeds
             Changefeeds_.reserve(proto.changefeeds_size());
@@ -529,6 +550,10 @@ class TTableDescription::TImpl {
         Indexes_.emplace_back(indexDescription);
     }
 
+    void AddMultiColumnStatistics(const TMultiColumnStatisticsDescription& statisticsDescription) {
+        MultiColumnStatistics_.emplace_back(statisticsDescription);
+    }
+
     void AddVectorKMeansTreeIndex(const std::string& indexName, EIndexType type, const std::vector<std::string>& indexColumns, const TKMeansTreeSettings& indexSettings) {
         Indexes_.emplace_back(TIndexDescription(indexName, type, indexColumns, {}, {}, indexSettings));
     }
@@ -628,6 +653,10 @@ class TTableDescription::TImpl {
         return Indexes_;
     }
 
+    const std::vector<TMultiColumnStatisticsDescription>& GetMultiColumnStatisticsDescriptions() const {
+        return MultiColumnStatistics_;
+    }
+
     const std::vector<TChangefeedDescription>& GetChangefeedDescriptions() const {
         return Changefeeds_;
     }
@@ -723,6 +752,7 @@ class TTableDescription::TImpl {
     std::vector<std::string> PrimaryKey_;
     std::vector<TTableColumn> Columns_;
     std::vector<TIndexDescription> Indexes_;
+    std::vector<TMultiColumnStatisticsDescription> MultiColumnStatistics_;
     std::vector<TChangefeedDescription> Changefeeds_;
     std::optional<TTtlSettings> TtlSettings_;
     std::string Owner_;
@@ -784,6 +814,10 @@ std::vector<TIndexDescription> TTableDescription::GetIndexDescriptions() const {
     return Impl_->GetIndexDescriptions();
 }
 
+std::vector<TMultiColumnStatisticsDescription> TTableDescription::GetMultiColumnStatisticsDescriptions() const {
+    return Impl_->GetMultiColumnStatisticsDescriptions();
+}
+
 std::vector<TChangefeedDescription> TTableDescription::GetChangefeedDescriptions() const {
     return Impl_->GetChangefeedDescriptions();
 }
@@ -836,6 +870,10 @@ void TTableDescription::AddSecondaryIndex(const TIndexDescription& indexDescript
     Impl_->AddSecondaryIndex(indexDescription);
 }
 
+void TTableDescription::AddMultiColumnStatistics(const TMultiColumnStatisticsDescription& statisticsDescription) {
+    Impl_->AddMultiColumnStatistics(statisticsDescription);
+}
+
 void TTableDescription::AddSyncSecondaryIndex(const std::string& indexName, const std::vector<std::string>& indexColumns) {
     AddSecondaryIndex(indexName, EIndexType::GlobalSync, indexColumns);
 }
@@ -1036,6 +1074,10 @@ void TTableDescription::SerializeTo(Ydb::Table::CreateTableRequest& request) con
         index.SerializeTo(*request.add_indexes());
     }
 
+    for (const auto& statistics : Impl_->GetMultiColumnStatisticsDescriptions()) {
+        statistics.SerializeTo(*request.add_statistics());
+    }
+
     if (const auto& ttl = Impl_->GetTtlSettings()) {
         ttl->SerializeTo(*request.mutable_ttl_settings());
     }
@@ -1320,6 +1362,11 @@ TTableBuilder& TTableBuilder::AddSecondaryIndex(const TIndexDescription& indexDe
     return *this;
 }
 
+TTableBuilder& TTableBuilder::AddMultiColumnStatistics(const TMultiColumnStatisticsDescription& statisticsDescription) {
+    TableDescription_.AddMultiColumnStatistics(statisticsDescription);
+    return *this;
+}
+
 TTableBuilder& TTableBuilder::AddSecondaryIndex(const std::string& indexName, EIndexType type, const std::vector<std::string>& indexColumns, const std::vector<std::string>& dataColumns) {
     TableDescription_.AddSecondaryIndex(indexName, type, indexColumns, dataColumns);
     return *this;
@@ -2993,6 +3040,8 @@ TFulltextIndexSettings::TAnalyzers FromProto(const Ydb::Table::FulltextIndexSett
             return ETokenizer::Standard;
         case Ydb::Table::FulltextIndexSettings::KEYWORD:
             return ETokenizer::Keyword;
+        case Ydb::Table::FulltextIndexSettings::ALPHANUMERIC:
+            return ETokenizer::Alphanumeric;
         default:
             return ETokenizer::Unspecified;
         }
@@ -3046,6 +3095,8 @@ Ydb::Table::FulltextIndexSettings::Analyzers ToProto(const TFulltextIndexSetting
             return Ydb::Table::FulltextIndexSettings::STANDARD;
         case ETokenizer::Keyword:
             return Ydb::Table::FulltextIndexSettings::KEYWORD;
+        case ETokenizer::Alphanumeric:
+            return Ydb::Table::FulltextIndexSettings::ALPHANUMERIC;
         case ETokenizer::Unspecified:
             return Ydb::Table::FulltextIndexSettings::TOKENIZER_UNSPECIFIED;
         }
@@ -3388,6 +3439,82 @@ bool operator!=(const TIndexDescription& lhs, const TIndexDescription& rhs) {
 
 ////////////////////////////////////////////////////////////////////////////////
 
+TMultiColumnStatisticsDescription::TMultiColumnStatisticsDescription(
+        const std::string& name,
+        const std::vector<std::string>& columns,
+        const std::vector<EMultiColumnStatisticsType>& types)
+    : Name_(name)
+    , Columns_(columns)
+    , Types_(types)
+{}
+
+TMultiColumnStatisticsDescription::TMultiColumnStatisticsDescription(const Ydb::Table::TableMultiColumnStatistics& proto)
+    : TMultiColumnStatisticsDescription(FromProto(proto))
+{}
+
+TMultiColumnStatisticsDescription::TMultiColumnStatisticsDescription(const Ydb::Table::TableMultiColumnStatisticsDescription& proto)
+    : TMultiColumnStatisticsDescription(FromProto(proto))
+{}
+
+template <typename TProto>
+TMultiColumnStatisticsDescription TMultiColumnStatisticsDescription::FromProto(const TProto& proto) {
+    std::vector<std::string> columns(proto.columns().begin(), proto.columns().end());
+    std::vector<EMultiColumnStatisticsType> types;
+    types.reserve(proto.types_size());
+    for (const auto type : proto.types()) {
+        switch (type) {
+        case Ydb::Table::TableMultiColumnStatistics::COUNT_MIN_SKETCH:
+            types.push_back(EMultiColumnStatisticsType::CountMinSketch);
+            break;
+        default:
+            types.push_back(EMultiColumnStatisticsType::Unknown);
+            break;
+        }
+    }
+    return TMultiColumnStatisticsDescription(proto.name(), columns, types);
+}
+
+const std::string& TMultiColumnStatisticsDescription::GetName() const {
+    return Name_;
+}
+
+const std::vector<std::string>& TMultiColumnStatisticsDescription::GetColumns() const {
+    return Columns_;
+}
+
+const std::vector<EMultiColumnStatisticsType>& TMultiColumnStatisticsDescription::GetTypes() const {
+    return Types_;
+}
+
+void TMultiColumnStatisticsDescription::SerializeTo(Ydb::Table::TableMultiColumnStatistics& proto) const {
+    proto.set_name(TStringType{Name_});
+    for (const auto& column : Columns_) {
+        proto.add_columns(TStringType{column});
+    }
+    for (const auto type : Types_) {
+        switch (type) {
+        case EMultiColumnStatisticsType::CountMinSketch:
+            proto.add_types(Ydb::Table::TableMultiColumnStatistics::COUNT_MIN_SKETCH);
+            break;
+        case EMultiColumnStatisticsType::Unknown:
+            proto.add_types(Ydb::Table::TableMultiColumnStatistics::STATISTIC_TYPE_UNSPECIFIED);
+            break;
+        }
+    }
+}
+
+bool operator==(const TMultiColumnStatisticsDescription& lhs, const TMultiColumnStatisticsDescription& rhs) {
+    return lhs.GetName() == rhs.GetName()
+        && lhs.GetColumns() == rhs.GetColumns()
+        && lhs.GetTypes() == rhs.GetTypes();
+}
+
+bool operator!=(const TMultiColumnStatisticsDescription& lhs, const TMultiColumnStatisticsDescription& rhs) {
+    return !(lhs == rhs);
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
 TChangefeedDescription::TChangefeedDescription(const std::string& name, EChangefeedMode mode, EChangefeedFormat format)
     : Name_(name)
     , Mode_(mode)
diff --git a/src/client/test_shard/CMakeLists.txt b/src/client/test_shard/CMakeLists.txt
new file mode 100644
index 00000000000..e32fc3e962a
--- /dev/null
+++ b/src/client/test_shard/CMakeLists.txt
@@ -0,0 +1,16 @@
+_ydb_sdk_add_library(client-ydb_test_shard)
+
+target_link_libraries(client-ydb_test_shard PUBLIC
+  yutil
+  api-grpc
+  impl-internal-make_request
+  client-ydb_common_client-impl
+  client-ydb_driver
+  client-types-status
+)
+
+target_sources(client-ydb_test_shard PRIVATE
+  test_shard.cpp
+)
+
+_ydb_sdk_make_client_component(TestShard client-ydb_test_shard)
diff --git a/src/client/test_shard/test_shard.cpp b/src/client/test_shard/test_shard.cpp
new file mode 100644
index 00000000000..4cff4e9607b
--- /dev/null
+++ b/src/client/test_shard/test_shard.cpp
@@ -0,0 +1,88 @@
+#include <ydb-cpp-sdk/client/test_shard/test_shard.h>
+
+#include <src/client/common_client/impl/client.h>
+#include <src/client/impl/internal/make_request/make.h>
+
+#include <src/api/grpc/ydb_test_shard_v1.grpc.pb.h>
+#include <src/api/protos/ydb_test_shard.pb.h>
+
+namespace NYdb::NTestShardSet {
+
+class TTestShardSetClient::TImpl : public TClientImplCommon<TTestShardSetClient::TImpl> {
+public:
+    TImpl(std::shared_ptr<TGRpcConnectionsImpl> connections, const TCommonClientSettings& settings)
+        : TClientImplCommon(std::move(connections), settings)
+    {}
+
+    TAsyncCreateTestShardSetResult CreateTestShardSet(const std::string& path,
+            const std::vector<std::string>& channels, uint32_t count,
+            const std::string& config,
+            const TCreateTestShardSetSettings& settings) {
+        auto request = MakeOperationRequest<Ydb::TestShardSet::CreateTestShardSetRequest>(settings);
+        request.set_path(path);
+        for (const auto& channel : channels) {
+            request.add_channels(channel);
+        }
+        request.set_count(count);
+        if (!config.empty()) {
+            request.set_config(config);
+        }
+
+        auto promise = NThreading::NewPromise<TCreateTestShardSetResult>();
+
+        auto extractor = [promise] (google::protobuf::Any* any, TPlainStatus status) mutable {
+            std::vector<uint64_t> tabletIds;
+            if (any) {
+                Ydb::TestShardSet::CreateTestShardSetResult result;
+                if (any->UnpackTo(&result)) {
+                    tabletIds.reserve(result.tablet_ids_size());
+                    for (int i = 0; i < result.tablet_ids_size(); ++i) {
+                        tabletIds.push_back(result.tablet_ids(i));
+                    }
+                }
+            }
+            promise.SetValue(TCreateTestShardSetResult(TStatus(std::move(status)), std::move(tabletIds)));
+        };
+
+        Connections_->RunDeferred<Ydb::TestShardSet::V1::TestShardSetService, Ydb::TestShardSet::CreateTestShardSetRequest, Ydb::TestShardSet::CreateTestShardSetResponse>(
+            std::move(request),
+            extractor,
+            &Ydb::TestShardSet::V1::TestShardSetService::Stub::AsyncCreateTestShardSet,
+            DbDriverState_,
+            INITIAL_DEFERRED_CALL_DELAY,
+            TRpcRequestSettings::Make(settings));
+
+        return promise.GetFuture();
+    }
+
+    TAsyncStatus DeleteTestShardSet(const std::string& path,
+            const TDeleteTestShardSetSettings& settings) {
+        auto request = MakeOperationRequest<Ydb::TestShardSet::DeleteTestShardSetRequest>(settings);
+        request.set_path(path);
+
+        return RunSimple<Ydb::TestShardSet::V1::TestShardSetService, Ydb::TestShardSet::DeleteTestShardSetRequest, Ydb::TestShardSet::DeleteTestShardSetResponse>(
+            std::move(request),
+            &Ydb::TestShardSet::V1::TestShardSetService::Stub::AsyncDeleteTestShardSet,
+            TRpcRequestSettings::Make(settings));
+    }
+};
+
+TTestShardSetClient::TTestShardSetClient(const TDriver& driver, const TCommonClientSettings& settings)
+    : Impl_(new TImpl(CreateInternalInterface(driver), settings))
+{}
+
+TTestShardSetClient::~TTestShardSetClient() = default;
+
+TAsyncCreateTestShardSetResult TTestShardSetClient::CreateTestShardSet(const std::string& path,
+        const std::vector<std::string>& channels, uint32_t count,
+        const std::string& config,
+        const TCreateTestShardSetSettings& settings) {
+    return Impl_->CreateTestShardSet(path, channels, count, config, settings);
+}
+
+TAsyncStatus TTestShardSetClient::DeleteTestShardSet(const std::string& path,
+        const TDeleteTestShardSetSettings& settings) {
+    return Impl_->DeleteTestShardSet(path, settings);
+}
+
+} // namespace NYdb::NTestShardSet
diff --git a/src/client/topic/codecs/codecs.cpp b/src/client/topic/codecs/codecs.cpp
index b8a1c21e56c..f14746b7469 100644
--- a/src/client/topic/codecs/codecs.cpp
+++ b/src/client/topic/codecs/codecs.cpp
@@ -172,6 +172,7 @@ void TKafkaBatchCodec::CompressWriteBlock(TWriteBlockCompression& ctx) const {
     using namespace NKafka;
 
     Y_ABORT_UNLESS(ctx.Payloads.size() == ctx.CreatedAt.size());
+    Y_ABORT_UNLESS(ctx.Payloads.size() == ctx.MessageKeys.size());
     Y_ABORT_UNLESS(!ctx.Payloads.empty());
 
     TKafkaRecordBatch kafkaBatch;
@@ -192,6 +193,9 @@ void TKafkaBatchCodec::CompressWriteBlock(TWriteBlockCompression& ctx) const {
         record.OffsetDelta = static_cast<TKafkaRecord::OffsetDeltaMeta::Type>(i);
         record.TimestampDelta = ctx.CreatedAt[i].MilliSeconds() - baseTimestamp;
         kafkaBatch.MaxTimestamp = Max<i64>(kafkaBatch.MaxTimestamp, static_cast<i64>(ctx.CreatedAt[i].MilliSeconds()));
+        if (ctx.MessageKeys[i]) {
+            record.SetKey(TString{ctx.MessageKeys[i]->data(), ctx.MessageKeys[i]->size()});
+        }
         record.Value = TKafkaRawBytes(ctx.Payloads[i].data(), ctx.Payloads[i].size());
         record.Length = record.Size(2) - NKafka::NPrivate::SizeOfVarint<TKafkaRecord::LengthMeta::Type>(0);
         kafkaBatch.Records.push_back(std::move(record));
diff --git a/src/client/topic/impl/direct_reader.cpp b/src/client/topic/impl/direct_reader.cpp
index 4cd2388ea56..332e0659de8 100644
--- a/src/client/topic/impl/direct_reader.cpp
+++ b/src/client/topic/impl/direct_reader.cpp
@@ -588,7 +588,8 @@ void TDirectReadSession::OnReadDone(NYdbGrpc::TGrpcStatus&& grpcStatus, size_t c
                 cbContext = SelfContext, partitionSessionId = partitionSessionId.value()
             ]() {
                 callbacks->OnDirectReadDone(messages);
-            }
+            },
+            ClientContext->GetCallbackGuardFactory()
         );
     }
 
diff --git a/src/client/topic/impl/read_session.cpp b/src/client/topic/impl/read_session.cpp
index 7cc416eb3aa..3c8c536ed16 100644
--- a/src/client/topic/impl/read_session.cpp
+++ b/src/client/topic/impl/read_session.cpp
@@ -40,7 +40,20 @@ TReadSession::~TReadSession() {
     Close(TDuration::Zero());
 
     Abort(EStatus::ABORTED, "Aborted");
-    ClearAllEvents();
+    if (CbContext) {
+        if (auto session = CbContext->LockShared()) {
+            const TInstant closeDeadline = TInstant::Now() + TDuration::Seconds(5);
+            if (!session->WaitAllDecompressionTasks(closeDeadline)) {
+                LOG_LAZY(Log, TLOG_WARNING, GetLogPrefix() << "Some decompression tasks are still running after read session destroy timeout");
+            }
+            ClearAllEvents();
+            session->ClearAllPartitionStreamEvents();
+        } else {
+            ClearAllEvents();
+        }
+    } else {
+        ClearAllEvents();
+    }
 
     if (CbContext) {
         CbContext->Cancel();
@@ -191,57 +204,77 @@ bool TReadSession::Close(TDuration timeout) {
         promise.TrySetValue(true);
     };
 
-    TDeferredActions<false> deferred;
-    with_lock(Lock) {
-        if (Closing || Aborting) {
-            return false;
-        }
-
-        if (!timeout) {
-            AbortImpl(EStatus::ABORTED, "Close with zero timeout", deferred);
-            return false;
+    std::shared_ptr<TCallbackContext<TSingleClusterReadSessionImpl<false>>> cbContextToCancel;
+    std::shared_ptr<TCallbackContext<TCountersLogger<false>>> dumpCountersContextToCancel;
+    TInstant closeDeadline;
+    bool result = false;
+    {
+        TDeferredActions<false> deferred;
+        with_lock(Lock) {
+            if (Closing || Aborting) {
+                return false;
+            }
+
+            if (!timeout) {
+                AbortImpl(EStatus::ABORTED, "Close with zero timeout", deferred);
+                return false;
+            }
+
+            Closing = true;
+            session = CbContext->TryGet();
         }
+        session->Close(callback);
 
-        Closing = true;
-        session = CbContext->TryGet();
-    }
-    session->Close(callback);
-
-    callback(); // For the case when there are no subsessions yet.
+        callback(); // For the case when there are no subsessions yet.
 
-    auto timeoutCallback = [=](bool) mutable {
-        promise.TrySetValue(false);
-    };
+        auto timeoutCallback = [=](bool) mutable {
+            promise.TrySetValue(false);
+        };
 
-    auto timeoutContext = Connections->CreateContext();
-    if (!timeoutContext) {
-        AbortImpl(EStatus::ABORTED, DRIVER_IS_STOPPING_DESCRIPTION, deferred);
-        return false;
+        auto timeoutContext = Connections->CreateContext();
+        if (!timeoutContext) {
+            AbortImpl(EStatus::ABORTED, DRIVER_IS_STOPPING_DESCRIPTION, deferred);
+            return false;
+        }
+        closeDeadline = TInstant::Now() + timeout;
+        Connections->ScheduleCallback(timeout,
+                                      std::move(timeoutCallback),
+                                      timeoutContext);
+
+        // Wait.
+        NThreading::TFuture<bool> resultFuture = promise.GetFuture();
+        result = resultFuture.GetValueSync();
+        if (result) {
+            Cancel(timeoutContext);
+
+            NYdb::NIssue::TIssues issues;
+            issues.AddIssue("Session was gracefully closed");
+            EventsQueue->Close(TSessionClosedEvent(EStatus::SUCCESS, std::move(issues)), deferred);
+        } else {
+            ++*Settings.Counters_->Errors;
+            session->Abort();
+
+            NYdb::NIssue::TIssues issues;
+            issues.AddIssue(TStringBuilder() << "Session was closed after waiting " << timeout);
+            EventsQueue->Close(TSessionClosedEvent(EStatus::TIMEOUT, std::move(issues)), deferred);
+        }
+        {
+            std::lock_guard guard(Lock);
+            Aborting = true; // Set abort flag for doing nothing on destructor.
+            cbContextToCancel = CbContext;
+            dumpCountersContextToCancel = DumpCountersContext;
+        }
+        if (!session->WaitAllDecompressionTasks(closeDeadline)) {
+            LOG_LAZY(Log, TLOG_WARNING, GetLogPrefix() << "Some decompression tasks are still running after read session close timeout");
+        }
+        ClearAllEvents();
+        session->ClearAllPartitionStreamEvents();
     }
-    Connections->ScheduleCallback(timeout,
-                                  std::move(timeoutCallback),
-                                  timeoutContext);
-
-    // Wait.
-    NThreading::TFuture<bool> resultFuture = promise.GetFuture();
-    const bool result = resultFuture.GetValueSync();
-    if (result) {
-        Cancel(timeoutContext);
-
-        NYdb::NIssue::TIssues issues;
-        issues.AddIssue("Session was gracefully closed");
-        EventsQueue->Close(TSessionClosedEvent(EStatus::SUCCESS, std::move(issues)), deferred);
-    } else {
-        ++*Settings.Counters_->Errors;
-        session->Abort();
-
-        NYdb::NIssue::TIssues issues;
-        issues.AddIssue(TStringBuilder() << "Session was closed after waiting " << timeout);
-        EventsQueue->Close(TSessionClosedEvent(EStatus::TIMEOUT, std::move(issues)), deferred);
+    if (cbContextToCancel) {
+        cbContextToCancel->Cancel();
     }
-    {
-        std::lock_guard guard(Lock);
-        Aborting = true; // Set abort flag for doing nothing on destructor.
+    if (dumpCountersContextToCancel) {
+        dumpCountersContextToCancel->Cancel();
     }
     return result;
 }
diff --git a/src/client/topic/impl/read_session_impl.h b/src/client/topic/impl/read_session_impl.h
index 483450d0e3c..ee994937b4f 100644
--- a/src/client/topic/impl/read_session_impl.h
+++ b/src/client/topic/impl/read_session_impl.h
@@ -27,7 +27,9 @@
 #include <util/digest/numeric.h>
 
 #include <atomic>
+#include <condition_variable>
 #include <deque>
+#include <mutex>
 #include <vector>
 
 
@@ -150,7 +152,9 @@ class TDeferredActions {
     // TODO(qyryq) Extract a separate TDeferredDirectReadActions class?
     void DeferReadFromProcessor(const typename IDirectReadProcessor::TPtr& processor, TDirectReadServerMessage* dst, typename IDirectReadProcessor::TReadCallback callback);
     void DeferScheduleCallback(TDuration delay, std::function<void(bool)> callback, TSingleClusterReadSessionContextPtr);
-    void DeferCallback(std::function<void()> callback);
+    void DeferCallback(
+        std::function<void()> callback,
+        NYdbGrpc::TQueueClientCallbackGuardFactory callbackGuardFactory = {});
 
     void DeferReadFromProcessor(const typename IProcessor<UseMigrationProtocol>::TPtr& processor, TServerMessage<UseMigrationProtocol>* dst, typename IProcessor<UseMigrationProtocol>::TReadCallback callback);
     void DeferStartExecutorTask(const typename IExecutor::TPtr& executor, typename IExecutor::TFunction&& task);
@@ -202,7 +206,12 @@ class TDeferredActions {
         };
 
         std::optional<TScheduledCallback> ScheduledCallback;
-        std::optional<std::function<void()>> Callback;
+        struct TCallback {
+            std::function<void()> Callback;
+            NYdbGrpc::TQueueClientCallbackGuardFactory CallbackGuardFactory;
+        };
+
+        std::optional<TCallback> Callback;
     } DirectReadActions;
 
     // Executor tasks.
@@ -257,8 +266,9 @@ class TDataDecompressionInfo : public std::enable_shared_from_this<TDataDecompre
     i64 StartDecompressionTasks(const typename IExecutor::TPtr& executor,
                                 i64 availableMemory,
                                 TDeferredActions<UseMigrationProtocol>& deferred);
-    void PlanDecompressionTasks(double averageCompressionRatio,
-                                TIntrusivePtr<TPartitionStreamImpl<UseMigrationProtocol>> partitionStream);
+    bool PlanDecompressionTasks(double averageCompressionRatio,
+                                TIntrusivePtr<TPartitionStreamImpl<UseMigrationProtocol>> partitionStream,
+                                TDeferredActions<UseMigrationProtocol>& deferred);
 
     void OnDestroyReadSession();
 
@@ -628,6 +638,7 @@ class TRawPartitionStreamEventQueue {
                            TReadSessionEventsQueue<UseMigrationProtocol>& queue,
                            TDeferredActions<UseMigrationProtocol>& deferred);
     void DeleteNotReadyTail(TDeferredActions<UseMigrationProtocol>& deferred);
+    void Cleanup(TDeferredActions<UseMigrationProtocol>& deferred);
 
     void GetDataEventImpl(TIntrusivePtr<TPartitionStreamImpl<UseMigrationProtocol>> partitionStream,
                           size_t& maxEventsCount,
@@ -962,6 +973,9 @@ class TReadSessionEventsQueue: public TBaseSessionEventsQueue<TAReadSessionSetti
         }
 
         // Delayed deletion is necessary to avoid deadlock with PushEvent
+        for (auto& queue : deferredDelete) {
+            queue.Cleanup(deferred);
+        }
         deferredDelete.clear();
 
         TReadSessionEventInfo<UseMigrationProtocol> info(event);
@@ -1251,6 +1265,9 @@ class TSingleClusterReadSessionImpl : public TEnableSelfContext<TSingleClusterRe
     void Commit(const TPartitionStreamImpl<UseMigrationProtocol>* partitionStream, ui64 startOffset, ui64 endOffset);
 
     void OnCreateNewDecompressionTask();
+    void OnDecompressionTaskFinished();
+    bool WaitAllDecompressionTasks(TInstant deadline) const;
+    void ClearAllPartitionStreamEvents();
     void OnDecompressionInfoDestroy(i64 compressedSize, i64 decompressedSize, i64 messagesCount, i64 serverBytesSize);
     void OnDecompressionInfoDestroyImpl(i64 compressedSize,
                                         i64 decompressedSize,
@@ -1268,7 +1285,7 @@ class TSingleClusterReadSessionImpl : public TEnableSelfContext<TSingleClusterRe
     void OnUserRetrievedEvent(i64 decompressedSize, size_t messagesCount) override;
 
     void Abort();
-    void AbortImpl();
+    void AbortImpl(TDeferredActions<UseMigrationProtocol>* deferred = nullptr);
     void Close(std::function<void()> callback);
     void AbortSession(TASessionClosedEvent<UseMigrationProtocol>&& closeEvent);
 
@@ -1337,6 +1354,7 @@ class TSingleClusterReadSessionImpl : public TEnableSelfContext<TSingleClusterRe
     void OnConnectTimeout(const NYdbGrpc::IQueueClientContextPtr& connectTimeoutContext);
     void OnConnect(TPlainStatus&&, typename IProcessor::TPtr&&, const NYdbGrpc::IQueueClientContextPtr& connectContext);
     void DestroyAllPartitionStreamsImpl(TDeferredActions<UseMigrationProtocol>& deferred); // Destroy all streams before setting new connection // Assumes that we're under lock.
+    void CleanupDecompressionQueueImpl(TDeferredActions<UseMigrationProtocol>& deferred); // Assumes that we're under lock.
 
     // Initing.
     inline void InitImpl(TDeferredActions<UseMigrationProtocol>& deferred); // Assumes that we're under lock.
@@ -1378,7 +1396,7 @@ class TSingleClusterReadSessionImpl : public TEnableSelfContext<TSingleClusterRe
 
     bool GetRangesMode() const;
 
-    void CallCloseCallbackImpl();
+    void CallCloseCallbackImpl(TDeferredActions<UseMigrationProtocol>* deferred = nullptr);
 
     void UpdateMemoryUsageStatisticsImpl();
     void UpdateReadSizeBudgetCounter(i64 value);
@@ -1534,6 +1552,8 @@ class TSingleClusterReadSessionImpl : public TEnableSelfContext<TSingleClusterRe
     bool Closing = false;
     std::function<void()> CloseCallback;
     std::atomic<int> DecompressionTasksInflight = 0;
+    mutable std::mutex DecompressionTasksInflightMutex;
+    mutable std::condition_variable DecompressionTasksInflightCondVar;
     i64 ReadSizeBudget;
     i64 ReadSizeServerDelta = 0;
 
diff --git a/src/client/topic/impl/read_session_impl.ipp b/src/client/topic/impl/read_session_impl.ipp
index c2a6c38e3be..0badf3eafc4 100644
--- a/src/client/topic/impl/read_session_impl.ipp
+++ b/src/client/topic/impl/read_session_impl.ipp
@@ -27,6 +27,7 @@
 #include <util/stream/mem.h>
 
 #include <atomic>
+#include <chrono>
 #include <utility>
 #include <variant>
 
@@ -267,6 +268,38 @@ void TRawPartitionStreamEventQueue<UseMigrationProtocol>::DeleteNotReadyTail(TDe
     swap(ready, NotReady);
 }
 
+template<bool UseMigrationProtocol>
+void TRawPartitionStreamEventQueue<UseMigrationProtocol>::Cleanup(TDeferredActions<UseMigrationProtocol>& deferred)
+{
+    std::vector<TDataDecompressionInfoPtr<UseMigrationProtocol>> infos;
+    TUserRetrievedEventsInfoAccumulator<UseMigrationProtocol> accumulator;
+
+    auto cleanupEvent = [&](TRawPartitionStreamEvent<UseMigrationProtocol>& event) {
+        if (!event.IsDataEvent()) {
+            return;
+        }
+
+        auto& dataEvent = event.GetDataEvent();
+        if (event.IsReady() || !dataEvent.SetAbandoned()) {
+            accumulator.Add(dataEvent.GetParent(), dataEvent.GetDataSize(), dataEvent.GetMessageCount());
+        } else {
+            infos.push_back(dataEvent.GetParent());
+        }
+    };
+
+    for (auto& event : Ready) {
+        cleanupEvent(event);
+    }
+    for (auto& event : NotReady) {
+        cleanupEvent(event);
+    }
+
+    deferred.DeferDestroyDecompressionInfos(std::move(infos));
+    deferred.DeferOnUserRetrievedEvent(std::move(accumulator));
+    Ready.clear();
+    NotReady.clear();
+}
+
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 // TDecompressionQueueItem
 
@@ -462,6 +495,7 @@ void TSingleClusterReadSessionImpl<UseMigrationProtocol>::BreakConnectionAndReco
 
 template<bool UseMigrationProtocol>
 void TSingleClusterReadSessionImpl<UseMigrationProtocol>::OnConnectTimeout(const NYdbGrpc::IQueueClientContextPtr& connectTimeoutContext) {
+    TDeferredActions<UseMigrationProtocol> deferred;
     {
         std::lock_guard guard(Lock);
         if (ConnectTimeoutContext == connectTimeoutContext) {
@@ -471,7 +505,7 @@ void TSingleClusterReadSessionImpl<UseMigrationProtocol>::OnConnectTimeout(const
             ConnectDelayContext = nullptr;
 
             if (Closing || Aborting) {
-                CallCloseCallbackImpl();
+                CallCloseCallbackImpl(&deferred);
                 return;
             }
         } else {
@@ -500,7 +534,7 @@ void TSingleClusterReadSessionImpl<UseMigrationProtocol>::OnConnect(
             ConnectDelayContext = nullptr;
 
             if (Closing || Aborting) {
-                CallCloseCallbackImpl();
+                CallCloseCallbackImpl(&deferred);
                 return;
             }
 
@@ -788,7 +822,7 @@ void TSingleClusterReadSessionImpl<UseMigrationProtocol>::ConfirmPartitionStream
                                 deferred);
     }
     if (!pushRes) {
-        AbortImpl();
+        AbortImpl(&deferred);
         return;
     }
     TClientMessage<UseMigrationProtocol> req;
@@ -938,7 +972,7 @@ void TSingleClusterReadSessionImpl<UseMigrationProtocol>::ReadFromProcessorImpl(
     }
     if (Closing && !HasCommitsInflightImpl()) {
         Processor->Cancel();
-        CallCloseCallbackImpl();
+        CallCloseCallbackImpl(&deferred);
         return;
     }
 
@@ -1158,8 +1192,11 @@ inline void TSingleClusterReadSessionImpl<true>::OnReadDoneImpl(
                                                                                 Settings.Decompress_);
         Y_ABORT_UNLESS(decompressionInfo);
 
-        decompressionInfo->PlanDecompressionTasks(AverageCompressionRatio,
-                                                  partitionStream);
+        if (!decompressionInfo->PlanDecompressionTasks(AverageCompressionRatio,
+                                                       partitionStream,
+                                                       deferred)) {
+            return;
+        }
 
         DecompressionQueue.emplace_back(decompressionInfo, partitionStream);
         StartDecompressionTasksImpl(deferred);
@@ -1196,7 +1233,7 @@ inline void TSingleClusterReadSessionImpl<true>::OnReadDoneImpl(
                  currentPartitionStream, NPersQueue::TReadSessionEvent::TPartitionStreamClosedEvent::EReason::Lost),
             deferred);
         if (!pushRes) {
-            AbortImpl();
+            AbortImpl(&deferred);
             return;
         }
         currentPartitionStream = partitionStream;
@@ -1208,7 +1245,7 @@ inline void TSingleClusterReadSessionImpl<true>::OnReadDoneImpl(
         NPersQueue::TReadSessionEvent::TCreatePartitionStreamEvent(partitionStream, msg.read_offset(), msg.end_offset()),
         deferred);
     if (!pushRes) {
-        AbortImpl();
+        AbortImpl(&deferred);
         return;
     }
 }
@@ -1237,12 +1274,12 @@ inline void TSingleClusterReadSessionImpl<true>::OnReadDoneImpl(
     } else {
         pushRes = EventsQueue->PushEvent(
             partitionStream,
-            NPersQueue::TReadSessionEvent::TDestroyPartitionStreamEvent(std::move(partitionStream), msg.commit_offset()),
+            NPersQueue::TReadSessionEvent::TDestroyPartitionStreamEvent(partitionStream, msg.commit_offset()),
             deferred);
     }
 
     if (!pushRes) {
-        AbortImpl();
+        AbortImpl(&deferred);
         return;
     }
 
@@ -1271,7 +1308,7 @@ inline void TSingleClusterReadSessionImpl<true>::OnReadDoneImpl(
                                                   partitionStream, partitionStream->GetMaxCommittedOffset()),
                                               deferred);
         if (!pushRes) {
-            AbortImpl();
+            AbortImpl(&deferred);
             return;
         }
     }
@@ -1286,7 +1323,7 @@ inline void TSingleClusterReadSessionImpl<true>::OnReadDoneImpl(
                 NPersQueue::TReadSessionEvent::TCommitAcknowledgementEvent(partitionStream, rangeProto.end_offset()),
                 deferred);
             if (!pushRes) {
-                AbortImpl();
+                AbortImpl(&deferred);
                 return;
             }
         }
@@ -1311,7 +1348,7 @@ inline void TSingleClusterReadSessionImpl<true>::OnReadDoneImpl(
                                               msg.end_offset(), TInstant::MilliSeconds(msg.write_watermark_ms())),
                                           deferred);
     if (!pushRes) {
-        AbortImpl();
+        AbortImpl(&deferred);
         return;
     }
 }
@@ -1408,8 +1445,11 @@ inline void TSingleClusterReadSessionImpl<false>::OnReadDoneImpl(
         serverBytesSize = 0;
         Y_ABORT_UNLESS(decompressionInfo);
 
-        decompressionInfo->PlanDecompressionTasks(AverageCompressionRatio,
-                                                  partitionStream);
+        if (!decompressionInfo->PlanDecompressionTasks(AverageCompressionRatio,
+                                                       partitionStream,
+                                                       deferred)) {
+            return;
+        }
         DecompressionQueue.emplace_back(decompressionInfo, partitionStream);
         StartDecompressionTasksImpl(deferred);
     }
@@ -1437,7 +1477,7 @@ inline void TSingleClusterReadSessionImpl<false>::StopPartitionSessionImpl(
         pushRes = EventsQueue->PushEvent(
             partitionStream,
             // TODO(qyryq) Is it safe to use GetMaxCommittedOffset here instead of StopPartitionSessionRequest.commmitted_offset?
-            TReadSessionEvent::TStopPartitionSessionEvent(std::move(partitionStream), committedOffset),
+            TReadSessionEvent::TStopPartitionSessionEvent(partitionStream, committedOffset),
             deferred);
     } else {
         // partitionStream->ConfirmDestroy();
@@ -1453,7 +1493,7 @@ inline void TSingleClusterReadSessionImpl<false>::StopPartitionSessionImpl(
     }
 
     if (!pushRes) {
-        AbortImpl();
+        AbortImpl(&deferred);
     }
 }
 
@@ -1589,7 +1629,7 @@ inline void TSingleClusterReadSessionImpl<false>::OnReadDoneImpl(
             deferred);
 
         if (!pushRes) {
-            AbortImpl();
+            AbortImpl(&deferred);
             return;
         }
     }
@@ -1615,7 +1655,7 @@ inline void TSingleClusterReadSessionImpl<false>::OnReadDoneImpl(
         deferred);
 
     if (!pushRes) {
-        AbortImpl();
+        AbortImpl(&deferred);
         return;
     }
 }
@@ -1725,10 +1765,10 @@ inline void TSingleClusterReadSessionImpl<false>::OnReadDoneImpl(
 
     bool pushRes = EventsQueue->PushEvent(
             partitionStream,
-            TReadSessionEvent::TEndPartitionSessionEvent(std::move(partitionStream), std::move(adjacentPartitionIds), std::move(childPartitionIds)),
+            TReadSessionEvent::TEndPartitionSessionEvent(partitionStream, std::move(adjacentPartitionIds), std::move(childPartitionIds)),
             deferred);
     if (!pushRes) {
-        AbortImpl();
+        AbortImpl(&deferred);
         return;
     }
 }
@@ -1752,7 +1792,7 @@ inline void TSingleClusterReadSessionImpl<false>::OnReadDoneImpl(
                                         partitionStream, rangeProto.committed_offset()),
                                    deferred);
             if (!pushRes) {
-                AbortImpl();
+                AbortImpl(&deferred);
                 return;
             }
         }
@@ -1780,7 +1820,7 @@ inline void TSingleClusterReadSessionImpl<false>::OnReadDoneImpl(
                                     msg.write_time_high_watermark()))),
                            deferred);
     if (!pushRes) {
-        AbortImpl();
+        AbortImpl(&deferred);
         return;
     }
 }
@@ -1840,10 +1880,10 @@ void TSingleClusterReadSessionImpl<UseMigrationProtocol>::DestroyAllPartitionStr
 
     for (auto&& [key, partitionStream] : PartitionStreams) {
         bool pushRes = EventsQueue->PushEvent(partitionStream,
-                                TClosedEvent(std::move(partitionStream), TClosedEvent::EReason::ConnectionLost),
+                                TClosedEvent(partitionStream, TClosedEvent::EReason::ConnectionLost),
                                deferred);
         if (!pushRes) {
-            AbortImpl();
+            AbortImpl(&deferred);
             return;
         }
     }
@@ -1851,11 +1891,79 @@ void TSingleClusterReadSessionImpl<UseMigrationProtocol>::DestroyAllPartitionStr
     CookieMapping.ClearMapping();
 }
 
+template<bool UseMigrationProtocol>
+void TSingleClusterReadSessionImpl<UseMigrationProtocol>::CleanupDecompressionQueueImpl(TDeferredActions<UseMigrationProtocol>& deferred) {
+    Y_ABORT_UNLESS(Lock.IsLocked());
+
+    if (DecompressionQueue.empty()) {
+        return;
+    }
+
+    std::vector<TDataDecompressionInfoPtr<UseMigrationProtocol>> infos;
+    infos.reserve(DecompressionQueue.size());
+    for (auto& item : DecompressionQueue) {
+        infos.push_back(item.BatchInfo);
+    }
+    DecompressionQueue.clear();
+
+    deferred.DeferDestroyDecompressionInfos(std::move(infos));
+}
+
 template<bool UseMigrationProtocol>
 void TSingleClusterReadSessionImpl<UseMigrationProtocol>::OnCreateNewDecompressionTask() {
     ++DecompressionTasksInflight;
 }
 
+template<bool UseMigrationProtocol>
+void TSingleClusterReadSessionImpl<UseMigrationProtocol>::OnDecompressionTaskFinished() {
+    Y_ABORT_UNLESS(DecompressionTasksInflight > 0);
+    if (--DecompressionTasksInflight == 0) {
+        DecompressionTasksInflightCondVar.notify_all();
+    }
+}
+
+template<bool UseMigrationProtocol>
+bool TSingleClusterReadSessionImpl<UseMigrationProtocol>::WaitAllDecompressionTasks(TInstant deadline) const {
+    const TDuration timeout = deadline - TInstant::Now();
+    if (timeout <= TDuration::Zero()) {
+        return DecompressionTasksInflight.load() == 0;
+    }
+
+    std::unique_lock guard(DecompressionTasksInflightMutex);
+    return DecompressionTasksInflightCondVar.wait_for(
+        guard,
+        std::chrono::microseconds(timeout.MicroSeconds()),
+        [&] {
+            return DecompressionTasksInflight.load() == 0;
+        });
+}
+
+template<bool UseMigrationProtocol>
+void TSingleClusterReadSessionImpl<UseMigrationProtocol>::ClearAllPartitionStreamEvents() {
+    TDeferredActions<UseMigrationProtocol> deferred;
+    std::vector<TIntrusivePtr<TPartitionStreamImpl<UseMigrationProtocol>>> streams;
+    std::vector<TRawPartitionStreamEventQueue<UseMigrationProtocol>> deferredDelete;
+    {
+        std::lock_guard guard(Lock);
+        streams.reserve(PartitionStreams.size());
+        for (auto& [_, partitionStream] : PartitionStreams) {
+            streams.push_back(partitionStream);
+        }
+    }
+
+    deferredDelete.reserve(streams.size());
+    for (auto& stream : streams) {
+        std::lock_guard guard(stream->GetLock());
+        if (stream->HasEvents()) {
+            deferredDelete.push_back(stream->ExtractQueue());
+        }
+    }
+
+    for (auto& queue : deferredDelete) {
+        queue.Cleanup(deferred);
+    }
+}
+
 template<bool UseMigrationProtocol>
 void TSingleClusterReadSessionImpl<UseMigrationProtocol>::OnDecompressionInfoDestroy(i64 compressedSize, i64 decompressedSize, i64 messagesCount, i64 serverBytesSize)
 {
@@ -1886,9 +1994,6 @@ void TSingleClusterReadSessionImpl<UseMigrationProtocol>::OnDataDecompressed(i64
 
     TDeferredActions<UseMigrationProtocol> deferred;
 
-    Y_ABORT_UNLESS(DecompressionTasksInflight > 0);
-    --DecompressionTasksInflight;
-
     *Settings.Counters_->BytesRead += decompressedSize;
     *Settings.Counters_->BytesReadCompressed += sourceSize;
     *Settings.Counters_->MessagesRead += messagesCount;
@@ -1948,8 +2053,9 @@ template<bool UseMigrationProtocol>
 void TSingleClusterReadSessionImpl<UseMigrationProtocol>::Abort() {
     LOG_LAZY(Log, TLOG_DEBUG, GetLogPrefix() << "Abort session to cluster");
 
+    TDeferredActions<UseMigrationProtocol> deferred;
     std::lock_guard guard(Lock);
-    AbortImpl();
+    AbortImpl(&deferred);
 }
 
 template<bool UseMigrationProtocol>
@@ -1962,12 +2068,12 @@ void TSingleClusterReadSessionImpl<UseMigrationProtocol>::AbortSession(TASession
 
 
 template<bool UseMigrationProtocol>
-void TSingleClusterReadSessionImpl<UseMigrationProtocol>::AbortImpl() {
+void TSingleClusterReadSessionImpl<UseMigrationProtocol>::AbortImpl(TDeferredActions<UseMigrationProtocol>* deferred) {
     Y_ABORT_UNLESS(Lock.IsLocked());
 
     if (!Aborting) {
         Aborting = true;
-        CallCloseCallbackImpl();
+        CallCloseCallbackImpl(deferred);
 
         // Cancel(ClientContext); // Don't cancel, because this is used only as factory for other contexts.
         Cancel(ConnectContext);
@@ -1985,13 +2091,19 @@ void TSingleClusterReadSessionImpl<UseMigrationProtocol>::AbortImpl() {
             }
         }
     }
+
+    if (deferred) {
+        CleanupDecompressionQueueImpl(*deferred);
+    }
 }
 
 template<bool UseMigrationProtocol>
 void TSingleClusterReadSessionImpl<UseMigrationProtocol>::Close(std::function<void()> callback) {
+    TDeferredActions<UseMigrationProtocol> deferred;
     std::lock_guard guard(Lock);
     if (Aborting) {
         callback();
+        return;
     }
 
     if (!Closing) {
@@ -2004,27 +2116,31 @@ void TSingleClusterReadSessionImpl<UseMigrationProtocol>::Close(std::function<vo
         Cancel(ConnectDelayContext);
 
         if (!Processor) {
-            CallCloseCallbackImpl();
+            CallCloseCallbackImpl(&deferred);
         } else {
             if (!HasCommitsInflightImpl()) {
                 Processor->Cancel();
-                CallCloseCallbackImpl();
+                CallCloseCallbackImpl(&deferred);
             }
         }
     }
 
-    AbortImpl();
+    AbortImpl(&deferred);
 }
 
 template<bool UseMigrationProtocol>
-void TSingleClusterReadSessionImpl<UseMigrationProtocol>::CallCloseCallbackImpl() {
+void TSingleClusterReadSessionImpl<UseMigrationProtocol>::CallCloseCallbackImpl(TDeferredActions<UseMigrationProtocol>* deferred) {
     Y_ABORT_UNLESS(Lock.IsLocked());
 
     if (CloseCallback) {
         CloseCallback();
         CloseCallback = {};
     }
-    AbortImpl();
+    if (!Aborting) {
+        AbortImpl(deferred);
+    } else if (deferred) {
+        CleanupDecompressionQueueImpl(*deferred);
+    }
 }
 
 template<bool UseMigrationProtocol>
@@ -2875,14 +2991,24 @@ void TReadSessionEventsQueue<UseMigrationProtocol>::GetDataEventCallbackSettings
 
 template<bool UseMigrationProtocol>
 void TReadSessionEventsQueue<UseMigrationProtocol>::ClearAllEvents() {
-    std::lock_guard<std::mutex> guard(TParent::Mutex);
-    while (!TParent::Events.empty()) {
-        auto& event = TParent::Events.front();
-        if (event.PartitionStream && event.PartitionStream->HasEvents()) {
-            event.PartitionStream->PopEvent();
+    TDeferredActions<UseMigrationProtocol> deferred;
+    std::vector<TRawPartitionStreamEventQueue<UseMigrationProtocol>> deferredDelete;
+    {
+        std::lock_guard<std::mutex> guard(TParent::Mutex);
+        deferredDelete.reserve(TParent::Events.size());
+        while (!TParent::Events.empty()) {
+            auto& event = TParent::Events.front();
+            if (!event.IsEmpty()) {
+                deferredDelete.push_back(event.PartitionStream->ExtractQueue());
+            }
+            TParent::Events.pop();
         }
-        TParent::Events.pop();
     }
+
+    for (auto& queue : deferredDelete) {
+        queue.Cleanup(deferred);
+    }
+    deferredDelete.clear();
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -3042,8 +3168,9 @@ i64 TDataDecompressionInfo<UseMigrationProtocol>::StartDecompressionTasks(
 }
 
 template<bool UseMigrationProtocol>
-void TDataDecompressionInfo<UseMigrationProtocol>::PlanDecompressionTasks(double averageCompressionRatio,
-                                                                          TIntrusivePtr<TPartitionStreamImpl<UseMigrationProtocol>> partitionStream) {
+bool TDataDecompressionInfo<UseMigrationProtocol>::PlanDecompressionTasks(double averageCompressionRatio,
+                                                                          TIntrusivePtr<TPartitionStreamImpl<UseMigrationProtocol>> partitionStream,
+                                                                          TDeferredActions<UseMigrationProtocol>& deferred) {
     constexpr size_t TASK_LIMIT = 512_KB;
     Y_ABORT_UNLESS(partitionStream);
 
@@ -3074,8 +3201,9 @@ void TDataDecompressionInfo<UseMigrationProtocol>::PlanDecompressionTasks(double
                                                      ReadyThresholds.back().Ready,
                                                      ReadyThresholds.back().Abandoned);
             if (!pushRes) {
-                session->AbortImpl();
-                return;
+                deferred.DeferDestroyDecompressionInfos({TDataDecompressionInfo::shared_from_this()});
+                session->AbortImpl(&deferred);
+                return false;
             }
         }
 
@@ -3099,6 +3227,8 @@ void TDataDecompressionInfo<UseMigrationProtocol>::PlanDecompressionTasks(double
     } else {
         ReadyThresholds.pop_back(); // Revert.
     }
+
+    return true;
 }
 
 template <bool UseMigrationProtocol>
@@ -3516,6 +3646,10 @@ void TDataDecompressionInfo<UseMigrationProtocol>::TDecompressionTask::operator(
         // Message is dropped due to partition stream cancellation, we should release decompressed memory
         parent->OnUserRetrievedEvent(DecompressedSize, messagesProcessed);
     }
+
+    if (auto session = parent->CbContext->LockShared()) {
+        session->OnDecompressionTaskFinished();
+    }
 }
 
 template<bool UseMigrationProtocol>
@@ -3575,9 +3709,15 @@ void TDeferredActions<UseMigrationProtocol>::DeferScheduleCallback(TDuration del
 }
 
 template<bool UseMigrationProtocol>
-void TDeferredActions<UseMigrationProtocol>::DeferCallback(std::function<void()> callback) {
+void TDeferredActions<UseMigrationProtocol>::DeferCallback(
+    std::function<void()> callback,
+    NYdbGrpc::TQueueClientCallbackGuardFactory callbackGuardFactory)
+{
     Y_ASSERT(!DirectReadActions.Callback);
-    DirectReadActions.Callback = std::move(callback);
+    DirectReadActions.Callback = typename TDirectReadDeferredActions::TCallback{
+        std::move(callback),
+        std::move(callbackGuardFactory)
+    };
 }
 
 template<bool UseMigrationProtocol>
@@ -3707,7 +3847,9 @@ template<bool UseMigrationProtocol>
 void TDeferredActions<UseMigrationProtocol>::DirectReadCallback() {
     auto& callback = DirectReadActions.Callback;
     if (callback) {
-        (*callback)();
+        NYdbGrpc::RunQueueClientCallback(callback->CallbackGuardFactory, [&] {
+            callback->Callback();
+        });
     }
 }
 
diff --git a/src/client/topic/impl/write_session_impl.cpp b/src/client/topic/impl/write_session_impl.cpp
index 0e737dea2a7..90c79da5f71 100644
--- a/src/client/topic/impl/write_session_impl.cpp
+++ b/src/client/topic/impl/write_session_impl.cpp
@@ -30,6 +30,18 @@ namespace {
 
 using TTxId = std::pair<std::string_view, std::string_view>;
 
+constexpr std::string_view MESSAGE_ATTRIBUTE_KEY = "__key";
+
+std::optional<std::string> GetMessageKey(const std::vector<std::pair<std::string, std::string>>& messageMeta) {
+    for (const auto& [key, value] : messageMeta) {
+        if (key == MESSAGE_ATTRIBUTE_KEY) {
+            return value;
+        }
+    }
+
+    return std::nullopt;
+}
+
 bool ValidateWriteSessionSettings(const TWriteSessionSettings& settings, NYdb::NIssue::TIssues& issues) {
     if (!settings.BatchInnerCodec_.has_value()) {
         return true;
@@ -102,7 +114,6 @@ TWriteSessionImpl::TWriteSessionImpl(
     , Client(std::move(client))
     , Connections(std::move(connections))
     , DbDriverState(std::move(dbDriverState))
-    , PrevToken(DbDriverState->CredentialsProvider ? DbDriverState->CredentialsProvider->GetAuthInfo() : "")
     , MaxBlockMessageCount(Settings.BatchFlushMessageCount_)
     , InitSeqNoPromise(NThreading::NewPromise<uint64_t>())
     , WakeupInterval(
@@ -1346,6 +1357,7 @@ void TWriteSessionImpl::CompressImpl(TBlock&& block_) {
             .Codec = codec,
             .Payloads = blockPtr->OriginalDataRefs,
             .CreatedAt = blockPtr->CreatedAt,
+            .MessageKeys = blockPtr->MessageKeys,
             .Data = blockPtr->Data,
             .CodecID = blockPtr->CodecID,
             .Compressed = blockPtr->Compressed,
@@ -1508,6 +1520,7 @@ size_t TWriteSessionImpl::WriteBatchImpl() {
             block.OriginalMemoryUsage += datum.size();
             block.OriginalDataRefs.emplace_back(datum);
             block.CreatedAt.emplace_back(createTs);
+            block.MessageKeys.emplace_back(GetMessageKey(currMessage.MessageMeta));
             if (CurrentBatch.Messages[i].Codec.has_value()) {
                 Y_ABORT_UNLESS(CurrentBatch.Messages.size() == 1);
                 block.CodecID = static_cast<ui32>(*currMessage.Codec);
@@ -1572,11 +1585,54 @@ void TWriteSessionImpl::UpdateTokenIfNeededImpl() {
 
     LOG_LAZY(DbDriverState->Log, TLOG_DEBUG, LogPrefixImpl() << "Write session: try to update token");
 
-    if (!DbDriverState->CredentialsProvider || UpdateTokenInProgress || !SessionEstablished) {
+    auto credentialsProvider = DbDriverState->GetCredentialsProvider();
+    if (!credentialsProvider || UpdateTokenInProgress || !SessionEstablished || Aborting) {
+        return;
+    }
+
+    auto authInfo = credentialsProvider->GetAuthInfoAsync();
+    if (authInfo.IsReady()) {
+        UpdateTokenImpl(authInfo);
+        return;
+    }
+    UpdateTokenInProgress = true;
+    try {
+        authInfo.Subscribe([cbContext = SelfContext](const auto& future) {
+            if (auto self = cbContext->LockShared()) try {
+                self->Connections->ScheduleCallback(TDuration::Zero(), [cbContext, future](bool ok) {
+                    if (auto self = cbContext->LockShared()) {
+                        if (!ok) {
+                            self->UpdateTokenInProgress = false;
+                            return;
+                        }
+                        std::lock_guard guard(self->Lock);
+                        self->UpdateTokenImpl(future);
+                    }
+                });
+            } catch (...) {
+                self->UpdateTokenInProgress = false;
+            }
+        });
+    } catch (...) {
+        UpdateTokenInProgress = false;
+    }
+}
+
+void TWriteSessionImpl::UpdateTokenImpl(const NThreading::TFuture<std::string>& future) {
+    Y_ABORT_UNLESS(Lock.IsLocked());
+
+    UpdateTokenInProgress = false;
+    if (!SessionEstablished || Aborting) {
         return;
     }
 
-    auto token = DbDriverState->CredentialsProvider->GetAuthInfo();
+    std::string token;
+    try {
+        token = future.GetValue();
+    } catch (...) {
+        CloseImpl(EStatus::CLIENT_UNAUTHENTICATED, CurrentExceptionMessage());
+        return;
+    }
     if (token == PrevToken) {
         return;
     }
diff --git a/src/client/topic/impl/write_session_impl.h b/src/client/topic/impl/write_session_impl.h
index 313352ee441..0acd8ee4a70 100644
--- a/src/client/topic/impl/write_session_impl.h
+++ b/src/client/topic/impl/write_session_impl.h
@@ -234,6 +234,7 @@ class TWriteSessionImpl : public TContinuationTokenIssuer,
         ui32 CodecID = static_cast<ui32>(ECodec::RAW);
         mutable std::vector<std::string_view> OriginalDataRefs;
         mutable std::vector<TInstant> CreatedAt;
+        mutable std::vector<std::optional<std::string>> MessageKeys;
         mutable TBuffer Data;
         bool Compressed = false;
         mutable bool Valid = true;
@@ -252,12 +253,14 @@ class TWriteSessionImpl : public TContinuationTokenIssuer,
             CodecID = rhs.CodecID;
             OriginalDataRefs.swap(rhs.OriginalDataRefs);
             CreatedAt.swap(rhs.CreatedAt);
+            MessageKeys.swap(rhs.MessageKeys);
             Data.Swap(rhs.Data);
             Compressed = rhs.Compressed;
 
             rhs.Data.Clear();
             rhs.OriginalDataRefs.clear();
             rhs.CreatedAt.clear();
+            rhs.MessageKeys.clear();
         }
     };
 
@@ -374,6 +377,7 @@ class TWriteSessionImpl : public TContinuationTokenIssuer,
     TStringBuilder LogPrefixImpl() const;
 
     void UpdateTokenIfNeededImpl();
+    void UpdateTokenImpl(const NThreading::TFuture<std::string>& future);
 
     void WriteInternal(TContinuationToken&& continuationToken, TWriteMessage&& message);
 
@@ -444,7 +448,7 @@ class TWriteSessionImpl : public TContinuationTokenIssuer,
     std::shared_ptr<IWriteSessionConnectionProcessorFactory> ConnectionFactory;
     TDbDriverStatePtr DbDriverState;
     std::string PrevToken;
-    bool UpdateTokenInProgress = false;
+    std::atomic_bool UpdateTokenInProgress = false;
     TInstant LastTokenUpdate = TInstant::Zero();
     std::shared_ptr<TWriteSessionEventsQueue> EventsQueue;
     NYdbGrpc::IQueueClientContextPtr ClientContext; // Common client context.
diff --git a/src/client/topic/ut/basic_usage_ut.cpp b/src/client/topic/ut/basic_usage_ut.cpp
index 6d34cd7c1f2..266fcba33e5 100644
--- a/src/client/topic/ut/basic_usage_ut.cpp
+++ b/src/client/topic/ut/basic_usage_ut.cpp
@@ -28,6 +28,7 @@
 #include <src/library/string_utils/base64/base64.h>
 
 #include <atomic>
+#include <mutex>
 #include <util/digest/murmur.h>
 #include <util/stream/zlib.h>
 
@@ -81,9 +82,19 @@ void ReadMessagesAndAssertOrderedBySeqNo(TTopicClient& client,
         ui64 SeqNo;
         std::string Data;
     };
-    std::vector<TMessageInfo> messages;
-    messages.reserve(expectedCount);
-    NThreading::TPromise<void> donePromise = NThreading::NewPromise<void>();
+    // Handlers may still run after Close(); keep shared ownership so late callbacks are safe.
+    struct TState {
+        std::mutex Lock;
+        std::vector<TMessageInfo> Messages;
+        NThreading::TPromise<void> DonePromise = NThreading::NewPromise<void>();
+
+        std::vector<TMessageInfo> CopyMessages() {
+            std::lock_guard guard(Lock);
+            return Messages;
+        }
+    };
+    auto state = std::make_shared<TState>();
+    state->Messages.reserve(expectedCount);
 
     TTopicReadSettings topicSettings(topicPath);
     topicSettings.ReadFromTimestamp(TInstant::Zero());
@@ -93,25 +104,31 @@ void ReadMessagesAndAssertOrderedBySeqNo(TTopicClient& client,
         .AutoPartitioningSupport(true)
         .AppendTopics(topicSettings);
 
-    readSettings.EventHandlers_.SimpleDataHandlers([&](TReadSessionEvent::TDataReceivedEvent& ev) {
+    readSettings.EventHandlers_.SimpleDataHandlers([state, expectedCount](TReadSessionEvent::TDataReceivedEvent& ev) {
+        std::lock_guard guard(state->Lock);
         for (auto& msg : ev.GetMessages()) {
-            messages.push_back(TMessageInfo{
+            if (state->Messages.size() >= expectedCount) {
+                break;
+            }
+            state->Messages.push_back(TMessageInfo{
                 msg.GetPartitionSession()->GetPartitionId(),
                 TString(msg.GetProducerId()),
                 msg.GetSeqNo(),
                 TString(msg.GetData()),
             });
         }
-        if (messages.size() >= expectedCount) {
-            donePromise.SetValue();
+        if (state->Messages.size() >= expectedCount) {
+            state->DonePromise.TrySetValue();
         }
     }, true);
 
     auto readSession = client.CreateReadSession(readSettings);
-    UNIT_ASSERT_C(donePromise.GetFuture().Wait(timeout),
-        "Expected to read " << expectedCount << " messages within " << timeout << ", got " << messages.size());
+    UNIT_ASSERT_C(state->DonePromise.GetFuture().Wait(timeout),
+        "Expected to read " << expectedCount << " messages within " << timeout);
     readSession->Close(TDuration::Seconds(5));
 
+    const auto messages = state->CopyMessages();
+
     UNIT_ASSERT_VALUES_EQUAL_C(messages.size(), expectedCount,
         "Read message count mismatch: got " << messages.size() << ", expected " << expectedCount);
 
diff --git a/src/client/topic/ut/ut_utils/topic_sdk_test_setup.cpp b/src/client/topic/ut/ut_utils/topic_sdk_test_setup.cpp
index 890356e19f0..b6d9da190ce 100644
--- a/src/client/topic/ut/ut_utils/topic_sdk_test_setup.cpp
+++ b/src/client/topic/ut/ut_utils/topic_sdk_test_setup.cpp
@@ -102,7 +102,8 @@ TTopicSdkTestSetup::TReadResult::TReadResult(TDriver& driver)
 TTopicSdkTestSetup::TReadResult::~TReadResult()
 {
     if (Reader) {
-        Reader->Close();
+        StartPartitionSessionEvents.clear();
+        Reader->Close(TDuration::Seconds(5));
         Reader.reset();
     }
 }
diff --git a/src/client/topic/ut/ut_utils/txusage_fixture.cpp b/src/client/topic/ut/ut_utils/txusage_fixture.cpp
index d38b1d5c6e6..b0c820a6018 100644
--- a/src/client/topic/ut/ut_utils/txusage_fixture.cpp
+++ b/src/client/topic/ut/ut_utils/txusage_fixture.cpp
@@ -1174,7 +1174,7 @@ void TFixture::SendLongTxLockStatus(const NActors::TActorId& actorId,
                                     NKikimrLongTxService::TEvLockStatus::EStatus status)
 {
     auto event =
-        std::make_unique<NKikimr::NLongTxService::TEvLongTxService::TEvLockStatus>(writeId.KeyId, writeId.NodeId,
+        std::make_unique<NKikimr::NLongTxService::TEvLongTxService::TEvLockStatus>(writeId.GetKeyId(), writeId.GetNodeId(),
                                                                                    status);
     auto& runtime = Setup->GetRuntime();
     runtime.SendToPipe(tabletId, actorId, event.release());
diff --git a/src/client/types/CMakeLists.txt b/src/client/types/CMakeLists.txt
index d31569ed37e..d4f14cdab82 100644
--- a/src/client/types/CMakeLists.txt
+++ b/src/client/types/CMakeLists.txt
@@ -8,8 +8,14 @@ add_subdirectory(status)
 _ydb_sdk_add_library(client-types)
 
 target_sources(client-types PRIVATE
-  ydb.cpp
   core_facility/simple_core_facility.cpp
+  virtual_timestamp.cpp
+  ydb.cpp
+)
+
+target_compile_options(client-types PRIVATE
+  "$<$<CXX_COMPILER_ID:MSVC>:/FI${YDB_SDK_SOURCE_DIR}/util/stream/str.h>"
+  "$<$<NOT:$<CXX_COMPILER_ID:MSVC>>:-include${YDB_SDK_SOURCE_DIR}/util/stream/str.h>"
 )
 
 target_link_libraries(client-types PUBLIC
diff --git a/src/client/types/core_facility/simple_core_facility.cpp b/src/client/types/core_facility/simple_core_facility.cpp
index 4356582b2a1..3c6b46797d4 100644
--- a/src/client/types/core_facility/simple_core_facility.cpp
+++ b/src/client/types/core_facility/simple_core_facility.cpp
@@ -2,7 +2,6 @@
 
 #include <util/generic/yexception.h>
 #include <util/stream/output.h>
-#include <util/system/yassert.h>
 
 namespace NYdb::inline V3 {
 
@@ -30,9 +29,6 @@ TSimpleCoreFacility::~TSimpleCoreFacility() {
 
 void TSimpleCoreFacility::AddPeriodicTask(TPeriodicCb&& cb, TDeadline::Duration period) {
     std::lock_guard lock(Mutex_);
-    Y_ABORT_UNLESS(!PeriodicStarted_);
-    PeriodicStarted_ = true;
-
     auto periodicCb = std::make_shared<TPeriodicCb>(std::move(cb));
     EnqueueTaskNoLock(
         TClock::now(),
@@ -46,15 +42,11 @@ void TSimpleCoreFacility::PostToResponseQueue(TPostTaskCb&& f) {
     if (!f) {
         return;
     }
-    {
-        std::lock_guard lock(Mutex_);
-        if (!Stop_) {
-            EnqueueTaskNoLock(TClock::now(), std::move(f));
-            Cv_.notify_one();
-            return;
-        }
+    std::lock_guard lock(Mutex_);
+    if (!Stop_) {
+        EnqueueTaskNoLock(TClock::now(), std::move(f));
+        Cv_.notify_one();
     }
-    f();
 }
 
 void TSimpleCoreFacility::EnqueueTaskNoLock(TTimePoint executeAt, TPostTaskCb&& task) {
diff --git a/src/client/types/core_facility/simple_core_facility.h b/src/client/types/core_facility/simple_core_facility.h
index 5444774dfc6..b9d6ab3ceca 100644
--- a/src/client/types/core_facility/simple_core_facility.h
+++ b/src/client/types/core_facility/simple_core_facility.h
@@ -51,7 +51,6 @@ class TSimpleCoreFacility final : public ICoreFacility {
     std::condition_variable Cv_;
     std::priority_queue<TScheduledTask, std::vector<TScheduledTask>, TScheduledTaskLess> Queue_;
     bool Stop_ = false;
-    bool PeriodicStarted_ = false;
     std::uint64_t NextSeqNo_ = 0;
 
     std::thread WorkerThread_;
diff --git a/src/client/types/credentials/credentials.cpp b/src/client/types/credentials/credentials.cpp
index 2a3e0a83a94..bbce4663342 100644
--- a/src/client/types/credentials/credentials.cpp
+++ b/src/client/types/credentials/credentials.cpp
@@ -1,8 +1,111 @@
 #include <ydb-cpp-sdk/client/types/credentials/credentials.h>
 #include <util/string/cast.h>
 
+#include <condition_variable>
+#include <mutex>
+#include <unordered_map>
+
 namespace NYdb::inline V3 {
 
+namespace NCredentials::NDetail {
+
+namespace {
+
+struct TCredentialsProviderCacheEntry {
+    std::mutex Mutex;
+    std::condition_variable Initialized;
+    bool Initializing = false;
+    std::weak_ptr<ICredentialsProvider> Provider;
+};
+
+class TCredentialsProviderCache {
+public:
+    TCredentialsProviderPtr Get(
+        const std::string& identity,
+        TCredentialsProviderCreator createProvider)
+    {
+        std::shared_ptr<TCredentialsProviderCacheEntry> entry;
+        {
+            std::lock_guard guard(Mutex_);
+            RemoveExpiredEntries();
+            auto [it, inserted] = Entries_.try_emplace(identity);
+            if (inserted) {
+                it->second = std::make_shared<TCredentialsProviderCacheEntry>();
+            }
+            entry = it->second;
+        }
+
+        std::unique_lock entryLock(entry->Mutex);
+        while (true) {
+            if (auto provider = entry->Provider.lock()) {
+                return provider;
+            }
+
+            if (!entry->Initializing) {
+                entry->Initializing = true;
+                break;
+            }
+
+            entry->Initialized.wait(entryLock, [&entry] {
+                return !entry->Initializing;
+            });
+        }
+
+        entryLock.unlock();
+
+        TCredentialsProviderPtr provider;
+        try {
+            provider = createProvider();
+        } catch (...) {
+            entryLock.lock();
+            entry->Initializing = false;
+            entryLock.unlock();
+            entry->Initialized.notify_all();
+            throw;
+        }
+
+        entryLock.lock();
+        entry->Provider = provider;
+        entry->Initializing = false;
+        entryLock.unlock();
+        entry->Initialized.notify_all();
+        return provider;
+    }
+
+private:
+    void RemoveExpiredEntries() {
+        for (auto it = Entries_.begin(); it != Entries_.end();) {
+            auto entry = it->second;
+            if (entry.use_count() == 2) { // The map and this local variable.
+                std::unique_lock entryLock(entry->Mutex, std::try_to_lock);
+                if (entryLock.owns_lock() && entry.use_count() == 2 && entry->Provider.expired()) {
+                    entryLock.unlock();
+                    entry.reset();
+                    it = Entries_.erase(it);
+                    continue;
+                }
+            }
+            ++it;
+        }
+    }
+
+private:
+    std::mutex Mutex_;
+    std::unordered_map<std::string, std::shared_ptr<TCredentialsProviderCacheEntry>> Entries_;
+};
+
+} // namespace
+
+TCredentialsProviderPtr GetOrCreateCachedProvider(
+    const std::string& identity,
+    TCredentialsProviderCreator createProvider)
+{
+    static TCredentialsProviderCache cache;
+    return cache.Get(identity, std::move(createProvider));
+}
+
+} // namespace NCredentials::NDetail
+
 class TInsecureCredentialsProvider : public ICredentialsProvider {
 public:
     TInsecureCredentialsProvider()
@@ -79,4 +182,3 @@ std::shared_ptr<ICredentialsProviderFactory> CreateOAuthCredentialsProviderFacto
 }
 
 } // namespace NYdb
-
diff --git a/src/client/types/credentials/login/login.cpp b/src/client/types/credentials/login/login.cpp
index 724039cb2e7..01afd3153e3 100644
--- a/src/client/types/credentials/login/login.cpp
+++ b/src/client/types/credentials/login/login.cpp
@@ -9,6 +9,8 @@
 
 #include <jwt-cpp/jwt.h>
 
+#include <exception>
+
 using namespace std::chrono_literals;
 
 namespace NYdb::inline V3 {
@@ -35,72 +37,99 @@ std::chrono::system_clock::time_point GetTokenExpiresAt(const std::string& token
     }
     return {};
 }
+
+bool IsRetryable(EStatus status) {
+    return status == EStatus::INTERNAL_ERROR || status == EStatus::ABORTED || status == EStatus::UNAVAILABLE ||
+        status == EStatus::OVERLOADED || status == EStatus::GENERIC_ERROR || status == EStatus::TIMEOUT ||
+        status == EStatus::CANCELLED || status == EStatus::UNDETERMINED || status == EStatus::SESSION_BUSY ||
+        status == EStatus::TRANSPORT_UNAVAILABLE || status == EStatus::CLIENT_RESOURCE_EXHAUSTED ||
+        status == EStatus::CLIENT_DEADLINE_EXCEEDED || status == EStatus::CLIENT_INTERNAL_ERROR ||
+        status == EStatus::CLIENT_CANCELLED || status == EStatus::CLIENT_DISCOVERY_FAILED ||
+        status == EStatus::CLIENT_LIMITS_REACHED;
+}
+
+bool IsRetryableOperation(EStatus status) {
+    return status == EStatus::ABORTED || status == EStatus::UNAVAILABLE || status == EStatus::OVERLOADED ||
+        status == EStatus::TIMEOUT || status == EStatus::SESSION_BUSY;
+}
 }
 
-class TLoginCredentialsProvider : public ICredentialsProvider {
+class TLoginCredentialsProvider : public ICredentialsProvider, public std::enable_shared_from_this<TLoginCredentialsProvider> {
 public:
     TLoginCredentialsProvider(std::weak_ptr<ICoreFacility> facility, TLoginCredentialsParams params);
-    virtual std::string GetAuthInfo() const override;
-    virtual bool IsValid() const override;
+    std::string GetAuthInfo() const override;
+    NThreading::TFuture<std::string> GetAuthInfoAsync() const override;
+    bool IsValid() const override;
+    void Start();
+    ~TLoginCredentialsProvider() { Fail("Login credentials provider stopped"); }
 
 private:
-    void PrepareToken();
+    bool OnPeriodicTick(EStatus status);
     void RequestToken();
-    bool IsOk() const;
-    void ParseToken();
-    std::string GetToken() const;
-    std::string GetError() const;
-    std::string GetTokenOrError() const;
-
-    enum class EState {
-        Empty,
-        Requesting,
-        Done,
-    };
+    void FinishRequest(Ydb::Auth::LoginResponse* response, TPlainStatus status, bool facilityAvailable);
+    void Fail(std::string error);
+    static std::string GetError(const TPlainStatus& status, const Ydb::Auth::LoginResponse& response);
 
     std::weak_ptr<ICoreFacility> Facility_;
     TLoginCredentialsParams Params_;
-    EState State_ = EState::Empty;
-    std::mutex Mutex_;
-    std::condition_variable Notify_;
-    std::atomic<ui64> TokenReceived_ = 1;
-    std::atomic<ui64> TokenParsed_ = 0;
-    std::optional<std::string> Token_;
-    std::optional<std::string> Error_;
-    TInstant TokenExpireAt_;
+    mutable std::mutex Mutex_;
     TInstant TokenRequestAt_;
-    TPlainStatus Status_;
-    Ydb::Auth::LoginResponse Response_;
+    bool Requesting_ = false;
+    bool HasToken_ = false;
+    bool Stopped_ = false;
+    mutable NThreading::TPromise<std::string> AuthInfo_;
 };
 
 TLoginCredentialsProvider::TLoginCredentialsProvider(std::weak_ptr<ICoreFacility> facility, TLoginCredentialsParams params)
     : Facility_(facility)
     , Params_(std::move(params))
-{
-    auto strongFacility = facility.lock();
-    if (strongFacility) {
-        auto periodicTask = [facility, this](NYdb::NIssue::TIssues&&, EStatus status) -> bool {
-            if (status != EStatus::SUCCESS) {
-                return false;
-            }
-
-            auto strongFacility = facility.lock();
-            if (!strongFacility) {
-                return false;
-            }
-
-            if (!TokenRequestAt_) {
-                return true;
-            }
-
-            if (TInstant::Now() >= TokenRequestAt_) {
-                RequestToken();
+    , AuthInfo_(NThreading::NewPromise<std::string>())
+{}
+
+void TLoginCredentialsProvider::Start() {
+    auto facility = Facility_.lock();
+    if (!facility) {
+        Fail("Login credentials provider response facility is not available");
+        return;
+    }
+    {
+        std::lock_guard lock(Mutex_);
+        Requesting_ = true;
+    }
+    try {
+        facility->AddPeriodicTask([weak = weak_from_this()](NYdb::NIssue::TIssues&&, EStatus status) {
+            if (auto self = weak.lock()) {
+                return self->OnPeriodicTick(status);
             }
+            return false;
+        }, 1s);
+    } catch (...) {
+        Fail(CurrentExceptionMessage());
+        return;
+    }
+    RequestToken();
+}
 
+bool TLoginCredentialsProvider::OnPeriodicTick(EStatus status) {
+    if (status != EStatus::SUCCESS) {
+        Fail("Login credentials provider periodic task failed");
+        return false;
+    }
+    {
+        std::lock_guard lock(Mutex_);
+        if (Stopped_) {
+            return false;
+        }
+        if (Requesting_ || TInstant::Now() < TokenRequestAt_) {
             return true;
-        };
-        strongFacility->AddPeriodicTask(std::move(periodicTask), 1min);
+        }
+        if (AuthInfo_.GetFuture().IsReady()) {
+            AuthInfo_ = NThreading::NewPromise<std::string>();
+        }
+        Requesting_ = true;
     }
+    RequestToken();
+    return true;
 }
 
 bool TLoginCredentialsProvider::IsValid() const {
@@ -108,31 +137,21 @@ bool TLoginCredentialsProvider::IsValid() const {
 }
 
 std::string TLoginCredentialsProvider::GetAuthInfo() const {
-    if (TokenParsed_ == TokenReceived_) {
-        return GetTokenOrError();
-    } else {
-        const_cast<TLoginCredentialsProvider*>(this)->PrepareToken(); // will block here
-        return GetTokenOrError();
-    }
+    return GetAuthInfoAsync().GetValueSync();
+}
+
+NThreading::TFuture<std::string> TLoginCredentialsProvider::GetAuthInfoAsync() const {
+    std::lock_guard lock(Mutex_);
+    return AuthInfo_.GetFuture();
 }
 
 void TLoginCredentialsProvider::RequestToken() {
     auto strongFacility = Facility_.lock();
     if (strongFacility) {
-        TokenRequestAt_ = {};
-
-        auto responseCb = [facility = Facility_, this](Ydb::Auth::LoginResponse* resp, TPlainStatus status) {
-            auto strongFacility = facility.lock();
-            if (strongFacility) {
-                std::lock_guard<std::mutex> lock(Mutex_);
-                Status_ = std::move(status);
-                if (resp != nullptr) {
-                    Response_ = std::move(*resp);
-                }
-                State_ = EState::Done;
-                TokenReceived_++;
+        auto responseCb = [facility = Facility_, weak = weak_from_this()](Ydb::Auth::LoginResponse* resp, TPlainStatus status) {
+            if (auto self = weak.lock()) {
+                self->FinishRequest(resp, std::move(status), !facility.expired());
             }
-            Notify_.notify_all();
         };
 
         Ydb::Auth::LoginRequest request;
@@ -141,84 +160,95 @@ void TLoginCredentialsProvider::RequestToken() {
         TRpcRequestSettings rpcSettings;
         rpcSettings.Deadline = TDeadline::AfterDuration(60s);
 
-        TGRpcConnectionsImpl::RunOnDiscoveryEndpoint<Ydb::Auth::V1::AuthService, Ydb::Auth::LoginRequest, Ydb::Auth::LoginResponse>(
-            strongFacility, std::move(request), std::move(responseCb), &Ydb::Auth::V1::AuthService::Stub::AsyncLogin,
-            rpcSettings);
+        try {
+            TGRpcConnectionsImpl::RunOnDiscoveryEndpoint<Ydb::Auth::V1::AuthService, Ydb::Auth::LoginRequest, Ydb::Auth::LoginResponse>(
+                strongFacility, std::move(request), std::move(responseCb), &Ydb::Auth::V1::AuthService::Stub::AsyncLogin,
+                rpcSettings);
+        } catch (...) {
+            Fail(CurrentExceptionMessage());
+        }
+    } else {
+        FinishRequest(nullptr, {}, false);
     }
 }
 
-void TLoginCredentialsProvider::PrepareToken() {
-    std::unique_lock<std::mutex> lock(Mutex_);
-    switch (State_) {
-        case EState::Empty:
-            State_ = EState::Requesting;
-            RequestToken();
-            [[fallthrough]];
-        case EState::Requesting:
-            Notify_.wait(lock, [&]{
-                return State_ == EState::Done;
-            });
-            [[fallthrough]];
-        case EState::Done:
-            ParseToken();
-            break;
+void TLoginCredentialsProvider::FinishRequest(
+    Ydb::Auth::LoginResponse* response,
+    TPlainStatus status,
+    bool facilityAvailable)
+{
+    if (!facilityAvailable) {
+        Fail("Login credentials provider response facility is not available");
+        return;
     }
-}
 
-bool TLoginCredentialsProvider::IsOk() const {
-    return State_ == EState::Done
-        && Status_.Ok()
-        && Response_.operation().status() == Ydb::StatusIds::SUCCESS;
-}
-
-void TLoginCredentialsProvider::ParseToken() { // works under mutex
-    if (TokenParsed_ != TokenReceived_) {
-        if (IsOk()) {
-            Token_ = GetToken();
-            Error_.reset();
-            TInstant now = TInstant::Now();
-            TokenExpireAt_ = ToInstant(GetTokenExpiresAt(Token_.value()));
-            TokenRequestAt_ = now + TDuration::Minutes((TokenExpireAt_ - now).Minutes() / 2);
-        } else {
-            Token_.reset();
-            Error_ = GetError();
+    Ydb::Auth::LoginResponse emptyResponse;
+    const auto& responseValue = response ? *response : emptyResponse;
+    const auto operationStatus = static_cast<EStatus>(responseValue.operation().status());
+    if (!status.Ok() || operationStatus != EStatus::SUCCESS) {
+        bool retry;
+        {
+            std::lock_guard lock(Mutex_);
+            retry = (!status.Ok() && IsRetryable(status.Status)) ||
+                (HasToken_ && status.Ok() && IsRetryableOperation(operationStatus));
+            if (retry) {
+                Requesting_ = false;
+                TokenRequestAt_ = TInstant::Now() + TDuration::Seconds(1);
+            }
         }
-        TokenParsed_ = TokenReceived_.load();
+        if (retry) {
+            return;
+        }
+        Fail(GetError(status, responseValue));
+        return;
     }
-}
 
-std::string TLoginCredentialsProvider::GetToken() const {
     Ydb::Auth::LoginResult result;
-    Response_.operation().result().UnpackTo(&result);
-    return result.token();
+    if (!responseValue.operation().result().UnpackTo(&result) || result.token().empty()) {
+        Fail("Login service returned an empty token");
+        return;
+    }
+    auto token = result.token();
+    const auto now = TInstant::Now();
+    NThreading::TPromise<std::string> promise;
+    {
+        std::lock_guard lock(Mutex_);
+        Requesting_ = false;
+        HasToken_ = true;
+        TokenRequestAt_ = now + (ToInstant(GetTokenExpiresAt(token)) - now) / 2;
+        promise = AuthInfo_;
+    }
+    promise.TrySetValue(std::move(token));
 }
 
-std::string TLoginCredentialsProvider::GetError() const {
-    if (Status_.Ok()) {
-        if (Response_.operation().issues_size() > 0) {
-            return Response_.operation().issues(0).message();
-        } else {
-            return Ydb::StatusIds_StatusCode_Name(Response_.operation().status());
-        }
-    } else {
-        TStringBuilder str;
-        str << "Couldn't get token for provided credentials from " << Status_.Endpoint
-            << " with status " << Status_.Status << ".";
-        for (const auto& issue : Status_.Issues) {
-            str << Endl << "Issue: " << issue;
-        }
-        return str;
+void TLoginCredentialsProvider::Fail(std::string error) {
+    NThreading::TPromise<std::string> promise;
+    {
+        std::lock_guard lock(Mutex_);
+        Stopped_ = true;
+        Requesting_ = false;
+        promise = AuthInfo_;
     }
+    promise.TrySetException(std::make_exception_ptr(yexception() << error));
 }
 
-std::string TLoginCredentialsProvider::GetTokenOrError() const {
-    if (Token_) {
-        return Token_.value();
+std::string TLoginCredentialsProvider::GetError(
+    const TPlainStatus& status,
+    const Ydb::Auth::LoginResponse& response)
+{
+    if (status.Ok()) {
+        if (response.operation().issues_size() > 0) {
+            return response.operation().issues(0).message();
+        }
+        return Ydb::StatusIds_StatusCode_Name(response.operation().status());
     }
-    if (Error_) {
-        ythrow yexception() << Error_.value();
+    TStringBuilder str;
+    str << "Couldn't get token for provided credentials from " << status.Endpoint
+        << " with status " << status.Status << ".";
+    for (const auto& issue : status.Issues) {
+            str << Endl << "Issue: " << issue;
     }
-    ythrow yexception() << "Wrong state of credentials provider";
+    return str;
 }
 
 class TLoginCredentialsProviderFactory : public ICredentialsProviderFactory {
@@ -241,7 +271,9 @@ std::shared_ptr<ICredentialsProvider> TLoginCredentialsProviderFactory::CreatePr
 }
 
 std::shared_ptr<ICredentialsProvider> TLoginCredentialsProviderFactory::CreateProvider(std::weak_ptr<ICoreFacility> facility) const {
-    return std::make_shared<TLoginCredentialsProvider>(std::move(facility), Params_);
+    auto provider = std::make_shared<TLoginCredentialsProvider>(std::move(facility), Params_);
+    provider->Start();
+    return provider;
 }
 
 std::shared_ptr<ICredentialsProviderFactory> CreateLoginCredentialsProviderFactory(TLoginCredentialsParams params) {
diff --git a/src/client/types/credentials/oauth2_token_exchange/credentials.cpp b/src/client/types/credentials/oauth2_token_exchange/credentials.cpp
index 57cbc427600..ac40fdc1993 100644
--- a/src/client/types/credentials/oauth2_token_exchange/credentials.cpp
+++ b/src/client/types/credentials/oauth2_token_exchange/credentials.cpp
@@ -1,4 +1,5 @@
 #include <ydb-cpp-sdk/client/types/credentials/oauth2_token_exchange/credentials.h>
+#include <ydb-cpp-sdk/client/types/core_facility/core_facility.h>
 
 #include <library/cpp/cgiparam/cgiparam.h>
 #include <library/cpp/http/misc/httpcodes.h>
@@ -85,18 +86,11 @@ bool IsRetryableError(TKeepAliveHttpClient::THttpCode code) {
         || code == HTTP_GATEWAY_TIME_OUT;
 }
 
-ERetryErrorClass RetryPolicyClass(TKeepAliveHttpClient::THttpCode code) {
-    return IsRetryableError(code) ? ERetryErrorClass::LongRetry : ERetryErrorClass::ShortRetry; // In case when we already have token we know that all params are correct and all errors are temporary
-}
-
-ERetryErrorClass SyncRetryPolicyClass(const std::exception* ex, bool retryAllErrors) {
+ERetryErrorClass RetryPolicyClass(const std::exception* ex) {
     if (const TTokenExchangeError* err = dynamic_cast<const TTokenExchangeError*>(ex)) {
         if (IsRetryableError(err->HttpCode)) {
             return ERetryErrorClass::LongRetry;
         }
-        if (retryAllErrors) {
-            return ERetryErrorClass::ShortRetry;
-        }
     }
     if (dynamic_cast<const TSystemError*>(ex)) {
         return ERetryErrorClass::ShortRetry;
@@ -106,8 +100,7 @@ ERetryErrorClass SyncRetryPolicyClass(const std::exception* ex, bool retryAllErr
     return ERetryErrorClass::NoRetry;
 }
 
-using TRetryPolicy = IRetryPolicy<TKeepAliveHttpClient::THttpCode>;
-using TSyncRetryPolicy = IRetryPolicy<const std::exception*, bool>;
+using TRetryPolicy = IRetryPolicy<const std::exception*>;
 
 struct TPrivateOauth2TokenExchangeParams: public TOauth2TokenExchangeParams {
     TPrivateOauth2TokenExchangeParams(const TOauth2TokenExchangeParams& params)
@@ -172,48 +165,65 @@ struct TPrivateOauth2TokenExchangeParams: public TOauth2TokenExchangeParams {
     }
 };
 
-class TOauth2TokenExchangeProviderImpl: public std::enable_shared_from_this<TOauth2TokenExchangeProviderImpl>
-{
+class TOauth2TokenExchangeProviderImpl final : public ICredentialsProvider {
     struct TTokenExchangeResult {
         std::string Token;
-        TInstant TokenDeadline;
         TInstant TokenRefreshTime;
     };
 
 public:
-    explicit TOauth2TokenExchangeProviderImpl(const TPrivateOauth2TokenExchangeParams& params)
+    TOauth2TokenExchangeProviderImpl(const TPrivateOauth2TokenExchangeParams& params,
+                                     std::weak_ptr<ICoreFacility> responseFacility)
         : Params(params)
+        , ResponseFacility(std::move(responseFacility))
+        , AuthInfo(NThreading::NewPromise<std::string>())
     {
-        ExchangeTokenSync(TInstant::Now());
+        ResponseFacility.expired() ? Stop() : Start();
+    }
+
+private:
+    void Start() {
+        try {
+            WorkerThread = std::thread([this] { Run(); });
+        } catch (...) {
+            Fail(std::current_exception());
+        }
     }
 
     void Stop() {
+        NThreading::TPromise<std::string> promise;
         {
             std::unique_lock<std::mutex> lock(StopMutex);
             Stopping = true;
             StopVar.notify_all();
         }
+        with_lock (Lock) {
+            promise = AuthInfo;
+        }
+        promise.TrySetException(std::make_exception_ptr(yexception() << PROV_ERR "stopped"));
 
-        if (RefreshTokenThread.joinable()) {
-            RefreshTokenThread.join();
+        if (WorkerThread.joinable()) {
+            WorkerThread.join();
         }
     }
 
-    std::string GetAuthInfo() const {
-        const TInstant now = TInstant::Now();
-        std::string token;
+public:
+    ~TOauth2TokenExchangeProviderImpl() {
+        Stop();
+    }
+
+    std::string GetAuthInfo() const override {
+        return GetAuthInfoAsync().GetValueSync();
+    }
+
+    NThreading::TFuture<std::string> GetAuthInfoAsync() const override {
         with_lock (Lock) {
-            if (Token.empty() || now >= TokenDeadline) { // Update sync. This can be if we have repeating error during token refresh process. In this case we will try for the last time and throw an error
-                ExchangeTokenSync(now, true);
-                token = Token;
-            } else {
-                if (now >= TokenRefreshTime) {
-                    TryRefreshToken();
-                }
-                token = Token; // Still valid
-            }
+            return AuthInfo.GetFuture();
         }
-        return token;
+    }
+
+    bool IsValid() const override {
+        return true;
     }
 
 private:
@@ -344,7 +354,6 @@ class TOauth2TokenExchangeProviderImpl: public std::enable_shared_from_this<TOau
 
         const TDuration expireDelta = TDuration::Seconds(expireTime);
         TTokenExchangeResult result;
-        result.TokenDeadline = now + expireDelta;
         result.TokenRefreshTime = now + expireDelta / 2;
         result.Token = TStringBuilder() << "Bearer " << token;
         return result;
@@ -361,31 +370,63 @@ class TOauth2TokenExchangeProviderImpl: public std::enable_shared_from_this<TOau
         return ProcessExchangeTokenResponse(now, statusCode, responseStream);
     }
 
-    void ExchangeTokenSync(TInstant now, bool retryAllErrors = false) const { // Is run under lock
-        TSyncRetryPolicy::IRetryState::TPtr retryState;
+    void Run() {
         while (true) {
-            try {
-                TTokenExchangeResult result = ExchangeToken(now);
-                Token = result.Token;
-                TokenDeadline = result.TokenDeadline;
-                TokenRefreshTime = result.TokenRefreshTime;
-                break;
-            } catch (const std::exception& ex) {
-                if (!retryState) {
-                    retryState = TSyncRetryPolicy::GetFixedIntervalPolicy( // retry more aggresively when we are in sync mode
-                        SyncRetryPolicyClass,
-                        TDuration::MilliSeconds(100), // delay // default
-                        TDuration::MilliSeconds(300), // long delay // default
-                        std::numeric_limits<size_t>::max(), // max retries // default
-                        Params.SyncUpdateTimeout_ // max time
-                    )->CreateRetryState();
+            TRetryPolicy::IRetryState::TPtr retryState;
+            TTokenExchangeResult result;
+            while (true) {
+                if (IsStopping()) {
+                    return;
+                }
+                try {
+                    result = ExchangeToken(TInstant::Now());
+                    break;
+                } catch (const std::exception& ex) {
+                    if (!retryState) {
+                        retryState = TRetryPolicy::GetExponentialBackoffPolicy(
+                            RetryPolicyClass,
+                            TDuration::MilliSeconds(10),
+                            TDuration::MilliSeconds(200),
+                            TDuration::Seconds(30))->CreateRetryState();
+                    }
+                    auto delay = retryState->GetNextRetryDelay(&ex);
+                    if (!delay) {
+                        Fail(std::current_exception());
+                        return;
+                    }
+                    std::unique_lock<std::mutex> lock(StopMutex);
+                    if (StopVar.wait_for(lock, TChronoDuration(delay->GetValue()), [this] { return Stopping; })) {
+                        return;
+                    }
+                } catch (...) {
+                    Fail(std::current_exception());
+                    return;
+                }
+            }
+
+            NThreading::TPromise<std::string> promise;
+            with_lock (Lock) {
+                promise = AuthInfo;
+            }
+            Complete([promise, token = std::move(result.Token)]() mutable {
+                promise.TrySetValue(std::move(token));
+            });
+
+            {
+                std::unique_lock<std::mutex> lock(StopMutex);
+                const auto delay = result.TokenRefreshTime - TInstant::Now();
+                if (delay > TDuration::Zero() &&
+                    StopVar.wait_for(lock, TChronoDuration(delay.GetValue()), [this] { return Stopping; }))
+                {
+                    return;
                 }
-                if (auto interval = retryState->GetNextRetryDelay(&ex, retryAllErrors)) {
-                    Sleep(*interval);
-                } else {
-                    throw;
+                if (Stopping) {
+                    return;
                 }
             }
+            with_lock (Lock) {
+                AuthInfo = NThreading::NewPromise<std::string>();
+            }
         }
     }
 
@@ -394,85 +435,32 @@ class TOauth2TokenExchangeProviderImpl: public std::enable_shared_from_this<TOau
         return Stopping;
     }
 
-    void RefreshToken() const {
-        TRetryPolicy::IRetryState::TPtr retryState;
-        TInstant deadline;
+    void Fail(std::exception_ptr error) const {
+        NThreading::TPromise<std::string> promise;
         with_lock (Lock) {
-            deadline = TokenDeadline;
-        }
-        while (!IsStopping()) {
-            const TInstant now = TInstant::Now();
-            try {
-                TTokenExchangeResult result = ExchangeToken(now);
-                with_lock (Lock) {
-                    Token = result.Token;
-                    TokenDeadline = result.TokenDeadline;
-                    TokenRefreshTime = result.TokenRefreshTime;
-                    break;
-                }
-            } catch (const std::exception& ex) { // If this error will repeat, we finally will get it syncronously in GetAuthInfo() and pass to client
-                if (!retryState) {
-                    retryState = TRetryPolicy::GetExponentialBackoffPolicy(
-                        RetryPolicyClass,
-                        TDuration::MilliSeconds(10), // min delay // default
-                        TDuration::MilliSeconds(200), // min long delay // default
-                        TDuration::Seconds(30), // max delay // default
-                        std::numeric_limits<size_t>::max(), // max retries // default
-                        deadline - TInstant::Now() // max time
-                    )->CreateRetryState();
-                } else {
-                    TKeepAliveHttpClient::THttpCode code = HTTP_CODE_MAX;
-                    if (const auto* err = dynamic_cast<const TTokenExchangeError*>(&ex)) {
-                        code = err->HttpCode;
-                    }
-                    if (auto delay = retryState->GetNextRetryDelay(code)) {
-                        std::unique_lock<std::mutex> lock(StopMutex);
-                        const bool stopping = StopVar.wait_for(
-                            lock,
-                            TChronoDuration(delay->GetValue()),
-                            [this]() {
-                                return Stopping;
-                            }
-                        );
-                        if (stopping) {
-                            break;
-                        }
-                    } else {
-                        break;
-                    }
-                }
-            }
+            promise = AuthInfo;
         }
-        TokenIsRefreshing.store(false);
+        Complete([promise, error = std::move(error)]() mutable {
+            promise.TrySetException(std::move(error));
+        });
     }
 
-    void TryRefreshToken() const { // Is run under lock
-        if (TokenIsRefreshing.load()) {
-            return;
-        }
-        if (RefreshTokenThread.joinable()) {
-            RefreshTokenThread.join();
-        }
-
-        TokenIsRefreshing.store(true);
-        RefreshTokenThread = std::thread(
-            [w = weak_from_this()]() {
-                if (auto p = w.lock()) {
-                    p->RefreshToken();
-                }
+    void Complete(TPostTaskCb&& callback) const noexcept {
+        try {
+            if (auto facility = ResponseFacility.lock()) {
+                facility->PostToResponseQueue(std::move(callback));
             }
-        );
+        } catch (...) {
+        }
     }
 
 private:
     TPrivateOauth2TokenExchangeParams Params;
+    std::weak_ptr<ICoreFacility> ResponseFacility;
 
-    TAdaptiveLock Lock;
-    mutable std::atomic<bool> TokenIsRefreshing = false;
-    mutable std::thread RefreshTokenThread;
-    mutable std::string Token;
-    mutable TInstant TokenDeadline;
-    mutable TInstant TokenRefreshTime;
+    mutable TAdaptiveLock Lock;
+    mutable NThreading::TPromise<std::string> AuthInfo;
+    std::thread WorkerThread;
 
     // Stop
     bool Stopping = false;
@@ -480,42 +468,31 @@ class TOauth2TokenExchangeProviderImpl: public std::enable_shared_from_this<TOau
     mutable std::condition_variable StopVar;
 };
 
-class TOauth2TokenExchangeProvider: public ICredentialsProvider {
-public:
-    explicit TOauth2TokenExchangeProvider(const TPrivateOauth2TokenExchangeParams& params)
-        : Impl(std::make_shared<TOauth2TokenExchangeProviderImpl>(params))
-    {
-    }
-
-    std::string GetAuthInfo() const override {
-        return Impl->GetAuthInfo();
-    }
-
-    bool IsValid() const override {
-        return true;
-    }
-
-    ~TOauth2TokenExchangeProvider() { // The last link tp provider is gone
-        Impl->Stop();
-    }
-
-private:
-    std::shared_ptr<TOauth2TokenExchangeProviderImpl> Impl;
-};
-
 class TOauth2TokenExchangeFactory: public ICredentialsProviderFactory {
 public:
     explicit TOauth2TokenExchangeFactory(const TOauth2TokenExchangeParams& params)
-        : Provider(std::make_shared<TOauth2TokenExchangeProvider>(params))
+        : Params(params)
     {
     }
 
     TCredentialsProviderPtr CreateProvider() const override {
+        std::lock_guard lock(Lock);
+        if (!Provider) {
+            auto facility = CreateSimpleCoreFacility();
+            Provider = std::make_shared<NCredentials::NDetail::TOwningFacilityCredentialsProvider>(
+                facility, std::make_shared<TOauth2TokenExchangeProviderImpl>(Params, facility));
+        }
         return Provider;
     }
 
+    TCredentialsProviderPtr CreateProvider(std::weak_ptr<ICoreFacility> facility) const override {
+        return std::make_shared<TOauth2TokenExchangeProviderImpl>(Params, std::move(facility));
+    }
+
 private:
-    std::shared_ptr<TOauth2TokenExchangeProvider> Provider;
+    TPrivateOauth2TokenExchangeParams Params;
+    mutable std::mutex Lock;
+    mutable TCredentialsProviderPtr Provider;
 };
 
 } // namespace
diff --git a/src/client/types/virtual_timestamp.cpp b/src/client/types/virtual_timestamp.cpp
new file mode 100644
index 00000000000..ae83730817c
--- /dev/null
+++ b/src/client/types/virtual_timestamp.cpp
@@ -0,0 +1,58 @@
+#include <ydb-cpp-sdk/client/types/virtual_timestamp.h>
+
+#include <util/stream/output.h>
+#include <util/string/printf.h>
+
+#include <tuple>
+
+namespace NYdb::inline V3 {
+namespace NScheme {
+
+TVirtualTimestamp::TVirtualTimestamp(uint64_t planStep, uint64_t txId)
+    : PlanStep(planStep)
+    , TxId(txId)
+{}
+
+TVirtualTimestamp::TVirtualTimestamp(const ::Ydb::VirtualTimestamp& proto)
+    : TVirtualTimestamp(proto.plan_step(), proto.tx_id())
+{}
+
+std::string TVirtualTimestamp::ToString() const {
+    TString result;
+    TStringOutput out(result);
+    Out(out);
+    return result;
+}
+
+void TVirtualTimestamp::Out(IOutputStream& out) const {
+    out << "{ plan_step: " << PlanStep
+      << ", tx_id: " << TxId
+      << " }";
+}
+
+bool TVirtualTimestamp::operator<(const TVirtualTimestamp& rhs) const {
+    return std::tie(PlanStep, TxId) < std::tie(rhs.PlanStep, rhs.TxId);
+}
+
+bool TVirtualTimestamp::operator<=(const TVirtualTimestamp& rhs) const {
+    return std::tie(PlanStep, TxId) <= std::tie(rhs.PlanStep, rhs.TxId);
+}
+
+bool TVirtualTimestamp::operator>(const TVirtualTimestamp& rhs) const {
+    return std::tie(PlanStep, TxId) > std::tie(rhs.PlanStep, rhs.TxId);
+}
+
+bool TVirtualTimestamp::operator>=(const TVirtualTimestamp& rhs) const {
+    return std::tie(PlanStep, TxId) >= std::tie(rhs.PlanStep, rhs.TxId);
+}
+
+bool TVirtualTimestamp::operator==(const TVirtualTimestamp& rhs) const {
+    return PlanStep == rhs.PlanStep && TxId == rhs.TxId;
+}
+
+bool TVirtualTimestamp::operator!=(const TVirtualTimestamp& rhs) const {
+    return !(*this == rhs);
+}
+
+} // namespace NScheme
+} // namespace NYdb
diff --git a/src/library/grpc/client/grpc_client_low.cpp b/src/library/grpc/client/grpc_client_low.cpp
index a54553e2110..30d7f29af43 100644
--- a/src/library/grpc/client/grpc_client_low.cpp
+++ b/src/library/grpc/client/grpc_client_low.cpp
@@ -216,7 +216,32 @@ void TChannelPool::EraseFromQueueByTime(const TInstant& lastUseTime, const std::
     LastUsedQueue_.erase(pos);
 }
 
+namespace {
+
+thread_local bool IsGrpcWorkerThread = false;
+
+class TGrpcWorkerThreadGuard {
+public:
+    TGrpcWorkerThreadGuard() {
+        IsGrpcWorkerThread = true;
+    }
+
+    ~TGrpcWorkerThreadGuard() {
+        IsGrpcWorkerThread = PreviousValue_;
+    }
+
+private:
+    const bool PreviousValue_ = IsGrpcWorkerThread;
+};
+
+} // namespace
+
+bool IsGRpcCompletionThread() {
+    return IsGrpcWorkerThread;
+}
+
 static void PullEvents(grpc::CompletionQueue* cq) {
+    TGrpcWorkerThreadGuard guard;
     TThread::SetCurrentThreadName("grpc_client");
     while (true) {
         void* tag;
diff --git a/src/library/grpc/client/grpc_client_low.h b/src/library/grpc/client/grpc_client_low.h
index fb0ae5b55af..42852001e8a 100644
--- a/src/library/grpc/client/grpc_client_low.h
+++ b/src/library/grpc/client/grpc_client_low.h
@@ -14,6 +14,8 @@
 
 #include <deque>
 #include <condition_variable>
+#include <functional>
+#include <memory>
 #include <typeinfo>
 #include <variant>
 #include <vector>
@@ -34,6 +36,8 @@ const size_t DEFAULT_NUM_THREADS = 2;
 
 void EnableGRpcTracing();
 
+bool IsGRpcCompletionThread();
+
 ////////////////////////////////////////////////////////////////////////////////
 
 struct TTcpKeepAliveSettings {
@@ -91,14 +95,48 @@ class TQueueClientFixedEvent : private IQueueClientEvent {
 class IQueueClientContext;
 using IQueueClientContextPtr = std::shared_ptr<IQueueClientContext>;
 
+class IQueueClientCallbackGuard {
+public:
+    virtual ~IQueueClientCallbackGuard() = default;
+    virtual bool IsEntered() const noexcept = 0;
+};
+
+class TNoopQueueClientCallbackGuard final : public IQueueClientCallbackGuard {
+public:
+    bool IsEntered() const noexcept override {
+        return true;
+    }
+};
+
+using TQueueClientCallbackGuardFactory = std::function<std::unique_ptr<IQueueClientCallbackGuard>()>;
+
 // Provider of IQueueClientContext instances
 class IQueueClientContextProvider {
 public:
     virtual ~IQueueClientContextProvider() = default;
 
     virtual IQueueClientContextPtr CreateContext() = 0;
+
+    virtual TQueueClientCallbackGuardFactory GetCallbackGuardFactory() {
+        return [] {
+            return std::make_unique<TNoopQueueClientCallbackGuard>();
+        };
+    }
 };
 
+template<class F>
+void RunQueueClientCallback(const TQueueClientCallbackGuardFactory& guardFactory, F&& f) {
+    std::unique_ptr<IQueueClientCallbackGuard> guard;
+    if (guardFactory) {
+        guard = guardFactory();
+    } else {
+        guard = std::make_unique<TNoopQueueClientCallbackGuard>();
+    }
+    if (guard->IsEntered()) {
+        f();
+    }
+}
+
 // Activity context for a low-level client
 class IQueueClientContext : public IQueueClientContextProvider {
 public:
@@ -208,9 +246,19 @@ class TGRpcRequestProcessorCommon {
 
     void GetInitialMetadata(std::unordered_multimap<std::string, std::string>* metadata);
 
+    void InitCallbackGuard(IQueueClientContextProvider* provider) {
+        CallbackGuardFactory_ = provider->GetCallbackGuardFactory();
+    }
+
+    template<class F>
+    void RunGuarded(F&& f) {
+        RunQueueClientCallback(CallbackGuardFactory_, std::forward<F>(f));
+    }
+
     grpc::Status Status;
     grpc::ClientContext Context;
     std::shared_ptr<IQueueClientContext> LocalContext;
+    TQueueClientCallbackGuardFactory CallbackGuardFactory_;
 };
 
 template<typename TStub, typename TRequest, typename TResponse>
@@ -230,7 +278,9 @@ class TSimpleRequestProcessor
 
     ~TSimpleRequestProcessor() {
         if (!Replied_ && Callback_) {
-            Callback_(TGrpcStatus::Internal("request left unhandled"), std::move(Reply_));
+            RunGuarded([&] {
+                Callback_(TGrpcStatus::Internal("request left unhandled"), std::move(Reply_));
+            });
             Callback_ = nullptr; // free resources as early as possible
         }
     }
@@ -247,7 +297,9 @@ class TSimpleRequestProcessor
             status = TGrpcStatus::Internal("Unexpected error");
         }
         Replied_ = true;
-        Callback_(std::move(status), std::move(Reply_));
+        RunGuarded([&] {
+            Callback_(std::move(status), std::move(Reply_));
+        });
         Callback_ = nullptr; // free resources as early as possible
         return false;
     }
@@ -263,10 +315,13 @@ class TSimpleRequestProcessor
     }
 
     void Start(TStub& stub, TAsyncRequest asyncRequest, const TRequest& request, IQueueClientContextProvider* provider) {
+        InitCallbackGuard(provider);
         auto context = provider->CreateContext();
         if (!context) {
             Replied_ = true;
-            Callback_(TGrpcStatus(grpc::StatusCode::CANCELLED, "Client is shutting down"), std::move(Reply_));
+            RunGuarded([&] {
+                Callback_(TGrpcStatus(grpc::StatusCode::CANCELLED, "Client is shutting down"), std::move(Reply_));
+            });
             Callback_ = nullptr;
             return;
         }
@@ -310,7 +365,9 @@ class TAdvancedRequestProcessor
 
     ~TAdvancedRequestProcessor() {
         if (!Replied_ && Callback_) {
-            Callback_(Context, TGrpcStatus::Internal("request left unhandled"), std::move(Reply_));
+            RunGuarded([&] {
+                Callback_(Context, TGrpcStatus::Internal("request left unhandled"), std::move(Reply_));
+            });
             Callback_ = nullptr; // free resources as early as possible
         }
     }
@@ -327,7 +384,9 @@ class TAdvancedRequestProcessor
             status = TGrpcStatus::Internal("Unexpected error");
         }
         Replied_ = true;
-        Callback_(Context, std::move(status), std::move(Reply_));
+        RunGuarded([&] {
+            Callback_(Context, std::move(status), std::move(Reply_));
+        });
         Callback_ = nullptr; // free resources as early as possible
         return false;
     }
@@ -343,10 +402,13 @@ class TAdvancedRequestProcessor
     }
 
     void Start(TStub& stub, TAsyncRequest asyncRequest, const TRequest& request, IQueueClientContextProvider* provider) {
+        InitCallbackGuard(provider);
         auto context = provider->CreateContext();
         if (!context) {
             Replied_ = true;
-            Callback_(Context, TGrpcStatus(grpc::StatusCode::CANCELLED, "Client is shutting down"), std::move(Reply_));
+            RunGuarded([&] {
+                Callback_(Context, TGrpcStatus(grpc::StatusCode::CANCELLED, "Client is shutting down"), std::move(Reply_));
+            });
             Callback_ = nullptr;
             return;
         }
@@ -583,7 +645,9 @@ class TStreamRequestReadProcessor
             }
         }
 
-        callback(std::move(status));
+        RunGuarded([&] {
+            callback(std::move(status));
+        });
     }
 
     void Read(TResponse* message, TReadCallback callback) override {
@@ -611,7 +675,9 @@ class TStreamRequestReadProcessor
             status = TGrpcStatus(grpc::StatusCode::OUT_OF_RANGE, "Read EOF");
         }
 
-        callback(std::move(status));
+        RunGuarded([&] {
+            callback(std::move(status));
+        });
     }
 
     void Finish(TReadCallback callback) override {
@@ -636,7 +702,9 @@ class TStreamRequestReadProcessor
             }
         }
 
-        callback(std::move(status));
+        RunGuarded([&] {
+            callback(std::move(status));
+        });
     }
 
     void AddFinishedCallback(TReadCallback callback) override {
@@ -660,16 +728,21 @@ class TStreamRequestReadProcessor
             }
         }
 
-        callback(std::move(status));
+        RunGuarded([&] {
+            callback(std::move(status));
+        });
     }
 
 private:
     void Start(TStub& stub, const TRequest& request, TAsyncRequest asyncRequest, IQueueClientContextProvider* provider) {
+        InitCallbackGuard(provider);
         auto context = provider->CreateContext();
         if (!context) {
             auto callback = std::move(Callback);
             TGrpcStatus status(grpc::StatusCode::CANCELLED, "Client is shutting down");
-            callback(std::move(status), nullptr);
+            RunGuarded([&] {
+                callback(std::move(status), nullptr);
+            });
             return;
         }
 
@@ -717,7 +790,9 @@ class TStreamRequestReadProcessor
             GetInitialMetadata(initialMetadata);
         }
 
-        callback(std::move(status));
+        RunGuarded([&] {
+            callback(std::move(status));
+        });
     }
 
     void OnStartDone(bool ok) {
@@ -735,7 +810,9 @@ class TStreamRequestReadProcessor
             Callback = nullptr;
         }
 
-        callback({ }, typename TBase::TPtr(this));
+        RunGuarded([&] {
+            callback({ }, typename TBase::TPtr(this));
+        });
     }
 
     void OnFinished(bool ok) {
@@ -780,14 +857,18 @@ class TStreamRequestReadProcessor
 
         for (auto& finishedCallback : finishedCallbacks) {
             auto statusCopy = status;
-            finishedCallback(std::move(statusCopy));
+            RunGuarded([&] {
+                finishedCallback(std::move(statusCopy));
+            });
         }
 
         if (startCallback) {
             if (status.Ok()) {
                 status = TGrpcStatus(grpc::StatusCode::UNKNOWN, "Unknown stream failure");
             }
-            startCallback(std::move(status), nullptr);
+            RunGuarded([&] {
+                startCallback(std::move(status), nullptr);
+            });
         } else if (readCallback) {
             if (status.Ok()) {
                 status = TGrpcStatus(grpc::StatusCode::OUT_OF_RANGE, "Read EOF");
@@ -797,9 +878,13 @@ class TStreamRequestReadProcessor
                         std::string(value.begin(), value.end()));
                 }
             }
-            readCallback(std::move(status));
+            RunGuarded([&] {
+                readCallback(std::move(status));
+            });
         } else if (finishCallback) {
-            finishCallback(std::move(status));
+            RunGuarded([&] {
+                finishCallback(std::move(status));
+            });
         }
     }
 
@@ -886,7 +971,9 @@ class TStreamRequestReadWriteProcessor
         }
 
         if (!status.Ok() && callback) {
-            callback(std::move(status));
+            RunGuarded([&] {
+                callback(std::move(status));
+            });
         }
     }
 
@@ -916,7 +1003,9 @@ class TStreamRequestReadWriteProcessor
             }
         }
 
-        callback(std::move(status));
+        RunGuarded([&] {
+            callback(std::move(status));
+        });
     }
 
     void Read(TResponse* message, TReadCallback callback) override {
@@ -944,7 +1033,9 @@ class TStreamRequestReadWriteProcessor
             status = TGrpcStatus(grpc::StatusCode::OUT_OF_RANGE, "Read EOF");
         }
 
-        callback(std::move(status));
+        RunGuarded([&] {
+            callback(std::move(status));
+        });
     }
 
     void Finish(TReadCallback callback) override {
@@ -974,7 +1065,9 @@ class TStreamRequestReadWriteProcessor
             }
         }
 
-        callback(std::move(status));
+        RunGuarded([&] {
+            callback(std::move(status));
+        });
     }
 
     void AddFinishedCallback(TReadCallback callback) override {
@@ -998,18 +1091,23 @@ class TStreamRequestReadWriteProcessor
             }
         }
 
-        callback(std::move(status));
+        RunGuarded([&] {
+            callback(std::move(status));
+        });
     }
 
 private:
     template<typename> friend class TServiceConnection;
 
     void Start(TStub& stub, TAsyncRequest asyncRequest, IQueueClientContextProvider* provider) {
+        InitCallbackGuard(provider);
         auto context = provider->CreateContext();
         if (!context) {
             auto callback = std::move(ConnectedCallback);
             TGrpcStatus status(grpc::StatusCode::CANCELLED, "Client is shutting down");
-            callback(std::move(status), nullptr);
+            RunGuarded([&] {
+                callback(std::move(status), nullptr);
+            });
             return;
         }
 
@@ -1042,7 +1140,9 @@ class TStreamRequestReadWriteProcessor
             ConnectedCallback = nullptr;
         }
 
-        callback({ }, typename TBase::TPtr(this));
+        RunGuarded([&] {
+            callback({ }, typename TBase::TPtr(this));
+        });
     }
 
     void OnReadDone(bool ok) {
@@ -1082,7 +1182,9 @@ class TStreamRequestReadWriteProcessor
             GetInitialMetadata(initialMetadata);
         }
 
-        callback(std::move(status));
+        RunGuarded([&] {
+            callback(std::move(status));
+        });
     }
 
     void OnWriteDone(bool ok) {
@@ -1121,7 +1223,9 @@ class TStreamRequestReadWriteProcessor
         }
 
         if (okCallback) {
-            okCallback(TGrpcStatus());
+            RunGuarded([&] {
+                okCallback(TGrpcStatus());
+            });
         }
     }
 
@@ -1172,20 +1276,26 @@ class TStreamRequestReadWriteProcessor
                 if (writeStatus.Ok()) {
                     writeStatus = TGrpcStatus(grpc::StatusCode::CANCELLED, "Write request dropped");
                 }
-                item.Callback(std::move(writeStatus));
+                RunGuarded([&] {
+                    item.Callback(std::move(writeStatus));
+                });
             }
         }
 
         for (auto& finishedCallback : finishedCallbacks) {
             TGrpcStatus statusCopy = status;
-            finishedCallback(std::move(statusCopy));
+            RunGuarded([&] {
+                finishedCallback(std::move(statusCopy));
+            });
         }
 
         if (connectedCallback) {
             if (status.Ok()) {
                 status = TGrpcStatus(grpc::StatusCode::UNKNOWN, "Unknown stream failure");
             }
-            connectedCallback(std::move(status), nullptr);
+            RunGuarded([&] {
+                connectedCallback(std::move(status), nullptr);
+            });
         } else if (readCallback) {
             if (status.Ok()) {
                 status = TGrpcStatus(grpc::StatusCode::OUT_OF_RANGE, "Read EOF");
@@ -1195,9 +1305,13 @@ class TStreamRequestReadWriteProcessor
                         std::string(value.begin(), value.end()));
                 }
             }
-            readCallback(std::move(status));
+            RunGuarded([&] {
+                readCallback(std::move(status));
+            });
         } else if (finishCallback) {
-            finishCallback(std::move(status));
+            RunGuarded([&] {
+                finishCallback(std::move(status));
+            });
         }
     }
 
diff --git a/src/library/grpc/client/grpc_common.cpp b/src/library/grpc/client/grpc_common.cpp
index 23f4dcbc2ca..3a2d7efa289 100644
--- a/src/library/grpc/client/grpc_common.cpp
+++ b/src/library/grpc/client/grpc_common.cpp
@@ -8,7 +8,6 @@
 #include <openssl/pem.h>
 #include <openssl/ssl.h>
 #include <openssl/x509.h>
-#include <openssl/x509v3.h>
 
 #include <memory>
 #include <string>
@@ -55,36 +54,26 @@ bool ValidateRootCertificates(const std::string& pemRootCerts, std::string& erro
     size_t certsParsed = 0;
     while (true) {
         std::unique_ptr<X509, decltype(&X509_free)> cert(
-            PEM_read_bio_X509(rootCertsBio, nullptr, nullptr, nullptr),
+            PEM_read_bio_X509_AUX(rootCertsBio, nullptr, nullptr, nullptr),
             &X509_free);
         if (!cert) {
-            const unsigned long errorCode = ERR_peek_last_error();
-            if (errorCode == 0 || ERR_GET_REASON(errorCode) == PEM_R_NO_START_LINE) {
-                ERR_clear_error();
-                break;
+            if (certsParsed == 0) {
+                errorMessage = "root CA PEM: failed to parse certificate #1: " + DrainOpenSslErrors();
+                return false;
             }
-            errorMessage = "root CA PEM: " + DrainOpenSslErrors();
-            return false;
-        }
 
-        std::unique_ptr<BASIC_CONSTRAINTS, decltype(&BASIC_CONSTRAINTS_free)> basicConstraints(
-            static_cast<BASIC_CONSTRAINTS*>(X509_get_ext_d2i(cert.get(), NID_basic_constraints, nullptr, nullptr)),
-            &BASIC_CONSTRAINTS_free);
-        const auto isCaCert = basicConstraints && basicConstraints->ca;
-
-        if (!isCaCert) {
+            // gRPC treats a read error as the end of the bundle and uses all
+            // certificates parsed before it.
             ERR_clear_error();
-            errorMessage = "root CA PEM: certificate is not a CA (BasicConstraints)";
-            return false;
+            break;
         }
+
+        // Match gRPC trust store semantics: with X509_V_FLAG_PARTIAL_CHAIN an
+        // explicitly trusted non-CA certificate may also be a trust anchor.
         ERR_clear_error();
         ++certsParsed;
     }
 
-    if (certsParsed == 0) {
-        errorMessage = "root CA PEM: no certificates parsed";
-        return false;
-    }
     return true;
 }
 
diff --git a/src/library/kafka/kafka_messages_int.h b/src/library/kafka/kafka_messages_int.h
index 99469c65fa1..89543bf4b54 100644
--- a/src/library/kafka/kafka_messages_int.h
+++ b/src/library/kafka/kafka_messages_int.h
@@ -640,7 +640,7 @@ class TypeStrategy<Meta, std::vector<TValueType>, TKafkaArrayDesc> {
 //
 template<typename Meta>
 inline void Write(TWriteCollector& collector, TKafkaWritable& writable, TKafkaInt16 version, const typename Meta::Type& value) {
-    if (VersionCheck<Meta::PresentVersions.Min, Meta::PresentVersions.Max>(version)) { 
+    if (VersionCheck<Meta::PresentVersions.Min, Meta::PresentVersions.Max>(version)) {
         if (VersionCheck<Meta::TaggedVersions.Min, Meta::TaggedVersions.Max>(version)) {
             if (!IsDefaultValue<Meta>(value)) {
                 ++collector.NumTaggedFields;
@@ -653,7 +653,7 @@ inline void Write(TWriteCollector& collector, TKafkaWritable& writable, TKafkaIn
 
 template<typename Meta>
 inline void Read(TKafkaReadable& readable, TKafkaInt16 version, typename Meta::Type& value) {
-    if (!VersionNone<Meta::TaggedVersions.Min, Meta::TaggedVersions.Max>() 
+    if (!VersionNone<Meta::TaggedVersions.Min, Meta::TaggedVersions.Max>()
         && VersionCheck<Meta::TaggedVersions.Min, Meta::TaggedVersions.Max>(version)) {
         return;
     } else {
diff --git a/src/library/operation_id/operation_id.cpp b/src/library/operation_id/operation_id.cpp
index d4c78ff18b3..fef20733293 100644
--- a/src/library/operation_id/operation_id.cpp
+++ b/src/library/operation_id/operation_id.cpp
@@ -82,6 +82,9 @@ std::string ProtoToString(const Ydb::TOperationId& proto) {
         case Ydb::TOperationId::ANALYZE:
             res << "ydb://analyze";
             break;
+        case Ydb::TOperationId::SET_NOT_NULL:
+            res << "ydb://setnotnull";
+            break;
         default:
             Y_ABORT_UNLESS(false, "unexpected kind");
     }
@@ -345,6 +348,10 @@ TOperationId::EKind ParseKind(const std::string_view value) {
         return TOperationId::ANALYZE;
     }
 
+    if (value.starts_with("setnotnull")) {
+        return TOperationId::SET_NOT_NULL;
+    }
+
     return TOperationId::UNUSED;
 }
 
diff --git a/src/library/operation_id/protos/operation_id.proto b/src/library/operation_id/protos/operation_id.proto
index 3791f0d3f08..296c37761b2 100644
--- a/src/library/operation_id/protos/operation_id.proto
+++ b/src/library/operation_id/protos/operation_id.proto
@@ -20,6 +20,7 @@ message TOperationId {
         COMPACTION = 13;
         FULL_BACKUP = 14;
         ANALYZE = 15;
+        SET_NOT_NULL = 16;
     }
 
     message TData {
diff --git a/tests/common/iam_mocks/iam_grpc_mock_server.cpp b/tests/common/iam_mocks/iam_grpc_mock_server.cpp
index a07a54fef8c..e6bd55103e2 100644
--- a/tests/common/iam_mocks/iam_grpc_mock_server.cpp
+++ b/tests/common/iam_mocks/iam_grpc_mock_server.cpp
@@ -10,6 +10,11 @@ void TIamTokenServiceStub::SetResponseToken(const std::string& token, int64_t ex
     ExpiresAtSeconds_ = expiresAtSeconds;
 }
 
+void TIamTokenServiceStub::SetStatus(grpc::Status status) {
+    std::lock_guard lock(Lock_);
+    Status_ = std::move(status);
+}
+
 grpc::Status TIamTokenServiceStub::Create(
     grpc::ServerContext*,
     const yandex::cloud::iam::v1::CreateIamTokenRequest* request,
@@ -19,6 +24,9 @@ grpc::Status TIamTokenServiceStub::Create(
     ++RequestCount_;
     LastRequest_ = *request;
     HasLastRequest_ = true;
+    if (!Status_.ok()) {
+        return Status_;
+    }
     response->set_iam_token(IamToken_);
     response->mutable_expires_at()->set_seconds(ExpiresAtSeconds_);
     response->mutable_expires_at()->set_nanos(0);
diff --git a/tests/common/iam_mocks/iam_grpc_mock_server.h b/tests/common/iam_mocks/iam_grpc_mock_server.h
index cb1666636ee..08747041ac9 100644
--- a/tests/common/iam_mocks/iam_grpc_mock_server.h
+++ b/tests/common/iam_mocks/iam_grpc_mock_server.h
@@ -21,6 +21,7 @@ namespace NYdb::NTest {
 class TIamTokenServiceStub final : public yandex::cloud::iam::v1::IamTokenService::Service {
 public:
     void SetResponseToken(const std::string& token, int64_t expiresAtSeconds = 4102444800);
+    void SetStatus(grpc::Status status);
 
     grpc::Status Create(
         grpc::ServerContext*,
@@ -34,6 +35,7 @@ class TIamTokenServiceStub final : public yandex::cloud::iam::v1::IamTokenServic
 private:
     mutable std::mutex Lock_;
     std::string IamToken_;
+    grpc::Status Status_;
     int64_t ExpiresAtSeconds_ = 4102444800;
     int RequestCount_ = 0;
     yandex::cloud::iam::v1::CreateIamTokenRequest LastRequest_;
diff --git a/tests/integration/metrics/main.cpp b/tests/integration/metrics/main.cpp
index 4ae308fd891..5616f670d5b 100644
--- a/tests/integration/metrics/main.cpp
+++ b/tests/integration/metrics/main.cpp
@@ -188,14 +188,26 @@ TEST(QueryMetricsIntegration, CreateSessionRecordsDuration) {
     auto args = MakeRunArgs();
     TQueryClient client(args.Driver, TClientSettings().Database(args.Database));
 
-    auto session = client.GetSession().ExtractValueSync();
-    ASSERT_TRUE(session.IsSuccess()) << session.GetIssues().ToString();
+    std::string sessionId;
+    {
+        auto sessionResult = client.GetSession().ExtractValueSync();
+        ASSERT_TRUE(sessionResult.IsSuccess()) << sessionResult.GetIssues().ToString();
+        sessionId = sessionResult.GetSession().GetId();
+    }
+
+    ASSERT_EQ(client.GetCurrentPoolSize(), 1);
+
+    {
+        auto sessionResult = client.GetSession().ExtractValueSync();
+        ASSERT_TRUE(sessionResult.IsSuccess()) << sessionResult.GetIssues().ToString();
+        EXPECT_EQ(sessionResult.GetSession().GetId(), sessionId);
+    }
 
     auto duration = args.Registry->GetHistogram(
         "ydb.client.operation.duration",
         DurationLabels(args.Database, "CreateSession", args.ServerAddress, args.ServerPort));
     ASSERT_NE(duration, nullptr) << "CreateSession duration histogram not created";
-    EXPECT_GE(duration->Count(), 1u);
+    EXPECT_EQ(duration->Count(), 1u);
 
     args.Driver.Stop(true);
 }
diff --git a/tests/slo_workloads/Dockerfile b/tests/slo_workloads/Dockerfile
index 5a5c7f28214..e51001c12cf 100644
--- a/tests/slo_workloads/Dockerfile
+++ b/tests/slo_workloads/Dockerfile
@@ -61,13 +61,13 @@ RUN wget $WGET_OPTS https://github.com/Kitware/CMake/releases/download/v${CMAKE_
     && rm cmake-install.sh
 
 # Install LLVM
-ENV LLVM_VERSION=16
+ENV LLVM_VERSION=17
 RUN wget $WGET_OPTS https://apt.llvm.org/llvm.sh && \
     chmod u+x llvm.sh && \
     ./llvm.sh ${LLVM_VERSION} && \
     rm llvm.sh
 
-# Update alternatives to use clang-16 by default
+# Update alternatives to use the selected Clang version by default
 RUN update-alternatives --install /usr/bin/clang clang /usr/bin/clang-${LLVM_VERSION} 10000 && \
     update-alternatives --install /usr/bin/clangd clangd /usr/bin/clangd-${LLVM_VERSION} 10000 && \
     update-alternatives --install /usr/bin/clang++ clang++ /usr/bin/clang++-${LLVM_VERSION} 10000
@@ -88,18 +88,19 @@ RUN wget $WGET_OPTS -O abseil-cpp-${ABSEIL_CPP_VERSION}.tar.gz https://github.co
     rm -rf abseil-cpp-${ABSEIL_CPP_VERSION}.tar.gz abseil-cpp-${ABSEIL_CPP_VERSION}
 
 # Install protobuf
-ENV PROTOBUF_VERSION=3.21.12
+ENV PROTOBUF_VERSION=25.0
 ENV PROTOBUF_INSTALL_DIR=/root/ydb_deps/protobuf
 RUN wget $WGET_OPTS -O protobuf-${PROTOBUF_VERSION}.tar.gz https://github.com/protocolbuffers/protobuf/archive/refs/tags/v${PROTOBUF_VERSION}.tar.gz && \
     tar -xvzf protobuf-${PROTOBUF_VERSION}.tar.gz && cd protobuf-${PROTOBUF_VERSION} && \
     mkdir build && cd build && \
-    cmake -G Ninja -DCMAKE_BUILD_TYPE=Release -Dprotobuf_BUILD_TESTS=OFF -Dprotobuf_INSTALL=ON -Dprotobuf_ABSL_PROVIDER=package .. && \
+    cmake -G Ninja -DCMAKE_PREFIX_PATH="${ABSEIL_CPP_INSTALL_DIR}" \
+    -DCMAKE_BUILD_TYPE=Release -Dprotobuf_BUILD_TESTS=OFF -Dprotobuf_INSTALL=ON -Dprotobuf_ABSL_PROVIDER=package .. && \
     cmake --build . --config Release && \
     cmake --install . --config Release --prefix ${PROTOBUF_INSTALL_DIR} && \
     rm -rf protobuf-${PROTOBUF_VERSION}.tar.gz protobuf-${PROTOBUF_VERSION}
 
 # Install grpc
-ENV GRPC_VERSION=1.54.3
+ENV GRPC_VERSION=1.60.2
 ENV GRPC_INSTALL_DIR=/root/ydb_deps/grpc
 RUN wget $WGET_OPTS -O grpc-${GRPC_VERSION}.tar.gz https://github.com/grpc/grpc/archive/refs/tags/v${GRPC_VERSION}.tar.gz && \
     tar -xvzf grpc-${GRPC_VERSION}.tar.gz && cd grpc-${GRPC_VERSION} && \
@@ -132,9 +133,9 @@ ENV BROTLI_INSTALL_DIR=/root/ydb_deps/brotli
 RUN wget $WGET_OPTS -O brotli-${BROTLI_VERSION}.tar.gz https://github.com/google/brotli/archive/refs/tags/v${BROTLI_VERSION}.tar.gz && \
     tar -xvzf brotli-${BROTLI_VERSION}.tar.gz && cd brotli-${BROTLI_VERSION} && \
     mkdir build && cd build && \
-    cmake -G Ninja -DCMAKE_BUILD_TYPE=Release .. && \
+    cmake -G Ninja -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=${BROTLI_INSTALL_DIR} .. && \
     cmake --build . --config Release && \
-    cmake --install . --config Release --prefix ${BROTLI_INSTALL_DIR} && \
+    cmake --install . --config Release && \
     rm -rf brotli-${BROTLI_VERSION}.tar.gz brotli-${BROTLI_VERSION}
 
 # Install jwt-cpp
diff --git a/tests/slo_workloads/Dockerfile.userver b/tests/slo_workloads/Dockerfile.userver
index c14b20bb4ee..42b29517e65 100644
--- a/tests/slo_workloads/Dockerfile.userver
+++ b/tests/slo_workloads/Dockerfile.userver
@@ -58,7 +58,7 @@ RUN wget $WGET_OPTS https://github.com/Kitware/CMake/releases/download/v${CMAKE_
     && rm cmake-install.sh
 
 # Install LLVM
-ENV LLVM_VERSION=16
+ENV LLVM_VERSION=17
 RUN wget $WGET_OPTS https://apt.llvm.org/llvm.sh && \
     chmod u+x llvm.sh && \
     ./llvm.sh ${LLVM_VERSION} && \
@@ -83,18 +83,19 @@ RUN wget $WGET_OPTS -O abseil-cpp-${ABSEIL_CPP_VERSION}.tar.gz https://github.co
     rm -rf abseil-cpp-${ABSEIL_CPP_VERSION}.tar.gz abseil-cpp-${ABSEIL_CPP_VERSION}
 
 # Install protobuf
-ENV PROTOBUF_VERSION=3.21.12
+ENV PROTOBUF_VERSION=25.0
 ENV PROTOBUF_INSTALL_DIR=/root/ydb_deps/protobuf
 RUN wget $WGET_OPTS -O protobuf-${PROTOBUF_VERSION}.tar.gz https://github.com/protocolbuffers/protobuf/archive/refs/tags/v${PROTOBUF_VERSION}.tar.gz && \
     tar -xvzf protobuf-${PROTOBUF_VERSION}.tar.gz && cd protobuf-${PROTOBUF_VERSION} && \
     mkdir build && cd build && \
-    cmake -G Ninja -DCMAKE_BUILD_TYPE=Release -Dprotobuf_BUILD_TESTS=OFF -Dprotobuf_INSTALL=ON -Dprotobuf_ABSL_PROVIDER=package .. && \
+    cmake -G Ninja -DCMAKE_PREFIX_PATH="${ABSEIL_CPP_INSTALL_DIR}" \
+    -DCMAKE_BUILD_TYPE=Release -Dprotobuf_BUILD_TESTS=OFF -Dprotobuf_INSTALL=ON -Dprotobuf_ABSL_PROVIDER=package .. && \
     cmake --build . --config Release && \
     cmake --install . --config Release --prefix ${PROTOBUF_INSTALL_DIR} && \
     rm -rf protobuf-${PROTOBUF_VERSION}.tar.gz protobuf-${PROTOBUF_VERSION}
 
 # Install grpc
-ENV GRPC_VERSION=1.54.3
+ENV GRPC_VERSION=1.60.2
 ENV GRPC_INSTALL_DIR=/root/ydb_deps/grpc
 RUN wget $WGET_OPTS -O grpc-${GRPC_VERSION}.tar.gz https://github.com/grpc/grpc/archive/refs/tags/v${GRPC_VERSION}.tar.gz && \
     tar -xvzf grpc-${GRPC_VERSION}.tar.gz && cd grpc-${GRPC_VERSION} && \
@@ -127,9 +128,9 @@ ENV BROTLI_INSTALL_DIR=/root/ydb_deps/brotli
 RUN wget $WGET_OPTS -O brotli-${BROTLI_VERSION}.tar.gz https://github.com/google/brotli/archive/refs/tags/v${BROTLI_VERSION}.tar.gz && \
     tar -xvzf brotli-${BROTLI_VERSION}.tar.gz && cd brotli-${BROTLI_VERSION} && \
     mkdir build && cd build && \
-    cmake -G Ninja -DCMAKE_BUILD_TYPE=Release .. && \
+    cmake -G Ninja -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=${BROTLI_INSTALL_DIR} .. && \
     cmake --build . --config Release && \
-    cmake --install . --config Release --prefix ${BROTLI_INSTALL_DIR} && \
+    cmake --install . --config Release && \
     rm -rf brotli-${BROTLI_VERSION}.tar.gz brotli-${BROTLI_VERSION}
 
 # Install jwt-cpp
diff --git a/tests/unit/client/CMakeLists.txt b/tests/unit/client/CMakeLists.txt
index b5574c44af6..95d7afa2284 100644
--- a/tests/unit/client/CMakeLists.txt
+++ b/tests/unit/client/CMakeLists.txt
@@ -12,6 +12,7 @@ add_ydb_test(NAME client-connection_string_ut GTEST
 add_ydb_test(NAME client-coordination_ut
   SOURCES
     coordination/coordination_ut.cpp
+    coordination/distributed_lock_ut.cpp
   LINK_LIBRARIES
     YDB-CPP-SDK::Coordination
     api-grpc
@@ -174,7 +175,11 @@ add_ydb_test(NAME client-build_info_ut GTEST
 add_ydb_test(NAME client-query_session_ut
   SOURCES
     query/client_session_ut.cpp
+    query/deferred_session_creation_ut.cpp
   LINK_LIBRARIES
+    api-grpc
+    cpp-testing-common
+    YDB-CPP-SDK::Query
     client-ydb_query-impl
     impl-session
     library-operation_id
@@ -185,6 +190,7 @@ add_ydb_test(NAME client-query_session_ut
 add_ydb_test(NAME client-query_stats_ut
   SOURCES
     query/query_stats_ut.cpp
+    query/virtual_timestamp_ut.cpp
   LINK_LIBRARIES
     YDB-CPP-SDK::Query
   LABELS
@@ -245,4 +251,4 @@ add_ydb_test(NAME client-metric_buffer_ut GTEST
     client-metrics
   LABELS
     unit
-)
\ No newline at end of file
+)
diff --git a/tests/unit/client/coordination/coordination_grpc_mock.h b/tests/unit/client/coordination/coordination_grpc_mock.h
new file mode 100644
index 00000000000..98922d8d9eb
--- /dev/null
+++ b/tests/unit/client/coordination/coordination_grpc_mock.h
@@ -0,0 +1,206 @@
+#pragma once
+
+#include <ydb-cpp-sdk/type_switcher.h>
+
+#include <src/api/grpc/ydb_coordination_v1.grpc.pb.h>
+#include <src/api/grpc/ydb_discovery_v1.grpc.pb.h>
+
+#include <grpcpp/server.h>
+#include <grpcpp/server_builder.h>
+#include <grpcpp/server_context.h>
+
+#include <grpc/impl/channel_arg_names.h>
+
+#include <util/generic/mapfindptr.h>
+
+#include <atomic>
+#include <memory>
+#include <mutex>
+#include <string>
+#include <unordered_map>
+
+namespace NCoordinationTest {
+
+class TMockDiscoveryService : public Ydb::Discovery::V1::DiscoveryService::Service {
+public:
+    grpc::Status ListEndpoints(
+            grpc::ServerContext* context,
+            const Ydb::Discovery::ListEndpointsRequest* request,
+            Ydb::Discovery::ListEndpointsResponse* response) override
+    {
+        Y_UNUSED(context);
+
+        const auto* result = MapFindPtr(MockResults, request->database());
+        Y_ABORT_UNLESS(result, "Mock service doesn't have a result for database '%s'", request->database().c_str());
+
+        auto* op = response->mutable_operation();
+        op->set_ready(true);
+        op->set_status(Ydb::StatusIds::SUCCESS);
+        op->mutable_result()->PackFrom(*result);
+        return grpc::Status::OK;
+    }
+
+    std::unordered_map<std::string, Ydb::Discovery::ListEndpointsResult> MockResults;
+};
+
+class TMockCoordinationService : public Ydb::Coordination::V1::CoordinationService::Service {
+public:
+    std::atomic<bool> FailNextAcquire{false};
+    std::atomic<bool> FailNextRelease{false};
+    std::atomic<bool> BreakNextPingWithoutSessionLoss{false};
+    // Zero means unlimited pong responses; set to a positive value to stop responding
+    // after N pings (used by SessionPingTimeout).
+    std::atomic<size_t> MaxPingResponses{0};
+
+    grpc::Status Session(
+            grpc::ServerContext* context,
+            grpc::ServerReaderWriter<
+                Ydb::Coordination::SessionResponse,
+                Ydb::Coordination::SessionRequest>* stream) override
+    {
+        Y_UNUSED(context);
+
+        Ydb::Coordination::SessionRequest request;
+
+        if (!stream->Read(&request)) {
+            return grpc::Status::OK;
+        }
+        Y_ABORT_UNLESS(request.has_session_start(), "Expected session start");
+        auto& start = request.session_start();
+        uint64_t sessionId = start.session_id();
+        if (!sessionId) {
+            sessionId = ++LastSessionId_;
+        }
+        {
+            Ydb::Coordination::SessionResponse response;
+            auto* started = response.mutable_session_started();
+            started->set_session_id(sessionId);
+            started->set_timeout_millis(start.timeout_millis());
+            stream->Write(response);
+        }
+        request.Clear();
+
+        size_t pingsReceived = 0;
+        while (stream->Read(&request)) {
+            if (request.has_ping()) {
+                if (BreakNextPingWithoutSessionLoss.exchange(false)) {
+                    return grpc::Status(grpc::StatusCode::UNAVAILABLE, "Injected recoverable transport failure");
+                }
+                const size_t maxResponses = MaxPingResponses.load();
+                if (!maxResponses || ++pingsReceived <= maxResponses) {
+                    Ydb::Coordination::SessionResponse response;
+                    auto* pong = response.mutable_pong();
+                    pong->set_opaque(request.ping().opaque());
+                    stream->Write(response);
+                }
+            } else if (request.has_acquire_semaphore()) {
+                const auto& acquire = request.acquire_semaphore();
+                Ydb::Coordination::SessionResponse response;
+                auto* result = response.mutable_acquire_semaphore_result();
+                result->set_req_id(acquire.req_id());
+                if (FailNextAcquire.exchange(false)) {
+                    result->set_status(Ydb::StatusIds::BAD_REQUEST);
+                    result->set_acquired(false);
+                } else {
+                    std::lock_guard guard(SemaphoreLock_);
+                    auto& sem = Semaphores_[acquire.name()];
+                    if (!sem.Held) {
+                        sem.Held = true;
+                        sem.OwnerSessionId = sessionId;
+                        sem.Data = acquire.data();
+                        result->set_status(Ydb::StatusIds::SUCCESS);
+                        result->set_acquired(true);
+                    } else {
+                        result->set_status(Ydb::StatusIds::SUCCESS);
+                        result->set_acquired(false);
+                    }
+                }
+                stream->Write(response);
+            } else if (request.has_release_semaphore()) {
+                const auto& release = request.release_semaphore();
+                Ydb::Coordination::SessionResponse response;
+                auto* result = response.mutable_release_semaphore_result();
+                result->set_req_id(release.req_id());
+                if (FailNextRelease.exchange(false)) {
+                    result->set_status(Ydb::StatusIds::BAD_REQUEST);
+                    result->set_released(false);
+                } else {
+                std::lock_guard guard(SemaphoreLock_);
+                auto it = Semaphores_.find(release.name());
+                if (it != Semaphores_.end() && it->second.Held && it->second.OwnerSessionId == sessionId) {
+                    it->second.Held = false;
+                    it->second.OwnerSessionId = 0;
+                    it->second.Data.clear();
+                    result->set_status(Ydb::StatusIds::SUCCESS);
+                    result->set_released(true);
+                } else {
+                    result->set_status(Ydb::StatusIds::SUCCESS);
+                    result->set_released(false);
+                }
+                }
+                stream->Write(response);
+            } else if (request.has_describe_semaphore()) {
+                const auto& describe = request.describe_semaphore();
+                Ydb::Coordination::SessionResponse response;
+                auto* result = response.mutable_describe_semaphore_result();
+                result->set_req_id(describe.req_id());
+                result->set_status(Ydb::StatusIds::SUCCESS);
+                auto* desc = result->mutable_semaphore_description();
+                desc->set_name(describe.name());
+                desc->set_ephemeral(true);
+                std::lock_guard guard(SemaphoreLock_);
+                if (const auto* sem = MapFindPtr(Semaphores_, describe.name()); sem && sem->Held) {
+                    auto* owner = desc->add_owners();
+                    owner->set_session_id(sem->OwnerSessionId);
+                    owner->set_count(static_cast<uint64_t>(-1));
+                    owner->set_data(sem->Data);
+                }
+                stream->Write(response);
+            } else if (request.has_session_stop()) {
+                Ydb::Coordination::SessionResponse response;
+                response.mutable_session_stopped();
+                stream->Write(response);
+                return grpc::Status::OK;
+            } else {
+                Y_ABORT_UNLESS(false, "Unexpected session request: %s", request.ShortDebugString().c_str());
+            }
+            request.Clear();
+        }
+
+        {
+            std::lock_guard guard(SemaphoreLock_);
+            for (auto& [name, sem] : Semaphores_) {
+                if (sem.OwnerSessionId == sessionId) {
+                    sem = {};
+                }
+            }
+        }
+
+        return grpc::Status::OK;
+    }
+
+private:
+    struct TSemaphoreState {
+        bool Held = false;
+        uint64_t OwnerSessionId = 0;
+        std::string Data;
+    };
+
+    std::atomic<uint64_t> LastSessionId_{0};
+    std::mutex SemaphoreLock_;
+    std::unordered_map<std::string, TSemaphoreState> Semaphores_;
+};
+
+template<class TService>
+std::unique_ptr<grpc::Server> StartGrpcServer(const std::string& address, TService& service) {
+    grpc::ServerBuilder builder;
+    builder.AddListeningPort(NYdb::TStringType{address}, grpc::InsecureServerCredentials());
+    builder.RegisterService(&service);
+    // Match YDB server defaults: allow client keepalive pings used by the SDK driver.
+    builder.AddChannelArgument(GRPC_ARG_HTTP2_MAX_PING_STRIKES, 0);
+    builder.AddChannelArgument(GRPC_ARG_HTTP2_MIN_RECV_PING_INTERVAL_WITHOUT_DATA_MS, 1000);
+    builder.AddChannelArgument(GRPC_ARG_HTTP2_MAX_PINGS_WITHOUT_DATA, 0);
+    return builder.BuildAndStart();
+}
+
+} // namespace NCoordinationTest
diff --git a/tests/unit/client/coordination/coordination_ut.cpp b/tests/unit/client/coordination/coordination_ut.cpp
index 75a8dcb1b1c..db6c8c5d277 100644
--- a/tests/unit/client/coordination/coordination_ut.cpp
+++ b/tests/unit/client/coordination/coordination_ut.cpp
@@ -2,119 +2,20 @@
 
 #include <ydb-cpp-sdk/type_switcher.h>
 
-#include <src/api/grpc/ydb_coordination_v1.grpc.pb.h>
-#include <src/api/grpc/ydb_discovery_v1.grpc.pb.h>
-
-#include <grpcpp/server.h>
-#include <grpcpp/server_builder.h>
-#include <grpcpp/server_context.h>
+#include "coordination_grpc_mock.h"
 
 #include <library/cpp/testing/unittest/registar.h>
 #include <library/cpp/testing/unittest/tests_data.h>
-#include <util/generic/mapfindptr.h>
 
 using namespace NYdb;
 using namespace NYdb::NCoordination;
-
-namespace {
-
-    class TMockDiscoveryService : public Ydb::Discovery::V1::DiscoveryService::Service {
-    public:
-        grpc::Status ListEndpoints(
-                grpc::ServerContext* context,
-                const Ydb::Discovery::ListEndpointsRequest* request,
-                Ydb::Discovery::ListEndpointsResponse* response) override
-        {
-            Y_UNUSED(context);
-
-            std::cerr << "ListEndpoints: " << request->ShortDebugString() << std::endl;
-
-            const auto* result = MapFindPtr(MockResults, request->database());
-            Y_ABORT_UNLESS(result, "Mock service doesn't have a result for database '%s'", request->database().c_str());
-
-            auto* op = response->mutable_operation();
-            op->set_ready(true);
-            op->set_status(Ydb::StatusIds::SUCCESS);
-            op->mutable_result()->PackFrom(*result);
-            return grpc::Status::OK;
-        }
-
-        // From database name to result
-        std::unordered_map<std::string, Ydb::Discovery::ListEndpointsResult> MockResults;
-    };
-
-    class TMockCoordinationService : public Ydb::Coordination::V1::CoordinationService::Service {
-    public:
-        grpc::Status Session(
-                grpc::ServerContext* context,
-                grpc::ServerReaderWriter<
-                    Ydb::Coordination::SessionResponse,
-                    Ydb::Coordination::SessionRequest>* stream) override
-        {
-            Y_UNUSED(context);
-
-            std::cerr << "Session stream started" << std::endl;
-
-            Ydb::Coordination::SessionRequest request;
-
-            // Process session start
-            {
-                if (!stream->Read(&request)) {
-                    // Disconnected before the request was sent
-                    return grpc::Status::OK;
-                }
-                std::cerr << "Session request: " << request.ShortDebugString() << std::endl;
-                Y_ABORT_UNLESS(request.has_session_start(), "Expected session start");
-                auto& start = request.session_start();
-                uint64_t sessionId = start.session_id();
-                if (!sessionId) {
-                    sessionId = ++LastSessionId;
-                }
-                Ydb::Coordination::SessionResponse response;
-                auto* started = response.mutable_session_started();
-                started->set_session_id(sessionId);
-                started->set_timeout_millis(start.timeout_millis());
-                stream->Write(response);
-                request.Clear();
-            }
-
-            size_t pings_received = 0;
-            while (stream->Read(&request)) {
-                std::cerr << "Session request: " << request.ShortDebugString() << std::endl;
-                Y_ABORT_UNLESS(request.has_ping(), "Only ping requests are supported");
-                if (++pings_received <= 2) {
-                    // Only reply to the first 2 ping requests
-                    Ydb::Coordination::SessionResponse response;
-                    auto* pong = response.mutable_pong();
-                    pong->set_opaque(request.ping().opaque());
-                    stream->Write(response);
-                }
-                request.Clear();
-            }
-
-            return grpc::Status::OK;
-        }
-
-    private:
-        std::atomic<uint64_t> LastSessionId{ 0 };
-    };
-
-    template<class TService>
-    std::unique_ptr<grpc::Server> StartGrpcServer(const std::string& address, TService& service) {
-        grpc::ServerBuilder builder;
-        builder.AddListeningPort(TStringType{address}, grpc::InsecureServerCredentials());
-        builder.RegisterService(&service);
-        return builder.BuildAndStart();
-    }
-
-} // namespace
+using namespace NCoordinationTest;
 
 Y_UNIT_TEST_SUITE(Coordination) {
 
     Y_UNIT_TEST(SessionStartTimeout) {
         TPortManager pm;
 
-        // Start a fake endpoint on a random port
         ui16 fakeEndpointPort = pm.GetPort();
         TInet6StreamSocket fakeEndpointSocket;
         {
@@ -126,7 +27,6 @@ Y_UNIT_TEST_SUITE(Coordination) {
                 "Failed to listen on port %" PRIu16, fakeEndpointPort);
         }
 
-        // Fill mock discovery service with our fake database
         TMockDiscoveryService discoveryService;
         {
             auto& dbResult = discoveryService.MockResults["/Root/My/DB"];
@@ -135,7 +35,6 @@ Y_UNIT_TEST_SUITE(Coordination) {
             endpoint->set_port(fakeEndpointPort);
         }
 
-        // Start our mock discovery service
         ui16 discoveryPort = pm.GetPort();
         std::string discoveryAddr = TStringBuilder() << "0.0.0.0:" << discoveryPort;
         auto discoveryServer = StartGrpcServer(discoveryAddr, discoveryService);
@@ -149,32 +48,25 @@ Y_UNIT_TEST_SUITE(Coordination) {
         auto settings = TSessionSettings()
             .Timeout(TDuration::MilliSeconds(500));
 
-        // We expect either connection or session start timeout
         auto startTimestamp = TInstant::Now();
         auto res = client.StartSession("/Some/Path", settings).ExtractValueSync();
         auto endTimestamp = TInstant::Now();
         auto elapsed = endTimestamp - startTimestamp;
 
-        std::cerr << "Got: " << ToString(res.GetStatus()) << ": " << res.GetIssues().ToString() << std::endl;
-
-        // Both connection and session timeout return EStatus::TIMEOUT
         UNIT_ASSERT_VALUES_EQUAL_C(res.GetStatus(), EStatus::TIMEOUT, res.GetIssues().ToString());
-
-        // Our timeout is 500ms, but allow up to 5 seconds of slack on very busy servers
         UNIT_ASSERT_C(elapsed < TDuration::Seconds(5), "Timeout after too much time: " << elapsed);
     }
 
     Y_UNIT_TEST(SessionPingTimeout) {
         TPortManager pm;
 
-        // Start a fake coordination service
         TMockCoordinationService coordinationService;
+        coordinationService.MaxPingResponses.store(2);
         ui16 coordinationPort = pm.GetPort();
         auto coordinationServer = StartGrpcServer(
                 TStringBuilder() << "0.0.0.0:" << coordinationPort,
                 coordinationService);
 
-        // Fill a fake discovery service
         TMockDiscoveryService discoveryService;
         {
             auto& dbResult = discoveryService.MockResults["/Root/My/DB"];
@@ -183,13 +75,11 @@ Y_UNIT_TEST_SUITE(Coordination) {
             endpoint->set_port(coordinationPort);
         }
 
-        // Start a fake discovery service
         ui16 discoveryPort = pm.GetPort();
         auto discoveryServer = StartGrpcServer(
                 TStringBuilder() << "0.0.0.0:" << discoveryPort,
                 discoveryService);
 
-        // Create a driver and a client
         auto config = TDriverConfig()
             .SetEndpoint(TStringBuilder() << "localhost:" << discoveryPort)
             .SetDatabase("/Root/My/DB");
@@ -216,29 +106,22 @@ Y_UNIT_TEST_SUITE(Coordination) {
         auto endTimestamp = TInstant::Now();
         auto elapsed = endTimestamp - startTimestamp;
 
-        // We expect first few pings to succeed
         UNIT_ASSERT_C(elapsed > TDuration::Seconds(1), "Elapsed time too short: " << elapsed);
-
-        // We expect timeout to hit pretty soon afterwards
         UNIT_ASSERT_C(elapsed < TDuration::Seconds(4), "Elapsed time too large: " << elapsed);
 
-        // Check the last failure stored in a session
         auto res2 = session.Close().ExtractValueSync();
-        std::cerr << "Close: " << ToString(res2.GetStatus()) << ": " << res2.GetIssues().ToString() << std::endl;
         UNIT_ASSERT_VALUES_EQUAL_C(res2.GetStatus(), EStatus::TIMEOUT, res2.GetIssues().ToString());
     }
 
     Y_UNIT_TEST(SessionCancelByDriver) {
         TPortManager pm;
 
-        // Start a fake coordination service
         TMockCoordinationService coordinationService;
         ui16 coordinationPort = pm.GetPort();
         auto coordinationServer = StartGrpcServer(
                 TStringBuilder() << "0.0.0.0:" << coordinationPort,
                 coordinationService);
 
-        // Fill a fake discovery service
         TMockDiscoveryService discoveryService;
         {
             auto& dbResult = discoveryService.MockResults["/Root/My/DB"];
@@ -247,13 +130,11 @@ Y_UNIT_TEST_SUITE(Coordination) {
             endpoint->set_port(coordinationPort);
         }
 
-        // Start a fake discovery service
         ui16 discoveryPort = pm.GetPort();
         auto discoveryServer = StartGrpcServer(
                 TStringBuilder() << "0.0.0.0:" << discoveryPort,
                 discoveryService);
 
-        // Create a driver and a client
         auto config = TDriverConfig()
             .SetEndpoint(TStringBuilder() << "localhost:" << discoveryPort)
             .SetDatabase("/Root/My/DB");
@@ -277,7 +158,6 @@ Y_UNIT_TEST_SUITE(Coordination) {
 
         auto session = res.ExtractResult();
 
-        // Stop and destroy driver, forcing session to be cancelled
         client.reset();
         driver->Stop();
         driver.reset();
@@ -286,13 +166,55 @@ Y_UNIT_TEST_SUITE(Coordination) {
         auto endTimestamp = TInstant::Now();
         auto elapsed = endTimestamp - startTimestamp;
 
-        // We expect session to be cancelled promptly
         UNIT_ASSERT_C(elapsed < TDuration::Seconds(1), "Elapsed time too large: " << elapsed);
 
-        // Check the last failure stored in a session
         auto res2 = session.Close().ExtractValueSync();
-        std::cerr << "Close: " << ToString(res2.GetStatus()) << ": " << res2.GetIssues().ToString() << std::endl;
         UNIT_ASSERT_VALUES_EQUAL_C(res2.GetStatus(), EStatus::CLIENT_CANCELLED, res2.GetIssues().ToString());
     }
 
+    Y_UNIT_TEST(SessionDropsDriverFromStateCallback) {
+        TPortManager pm;
+
+        TMockCoordinationService coordinationService;
+        ui16 coordinationPort = pm.GetPort();
+        auto coordinationServer = StartGrpcServer(
+                TStringBuilder() << "0.0.0.0:" << coordinationPort,
+                coordinationService);
+
+        TMockDiscoveryService discoveryService;
+        {
+            auto& dbResult = discoveryService.MockResults["/Root/My/DB"];
+            auto* endpoint = dbResult.add_endpoints();
+            endpoint->set_address("localhost");
+            endpoint->set_port(coordinationPort);
+        }
+
+        ui16 discoveryPort = pm.GetPort();
+        auto discoveryServer = StartGrpcServer(
+                TStringBuilder() << "0.0.0.0:" << discoveryPort,
+                discoveryService);
+
+        auto config = TDriverConfig()
+            .SetEndpoint(TStringBuilder() << "localhost:" << discoveryPort)
+            .SetDatabase("/Root/My/DB");
+        std::optional<TDriver> driver(std::in_place, config);
+        std::optional<TClient> client(std::in_place, *driver);
+
+        auto droppedPromise = NThreading::NewPromise();
+        auto droppedFuture = droppedPromise.GetFuture();
+        auto settings = TSessionSettings()
+            .OnStateChanged([&](auto state) mutable {
+                if (state == ESessionState::ATTACHED) {
+                    client.reset();
+                    driver.reset();
+                    droppedPromise.SetValue();
+                }
+            })
+            .Timeout(TDuration::MilliSeconds(1000));
+
+        auto res = client->StartSession("/Some/Path", settings).ExtractValueSync();
+        UNIT_ASSERT_VALUES_EQUAL_C(res.GetStatus(), EStatus::SUCCESS, res.GetIssues().ToString());
+        UNIT_ASSERT(droppedFuture.Wait(TDuration::Seconds(10)));
+    }
+
 }
diff --git a/tests/unit/client/coordination/distributed_lock_ut.cpp b/tests/unit/client/coordination/distributed_lock_ut.cpp
new file mode 100644
index 00000000000..1500836f515
--- /dev/null
+++ b/tests/unit/client/coordination/distributed_lock_ut.cpp
@@ -0,0 +1,227 @@
+#include <ydb-cpp-sdk/client/coordination/distributed_lock.h>
+
+#include <ydb-cpp-sdk/type_switcher.h>
+
+#include "coordination_grpc_mock.h"
+
+#include <library/cpp/testing/unittest/registar.h>
+#include <library/cpp/testing/unittest/tests_data.h>
+
+#include <util/system/hostname.h>
+#include <util/system/thread.h>
+
+#include <mutex>
+#include <optional>
+
+using namespace NYdb;
+using namespace NYdb::NCoordination;
+using namespace NCoordinationTest;
+
+namespace {
+
+constexpr TDuration TEST_TIMEOUT = TDuration::MilliSeconds(500);
+constexpr const char* COORD_PATH = "/Some/CoordPath";
+constexpr const char* SEMAPHORE_NAME = "test-lock";
+constexpr const char* ANOTHER_SEMAPHORE_NAME = "another-test-lock";
+
+struct TTestEnv {
+    TPortManager PortManager;
+    TMockDiscoveryService DiscoveryService;
+    TMockCoordinationService CoordinationService;
+    std::unique_ptr<grpc::Server> CoordinationServer;
+    std::unique_ptr<grpc::Server> DiscoveryServer;
+    std::optional<TDriver> Driver;
+    std::optional<TClient> Client;
+
+    TTestEnv() {
+        ui16 coordinationPort = PortManager.GetPort();
+        CoordinationServer = StartGrpcServer(
+            TStringBuilder() << "0.0.0.0:" << coordinationPort,
+            CoordinationService);
+
+        auto& dbResult = DiscoveryService.MockResults["/Root/My/DB"];
+        auto* endpoint = dbResult.add_endpoints();
+        endpoint->set_address("localhost");
+        endpoint->set_port(coordinationPort);
+
+        ui16 discoveryPort = PortManager.GetPort();
+        DiscoveryServer = StartGrpcServer(
+            TStringBuilder() << "0.0.0.0:" << discoveryPort,
+            DiscoveryService);
+
+        Driver.emplace(TDriverConfig()
+            .SetEndpoint(TStringBuilder() << "localhost:" << discoveryPort)
+            .SetDatabase("/Root/My/DB"));
+        Client.emplace(*Driver);
+    }
+
+    ~TTestEnv() {
+        Client.reset();
+        Driver.reset();
+        if (CoordinationServer) {
+            CoordinationServer->Shutdown();
+            CoordinationServer->Wait();
+        }
+        if (DiscoveryServer) {
+            DiscoveryServer->Shutdown();
+            DiscoveryServer->Wait();
+        }
+    }
+};
+
+TSession MakeSession(TTestEnv& env) {
+    auto sessionResult = env.Client->StartSession(
+        COORD_PATH,
+        TSessionSettings().Timeout(TEST_TIMEOUT)
+    ).ExtractValueSync();
+    UNIT_ASSERT_VALUES_EQUAL_C(sessionResult.GetStatus(), EStatus::SUCCESS, sessionResult.GetIssues().ToString());
+    return sessionResult.ExtractResult();
+}
+
+TDistributedLock MakeLock(TSession session, const char* name = SEMAPHORE_NAME) {
+    return session.CreateDistributedLock(
+        TDistributedLockSettings().Name(name).Timeout(TEST_TIMEOUT));
+}
+
+} // namespace
+
+Y_UNIT_TEST_SUITE(DistributedLock) {
+
+    Y_UNIT_TEST(LockUnlock) {
+        TTestEnv env;
+        auto session = MakeSession(env);
+        auto lock = MakeLock(session);
+        lock.lock();
+        lock.unlock();
+    }
+
+    Y_UNIT_TEST(LockGuard) {
+        TTestEnv env;
+        auto session = MakeSession(env);
+        auto lock = MakeLock(session);
+        std::lock_guard guard(lock);
+    }
+
+    Y_UNIT_TEST(TryLockSuccess) {
+        TTestEnv env;
+        auto session = MakeSession(env);
+        auto lock = MakeLock(session);
+        UNIT_ASSERT(lock.try_lock());
+        lock.unlock();
+    }
+
+    Y_UNIT_TEST(TryLockFailsWhenHeld) {
+        TTestEnv env;
+        auto sessionA = MakeSession(env);
+        auto sessionB = MakeSession(env);
+        auto lockA = MakeLock(sessionA);
+        auto lockB = MakeLock(sessionB);
+        lockA.lock();
+        UNIT_ASSERT(!lockB.try_lock());
+        lockA.unlock();
+    }
+
+    Y_UNIT_TEST(MultipleLockNamesInOneSession) {
+        TTestEnv env;
+        auto session = MakeSession(env);
+        auto lockA = MakeLock(session);
+        auto lockB = MakeLock(session, ANOTHER_SEMAPHORE_NAME);
+        lockA.lock();
+        lockB.lock();
+        lockB.unlock();
+        lockA.unlock();
+    }
+
+    Y_UNIT_TEST(LockThrowsOnAcquireFailure) {
+        TTestEnv env;
+        env.CoordinationService.FailNextAcquire.store(true);
+        auto session = MakeSession(env);
+        auto lock = MakeLock(session);
+        UNIT_ASSERT_EXCEPTION(lock.lock(), TYdbLockException);
+        UNIT_ASSERT(!lock.getStopToken().stop_requested());
+        lock.lock();
+        lock.unlock();
+    }
+
+    Y_UNIT_TEST(UnlockFailureNotifiesStopToken) {
+        TTestEnv env;
+        auto session = MakeSession(env);
+        auto lock = MakeLock(session);
+        lock.lock();
+        auto token = lock.getStopToken();
+        env.CoordinationService.FailNextRelease.store(true);
+        lock.unlock();
+        UNIT_ASSERT(token.stop_requested());
+    }
+
+    Y_UNIT_TEST(OwnerDataIsHostName) {
+        TTestEnv env;
+        auto session = MakeSession(env);
+        auto lock = MakeLock(session);
+        lock.lock();
+
+        auto describeResult = session.DescribeSemaphore(
+            SEMAPHORE_NAME,
+            TDescribeSemaphoreSettings().IncludeOwners(true)
+        ).ExtractValueSync();
+        UNIT_ASSERT_VALUES_EQUAL_C(describeResult.GetStatus(), EStatus::SUCCESS, describeResult.GetIssues().ToString());
+
+        const auto& description = describeResult.GetResult();
+        UNIT_ASSERT_VALUES_EQUAL(description.GetOwners().size(), 1u);
+        UNIT_ASSERT_VALUES_EQUAL(description.GetOwners()[0].GetData(), FQDNHostName());
+
+        lock.unlock();
+    }
+
+    Y_UNIT_TEST(GetStopTokenInitiallyValid) {
+        TTestEnv env;
+        auto session = MakeSession(env);
+        auto lock = MakeLock(session);
+        UNIT_ASSERT(!lock.getStopToken().stop_requested());
+    }
+
+    Y_UNIT_TEST(SessionExpiryWhileHoldingLock) {
+        TTestEnv env;
+        env.CoordinationService.MaxPingResponses.store(2);
+        auto session = MakeSession(env);
+        auto lock = MakeLock(session);
+        lock.lock();
+        const TInstant deadline = TInstant::Now() + TDuration::Seconds(5);
+        while (!lock.getStopToken().stop_requested() && TInstant::Now() < deadline) {
+            Sleep(TDuration::MilliSeconds(50));
+        }
+        UNIT_ASSERT(lock.getStopToken().stop_requested());
+        lock.unlock();
+
+        UNIT_ASSERT_EXCEPTION(lock.lock(), TYdbLockException);
+
+        env.CoordinationService.MaxPingResponses.store(0);
+        auto newSession = MakeSession(env);
+        auto newLock = MakeLock(newSession);
+        newLock.lock();
+        UNIT_ASSERT(!newLock.getStopToken().stop_requested());
+        newLock.unlock();
+    }
+
+    Y_UNIT_TEST(RecoverableTransportFailureDoesNotNotifyStopToken) {
+        TTestEnv env;
+        auto session = MakeSession(env);
+        auto lock = MakeLock(session);
+        lock.lock();
+        auto token = lock.getStopToken();
+
+        env.CoordinationService.BreakNextPingWithoutSessionLoss.store(true);
+        auto pingResult = session.Ping().ExtractValueSync();
+        UNIT_ASSERT_VALUES_UNEQUAL(pingResult.GetStatus(), EStatus::SUCCESS);
+
+        const TInstant deadline = TInstant::Now() + TDuration::Seconds(5);
+        while (session.GetConnectionState() != EConnectionState::CONNECTED && TInstant::Now() < deadline) {
+            Sleep(TDuration::MilliSeconds(50));
+        }
+        UNIT_ASSERT_VALUES_EQUAL(session.GetConnectionState(), EConnectionState::CONNECTED);
+        UNIT_ASSERT(!token.stop_requested());
+
+        lock.unlock();
+    }
+
+}
diff --git a/tests/unit/client/driver/driver_ut.cpp b/tests/unit/client/driver/driver_ut.cpp
index 03406f23f4a..54ce45af0f9 100644
--- a/tests/unit/client/driver/driver_ut.cpp
+++ b/tests/unit/client/driver/driver_ut.cpp
@@ -1,6 +1,12 @@
+#include <ydb-cpp-sdk/client/resources/ydb_resources.h>
 #include <ydb-cpp-sdk/client/table/table.h>
+#include <ydb-cpp-sdk/client/types/credentials/credentials.h>
 #include <ydb-cpp-sdk/client/types/exceptions/exceptions.h>
 #include <ydb-cpp-sdk/type_switcher.h>
+#include <src/client/impl/observability/constants.h>
+#include <src/library/grpc/client/grpc_common.h>
+#include <tests/common/fake_metric_registry.h>
+#include <tests/common/fake_trace_provider.h>
 
 #include <src/api/grpc/ydb_discovery_v1.grpc.pb.h>
 #include <src/api/grpc/ydb_table_v1.grpc.pb.h>
@@ -14,6 +20,8 @@
 #include <util/generic/mapfindptr.h>
 
 #include <atomic>
+#include <functional>
+#include <memory>
 
 #include <google/protobuf/text_format.h>
 
@@ -22,6 +30,24 @@ using namespace NYdb::NTable;
 
 namespace {
 
+    constexpr const char LegacyV1Certificate[] = R"(-----BEGIN CERTIFICATE-----
+MIIBbTCCARMCFBthJdWIg/H6ITeelffnCYoK8fDFMAoGCCqGSM49BAMCMDkxCzAJ
+BgNVBAYTAlJVMQwwCgYDVQQKDANZREIxHDAaBgNVBAMME0xlZ2FjeSBUZXN0IFJv
+b3QgQ0EwHhcNMjYwNzI3MDk0NDU2WhcNMzYwNzI0MDk0NDU2WjA5MQswCQYDVQQG
+EwJSVTEMMAoGA1UECgwDWURCMRwwGgYDVQQDDBNMZWdhY3kgVGVzdCBSb290IENB
+MFkwEwYHKoZIzj0CAQYIKoZIzj0DAQcDQgAE4zlS2ha5hOd20QJEh17FP/mjkzsO
+PmwF7iY9zJ0HILwBjqxJSCGnNMMdT+A2d+Nry6de3WC6RkR72HTe6gffuTAKBggq
+hkjOPQQDAgNIADBFAiEA/0rBKAconmtFcliTZ0i9HzIkQeG+E/zVMiUvlhwpylYC
+IGfPhGBVwOMnr+uhwtpj4PAOIrlOQD/fBsaRtYuBRdg2
+-----END CERTIFICATE-----)";
+
+    std::string ReadBuildInfo(grpc::ServerContext* context) {
+        const auto& metadata = context->client_metadata();
+        const auto it = metadata.find(YDB_SDK_BUILD_INFO_HEADER);
+        Y_ABORT_UNLESS(it != metadata.end());
+        return {it->second.data(), it->second.length()};
+    }
+
     class TMockDiscoveryService : public Ydb::Discovery::V1::DiscoveryService::Service {
     public:
         grpc::Status ListEndpoints(
@@ -29,7 +55,7 @@ namespace {
                 const Ydb::Discovery::ListEndpointsRequest* request,
                 Ydb::Discovery::ListEndpointsResponse* response) override
         {
-            Y_UNUSED(context);
+            BuildInfo = ReadBuildInfo(context);
 
             std::cerr << "ListEndpoints: " << request->ShortDebugString() << std::endl;
 
@@ -45,6 +71,7 @@ namespace {
 
         // From database name to result
         std::unordered_map<std::string, Ydb::Discovery::ListEndpointsResult> MockResults;
+        std::string BuildInfo;
     };
 
     class TMockTableService : public Ydb::Table::V1::TableService::Service {
@@ -54,7 +81,7 @@ namespace {
                 const Ydb::Table::CreateSessionRequest* request,
                 Ydb::Table::CreateSessionResponse* response) override
         {
-            Y_UNUSED(context);
+            BuildInfo = ReadBuildInfo(context);
 
             std::cerr << "CreateSession: " << request->ShortDebugString() << std::endl;
 
@@ -67,6 +94,8 @@ namespace {
             op->mutable_result()->PackFrom(result);
             return grpc::Status::OK;
         }
+
+        std::string BuildInfo;
     };
 
     template<class TService>
@@ -77,9 +106,137 @@ namespace {
         return builder.BuildAndStart();
     }
 
+    class TCountingCredentialsProvider final : public ICredentialsProvider {
+    public:
+        std::string GetAuthInfo() const override {
+            return "token";
+        }
+
+        bool IsValid() const override {
+            return true;
+        }
+    };
+
+    class TCountingCredentialsProviderFactory final : public ICredentialsProviderFactory {
+    public:
+        explicit TCountingCredentialsProviderFactory(std::atomic_int& providerCount)
+            : ProviderCount_(providerCount)
+        {}
+
+        TCredentialsProviderPtr CreateProvider() const override {
+            ++ProviderCount_;
+            return std::make_shared<TCountingCredentialsProvider>();
+        }
+
+        std::string GetClientIdentity() const override {
+            return "same-credentials";
+        }
+
+    private:
+        std::atomic_int& ProviderCount_;
+    };
+
+    class TDeferredAuthProvider final : public ICredentialsProvider {
+    public:
+        TDeferredAuthProvider()
+            : AuthInfo_(NThreading::NewPromise<std::string>())
+        {}
+
+        std::string GetAuthInfo() const override {
+            return AuthInfo_.GetFuture().GetValueSync();
+        }
+
+        NThreading::TFuture<std::string> GetAuthInfoAsync() const override {
+            return AuthInfo_.GetFuture();
+        }
+
+        bool IsValid() const override {
+            return true;
+        }
+
+        void SetReady() {
+            AuthInfo_.SetValue("token");
+        }
+
+    private:
+        NThreading::TPromise<std::string> AuthInfo_;
+    };
+
+    class TDeferredCredentialsFactory final : public ICredentialsProviderFactory {
+    public:
+        TDeferredCredentialsFactory()
+            : Provider_(std::make_shared<TDeferredAuthProvider>())
+        {}
+
+        TCredentialsProviderPtr CreateProvider() const override {
+            return Provider_;
+        }
+
+        void SetReady() {
+            Provider_->SetReady();
+        }
+
+    private:
+        std::shared_ptr<TDeferredAuthProvider> Provider_;
+    };
+
 } // namespace
 
+Y_UNIT_TEST_SUITE(DeferredCredentialsTest) {
+    Y_UNIT_TEST(RequestWaitsForAuthInfo) {
+        auto factory = std::make_shared<TDeferredCredentialsFactory>();
+        auto driver = TDriver(TDriverConfig()
+            .SetEndpoint("localhost:100")
+            .SetCredentialsProviderFactory(factory));
+        auto result = TTableClient(driver).CreateSession();
+
+        UNIT_ASSERT(!result.Wait(TDuration::MilliSeconds(100)));
+        factory->SetReady();
+        UNIT_ASSERT(result.Wait(TDuration::Seconds(10)));
+        UNIT_ASSERT_VALUES_EQUAL(result.GetValue().GetStatus(), EStatus::TRANSPORT_UNAVAILABLE);
+    }
+
+    Y_UNIT_TEST(RequestDeadlineWhileWaitingForCredentials) {
+        auto factory = std::make_shared<TDeferredCredentialsFactory>();
+        auto driver = TDriver(TDriverConfig()
+            .SetEndpoint("localhost:100")
+            .SetCredentialsProviderFactory(factory));
+        auto result = TTableClient(driver).CreateSession(
+            TCreateSessionSettings().ClientTimeout(TDuration::MilliSeconds(100))).GetValueSync();
+
+        UNIT_ASSERT_VALUES_EQUAL(result.GetStatus(), EStatus::CLIENT_DEADLINE_EXCEEDED);
+    }
+
+    Y_UNIT_TEST(DriverStopCancelsCredentialsWait) {
+        auto factory = std::make_shared<TDeferredCredentialsFactory>();
+        auto driver = TDriver(TDriverConfig()
+            .SetEndpoint("localhost:100")
+            .SetCredentialsProviderFactory(factory));
+        auto result = TTableClient(driver).CreateSession();
+
+        driver.Stop(true);
+        UNIT_ASSERT(result.Wait(TDuration::Seconds(10)));
+        UNIT_ASSERT_VALUES_EQUAL(result.GetValue().GetStatus(), EStatus::CLIENT_CANCELLED);
+    }
+}
+
 Y_UNIT_TEST_SUITE(CppGrpcClientSimpleTest) {
+    Y_UNIT_TEST(ReusesCredentialsProviderForSameIdentity) {
+        std::atomic_int providerCount = 0;
+        auto driver = TDriver(
+            TDriverConfig()
+                .SetEndpoint("localhost:1")
+                .SetDatabase("/Root")
+                .SetDiscoveryMode(EDiscoveryMode::Off));
+
+        auto firstClient = TTableClient(driver, TClientSettings().CredentialsProviderFactory(
+            std::make_shared<TCountingCredentialsProviderFactory>(providerCount)));
+        auto secondClient = TTableClient(driver, TClientSettings().CredentialsProviderFactory(
+            std::make_shared<TCountingCredentialsProviderFactory>(providerCount)));
+
+        UNIT_ASSERT_VALUES_EQUAL(providerCount.load(), 1);
+    }
+
     Y_UNIT_TEST(InvalidRootCertificatePemFailsFast) {
         auto driver = TDriver(
             TDriverConfig()
@@ -92,6 +249,35 @@ Y_UNIT_TEST_SUITE(CppGrpcClientSimpleTest) {
         UNIT_ASSERT_EQUAL(result.GetStatus(), EStatus::TRANSPORT_UNAVAILABLE);
         UNIT_ASSERT_STRING_CONTAINS(result.GetIssues().ToString(), "Client TLS credentials validation failed");
         UNIT_ASSERT_STRING_CONTAINS(result.GetIssues().ToString(), "root CA PEM:");
+        UNIT_ASSERT_STRING_CONTAINS(result.GetIssues().ToString(), "failed to parse certificate #1");
+    }
+
+    Y_UNIT_TEST(LegacyV1TrustAnchorPassesValidation) {
+        auto driver = TDriver(
+            TDriverConfig()
+                .SetEndpoint("localhost:100")
+                .UseSecureConnection(LegacyV1Certificate));
+        auto client = NTable::TTableClient(driver);
+
+        auto result = client.CreateSession().GetValueSync();
+        auto issues = result.GetIssues().ToString();
+
+        UNIT_ASSERT_EQUAL(result.GetStatus(), EStatus::TRANSPORT_UNAVAILABLE);
+        UNIT_ASSERT(issues.find("Client TLS credentials validation failed") == std::string::npos);
+    }
+
+    Y_UNIT_TEST(MalformedCertificateAfterValidRootPassesValidation) {
+        const std::string rootBundle = std::string(LegacyV1Certificate) + R"(
+-----BEGIN CERTIFICATE-----
+not-base64
+-----END CERTIFICATE-----)";
+        grpc::SslCredentialsOptions sslOptions{
+            .pem_root_certs = NYdb::TStringType{rootBundle},
+        };
+        std::string validationDetail;
+
+        UNIT_ASSERT(NYdbGrpc::ValidateTlsCredentials(sslOptions, validationDetail));
+        UNIT_ASSERT(validationDetail.empty());
     }
 
     Y_UNIT_TEST(EmptyRootCertificateWithoutClientCredentialsKeepsBehavior) {
@@ -217,7 +403,10 @@ Y_UNIT_TEST_SUITE(CppGrpcClientSimpleTest) {
         auto driver = TDriver(
             TDriverConfig()
                 .SetEndpoint(TStringBuilder() << "localhost:" << discoveryPort)
-                .SetDatabase("/Root/My/DB"));
+                .SetDatabase("/Root/My/DB")
+                .SetTraceProvider(std::make_shared<NTests::TFakeTraceProvider>())
+                .SetMetricRegistry(std::make_shared<NTests::TFakeMetricRegistry>())
+                .AppendBuildInfo("test-client/1.2.3"));
         auto client = NTable::TTableClient(driver);
         auto sessionFuture = client.CreateSession();
 
@@ -226,6 +415,15 @@ Y_UNIT_TEST_SUITE(CppGrpcClientSimpleTest) {
         UNIT_ASSERT(sessionResult.IsSuccess());
         auto session = sessionResult.GetSession();
         UNIT_ASSERT_VALUES_EQUAL(session.GetId(), "my-session-id");
+
+        const auto baseBuildInfo = "ydb-cpp-sdk/" + GetSdkSemver();
+        UNIT_ASSERT_VALUES_EQUAL(
+            discoveryService.BuildInfo,
+            baseBuildInfo
+                + " ydb-sdk-tracing/" + std::string(NObservability::kTracingChainVersion)
+                + " ydb-sdk-metrics/" + std::string(NObservability::kMetricsChainVersion)
+                + ";test-client/1.2.3");
+        UNIT_ASSERT_VALUES_EQUAL(tableService.BuildInfo, baseBuildInfo + ";test-client/1.2.3");
     }
 
     Y_UNIT_TEST(WithoutDiscoveryDriverLevel) {
diff --git a/tests/unit/client/iam/grpc_iam_ut.cpp b/tests/unit/client/iam/grpc_iam_ut.cpp
index e5eaa9ed1a9..075357f8c18 100644
--- a/tests/unit/client/iam/grpc_iam_ut.cpp
+++ b/tests/unit/client/iam/grpc_iam_ut.cpp
@@ -16,6 +16,7 @@
 #include <mutex>
 #include <string>
 #include <thread>
+#include <vector>
 
 #include <util/generic/yexception.h>
 
@@ -32,19 +33,19 @@ TEST(GrpcIamCredentialsProvider, TeardownWhileIamCreatePendingCompletes) {
     TIamOAuth params = MakeOAuthParams(server.Endpoint());
     params.RequestTimeout = TDuration::MilliSeconds(400);
 
-    auto work = [&params] {
-        auto facility = std::make_shared<TSimpleCoreFacility>();
-        TIamOAuthCredentialsProvider<CreateIamTokenRequest, CreateIamTokenResponse, IamTokenService> provider(
-            params,
-            facility);
-        (void)provider;
-    };
-
-    std::future<void> done = std::async(std::launch::async, work);
+    auto facility = std::make_shared<TSimpleCoreFacility>();
+    auto provider = std::make_shared<TIamOAuthCredentialsProvider<
+        CreateIamTokenRequest, CreateIamTokenResponse, IamTokenService>>(params, facility);
+    auto authInfo = provider->GetAuthInfoAsync();
+    ASSERT_FALSE(authInfo.IsReady());
 
     ASSERT_TRUE(iamService.WaitUntilRpcEntered(std::chrono::seconds(5)))
         << "server should have accepted the IAM Create call";
 
+    std::future<void> done = std::async(std::launch::async, [provider = std::move(provider)]() mutable {
+        provider.reset();
+    });
+
     ASSERT_EQ(done.wait_for(std::chrono::seconds(20)), std::future_status::ready)
         << "provider destructor must finish while an IAM Create is still blocked on the server "
            "(in-flight RPC vs channel teardown).";
@@ -66,16 +67,15 @@ TEST(GrpcIamCredentialsProvider, TeardownWhileIamCreatePendingCompletesViaFactor
     auto factory = std::make_shared<TIamOAuthCredentialsProviderFactory<
         CreateIamTokenRequest, CreateIamTokenResponse, IamTokenService>>(params);
 
-    auto work = [&factory] {
-        auto provider = factory->CreateProvider();
-        (void)provider;
-    };
-
-    std::future<void> done = std::async(std::launch::async, work);
+    auto provider = factory->CreateProvider();
 
     ASSERT_TRUE(iamService.WaitUntilRpcEntered(std::chrono::seconds(5)))
         << "server should have accepted the IAM Create call";
 
+    std::future<void> done = std::async(std::launch::async, [provider = std::move(provider)]() mutable {
+        provider.reset();
+    });
+
     ASSERT_EQ(done.wait_for(std::chrono::seconds(20)), std::future_status::ready)
         << "factory wrapper teardown must finish while an IAM Create is still blocked on the server";
     done.get();
@@ -84,6 +84,73 @@ TEST(GrpcIamCredentialsProvider, TeardownWhileIamCreatePendingCompletesViaFactor
     server.Stop();
 }
 
+TEST(GrpcIamCredentialsProviderFactory, NoArgProvidersAreCachedAcrossFactoryInstances) {
+    TIamTokenServiceStub iamStub;
+    iamStub.SetResponseToken("unit-test-iam-token");
+    TIamGrpcServer server(&iamStub);
+    ASSERT_TRUE(server.Start());
+
+    using TOAuthFactory = TIamOAuthCredentialsProviderFactory<
+        CreateIamTokenRequest, CreateIamTokenResponse, IamTokenService>;
+    const auto oauthParams = MakeOAuthParams(server.Endpoint());
+
+    std::vector<std::future<TCredentialsProviderPtr>> oauthProviders;
+    for (size_t i = 0; i < 8; ++i) {
+        auto factory = std::make_shared<TOAuthFactory>(oauthParams);
+        oauthProviders.emplace_back(std::async(std::launch::async, [factory] {
+            return factory->CreateProvider();
+        }));
+    }
+
+    auto firstOAuthProvider = oauthProviders.front().get();
+    for (size_t i = 1; i < oauthProviders.size(); ++i) {
+        EXPECT_EQ(firstOAuthProvider, oauthProviders[i].get());
+    }
+    EXPECT_EQ(firstOAuthProvider->GetAuthInfo(), "unit-test-iam-token");
+    EXPECT_EQ(iamStub.GetRequestCount(), 1);
+
+    using TJwtFactory = TIamJwtCredentialsProviderFactory<
+        CreateIamTokenRequest, CreateIamTokenResponse, IamTokenService>;
+    const auto jwtParams = MakeJwtParams(server.Endpoint());
+    auto firstJwtProvider = std::make_shared<TJwtFactory>(jwtParams)->CreateProvider();
+    auto secondJwtProvider = std::make_shared<TJwtFactory>(jwtParams)->CreateProvider();
+
+    EXPECT_EQ(firstJwtProvider, secondJwtProvider);
+    EXPECT_EQ(firstJwtProvider->GetAuthInfo(), "unit-test-iam-token");
+    EXPECT_EQ(iamStub.GetRequestCount(), 2);
+
+    auto differentOAuthParams = oauthParams;
+    differentOAuthParams.OAuthToken = "different-oauth-token";
+    auto differentOAuthProvider = std::make_shared<TOAuthFactory>(differentOAuthParams)->CreateProvider();
+    EXPECT_NE(firstOAuthProvider, differentOAuthProvider);
+    EXPECT_EQ(differentOAuthProvider->GetAuthInfo(), "unit-test-iam-token");
+    EXPECT_EQ(iamStub.GetRequestCount(), 3);
+
+    server.Stop();
+}
+
+TEST(GrpcIamCredentialsProviderFactory, ReadyCallbackCanReleaseNoArgProvider) {
+    TIamTokenServiceStub iamStub;
+    iamStub.SetResponseToken("unit-test-iam-token");
+    TIamGrpcServer server(&iamStub);
+    ASSERT_TRUE(server.Start());
+
+    auto provider = std::make_shared<TIamOAuthCredentialsProviderFactory<
+        CreateIamTokenRequest, CreateIamTokenResponse, IamTokenService>>(
+            MakeOAuthParams(server.Endpoint()))->CreateProvider();
+    auto released = std::make_shared<std::promise<void>>();
+    auto authInfo = provider->GetAuthInfoAsync();
+    ASSERT_TRUE(authInfo.IsReady());
+    authInfo.Subscribe(
+        [provider = std::move(provider), released](const auto&) mutable {
+            provider.reset();
+            released->set_value();
+        });
+
+    ASSERT_EQ(released->get_future().wait_for(std::chrono::seconds(10)), std::future_status::ready);
+    server.Stop();
+}
+
 namespace {
 
 class TSlowBlockingAuthProvider final : public ICredentialsProvider {
@@ -91,6 +158,7 @@ class TSlowBlockingAuthProvider final : public ICredentialsProvider {
     std::string GetAuthInfo() const override {
         std::unique_lock lock(Mutex_);
         if (++CallCount_ > 1) {
+            BlockedCv_.notify_all();
             BlockedCv_.wait(lock, [this] { return Released_; });
         }
         return "slow-auth-token";
@@ -109,16 +177,8 @@ class TSlowBlockingAuthProvider final : public ICredentialsProvider {
     }
 
     bool WaitUntilBlocked(std::chrono::milliseconds timeout) const {
-        const auto deadline = std::chrono::steady_clock::now() + timeout;
-        while (std::chrono::steady_clock::now() < deadline) {
-            std::lock_guard lock(Mutex_);
-            if (CallCount_ > 1 && !Released_) {
-                return true;
-            }
-            std::this_thread::sleep_for(std::chrono::milliseconds(2));
-        }
-        std::lock_guard lock(Mutex_);
-        return CallCount_ > 1 && !Released_;
+        std::unique_lock lock(Mutex_);
+        return BlockedCv_.wait_for(lock, timeout, [this] { return CallCount_ > 1; });
     }
 
 private:
@@ -128,30 +188,36 @@ class TSlowBlockingAuthProvider final : public ICredentialsProvider {
     bool Released_ = false;
 };
 
-class TFailThenSucceedAuthProvider final : public ICredentialsProvider {
+class TDeferredAuthProvider final : public ICredentialsProvider {
 public:
-    explicit TFailThenSucceedAuthProvider(int failCount)
-        : FailCount_(failCount)
+    TDeferredAuthProvider()
+        : AuthInfo_(NThreading::NewPromise<std::string>())
     {}
 
     std::string GetAuthInfo() const override {
-        if (CallCount_.fetch_add(1) < FailCount_) {
-            ythrow yexception() << "auth failure";
-        }
-        return "auth-token";
+        return AuthInfo_.GetFuture().GetValueSync();
+    }
+
+    NThreading::TFuture<std::string> GetAuthInfoAsync() const override {
+        ++CallCount_;
+        return AuthInfo_.GetFuture();
     }
 
     bool IsValid() const override {
         return true;
     }
 
-    int GetCallCount() const {
+    int CallCount() const {
         return CallCount_.load();
     }
 
+    void SetReady() {
+        AuthInfo_.SetValue("auth-token");
+    }
+
 private:
-    const int FailCount_;
     mutable std::atomic<int> CallCount_{0};
+    NThreading::TPromise<std::string> AuthInfo_;
 };
 
 } // namespace
@@ -207,13 +273,13 @@ TEST(GrpcIamCredentialsProvider, StopDuringFillContextDoesNotHang) {
     server.Stop();
 }
 
-TEST(GrpcIamCredentialsProvider, FillContextAuthExceptionSurvivesAndRecovers) {
+TEST(GrpcIamCredentialsProvider, WaitsForNestedAuthWithoutPollingIt) {
     TIamTokenServiceStub iamStub;
     iamStub.SetResponseToken("unit-test-iam-token");
     TIamGrpcServer server(&iamStub);
     ASSERT_TRUE(server.Start());
 
-    auto authProvider = std::make_shared<TFailThenSucceedAuthProvider>(2);
+    auto authProvider = std::make_shared<TDeferredAuthProvider>();
 
     TIamOAuth params = MakeOAuthParams(server.Endpoint());
     auto facility = std::make_shared<TSimpleCoreFacility>();
@@ -230,9 +296,64 @@ TEST(GrpcIamCredentialsProvider, FillContextAuthExceptionSurvivesAndRecovers) {
         facility,
         authProvider);
 
-    EXPECT_EQ(provider.GetAuthInfo(), "unit-test-iam-token");
+    auto future = provider.GetAuthInfoAsync();
+    for (int i = 0; i < 100 && authProvider->CallCount() == 0; ++i) {
+        std::this_thread::sleep_for(std::chrono::milliseconds(10));
+    }
+    ASSERT_EQ(authProvider->CallCount(), 1);
+    std::this_thread::sleep_for(std::chrono::milliseconds(300));
+    EXPECT_EQ(authProvider->CallCount(), 1);
+
+    authProvider->SetReady();
+    ASSERT_TRUE(future.Wait(TDuration::Seconds(10)));
+    EXPECT_EQ(future.GetValue(), "unit-test-iam-token");
     EXPECT_EQ(iamStub.GetRequestCount(), 1);
-    EXPECT_GE(authProvider->GetCallCount(), 3);
+
+    server.Stop();
+}
+
+TEST(GrpcIamCredentialsProvider, RetriesTransientFailure) {
+    TIamTokenServiceStub iamStub;
+    iamStub.SetResponseToken("unit-test-iam-token");
+    iamStub.SetStatus(grpc::Status(grpc::StatusCode::UNAVAILABLE, "retry"));
+    TIamGrpcServer server(&iamStub);
+    ASSERT_TRUE(server.Start());
+
+    auto facility = std::make_shared<TSimpleCoreFacility>();
+    auto provider = std::make_shared<TIamOAuthCredentialsProvider<
+        CreateIamTokenRequest, CreateIamTokenResponse, IamTokenService>>(
+            MakeOAuthParams(server.Endpoint()), facility);
+    auto future = provider->GetAuthInfoAsync();
+    for (int i = 0; i < 1000 && iamStub.GetRequestCount() == 0; ++i) {
+        std::this_thread::sleep_for(std::chrono::milliseconds(10));
+    }
+    ASSERT_GT(iamStub.GetRequestCount(), 0);
+    ASSERT_FALSE(future.IsReady());
+
+    iamStub.SetStatus(grpc::Status::OK);
+    ASSERT_TRUE(future.Wait(TDuration::Seconds(10)));
+    EXPECT_EQ(future.GetValue(), "unit-test-iam-token");
+    EXPECT_GT(iamStub.GetRequestCount(), 1);
+
+    server.Stop();
+}
+
+TEST(GrpcIamCredentialsProvider, DoesNotRetryTerminalFailure) {
+    TIamTokenServiceStub iamStub;
+    iamStub.SetStatus(grpc::Status(grpc::StatusCode::PERMISSION_DENIED, "terminal"));
+    TIamGrpcServer server(&iamStub);
+    ASSERT_TRUE(server.Start());
+
+    auto facility = std::make_shared<TSimpleCoreFacility>();
+    auto provider = std::make_shared<TIamOAuthCredentialsProvider<
+        CreateIamTokenRequest, CreateIamTokenResponse, IamTokenService>>(
+            MakeOAuthParams(server.Endpoint()), facility);
+    auto future = provider->GetAuthInfoAsync();
+    ASSERT_TRUE(future.Wait(TDuration::Seconds(10)));
+    EXPECT_THROW(future.GetValue(), yexception);
+    const int requests = iamStub.GetRequestCount();
+    std::this_thread::sleep_for(std::chrono::milliseconds(300));
+    EXPECT_EQ(iamStub.GetRequestCount(), requests);
 
     server.Stop();
 }
diff --git a/tests/unit/client/iam/http_iam_ut.cpp b/tests/unit/client/iam/http_iam_ut.cpp
index f2ed793fe85..e6cad44cbdd 100644
--- a/tests/unit/client/iam/http_iam_ut.cpp
+++ b/tests/unit/client/iam/http_iam_ut.cpp
@@ -1,9 +1,12 @@
 #include <ydb-cpp-sdk/client/iam/iam.h>
+#include <ydb-cpp-sdk/client/types/core_facility/core_facility.h>
 
 #include <tests/common/iam_mocks/iam_http_mock_server.h>
 
 #include <gtest/gtest.h>
 
+#include <util/datetime/base.h>
+
 #include <atomic>
 #include <thread>
 #include <vector>
@@ -11,6 +14,20 @@
 using namespace NYdb;
 using namespace NYdb::NTest;
 
+TEST(IamCredentialsProviderFactory, NoArgProviderIsCachedAcrossFactoryInstances) {
+    TMetadataServer server;
+    server.SetStrictMode(false);
+    server.SetResponse(HTTP_OK, MakeTokenResponse("cached-token", 3600));
+
+    const TIamHost params = MakeMetadataParams(server.Port);
+    auto firstProvider = CreateIamCredentialsProviderFactory(params)->CreateProvider();
+    auto secondProvider = CreateIamCredentialsProviderFactory(params)->CreateProvider();
+
+    EXPECT_EQ(firstProvider, secondProvider);
+    EXPECT_EQ(firstProvider->GetAuthInfo(), "cached-token");
+    EXPECT_EQ(server.GetRequestCount(), 1);
+}
+
 TEST(IamCredentialsProvider, ExpiryFieldSupport) {
     TMetadataServer server;
     server.SetStrictMode(false);
@@ -49,14 +66,40 @@ TEST(IamCredentialsProvider, NoExpiryFieldFallback) {
 TEST(IamCredentialsProvider, ServerError) {
     TMetadataServer server;
     server.SetStrictMode(false);
-    server.SetResponse(HTTP_INTERNAL_SERVER_ERROR, "");
+    server.SetResponse(HTTP_BAD_REQUEST, "");
 
     TIamHost params = MakeMetadataParams(server.Port);
 
     auto factory = CreateIamCredentialsProviderFactory(params);
     auto provider = factory->CreateProvider();
 
-    EXPECT_EQ(provider->GetAuthInfo(), "");
+    EXPECT_THROW(provider->GetAuthInfo(), yexception);
+}
+
+TEST(IamCredentialsProvider, RetriesTransientError) {
+    TMetadataServer server;
+    server.SetStrictMode(false);
+    server.SetResponse(HTTP_OK, MakeTokenResponse("old-token", 3600));
+
+    TIamHost params = MakeMetadataParams(server.Port);
+    params.RefreshPeriod = TDuration::MilliSeconds(100);
+
+    auto facility = CreateSimpleCoreFacility();
+    auto provider = CreateIamCredentialsProviderFactory(params)->CreateProvider(facility);
+    EXPECT_EQ(provider->GetAuthInfo(), "old-token");
+
+    const int countBeforeRefresh = server.GetRequestCount();
+    server.SetResponse(HTTP_INTERNAL_SERVER_ERROR, "");
+    for (int i = 0; i < 1000 && server.GetRequestCount() == countBeforeRefresh; ++i) {
+        Sleep(TDuration::MilliSeconds(10));
+    }
+    ASSERT_GT(server.GetRequestCount(), countBeforeRefresh);
+    auto future = provider->GetAuthInfoAsync();
+    EXPECT_FALSE(future.IsReady());
+
+    server.SetResponse(HTTP_OK, MakeTokenResponse("new-token", 3600));
+    ASSERT_TRUE(future.Wait(TDuration::Seconds(10)));
+    EXPECT_EQ(future.GetValue(), "new-token");
 }
 
 TEST(IamCredentialsProvider, ConcurrentAccess) {
diff --git a/tests/unit/client/iam_private/grpc_iam_service_ut.cpp b/tests/unit/client/iam_private/grpc_iam_service_ut.cpp
index f557bd804c5..8914e6db4e0 100644
--- a/tests/unit/client/iam_private/grpc_iam_service_ut.cpp
+++ b/tests/unit/client/iam_private/grpc_iam_service_ut.cpp
@@ -7,7 +7,9 @@
 
 #include <gtest/gtest.h>
 
+#include <atomic>
 #include <chrono>
+#include <exception>
 #include <future>
 #include <memory>
 #include <string>
@@ -28,6 +30,7 @@ class TIamServiceStub final : public IamTokenService::Service {
         const CreateIamTokenRequest*,
         CreateIamTokenResponse* response) override
     {
+        ++CreateRequestCount_;
         response->set_iam_token("inner-jwt-token");
         response->mutable_expires_at()->set_seconds(4102444800);
         return grpc::Status::OK;
@@ -38,20 +41,192 @@ class TIamServiceStub final : public IamTokenService::Service {
         const CreateIamTokenForServiceRequest*,
         CreateIamTokenResponse* response) override
     {
+        ++CreateForServiceRequestCount_;
         response->set_iam_token("outer-service-token");
         response->mutable_expires_at()->set_seconds(4102444800);
         return grpc::Status::OK;
     }
+
+    int GetCreateRequestCount() const {
+        return CreateRequestCount_.load();
+    }
+
+    int GetCreateForServiceRequestCount() const {
+        return CreateForServiceRequestCount_.load();
+    }
+
+private:
+    std::atomic<int> CreateRequestCount_{0};
+    std::atomic<int> CreateForServiceRequestCount_{0};
 };
 
+using TJwtFactory = TIamJwtCredentialsProviderFactory<
+    CreateIamTokenRequest, CreateIamTokenResponse, IamTokenService>;
+
+using TOAuthFactory = TIamOAuthCredentialsProviderFactory<
+    CreateIamTokenRequest, CreateIamTokenResponse, IamTokenService>;
+
+TIamServiceParams MakeServiceParams(TCredentialsProviderFactoryPtr nestedFactory) {
+    TIamServiceParams params;
+    params.ServiceId = "unit-test-service";
+    params.MicroserviceId = "unit-test-microservice";
+    params.ResourceId = "unit-test-resource";
+    params.ResourceType = "unit-test-resource-type";
+    params.TargetServiceAccountId = "unit-test-target";
+    params.SystemServiceAccountCredentials = std::move(nestedFactory);
+    return params;
+}
+
+class TFlakyIamServiceStub final : public IamTokenService::Service {
+public:
+    grpc::Status Create(
+        grpc::ServerContext*,
+        const CreateIamTokenRequest*,
+        CreateIamTokenResponse* response) override
+    {
+        if (Attempts_.fetch_add(1) == 0) {
+            return grpc::Status(grpc::StatusCode::UNAVAILABLE, "transient failure");
+        }
+        response->set_iam_token("oauth-token");
+        response->mutable_expires_at()->set_seconds(4102444800);
+        return grpc::Status::OK;
+    }
+
+    size_t Attempts() const {
+        return Attempts_.load();
+    }
+
+private:
+    std::atomic_size_t Attempts_ = 0;
+};
+
+class TFailingCoreFacility final : public ICoreFacility {
+public:
+    void AddPeriodicTask(TPeriodicCb&& callback, TDeadline::Duration) override {
+        NYdb::NIssue::TIssues issues;
+        callback(std::move(issues), EStatus::CLIENT_CANCELLED);
+    }
+
+    void PostToResponseQueue(TPostTaskCb&&) override {}
+};
+
+using TTestOAuthFactory = TIamOAuthCredentialsProviderFactory<
+    CreateIamTokenRequest, CreateIamTokenResponse, IamTokenService>;
+
+TTestOAuthFactory MakeOAuthFactory() {
+    TIamOAuth params;
+    params.Endpoint = "localhost:1";
+    params.EnableSsl = false;
+    params.OAuthToken = "token";
+    return TTestOAuthFactory(params);
+}
+
 } // namespace
 
-// Regression test for the deprecated no-arg CreateProvider() on the IAM service-account
-// factory with a nested gRPC JWT auth provider. Before the fix, both providers shared a single
-// TSimpleCoreFacility, each registered a periodic refresh task, and TSimpleCoreFacility's
-// single-task invariant tripped Y_ABORT_UNLESS and killed the process. The fix gives the
-// nested auth provider its own facility (via a recursive no-arg CreateProvider()), so the two
-// periodic tasks land on separate facilities.
+TEST(IamCredentialsProviderIdentity, IdentityIsValueBased) {
+    const auto jwtParams = MakeJwtParams("iam.example:443");
+    const auto firstJwtFactory = std::make_shared<TJwtFactory>(jwtParams);
+    const auto secondJwtFactory = std::make_shared<TJwtFactory>(jwtParams);
+    const auto jwtIdentity = firstJwtFactory->GetClientIdentity();
+    EXPECT_EQ(jwtIdentity, secondJwtFactory->GetClientIdentity());
+    auto differentJwtParams = jwtParams;
+    differentJwtParams.JwtParams.KeyId = "different-key";
+    EXPECT_NE(jwtIdentity, TJwtFactory(differentJwtParams).GetClientIdentity());
+
+    const auto oauthParams = MakeOAuthParams("iam.example:443");
+    const auto firstOAuthFactory = std::make_shared<TOAuthFactory>(oauthParams);
+    const auto secondOAuthFactory = std::make_shared<TOAuthFactory>(oauthParams);
+    const auto oauthIdentity = firstOAuthFactory->GetClientIdentity();
+    EXPECT_EQ(oauthIdentity, secondOAuthFactory->GetClientIdentity());
+    auto differentOAuthParams = oauthParams;
+    differentOAuthParams.OAuthToken = "different-token";
+    EXPECT_NE(oauthIdentity, TOAuthFactory(differentOAuthParams).GetClientIdentity());
+
+    auto firstServiceParams = MakeServiceParams(firstJwtFactory);
+    const auto firstServiceFactory = CreateIamServiceCredentialsProviderFactory(firstServiceParams);
+    const auto secondServiceFactory = CreateIamServiceCredentialsProviderFactory(
+        MakeServiceParams(secondJwtFactory));
+    const auto serviceIdentity = firstServiceFactory->GetClientIdentity();
+    EXPECT_EQ(serviceIdentity, secondServiceFactory->GetClientIdentity());
+    firstServiceParams.Endpoint = "different-iam.example:443";
+    EXPECT_NE(
+        serviceIdentity,
+        CreateIamServiceCredentialsProviderFactory(firstServiceParams)->GetClientIdentity());
+}
+
+TEST(IamServiceCredentialsProvider, NoArgProviderIsCachedAcrossFactoryInstances) {
+    TIamServiceStub stub;
+    TIamGrpcServer server(&stub);
+    ASSERT_TRUE(server.Start());
+
+    const auto jwtParams = MakeJwtParams(server.Endpoint());
+    auto firstServiceParams = MakeServiceParams(std::make_shared<TJwtFactory>(jwtParams));
+    firstServiceParams.Endpoint = server.Endpoint();
+    firstServiceParams.EnableSsl = false;
+    firstServiceParams.RequestTimeout = TDuration::Seconds(5);
+
+    auto secondServiceParams = MakeServiceParams(std::make_shared<TJwtFactory>(jwtParams));
+    secondServiceParams.Endpoint = server.Endpoint();
+    secondServiceParams.EnableSsl = false;
+    secondServiceParams.RequestTimeout = TDuration::Seconds(5);
+
+    auto firstProvider = CreateIamServiceCredentialsProviderFactory(firstServiceParams)->CreateProvider();
+    auto secondProvider = CreateIamServiceCredentialsProviderFactory(secondServiceParams)->CreateProvider();
+
+    EXPECT_EQ(firstProvider, secondProvider);
+    EXPECT_EQ(firstProvider->GetAuthInfo(), "outer-service-token");
+    EXPECT_EQ(stub.GetCreateRequestCount(), 1);
+    EXPECT_EQ(stub.GetCreateForServiceRequestCount(), 1);
+
+    secondServiceParams.TargetServiceAccountId = "another-target";
+    auto differentProvider = CreateIamServiceCredentialsProviderFactory(secondServiceParams)->CreateProvider();
+    EXPECT_NE(firstProvider, differentProvider);
+    EXPECT_EQ(differentProvider->GetAuthInfo(), "outer-service-token");
+    EXPECT_EQ(stub.GetCreateRequestCount(), 1);
+    EXPECT_EQ(stub.GetCreateForServiceRequestCount(), 2);
+
+    server.Stop();
+}
+
+TEST(IamCredentialsProvider, AuthInfoFailsWithExpiredFacility) {
+    auto provider = MakeOAuthFactory().CreateProvider(std::weak_ptr<ICoreFacility>{});
+    auto future = provider->GetAuthInfoAsync();
+
+    ASSERT_TRUE(future.IsReady());
+    EXPECT_THROW(future.GetValue(), std::exception);
+}
+
+TEST(IamCredentialsProvider, AuthInfoFailsWhenPeriodicTaskIsRejected) {
+    auto facility = std::make_shared<TFailingCoreFacility>();
+    auto provider = MakeOAuthFactory().CreateProvider(std::weak_ptr<ICoreFacility>(facility));
+    auto future = provider->GetAuthInfoAsync();
+
+    ASSERT_TRUE(future.IsReady());
+    EXPECT_THROW(future.GetValue(), std::exception);
+}
+
+TEST(IamCredentialsProvider, AuthInfoRetriesTransientIamFailure) {
+    TFlakyIamServiceStub stub;
+    TIamGrpcServer server(&stub);
+    ASSERT_TRUE(server.Start());
+
+    TIamOAuth params;
+    params.Endpoint = server.Endpoint();
+    params.EnableSsl = false;
+    params.OAuthToken = "token";
+    params.RequestTimeout = TDuration::Seconds(2);
+
+    auto provider = TTestOAuthFactory(params).CreateProvider();
+    auto future = provider->GetAuthInfoAsync();
+    ASSERT_TRUE(future.Wait(TDuration::Seconds(10)));
+
+    EXPECT_EQ(future.GetValue(), "oauth-token");
+    EXPECT_GE(stub.Attempts(), 2u);
+
+    server.Stop();
+}
+
+// The no-arg service provider keeps nested gRPC authentication on a separate facility.
 TEST(IamServiceCredentialsProvider, NoArgCreateProviderWithGrpcInnerCreds) {
     TIamServiceStub stub;
     TIamGrpcServer server(&stub);
diff --git a/tests/unit/client/oauth2_token_exchange/credentials_ut.cpp b/tests/unit/client/oauth2_token_exchange/credentials_ut.cpp
index 04d47619998..b6352029b70 100644
--- a/tests/unit/client/oauth2_token_exchange/credentials_ut.cpp
+++ b/tests/unit/client/oauth2_token_exchange/credentials_ut.cpp
@@ -1,5 +1,6 @@
 #include <ydb-cpp-sdk/client/types/credentials/oauth2_token_exchange/credentials.h>
 #include <ydb-cpp-sdk/client/types/credentials/oauth2_token_exchange/from_file.h>
+#include <ydb-cpp-sdk/client/types/core_facility/core_facility.h>
 #include <tests/unit/client/oauth2_token_exchange/helpers/test_token_exchange_server.h>
 
 #include <src/library/string_utils/base64/base64.h>
@@ -12,6 +13,8 @@
 #include <util/string/builder.h>
 #include <util/system/tempfile.h>
 
+#include <future>
+
 using namespace NYdb;
 
 extern const std::string TestRSAPrivateKeyContent;
@@ -108,6 +111,19 @@ struct TTestConfigFile : public TJsonFiller<TTestConfigFile> {
 };
 
 Y_UNIT_TEST_SUITE(TestTokenExchange) {
+    bool WaitRequest(TTestTokenExchangeServer& server, TDuration timeout) {
+        const auto deadline = TInstant::Now() + timeout;
+        do {
+            bool received = false;
+            server.WithLock([&] { received = server.Check.InputParams.has_value(); });
+            if (received) {
+                return true;
+            }
+            Sleep(TDuration::MilliSeconds(10));
+        } while (TInstant::Now() < deadline);
+        return false;
+    }
+
     void Exchanges(bool fromConfig) {
         TTestTokenExchangeServer server;
         server.Check.ExpectedInputParams.emplace("grant_type", "urn:ietf:params:oauth:grant-type:token-exchange");
@@ -405,28 +421,6 @@ Y_UNIT_TEST_SUITE(TestTokenExchange) {
         server.Check.ExpectedInputParams.erase("scope");
 
 
-        server.Check.ExpectedErrorPart = "can not connect to";
-        server.Check.ExpectRequest = false;
-        if (fromConfig) {
-            server.RunFromConfig(
-                TTestConfigFile()
-                    .Field("token-endpoint", "https://localhost:42/aaa")
-                    .SubMap("subject-credentials")
-                        .Field("type", "Fixed")
-                        .Field("token", "test_token")
-                        .Field("token-type", "test_token_type")
-                        .Build()
-                    .Build()
-            );
-        } else {
-            server.Run(
-                TOauth2TokenExchangeParams()
-                    .TokenEndpoint("https://localhost:42/aaa")
-                    .SubjectTokenSource(CreateFixedTokenSource("test_token", "test_token_type"))
-            );
-        }
-        server.Check.ExpectRequest = true;
-
         // parsing response
         server.Check.StatusCode = HTTP_FORBIDDEN;
         server.Check.Response = R"(not json)";
@@ -488,16 +482,13 @@ Y_UNIT_TEST_SUITE(TestTokenExchange) {
 
         server.WithLock(
             [&]() {
+                server.Check.Reset();
                 server.Check.Response = R"({"access_token": "token_2", "token_type": "bearer", "expires_in": 1})";
             }
         );
 
-        Sleep(TDuration::Seconds(1));
-        server.Run(
-            [&]() {
-                UNIT_ASSERT_VALUES_EQUAL(factory->CreateProvider()->GetAuthInfo(), "Bearer token_2");
-            }
-        );
+        UNIT_ASSERT(WaitRequest(server, TDuration::Seconds(10)));
+        UNIT_ASSERT_VALUES_EQUAL(factory->CreateProvider()->GetAuthInfo(), "Bearer token_2");
     }
 
     Y_UNIT_TEST(UpdatesToken) {
@@ -540,138 +531,44 @@ Y_UNIT_TEST_SUITE(TestTokenExchange) {
         UNIT_ASSERT_VALUES_EQUAL(factory->CreateProvider()->GetAuthInfo(), "Bearer the_only_token");
     }
 
-    Y_UNIT_TEST(UpdatesTokenInBackgroud) {
-        TCredentialsProviderFactoryPtr factory;
-        TInstant startTime;
-
-        TTestTokenExchangeServer server;
-        server.Check.ExpectedInputParams.emplace("grant_type", "urn:ietf:params:oauth:grant-type:token-exchange");
-        server.Check.ExpectedInputParams.emplace("requested_token_type", "urn:ietf:params:oauth:token-type:access_token");
-        server.Check.ExpectedInputParams.emplace("actor_token", "test_token");
-        server.Check.ExpectedInputParams.emplace("actor_token_type", "test_token_type");
-
-        for (int i = 0; i < 2; ++i) {
-            server.WithLock(
-                [&]() {
-                    server.Check.Response = R"({"access_token": "token_1", "token_type": "bearer", "expires_in": 2})";
-                }
-            );
-            if (!factory) {
-                server.Run(
-                    [&]() {
-                        factory = CreateOauth2TokenExchangeCredentialsProviderFactory(
-                            TOauth2TokenExchangeParams()
-                                .TokenEndpoint(server.GetEndpoint())
-                                .ActorTokenSource(CreateFixedTokenSource("test_token", "test_token_type")));
-                        startTime = TInstant::Now();
-                        UNIT_ASSERT_VALUES_EQUAL(factory->CreateProvider()->GetAuthInfo(), "Bearer token_1");
-                    }
-                );
-            }
-
-            server.WithLock(
-                [&]() {
-                    server.Check.Reset();
-                    if (i == 0) {
-                        server.Check.Response = R"({"access_token": "token_2", "token_type": "bearer", "expires_in": 2})";
-                    } else {
-                        server.Check.Response = R"({"access_token": "token_3", "token_type": "bearer", "expires_in": 2})";
-                    }
-                }
-            );
-
-            SleepUntil(startTime + TDuration::Seconds(1) + TDuration::MilliSeconds(5));
-            const std::string token = factory->CreateProvider()->GetAuthInfo();
-            TInstant halfTimeTokenValid = TInstant::Now();
-            if (halfTimeTokenValid < startTime + TDuration::Seconds(2)) { // valid => got cached token, but async update must be run after half time token is valid
-                if (i == 0) {
-                    UNIT_ASSERT_VALUES_EQUAL(token, "Bearer token_1");
-                } else {
-                    UNIT_ASSERT_VALUES_EQUAL(token, "Bearer token_2");
-                }
-                do {
-                    Sleep(TDuration::MilliSeconds(10));
-                    bool gotRequest = false;
-                    server.WithLock(
-                        [&]() {
-                            if (server.Check.InputParams) { // InputParams are created => got the request
-                                gotRequest = true;
-                            }
-                        }
-                    );
-                    if (gotRequest) {
-                        startTime = TInstant::Now(); // for second iteration
-                        break;
-                    }
-                } while (TInstant::Now() <= startTime + TDuration::Seconds(30));
-                server.CheckExpectations();
-                server.WithLock(
-                    [&]() {
-                        server.Check.Reset();
-                        server.Check.Response = R"(invalid response)"; // update must finish asyncronously
-                    }
-                );
-                Sleep(TDuration::MilliSeconds(500)); // After the request is got, it takes some time to get updated token
-                if (i == 0) { // Finally check that we got updated token
-                    UNIT_ASSERT_VALUES_EQUAL(factory->CreateProvider()->GetAuthInfo(), "Bearer token_2");
-                } else {
-                    UNIT_ASSERT_VALUES_EQUAL(factory->CreateProvider()->GetAuthInfo(), "Bearer token_3");
-                }
-                Cerr << "Checked backgroud update on " << i << " iteration" << Endl;
-            }
-        }
-    }
-
     Y_UNIT_TEST(UpdatesTokenAndRetriesErrors) {
         TCredentialsProviderFactoryPtr factory;
+        auto facility = CreateSimpleCoreFacility();
+        TCredentialsProviderPtr provider;
 
         TTestTokenExchangeServer server;
         server.Check.ExpectedInputParams.emplace("grant_type", "urn:ietf:params:oauth:grant-type:token-exchange");
         server.Check.ExpectedInputParams.emplace("requested_token_type", "urn:ietf:params:oauth:token-type:access_token");
         server.Check.ExpectedInputParams.emplace("subject_token", "test_token");
         server.Check.ExpectedInputParams.emplace("subject_token_type", "test_token_type");
-        server.Check.Response = R"({"access_token": "token_1", "token_type": "bearer", "expires_in": 6})";
+        server.Check.Response = R"({"access_token": "token_1", "token_type": "bearer", "expires_in": 2})";
         server.Run(
             [&]() {
                 factory = CreateOauth2TokenExchangeCredentialsProviderFactory(
                     TOauth2TokenExchangeParams()
                         .TokenEndpoint(server.GetEndpoint())
                         .SubjectTokenSource(CreateFixedTokenSource("test_token", "test_token_type")));
-                UNIT_ASSERT_VALUES_EQUAL(factory->CreateProvider()->GetAuthInfo(), "Bearer token_1");
+                provider = factory->CreateProvider(facility);
+                UNIT_ASSERT_VALUES_EQUAL(provider->GetAuthInfo(), "Bearer token_1");
             }
         );
 
         server.WithLock(
             [&]() {
                 server.Check.Reset();
-                server.Check.StatusCode = HTTP_BAD_REQUEST; // all errors are temporary, because the first attempt is always successful (in constructor)
+                server.Check.StatusCode = HTTP_INTERNAL_SERVER_ERROR;
                 server.Check.Response = R"({"error": "tmp", "error_description": "temporary error"})";
             }
         );
 
-        Sleep(TDuration::Seconds(3) + TDuration::MilliSeconds(5));
-        UNIT_ASSERT_VALUES_EQUAL(factory->CreateProvider()->GetAuthInfo(), "Bearer token_1");
-
-        auto waitRequest = [&](TDuration howLong) {
-            TInstant startTime = TInstant::Now();
-            bool gotRequest = false;
-            do {
-                Sleep(TDuration::MilliSeconds(10));
-                server.WithLock(
-                    [&]() {
-                        if (server.Check.InputParams) { // InputParams are created => got the request
-                            gotRequest = true;
-                        }
-                    }
-                );
-                if (gotRequest) {
-                    break;
-                }
-            } while (TInstant::Now() <= startTime + howLong);
-            return gotRequest;
-        };
-
-        UNIT_ASSERT(waitRequest(TDuration::Seconds(30)));
+        UNIT_ASSERT(WaitRequest(server, TDuration::Seconds(30)));
+        auto future = provider->GetAuthInfoAsync();
+        UNIT_ASSERT(!future.IsReady());
+        auto released = std::make_shared<std::promise<void>>();
+        future.Subscribe([provider = std::move(provider), released](const auto&) mutable {
+            provider.reset();
+            released->set_value();
+        });
 
         server.WithLock(
             [&]() {
@@ -681,24 +578,15 @@ Y_UNIT_TEST_SUITE(TestTokenExchange) {
             }
         );
 
-        UNIT_ASSERT(waitRequest(TDuration::Seconds(10)));
-        Sleep(TDuration::MilliSeconds(500)); // After the request is got, it takes some time to get updated token
-        UNIT_ASSERT_VALUES_EQUAL(factory->CreateProvider()->GetAuthInfo(), "Bearer token_2");
-
-        server.WithLock(
-            [&]() {
-                server.Check.Reset();
-                server.Check.StatusCode = HTTP_INTERNAL_SERVER_ERROR;
-                server.Check.Response = R"({})";
-            }
-        );
-
-        Sleep(TDuration::Seconds(2));
-        UNIT_ASSERT_EXCEPTION(factory->CreateProvider()->GetAuthInfo(), std::runtime_error);
+        UNIT_ASSERT(future.Wait(TDuration::Seconds(10)));
+        UNIT_ASSERT_VALUES_EQUAL(future.GetValue(), "Bearer token_2");
+        UNIT_ASSERT(released->get_future().wait_for(std::chrono::seconds(10)) == std::future_status::ready);
     }
 
     Y_UNIT_TEST(ShutdownWhileRefreshingToken) {
         TCredentialsProviderFactoryPtr factory;
+        auto facility = CreateSimpleCoreFacility();
+        TCredentialsProviderPtr provider;
 
         TTestTokenExchangeServer server;
         server.Check.ExpectedInputParams.emplace("grant_type", "urn:ietf:params:oauth:grant-type:token-exchange");
@@ -713,7 +601,8 @@ Y_UNIT_TEST_SUITE(TestTokenExchange) {
                     TOauth2TokenExchangeParams()
                         .TokenEndpoint(server.GetEndpoint())
                         .SubjectTokenSource(CreateFixedTokenSource("test_token", "test_token_type")));
-                UNIT_ASSERT_VALUES_EQUAL(factory->CreateProvider()->GetAuthInfo(), "Bearer token_1");
+                provider = factory->CreateProvider(facility);
+                UNIT_ASSERT_VALUES_EQUAL(provider->GetAuthInfo(), "Bearer token_1");
             }
         );
 
@@ -725,14 +614,16 @@ Y_UNIT_TEST_SUITE(TestTokenExchange) {
             }
         );
 
-        Sleep(TDuration::Seconds(3) + TDuration::MilliSeconds(5));
-
-        UNIT_ASSERT_VALUES_EQUAL(factory->CreateProvider()->GetAuthInfo(), "Bearer token_1");
+        UNIT_ASSERT(WaitRequest(server, TDuration::Seconds(30)));
+        auto future = provider->GetAuthInfoAsync();
+        UNIT_ASSERT(!future.IsReady());
 
         const TInstant shutdownStart = TInstant::Now();
-        factory = nullptr;
+        provider = nullptr;
         const TInstant shutdownStop = TInstant::Now();
-        Cerr << "Shutdown: " << (shutdownStop - shutdownStart) << Endl;
+        UNIT_ASSERT(shutdownStop - shutdownStart < TDuration::Seconds(1));
+        UNIT_ASSERT(future.IsReady());
+        UNIT_ASSERT_EXCEPTION(future.GetValue(), yexception);
     }
 
     Y_UNIT_TEST(ExchangesFromFileConfig) {
diff --git a/tests/unit/client/oauth2_token_exchange/helpers/test_token_exchange_server.cpp b/tests/unit/client/oauth2_token_exchange/helpers/test_token_exchange_server.cpp
index 1e745f8e618..26da1c120be 100644
--- a/tests/unit/client/oauth2_token_exchange/helpers/test_token_exchange_server.cpp
+++ b/tests/unit/client/oauth2_token_exchange/helpers/test_token_exchange_server.cpp
@@ -17,9 +17,7 @@ void TTestTokenExchangeServer::Run(const NYdb::TOauth2TokenExchangeParams& param
     std::string token;
     Run([&]() {
         auto factory = CreateOauth2TokenExchangeCredentialsProviderFactory(params);
-        if (!expectedToken.empty()) {
-            token = factory->CreateProvider()->GetAuthInfo();
-        }
+        token = factory->CreateProvider()->GetAuthInfo();
     },
     checkExpectations);
 
@@ -32,9 +30,7 @@ void TTestTokenExchangeServer::RunFromConfig(const std::string& fileName, const
     std::string token;
     Run([&]() {
         auto factory = NYdb::CreateOauth2TokenExchangeFileCredentialsProviderFactory(fileName, explicitTokenEndpoint);
-        if (!expectedToken.empty()) {
-            token = factory->CreateProvider()->GetAuthInfo();
-        }
+        token = factory->CreateProvider()->GetAuthInfo();
     },
     checkExpectations);
 
diff --git a/tests/unit/client/observability/metric_buffer_ut.cpp b/tests/unit/client/observability/metric_buffer_ut.cpp
index 0ec0176c86b..aaef9051d04 100644
--- a/tests/unit/client/observability/metric_buffer_ut.cpp
+++ b/tests/unit/client/observability/metric_buffer_ut.cpp
@@ -232,11 +232,11 @@ TEST(MetricBufferTest, ThresholdTriggersImmediateFlush) {
     std::this_thread::sleep_for(std::chrono::milliseconds(20));
     EXPECT_EQ(fakeCounter->Get(), 0);
 
-    for (int i = 0; i < 50; ++i) {
+    for (int i = 0; i < 28; ++i) {
         counter->Inc();
     }
-    SpinUntil([&]{ return fakeCounter->Get() == 150; });
-    EXPECT_EQ(fakeCounter->Get(), 150);
+    SpinUntil([&]{ return fakeCounter->Get() == 128; });
+    EXPECT_EQ(fakeCounter->Get(), 128);
 }
 
 // ---------------------------------------------------------------------------
@@ -332,8 +332,6 @@ TEST(MetricBufferTest, OverflowDropsUpdatesAndReportsDroppedMetrics) {
     auto fakeHist = fix.Fake->GetHistogram(kHistogram, {});
     ASSERT_NE(fakeCounter, nullptr);
     ASSERT_NE(fakeHist, nullptr);
-    EXPECT_LE(fakeCounter->Get(), 8);
-    EXPECT_LE(fakeHist->Count(), 8u);
 
     auto droppedCounter = fix.Fake->GetCounter(
         "ydb_sdk_metric_buffer_dropped_updates_total", {{"instrument", "counter"}});
@@ -341,8 +339,9 @@ TEST(MetricBufferTest, OverflowDropsUpdatesAndReportsDroppedMetrics) {
         "ydb_sdk_metric_buffer_dropped_updates_total", {{"instrument", "histogram"}});
     ASSERT_NE(droppedCounter, nullptr);
     ASSERT_NE(droppedHistogram, nullptr);
-    EXPECT_GT(droppedCounter->Get(), 0);
-    EXPECT_GT(droppedHistogram->Get(), 0);
+    EXPECT_EQ(fakeCounter->Get() + droppedCounter->Get(), 50);
+    EXPECT_EQ(fakeHist->Count() + droppedHistogram->Get(), 50);
+    EXPECT_GT(droppedCounter->Get() + droppedHistogram->Get(), 0);
 }
 
 TEST(MetricBufferTest, ZeroPendingLimitDisablesDropping) {
diff --git a/tests/unit/client/query/deferred_session_creation_ut.cpp b/tests/unit/client/query/deferred_session_creation_ut.cpp
new file mode 100644
index 00000000000..42c2cb8ed70
--- /dev/null
+++ b/tests/unit/client/query/deferred_session_creation_ut.cpp
@@ -0,0 +1,143 @@
+#include <ydb-cpp-sdk/client/driver/driver.h>
+#include <ydb-cpp-sdk/client/query/client.h>
+
+#include <library/cpp/testing/common/network.h>
+#include <library/cpp/testing/unittest/registar.h>
+
+#include <util/string/builder.h>
+
+#include <src/api/grpc/ydb_query_v1.grpc.pb.h>
+
+#include <grpcpp/server.h>
+#include <grpcpp/server_builder.h>
+#include <grpcpp/server_context.h>
+
+#include <thread>
+
+using namespace NYdb;
+using namespace NYdb::NQuery;
+
+namespace {
+
+constexpr TDuration kShortDeadline = TDuration::MilliSeconds(50);
+constexpr TDuration kSlowAttach = TDuration::MilliSeconds(300);
+
+class TDelayedMockQueryService : public Ydb::Query::V1::QueryService::Service {
+public:
+    TDuration AttachDelay = TDuration::Zero();
+
+    grpc::Status CreateSession(
+        grpc::ServerContext*,
+        const Ydb::Query::CreateSessionRequest*,
+        Ydb::Query::CreateSessionResponse* response) override
+    {
+        response->set_status(Ydb::StatusIds::SUCCESS);
+        response->set_session_id("fake-query-session-id");
+        response->set_node_id(1);
+        return grpc::Status::OK;
+    }
+
+    grpc::Status AttachSession(
+        grpc::ServerContext* context,
+        const Ydb::Query::AttachSessionRequest*,
+        grpc::ServerWriter<Ydb::Query::SessionState>* writer) override
+    {
+        if (AttachDelay != TDuration::Zero()) {
+            std::this_thread::sleep_for(std::chrono::milliseconds(AttachDelay.MilliSeconds()));
+        }
+        Ydb::Query::SessionState state;
+        state.set_status(Ydb::StatusIds::SUCCESS);
+        writer->Write(state);
+        while (!context->IsCancelled()) {
+            std::this_thread::sleep_for(std::chrono::milliseconds(50));
+        }
+        return grpc::Status::OK;
+    }
+};
+
+template <class TService>
+std::unique_ptr<grpc::Server> StartGrpcServer(const std::string& address, TService& service) {
+    return grpc::ServerBuilder()
+        .AddListeningPort(TString{address}, grpc::InsecureServerCredentials())
+        .RegisterService(&service)
+        .BuildAndStart();
+}
+
+TCreateSessionSettings ShortDeadlineSettings() {
+    return TCreateSessionSettings()
+        .ClientTimeout(kShortDeadline)
+        .Deadline(TDeadline::AfterDuration(kShortDeadline));
+}
+
+std::unique_ptr<TQueryClient> MakeClient(TDriver& driver, bool deferred) {
+    return std::make_unique<TQueryClient>(
+        driver,
+        TClientSettings().SessionPoolSettings(
+            TSessionPoolSettings().UseDeferredSessionCreation(deferred)));
+}
+
+} // namespace
+
+Y_UNIT_TEST_SUITE(DeferredGetSession) {
+
+Y_UNIT_TEST(TimeoutThenPoolWarmup) {
+    NTesting::InitPortManagerFromEnv();
+    const auto port = NTesting::GetFreePort();
+    const auto endpoint = TStringBuilder() << "127.0.0.1:" << port;
+
+    TDelayedMockQueryService service;
+    service.AttachDelay = kSlowAttach;
+    auto server = StartGrpcServer(endpoint, service);
+
+    TDriver driver(
+        TDriverConfig()
+            .SetEndpoint(endpoint)
+            .SetDiscoveryMode(EDiscoveryMode::Off)
+            .SetDatabase("/Root/My/DB"));
+    auto client = MakeClient(driver, /*deferred=*/true);
+
+    const auto result = client->GetSession(ShortDeadlineSettings()).ExtractValueSync();
+    UNIT_ASSERT(!result.IsSuccess());
+    UNIT_ASSERT_EQUAL(result.GetStatus(), EStatus::CLIENT_DEADLINE_EXCEEDED);
+
+    for (int i = 0; i < 40; ++i) {
+        if (client->GetCurrentPoolSize() == 1 && client->GetActiveSessionCount() == 0) {
+            break;
+        }
+        std::this_thread::sleep_for(std::chrono::milliseconds(50));
+    }
+    UNIT_ASSERT_EQUAL(client->GetCurrentPoolSize(), 1);
+    UNIT_ASSERT_EQUAL(client->GetActiveSessionCount(), 0);
+
+    client.reset();
+    driver.Stop(true);
+}
+
+Y_UNIT_TEST(DisabledWaitsForAttach) {
+    NTesting::InitPortManagerFromEnv();
+    const auto port = NTesting::GetFreePort();
+    const auto endpoint = TStringBuilder() << "127.0.0.1:" << port;
+
+    TDelayedMockQueryService service;
+    service.AttachDelay = kSlowAttach;
+    auto server = StartGrpcServer(endpoint, service);
+
+    TDriver driver(
+        TDriverConfig()
+            .SetEndpoint(endpoint)
+            .SetDiscoveryMode(EDiscoveryMode::Off)
+            .SetDatabase("/Root/My/DB"));
+    auto client = MakeClient(driver, /*deferred=*/false);
+
+    const auto started = TInstant::Now();
+    const auto result = client->GetSession(ShortDeadlineSettings()).ExtractValueSync();
+    UNIT_ASSERT(result.IsSuccess());
+    UNIT_ASSERT(!result.GetSession().GetId().empty());
+    UNIT_ASSERT_GE(TInstant::Now() - started, kSlowAttach);
+    UNIT_ASSERT_EQUAL(client->GetActiveSessionCount(), 1);
+
+    client.reset();
+    driver.Stop(true);
+}
+
+}
diff --git a/tests/unit/client/query/virtual_timestamp_ut.cpp b/tests/unit/client/query/virtual_timestamp_ut.cpp
new file mode 100644
index 00000000000..11e18117f4a
--- /dev/null
+++ b/tests/unit/client/query/virtual_timestamp_ut.cpp
@@ -0,0 +1,42 @@
+#include <ydb-cpp-sdk/client/types/virtual_timestamp.h>
+
+#include <library/cpp/testing/unittest/registar.h>
+
+using NYdb::NScheme::TVirtualTimestamp;
+
+Y_UNIT_TEST_SUITE(VirtualTimestamp) {
+    Y_UNIT_TEST(LexicographicLess) {
+        UNIT_ASSERT(TVirtualTimestamp(1, 100) < TVirtualTimestamp(2, 1));
+        UNIT_ASSERT(TVirtualTimestamp(1, 50) < TVirtualTimestamp(1, 100));
+        UNIT_ASSERT(!(TVirtualTimestamp(2, 1) < TVirtualTimestamp(1, 100)));
+        UNIT_ASSERT(!(TVirtualTimestamp(1, 100) < TVirtualTimestamp(1, 100)));
+    }
+
+    Y_UNIT_TEST(LexicographicGreater) {
+        UNIT_ASSERT(TVirtualTimestamp(2, 1) > TVirtualTimestamp(1, 100));
+        UNIT_ASSERT(TVirtualTimestamp(1, 100) > TVirtualTimestamp(1, 50));
+        UNIT_ASSERT(!(TVirtualTimestamp(1, 100) > TVirtualTimestamp(2, 1)));
+        UNIT_ASSERT(!(TVirtualTimestamp(1, 100) > TVirtualTimestamp(1, 100)));
+    }
+
+    Y_UNIT_TEST(LessOrEqual) {
+        UNIT_ASSERT(TVirtualTimestamp(1, 100) <= TVirtualTimestamp(1, 100));
+        UNIT_ASSERT(TVirtualTimestamp(1, 50) <= TVirtualTimestamp(1, 100));
+        UNIT_ASSERT(TVirtualTimestamp(1, 100) <= TVirtualTimestamp(2, 1));
+        UNIT_ASSERT(!(TVirtualTimestamp(2, 1) <= TVirtualTimestamp(1, 100)));
+    }
+
+    Y_UNIT_TEST(GreaterOrEqual) {
+        UNIT_ASSERT(TVirtualTimestamp(1, 100) >= TVirtualTimestamp(1, 100));
+        UNIT_ASSERT(TVirtualTimestamp(1, 100) >= TVirtualTimestamp(1, 50));
+        UNIT_ASSERT(TVirtualTimestamp(2, 1) >= TVirtualTimestamp(1, 100));
+        UNIT_ASSERT(!(TVirtualTimestamp(1, 50) >= TVirtualTimestamp(1, 100)));
+    }
+
+    Y_UNIT_TEST(Equality) {
+        UNIT_ASSERT(TVirtualTimestamp(1, 100) == TVirtualTimestamp(1, 100));
+        UNIT_ASSERT(!(TVirtualTimestamp(1, 100) == TVirtualTimestamp(1, 101)));
+        UNIT_ASSERT(!(TVirtualTimestamp(1, 100) == TVirtualTimestamp(2, 100)));
+        UNIT_ASSERT(TVirtualTimestamp(1, 100) != TVirtualTimestamp(2, 100));
+    }
+}
diff --git a/tests/unit/client/retry_range/retry_range_ut.cpp b/tests/unit/client/retry_range/retry_range_ut.cpp
index 5062c14e9e9..60dd6b8f1c3 100644
--- a/tests/unit/client/retry_range/retry_range_ut.cpp
+++ b/tests/unit/client/retry_range/retry_range_ut.cpp
@@ -158,16 +158,6 @@ struct TTableClientFixture {
                 .SetDatabase("/Root/My/DB"));
         Client = std::make_unique<NTable::TTableClient>(*Driver);
     }
-
-    ~TTableClientFixture() {
-        Client.reset();
-        if (Driver) {
-            Driver->Stop(true);
-        }
-        if (GrpcServer) {
-            GrpcServer->Shutdown();
-        }
-    }
 };
 
 struct TQueryClientFixture {
@@ -190,16 +180,6 @@ struct TQueryClientFixture {
                 .SetDatabase("/Root/My/DB"));
         Client = std::make_unique<NQuery::TQueryClient>(*Driver);
     }
-
-    ~TQueryClientFixture() {
-        Client.reset();
-        if (Driver) {
-            Driver->Stop(true);
-        }
-        if (GrpcServer) {
-            GrpcServer->Shutdown();
-        }
-    }
 };
 
 } // namespace
diff --git a/tests/unit/client/table/table_ut.cpp b/tests/unit/client/table/table_ut.cpp
index 1f2bd3198b1..5788a703b60 100644
--- a/tests/unit/client/table/table_ut.cpp
+++ b/tests/unit/client/table/table_ut.cpp
@@ -13,6 +13,11 @@
 
 #include <gtest/gtest.h>
 
+#include <atomic>
+#include <chrono>
+#include <future>
+#include <thread>
+
 using namespace NYdb;
 
 namespace {
@@ -59,6 +64,11 @@ namespace {
 
             //
 
+            if (CreateTableStarted) {
+                CreateTableStarted->set_value();
+                ContinueCreateTable.wait();
+            }
+
             auto op = response->mutable_operation();
 
             op->set_ready(true);
@@ -69,6 +79,24 @@ namespace {
             return grpc::Status::OK;
         }
 
+        virtual grpc::Status DeleteSession(
+            grpc::ServerContext* /* context */,
+            const Ydb::Table::DeleteSessionRequest* request,
+            Ydb::Table::DeleteSessionResponse* response
+        ) override {
+            std::cerr << "DeleteSession():" << std::endl
+                << request->DebugString()
+                << std::endl;
+
+            ++DeleteSessionRequests;
+
+            auto op = response->mutable_operation();
+            op->set_ready(true);
+            op->set_status(Ydb::StatusIds::SUCCESS);
+
+            return grpc::Status::OK;
+        }
+
         virtual grpc::Status AlterTable(
             grpc::ServerContext* /* context */,
             const Ydb::Table::AlterTableRequest* request,
@@ -92,6 +120,9 @@ namespace {
 
         std::optional<Ydb::Table::CreateTableRequest> LastCreateTableRequest;
         std::optional<Ydb::Table::AlterTableRequest> LastAlterTableRequest;
+        std::atomic_uint DeleteSessionRequests = 0;
+        std::promise<void>* CreateTableStarted = nullptr;
+        std::shared_future<void> ContinueCreateTable;
     };
 
     /**
@@ -112,6 +143,18 @@ namespace {
             .BuildAndStart();
     }
 
+    template<class TPredicate>
+    bool WaitUntil(TPredicate&& predicate, std::chrono::milliseconds timeout = std::chrono::seconds(10)) {
+        const auto deadline = std::chrono::steady_clock::now() + timeout;
+        while (std::chrono::steady_clock::now() < deadline) {
+            if (predicate()) {
+                return true;
+            }
+            std::this_thread::sleep_for(std::chrono::milliseconds(10));
+        }
+        return predicate();
+    }
+
     /**
      * Configure and start a local GRPC server with the mocked table API service.
      *
@@ -160,6 +203,307 @@ namespace {
 
 } // namespace <anonymous>
 
+TEST(TableTest, SessionHandleDestructionSendsDeleteSession) {
+    TMockTableService tableService;
+    std::unique_ptr<grpc::Server> grpcServer;
+    std::unique_ptr<TDriver> driver;
+    std::unique_ptr<NTable::TTableClient> tableClient;
+    std::unique_ptr<NTable::TSession> tableSession;
+
+    StartServerWithTableService(
+        tableService,
+        grpcServer,
+        driver,
+        tableClient,
+        tableSession
+    );
+
+    tableSession.reset();
+    ASSERT_TRUE(WaitUntil([&] {
+        return tableService.DeleteSessionRequests.load() == 1u;
+    }));
+
+    tableClient.reset();
+    driver.reset();
+}
+
+TEST(TableTest, ClientDestructorSendsDeleteSessionForPooledSessions) {
+    TMockTableService tableService;
+    std::unique_ptr<grpc::Server> grpcServer;
+    std::unique_ptr<TDriver> driver;
+    std::unique_ptr<NTable::TTableClient> tableClient;
+    std::unique_ptr<NTable::TSession> tableSession;
+
+    StartServerWithTableService(
+        tableService,
+        grpcServer,
+        driver,
+        tableClient,
+        tableSession
+    );
+
+    tableSession.reset();
+    ASSERT_TRUE(WaitUntil([&] {
+        return tableService.DeleteSessionRequests.load() == 1u;
+    }));
+    tableService.DeleteSessionRequests.store(0);
+
+    {
+        auto pooledSessionResult = tableClient->GetSession().ExtractValueSync();
+        ASSERT_TRUE(pooledSessionResult.IsSuccess());
+        auto pooledSession = pooledSessionResult.GetSession();
+    }
+
+    tableClient.reset();
+    ASSERT_TRUE(WaitUntil([&] {
+        return tableService.DeleteSessionRequests.load() == 1u;
+    }));
+
+    driver.reset();
+}
+
+TEST(TableTest, ExplicitStopClosesPooledSessions) {
+    TMockTableService tableService;
+    std::unique_ptr<grpc::Server> grpcServer;
+    std::unique_ptr<TDriver> driver;
+    std::unique_ptr<NTable::TTableClient> tableClient;
+    std::unique_ptr<NTable::TSession> tableSession;
+
+    StartServerWithTableService(
+        tableService,
+        grpcServer,
+        driver,
+        tableClient,
+        tableSession
+    );
+
+    tableSession.reset();
+    ASSERT_TRUE(WaitUntil([&] {
+        return tableService.DeleteSessionRequests.load() == 1u;
+    }));
+    tableService.DeleteSessionRequests.store(0);
+
+    {
+        auto pooledSessionResult = tableClient->GetSession().ExtractValueSync();
+        ASSERT_TRUE(pooledSessionResult.IsSuccess());
+        auto pooledSession = pooledSessionResult.GetSession();
+    }
+
+    ASSERT_EQ(tableService.DeleteSessionRequests.load(), 0u);
+
+    ASSERT_TRUE(tableClient->Stop().Wait(TDuration::Seconds(10)));
+    ASSERT_EQ(tableService.DeleteSessionRequests.load(), 1u);
+}
+
+TEST(TableTest, CheckedOutPooledSessionClosesRemotelyAfterExplicitStop) {
+    TMockTableService tableService;
+    std::unique_ptr<grpc::Server> grpcServer;
+    std::unique_ptr<TDriver> driver;
+    std::unique_ptr<NTable::TTableClient> tableClient;
+    std::unique_ptr<NTable::TSession> tableSession;
+
+    StartServerWithTableService(
+        tableService,
+        grpcServer,
+        driver,
+        tableClient,
+        tableSession
+    );
+
+    tableSession.reset();
+    ASSERT_TRUE(WaitUntil([&] {
+        return tableService.DeleteSessionRequests.load() == 1u;
+    }));
+    tableService.DeleteSessionRequests.store(0);
+
+    {
+        auto pooledSessionResult = tableClient->GetSession().ExtractValueSync();
+        ASSERT_TRUE(pooledSessionResult.IsSuccess());
+        auto pooledSession = pooledSessionResult.GetSession();
+
+        ASSERT_TRUE(tableClient->Stop().Wait(TDuration::Seconds(10)));
+        ASSERT_EQ(tableService.DeleteSessionRequests.load(), 0u);
+    }
+
+    ASSERT_TRUE(WaitUntil([&] {
+        return tableService.DeleteSessionRequests.load() == 1u;
+    }));
+}
+
+TEST(TableTest, DriverStopFromResponseCallbackRunsStopNotifications) {
+    TMockTableService tableService;
+    std::unique_ptr<grpc::Server> grpcServer;
+    std::unique_ptr<TDriver> driver;
+    std::unique_ptr<NTable::TTableClient> tableClient;
+    std::unique_ptr<NTable::TSession> tableSession;
+
+    StartServerWithTableService(
+        tableService,
+        grpcServer,
+        driver,
+        tableClient,
+        tableSession
+    );
+
+    {
+        auto pooledSessionResult = tableClient->GetSession().ExtractValueSync();
+        ASSERT_TRUE(pooledSessionResult.IsSuccess());
+        auto pooledSession = pooledSessionResult.GetSession();
+    }
+
+    std::promise<void> createTableStarted;
+    auto createTableStartedFuture = createTableStarted.get_future();
+    std::promise<void> continueCreateTable;
+    tableService.CreateTableStarted = &createTableStarted;
+    tableService.ContinueCreateTable = continueCreateTable.get_future().share();
+
+    std::promise<void> callbackDone;
+    auto callbackDoneFuture = callbackDone.get_future();
+    std::atomic_bool success = false;
+
+    auto requestFuture = tableSession->CreateTable(
+        "/Root/My/DB/driver_stop_from_callback",
+        NTable::TTableBuilder().Build()
+    );
+
+    ASSERT_EQ(createTableStartedFuture.wait_for(std::chrono::seconds(10)), std::future_status::ready);
+
+    requestFuture.Subscribe([&](const NThreading::TFuture<TStatus>& future) mutable {
+        success.store(future.GetValue().IsSuccess());
+        driver->Stop(true);
+        callbackDone.set_value();
+    });
+
+    continueCreateTable.set_value();
+
+    ASSERT_EQ(callbackDoneFuture.wait_for(std::chrono::seconds(10)), std::future_status::ready);
+    ASSERT_TRUE(success.load());
+
+    ASSERT_TRUE(WaitUntil([&] {
+        return tableService.DeleteSessionRequests.load() >= 1u;
+    }));
+    ASSERT_TRUE(WaitUntil([&] {
+        auto stoppedSessionResult = tableClient->CreateSession().ExtractValueSync();
+        return stoppedSessionResult.GetStatus() == EStatus::CLIENT_CANCELLED;
+    }));
+}
+
+TEST(TableTest, DropLastOwnersFromResponseCallbackDoesNotDeadlock) {
+    TMockTableService tableService;
+    std::unique_ptr<grpc::Server> grpcServer;
+    std::unique_ptr<TDriver> driver;
+    std::unique_ptr<NTable::TTableClient> tableClient;
+    std::unique_ptr<NTable::TSession> tableSession;
+
+    StartServerWithTableService(
+        tableService,
+        grpcServer,
+        driver,
+        tableClient,
+        tableSession
+    );
+
+    std::weak_ptr<TGRpcConnectionsImpl> connections = CreateInternalInterface(*driver);
+
+    {
+        auto pooledSessionResult = tableClient->GetSession().ExtractValueSync();
+        ASSERT_TRUE(pooledSessionResult.IsSuccess());
+        auto pooledSession = pooledSessionResult.GetSession();
+    }
+
+    std::promise<void> createTableStarted;
+    auto createTableStartedFuture = createTableStarted.get_future();
+    std::promise<void> continueCreateTable;
+    tableService.CreateTableStarted = &createTableStarted;
+    tableService.ContinueCreateTable = continueCreateTable.get_future().share();
+
+    std::promise<void> callbackDone;
+    auto callbackDoneFuture = callbackDone.get_future();
+    std::atomic_bool success = false;
+
+    auto requestFuture = tableSession->CreateTable(
+        "/Root/My/DB/drop_owners",
+        NTable::TTableBuilder().Build()
+    );
+
+    ASSERT_EQ(createTableStartedFuture.wait_for(std::chrono::seconds(10)), std::future_status::ready);
+
+    requestFuture.Subscribe([&](const NThreading::TFuture<TStatus>& future) mutable {
+        success.store(future.GetValue().IsSuccess());
+        tableSession.reset();
+        tableClient.reset();
+        driver.reset();
+        callbackDone.set_value();
+    });
+
+    continueCreateTable.set_value();
+
+    ASSERT_EQ(callbackDoneFuture.wait_for(std::chrono::seconds(10)), std::future_status::ready);
+    ASSERT_TRUE(success.load());
+    ASSERT_TRUE(WaitUntil([&] {
+        return connections.expired();
+    }));
+    ASSERT_EQ(tableService.DeleteSessionRequests.load(), 2u);
+}
+
+TEST(TableTest, DriverStopFromResponseCallbackThenDropOwnersDoesNotDeadlock) {
+    TMockTableService tableService;
+    std::unique_ptr<grpc::Server> grpcServer;
+    std::unique_ptr<TDriver> driver;
+    std::unique_ptr<NTable::TTableClient> tableClient;
+    std::unique_ptr<NTable::TSession> tableSession;
+
+    StartServerWithTableService(
+        tableService,
+        grpcServer,
+        driver,
+        tableClient,
+        tableSession
+    );
+
+    std::weak_ptr<TGRpcConnectionsImpl> connections = CreateInternalInterface(*driver);
+
+    {
+        auto pooledSessionResult = tableClient->GetSession().ExtractValueSync();
+        ASSERT_TRUE(pooledSessionResult.IsSuccess());
+        auto pooledSession = pooledSessionResult.GetSession();
+    }
+
+    std::promise<void> createTableStarted;
+    auto createTableStartedFuture = createTableStarted.get_future();
+    std::promise<void> continueCreateTable;
+    tableService.CreateTableStarted = &createTableStarted;
+    tableService.ContinueCreateTable = continueCreateTable.get_future().share();
+
+    std::promise<void> callbackDone;
+    auto callbackDoneFuture = callbackDone.get_future();
+    std::atomic_bool success = false;
+
+    auto requestFuture = tableSession->CreateTable(
+        "/Root/My/DB/driver_stop_drop_owners",
+        NTable::TTableBuilder().Build()
+    );
+
+    ASSERT_EQ(createTableStartedFuture.wait_for(std::chrono::seconds(10)), std::future_status::ready);
+
+    requestFuture.Subscribe([&](const NThreading::TFuture<TStatus>& future) mutable {
+        success.store(future.GetValue().IsSuccess());
+        driver->Stop(true);
+        tableSession.reset();
+        tableClient.reset();
+        driver.reset();
+        callbackDone.set_value();
+    });
+
+    continueCreateTable.set_value();
+
+    ASSERT_EQ(callbackDoneFuture.wait_for(std::chrono::seconds(10)), std::future_status::ready);
+    ASSERT_TRUE(success.load());
+    ASSERT_TRUE(WaitUntil([&] {
+        return connections.expired();
+    }));
+}
+
 /**
  * Verify that the SDK creates the CREATE TABLE request correctly,
  * when no metrics configuration is provided.
diff --git a/tools/enum_parser/enum_parser/main.cpp b/tools/enum_parser/enum_parser/main.cpp
index 433a61a5db9..c87f76e98dc 100644
--- a/tools/enum_parser/enum_parser/main.cpp
+++ b/tools/enum_parser/enum_parser/main.cpp
@@ -269,8 +269,8 @@ void GenerateEnum(
     out << "        NAMES_INITIALIZATION_PAIRS,\n";
     out << "        VALUES_INITIALIZATION_PAIRS,\n";
     out << "        CPP_NAMES_INITIALIZATION_ARRAY,\n";
-    out << "        " << WrapStringBuf(outerScopeStr) << ",\n";
-    out << "        " << WrapStringBuf(name) << "\n";
+    out << "        ::NEnumSerializationRuntime::CommonStringBuffer(" << WrapStringBuf(outerScopeStr) << ", " << WrapStringBuf(name) << ").first,\n";
+    out << "        ::NEnumSerializationRuntime::CommonStringBuffer(" << WrapStringBuf(outerScopeStr) << ", " << WrapStringBuf(name) << ").second,\n";
     out << "    };\n\n";
 
     // Properties
diff --git a/tools/enum_parser/enum_serialization_runtime/README.md b/tools/enum_parser/enum_serialization_runtime/README.md
index b8b4dd92cf6..05c30f3ec41 100644
--- a/tools/enum_parser/enum_serialization_runtime/README.md
+++ b/tools/enum_parser/enum_serialization_runtime/README.md
@@ -22,5 +22,5 @@ Use `GENERATE_ENUM_SERIALIZATION_WITH_HEADER` and `GENERATE_ENUM_SERIALIZATION`
  3) как следствие, он меньше засоряет во время исполнения кеш инструкций процессора одинаковыми или очень похожими специализациями функций.
 
 
-Преобразование между `enum` и `int` выносится в пользовательский код (в шаблонные `inline` функции), и производится только в момент непосредственного использования (первым действием в семействе функций `ToString`, последним действием в семуйстве функций `FromString`), где оптимизирующий компилятор обычно может заменить их на no-op или на простые операции со значениями в регистрах.
+Преобразование между `enum` и `int` выносится в пользовательский код (в шаблонные `inline` функции), и производится только в момент непосредственного использования (первым действием в семействе функций `ToString`, последним действием в семействе функций `FromString`), где оптимизирующий компилятор обычно может заменить их на no-op или на простые операции со значениями в регистрах.
 А контейнеры вида `TVector<EEnum>` и `TMap<EEnum, ...>`, которые возвращаются из функций `util/generic/serialized_enum.h`, заменяются на специальные классы `TArrayView` и `TMappedDictView`. Они также поддерживают быстрое и преобразование из перечислений в целочисленные типы и обратно  в момент использования, и не требуют создавать специализации для каждого из возможных типов-перечислений.
diff --git a/tools/enum_parser/enum_serialization_runtime/enum_runtime.h b/tools/enum_parser/enum_serialization_runtime/enum_runtime.h
index 7c85ed3934a..7362c3d243b 100644
--- a/tools/enum_parser/enum_serialization_runtime/enum_runtime.h
+++ b/tools/enum_parser/enum_serialization_runtime/enum_runtime.h
@@ -173,4 +173,16 @@ namespace NEnumSerializationRuntime {
             return {TCast::CastToRepresentationType(key), name};
         }
     };
+
+    constexpr std::pair<TStringBuf, TStringBuf> CommonStringBuffer(const TStringBuf a, const TStringBuf b) {
+        if (!a.empty() && !b.empty()) {
+            if (a.StartsWith(b)) {
+                return {a, TStringBuf{a.data(), b.size()}};
+            }
+            if (b.StartsWith(a)) {
+                return {TStringBuf{b.data(), a.size()}, b};
+            }
+        }
+        return {a, b};
+    }
 }
diff --git a/tools/enum_parser/parse_enum/parse_enum.cpp b/tools/enum_parser/parse_enum/parse_enum.cpp
index 07712411aea..53102781aec 100644
--- a/tools/enum_parser/parse_enum/parse_enum.cpp
+++ b/tools/enum_parser/parse_enum/parse_enum.cpp
@@ -146,6 +146,20 @@ class TEnumContext: public TCppFullSax {
         InEnumState = AfterCppName;
     }
 
+    void DoKeyword(const TText& text) override {
+        if (InValue == InEnumState || InValueCall == InEnumState) {
+            AppendValue(text.Data);
+            return;
+        }
+    }
+
+    void DoCharacter(const TText& text) override {
+        if (InValue == InEnumState || InValueCall == InEnumState) {
+            AppendValue(text.Data);
+            return;
+        }
+    }
+
     void DoMultiLineComment(const TText& text) override {
         Y_ENSURE(text.Data.size() >= 4, "Invalid multiline comment " << text.Data.Quote() << ". ");
         TString commentText = text.Data.substr(2, text.Data.size() - 4);
diff --git a/tools/enum_parser/parse_enum/parse_enum_ut.cpp b/tools/enum_parser/parse_enum/parse_enum_ut.cpp
index 21ed6a2fc4a..5f7972d9a74 100644
--- a/tools/enum_parser/parse_enum/parse_enum_ut.cpp
+++ b/tools/enum_parser/parse_enum/parse_enum_ut.cpp
@@ -3,10 +3,30 @@
 
 #include <tools/enum_parser/parse_enum/parse_enum.h>
 
+#include <util/generic/array_ref.h>
+#include <util/generic/maybe.h>
+
 typedef TEnumParser::TEnum TEnum;
 typedef TEnumParser::TEnums TEnums;
 typedef TEnumParser::TItems TItems;
 
+namespace {
+    using TNameValuePair = std::pair<TStringBuf, TMaybe<TStringBuf>>;
+
+    void CompareNameValueItems(TConstArrayRef<TNameValuePair> ref, const TEnum& e) {
+        const TItems& it = e.Items;
+        for (size_t i = 0; i < Min(ref.size(), it.size()); ++i) {
+            const auto& [refCppName, refValue] = ref[i];
+            UNIT_ASSERT_VALUES_EQUAL_C(it[i].CppName, refCppName, e.CppName);
+            UNIT_ASSERT_EQUAL_C(it[i].Value.Defined(), refValue.Defined(), e.CppName);
+            if (refValue.Defined() && it[i].Value.Defined()) {
+                UNIT_ASSERT_VALUES_EQUAL_C(*it[i].Value, *refValue, e.CppName);
+            }
+        }
+        UNIT_ASSERT_VALUES_EQUAL_C(it.size(), ref.size(), e.CppName);
+    }
+}
+
 Y_UNIT_TEST_SUITE(TEnumParserTest) {
 
     Y_UNIT_TEST(MainTest) {
@@ -312,4 +332,42 @@ Y_UNIT_TEST_SUITE(TEnumParserTest) {
             UNIT_ASSERT(CurrentExceptionMessage().Contains("https://clubs.at.yandex-team.ru/stackoverflow/2603"));
         }
     }
+
+    Y_UNIT_TEST(DigitSeparatorTest) {
+        TString text = NResource::Find("/digit_separator");
+        TMemoryInput input(text.data(), text.size());
+        TEnumParser parser(input);
+        const TEnums& enums = parser.Enums;
+        UNIT_ASSERT_VALUES_EQUAL(enums.size(), 2u);
+        {
+            const TEnum& e = enums[0];
+            UNIT_ASSERT_VALUES_EQUAL(e.CppName, "ELiterals");
+            static constexpr TNameValuePair ref[]{
+                {"Char1", "sizeof(u8'.')"},
+                {"Char2", "sizeof(u8'0')"},
+                {"Int", "123'456'789"},
+                {"Float1", "int(456'789.123'456)"},
+                {"Float2", "int(1'2e0'1)"},
+                {"Float3", "int(0x1'2p4)"},
+            };
+            CompareNameValueItems(ref, e);
+            UNIT_ASSERT_VALUES_EQUAL(e.Scope.size(), 0u);
+        }
+        {
+            const TEnum& e = enums[1];
+            UNIT_ASSERT_VALUES_EQUAL(e.Scope.size(), 0u);
+            UNIT_ASSERT_VALUES_EQUAL(e.CppName, "ETimePrecision");
+            static constexpr TNameValuePair ref[]{
+                {"MicroSeconds", "1"},
+                {"MilliSeconds", "1'000"},
+                {"Seconds", "1'000'000"},
+                {"Minutes", "60'000'000"},
+                {"Hours", "3'600'000'000"},
+                {"Days", "86'400'000'000"},
+                {"Weeks", "604'800'000'000"},
+            };
+            CompareNameValueItems(ref, e);
+            UNIT_ASSERT_VALUES_EQUAL(e.Scope.size(), 0u);
+        }
+    }
 }
diff --git a/tools/enum_parser/parse_enum/ut/digit_separator.h b/tools/enum_parser/parse_enum/ut/digit_separator.h
new file mode 100644
index 00000000000..d9d4a0ef38a
--- /dev/null
+++ b/tools/enum_parser/parse_enum/ut/digit_separator.h
@@ -0,0 +1,20 @@
+#pragma once
+
+enum class ELiterals {
+    Char1 = sizeof(u8'.'),
+    Char2 = sizeof(u8'0'),
+    Int = 123'456'789,
+    Float1 = int(456'789.123'456),
+    Float2 = int(1'2e0'1),
+    Float3 = int(0x1'2p4),
+};
+
+enum class ETimePrecision : unsigned long long {
+    MicroSeconds    =               1   /* "us" */,
+    MilliSeconds    =           1'000   /* "ms" */,
+    Seconds         =       1'000'000   /* "s" */,
+    Minutes         =      60'000'000   /* "m" */,
+    Hours           =   3'600'000'000   /* "h" */,
+    Days            =  86'400'000'000   /* "d" */,
+    Weeks           = 604'800'000'000   /* "w" */,
+};
diff --git a/tools/rescompiler/main.cpp b/tools/rescompiler/main.cpp
index 98a5b9413bc..31d07680c8c 100644
--- a/tools/rescompiler/main.cpp
+++ b/tools/rescompiler/main.cpp
@@ -8,52 +8,128 @@
 #include <util/string/vector.h>
 #include <util/string/split.h>
 
+static inline void Formatter(IOutputStream& stream, std::string_view fmt, TVector<std::string_view>&& views) {
+    constexpr auto INF = std::string::npos;
+    size_t pos = 0;
+    auto view = views.begin();
+    while (pos != INF && pos < fmt.size()) {
+        size_t found = fmt.find("{}", pos);
+        stream << fmt.substr(pos, found == INF ? INF : found - pos);
+        pos = found == INF ? INF : found + 2;
+        if (view != views.end()) {
+            stream << *view;
+            ++view;
+        }
+    }
+}
+
 using namespace NResource;
 
-static inline void GenOne(const TString& data, const TString& key, IOutputStream& out) {
-    const TString name = "name" + ToString(CityHash64(key.data(), key.size()));
+static inline void EmitHex(IOutputStream& stream, const TString& view) {
+    const unsigned char* data = reinterpret_cast<const unsigned char*>(view.data());
+    size_t len = view.size();
 
-    out << "static const unsigned char " << name << "[] = {";
+    constexpr size_t CHAR2HEX = 5; // len('0x??,') == 5
+    constexpr size_t MAX_STEP = 16;
+    constexpr size_t STEPS[] = {MAX_STEP, 1};
 
-    const TString c = Compress(data);
-    char buf[16];
+    auto print = [](char* out, const unsigned char* iter, const unsigned char* end) {
+        char templ[CHAR2HEX + 1] = "0x??,";
+        while (iter != end) {
+            HexEncode(iter, 1ULL, templ + 2ULL);
+            memcpy(out, templ, CHAR2HEX);
+            iter++;
+            out += CHAR2HEX;
+        }
+    };
 
-    for (size_t i = 0; i < c.size(); ++i) {
-        if ((i % 10) == 0) {
-            out << "\n    ";
+    char buf[CHAR2HEX * MAX_STEP + 4] = {};
+    for (size_t step : STEPS) {
+        while (len >= step) {
+            print(buf, data, data + step);
+            buf[CHAR2HEX * step] = 0;
+            len -= step;
+            data += step;
+            stream << buf << (step > 1 ? "\n" : "");
         }
+    }
+    stream << '\n';
+}
 
-        const char ch = c[i];
+static inline void EmitHexArray(const TString& data, const TString& varName, IOutputStream& out) {
+    const TString c = Compress(data);
+    out << "static const unsigned char " << varName << "[] = {\n";
+    EmitHex(out, c);
+    out << "};\n";
+}
 
-        out << "0x" << TStringBuf(buf, HexEncode(&ch, 1, buf)) << ", ";
+static inline void GenOne(const TString& data, const TString& key, IOutputStream& out, bool isFile, bool useSections) {
+    const TString name = "name" + ToString(CityHash64(key.data(), key.size()));
+
+    if (useSections) {
+        if (isFile) {
+            Formatter(out, R"__(
+            extern "C" const char {}[];
+            extern "C" const char {}_end[];
+            static const int REG_{} = NResource::LightRegisterI("{}", {}, {}_end);
+            )__", {data, data, name, key, data, data});
+        } else {
+            EmitHexArray(data, name, out);
+            Formatter(out, R"__(
+            static const int REG_{} = NResource::LightRegisterS("{}", (const char*){}, sizeof({}));
+            )__", {name, key, name, name});
+        }
+        return;
     }
 
-    out << "\n};\n\nstatic const NResource::TRegHelper REG_" << name << "(\"" << key << "\", TStringBuf((const char*)" << name << ", sizeof(" << name << ")));\n";
+    EmitHexArray(data, name, out);
+    Formatter(out, R"__(
+    static const NResource::TRegHelper REG_{}("{}", TStringBuf((const char*){}, sizeof({})));
+    )__", {name, key, name, name});
 }
 
-int main(int argc, char** argv) {
-    if ((argc < 4) || (argc % 2)) {
-        Cerr << "usage: " << argv[0] << " outfile [infile path]+ [- key=value]+" << Endl;
+static inline void EmitHeader(IOutputStream& out, bool useSections) {
+    if (useSections) {
+        out << R"__(
+            // This function are defined in "library/cpp/resource/registry.cpp"
+            namespace NResource {
+                int LightRegisterS(const char*, const char*, unsigned long);
+                int LightRegisterI(const char*, const char*, const char*);
+            }
+            )__";
+    } else {
+        out << "#include <library/cpp/resource/registry.h>\n";
+    }
+}
 
+int main(int argc, char** argv) {
+    if (argc < 4) {
+        Cerr << "usage: " << argv[0] << " outfile [?--use-sections] [infile path]+ [- key=value]+" << Endl;
         return 1;
     }
 
     TFixedBufferFileOutput out(argv[1]);
+    bool useSections = false;
+    if (TStringBuf(argv[2]) == "--use-sections") {
+        useSections = true;
+        argv += 3;
+    } else {
+        argv += 2;
+    }
 
-    argv = argv + 2;
-
-    out << "#include <library/cpp/resource/registry.h>\n\n";
+    EmitHeader(out, useSections);
 
     while (*argv) {
         if ("-"sv == *argv) {
             TVector<TString> items = StringSplitter(TString(*(argv + 1))).Split('=').Limit(2).ToList<TString>();
-            GenOne(TString(items[1]), TString(items[0]), out);
+            GenOne(TString(items[1]), TString(items[0]), out, false /*isFile*/, useSections);
         } else {
             const char* key = *(argv + 1);
             if (*key == '-') {
                 ++key;
             }
-            GenOne(TUnbufferedFileInput(*argv).ReadAll(), key, out);
+            TString data = useSections ? *argv : TUnbufferedFileInput(*argv).ReadAll();
+            GenOne(data, key, out, true /*isFile*/, useSections);
         }
         argv += 2;
     }
diff --git a/util/CMakeLists.txt b/util/CMakeLists.txt
index 0b9c5175fb4..2da80278392 100644
--- a/util/CMakeLists.txt
+++ b/util/CMakeLists.txt
@@ -45,6 +45,7 @@ if (YDB_SDK_TESTS)
       folder/iterator_ut.cpp
       folder/path_ut.cpp
       folder/pathsplit_ut.cpp
+      folder/tempdir_ut.cpp
     LINK_LIBRARIES
       yutil
       cpp-testing-unittest_main
@@ -66,7 +67,7 @@ if (YDB_SDK_TESTS)
       generic/buffer_ut.cpp
       generic/cast_ut.cpp
       generic/deque_ut.cpp
-      generic/enum_range_ut.cpp
+      generic/enum_cast_ut.cpp
       generic/explicit_type_ut.cpp
       generic/flags_ut.cpp
       generic/function_ref_ut.cpp
@@ -109,9 +110,16 @@ if (YDB_SDK_TESTS)
     LINK_LIBRARIES
       yutil
       cpp-testing-unittest_main
+      enum_serialization_runtime
+      case_insensitive_string
     LABELS
       unit
   )
+  generate_enum_serilization(util-generic-ut
+    ${YDB_SDK_SOURCE_DIR}/util/generic/enum_cast_ut.h
+    INCLUDE_HEADERS
+    util/generic/enum_cast_ut.h
+  )
 
   add_ydb_test(NAME util-generic-yexception_ut
     WORKING_DIRECTORY
@@ -209,6 +217,7 @@ if (YDB_SDK_TESTS)
       stream/length_ut.cpp
       stream/mem_ut.cpp
       stream/multi_ut.cpp
+      stream/output_ut.cpp
       stream/printf_ut.cpp
       stream/str_ut.cpp
       stream/tokenizer_ut.cpp
@@ -256,12 +265,14 @@ if (YDB_SDK_TESTS)
       system/backtrace_ut.cpp
       system/byteorder_ut.cpp
       system/compat_ut.cpp
+      system/compiler_ut.c
       system/compiler_ut.cpp
       system/condvar_ut.cpp
       system/context_ut.cpp
       system/cpu_id_ut.cpp
       system/daemon_ut.cpp
       system/datetime_ut.cpp
+      system/defaults_ut.c
       system/direct_io_ut.cpp
       system/env_ut.cpp
       system/error_ut.cpp
@@ -381,6 +392,17 @@ if (YDB_SDK_TESTS)
     LABELS
       unit
   )
+
+  add_ydb_test(NAME util-ut
+    SOURCES
+      ysafeptr_ut.cpp
+      ysaveload_ut.cpp
+    LINK_LIBRARIES
+      yutil
+      cpp-testing-unittest_main
+    LABELS
+      unit
+  )
 endif(YDB_SDK_TESTS)
 
 _ydb_sdk_add_library(yutil)
@@ -447,10 +469,10 @@ target_joined_source(yutil
   ${YDB_SDK_SOURCE_DIR}/util/generic/array_size.cpp
   ${YDB_SDK_SOURCE_DIR}/util/generic/bitmap.cpp
   ${YDB_SDK_SOURCE_DIR}/util/generic/bitops.cpp
-  ${YDB_SDK_SOURCE_DIR}/util/generic/bt_exception.cpp
   ${YDB_SDK_SOURCE_DIR}/util/generic/buffer.cpp
   ${YDB_SDK_SOURCE_DIR}/util/generic/cast.cpp
   ${YDB_SDK_SOURCE_DIR}/util/generic/deque.cpp
+  ${YDB_SDK_SOURCE_DIR}/util/generic/enum_cast.cpp
   ${YDB_SDK_SOURCE_DIR}/util/generic/explicit_type.cpp
   ${YDB_SDK_SOURCE_DIR}/util/generic/fastqueue.cpp
   ${YDB_SDK_SOURCE_DIR}/util/generic/flags.cpp
@@ -552,7 +574,6 @@ target_joined_source(yutil
   ${YDB_SDK_SOURCE_DIR}/util/stream/aligned.cpp
   ${YDB_SDK_SOURCE_DIR}/util/stream/buffer.cpp
   ${YDB_SDK_SOURCE_DIR}/util/stream/buffered.cpp
-  ${YDB_SDK_SOURCE_DIR}/util/stream/debug.cpp
   ${YDB_SDK_SOURCE_DIR}/util/stream/direct_io.cpp
   ${YDB_SDK_SOURCE_DIR}/util/stream/file.cpp
   ${YDB_SDK_SOURCE_DIR}/util/stream/format.cpp
@@ -606,7 +627,6 @@ target_joined_source(yutil
   ${YDB_SDK_SOURCE_DIR}/util/system/condvar.cpp
   ${YDB_SDK_SOURCE_DIR}/util/system/daemon.cpp
   ${YDB_SDK_SOURCE_DIR}/util/system/datetime.cpp
-  ${YDB_SDK_SOURCE_DIR}/util/system/defaults.c
   ${YDB_SDK_SOURCE_DIR}/util/system/direct_io.cpp
   ${YDB_SDK_SOURCE_DIR}/util/system/dynlib.cpp
   ${YDB_SDK_SOURCE_DIR}/util/system/env.cpp
@@ -663,6 +683,7 @@ target_joined_source(yutil
   ${YDB_SDK_SOURCE_DIR}/util/system/sys_alloc.cpp
   ${YDB_SDK_SOURCE_DIR}/util/system/sysstat.cpp
   ${YDB_SDK_SOURCE_DIR}/util/system/tempfile.cpp
+  ${YDB_SDK_SOURCE_DIR}/util/system/thread.cpp
   ${YDB_SDK_SOURCE_DIR}/util/system/tls.cpp
   ${YDB_SDK_SOURCE_DIR}/util/system/type_name.cpp
   ${YDB_SDK_SOURCE_DIR}/util/system/unaligned_mem.cpp
@@ -676,7 +697,6 @@ target_joined_source(yutil
   all_system_4.cpp
   ${YDB_SDK_SOURCE_DIR}/util/system/mem_info.cpp
   ${YDB_SDK_SOURCE_DIR}/util/system/sem.cpp
-  ${YDB_SDK_SOURCE_DIR}/util/system/thread.cpp
   ${YDB_SDK_SOURCE_DIR}/util/system/types.cpp
 )
 
diff --git a/util/README.md b/util/README.md
index 496efa633c1..f7654339874 100644
--- a/util/README.md
+++ b/util/README.md
@@ -5,15 +5,6 @@ Style guide for the util folder is a stricter version of
 (mostly in terms of ambiguity resolution).
 
  * all {} must be in K&R style
- * &, * tied closer to a type, not to variable
- * always use `using` not `typedef`
- * even a single line block must be in braces {}:
-   ```
-   if (A) {
-       B();
-   }
-   ```
- * _ at the end of private data member of a class - `First_`, `Second_`
  * every .h file must be accompanied with corresponding .cpp to avoid a leakage and check that it is self contained
  * prohibited to use `printf`-like functions
 
@@ -46,13 +37,13 @@ Don't forget to run tests from folder `tests`: `ya make -t tests`
 In order to make a commit, you have to get approval from one of
 [util](https://arcanum.yandex-team.ru/arc/trunk/arcadia/groups/util) members.
 
-If no comments have been received withing 1–2 days, it is OK
+If no comments have been received within 1–2 working (for the reviewers) days, it is OK
 to send a graceful ping into [Igni et ferro](https://wiki.yandex-team.ru/ignietferro/) chat.
 
 Certain exceptions apply. The following trivial changes do not need to be reviewed:
 
-* docs, comments, typo fixes,
-* renaming of an internal variable to match the styleguide.
+* grammar and misspelling fixes,
+* making the code compliant with the style guide.
 
 Whenever a breaking change happens to accidentally land into trunk, reverting it does not need to be reviewed.
 
@@ -66,5 +57,5 @@ To limit the incoming review request queue size, util reviewers follow these rul
 
 Review requests discarded as stale may be reopened or resubmitted by any committer willing to push them to completion.
 
-**Note:** It's an author's duty to push the review request to completion. 
+**Note:** It's an author's duty to push the review request to completion.
 If util reviewers stop responding to updates, they should be politely pinged via appropriate means of communication.
diff --git a/util/charset/unicode_table.h b/util/charset/unicode_table.h
index 9e171b25832..3479fef5ef7 100644
--- a/util/charset/unicode_table.h
+++ b/util/charset/unicode_table.h
@@ -101,15 +101,17 @@ namespace NUnicodeTable {
         }
 
         inline TValueRef Get(size_t key, TValueRef value) const {
-            if (key >= Size())
+            if (key >= Size()) {
                 return value;
+            }
 
             return GetImpl(key);
         }
 
         inline TValueRef Get(size_t key, size_t defaultKey) const {
-            if (key >= Size())
+            if (key >= Size()) {
                 return Get(defaultKey);
+            }
 
             return GetImpl(key);
         }
@@ -120,4 +122,4 @@ namespace NUnicodeTable {
     };
 
     const size_t UNICODE_TABLE_SHIFT = 5;
-}
+} // namespace NUnicodeTable
diff --git a/util/charset/unidata.h b/util/charset/unidata.h
index 400d3141868..4c676c4d9c6 100644
--- a/util/charset/unidata.h
+++ b/util/charset/unidata.h
@@ -126,7 +126,7 @@ namespace NUnicode {
         inline bool IsBidi(wchar32 ch, ui32 type) {
             return ((NUnicode::NPrivate::CharInfo(ch) >> BIDI_OFFSET) & 15) == type;
         }
-    }
+    } // namespace NPrivate
 
     inline size_t UnicodeInstancesLimit() {
         return NPrivate::UnidataTable().Size();
@@ -142,7 +142,7 @@ namespace NUnicode {
     inline bool CharHasType(wchar32 ch, ui64 type_bits) {
         return (SHIFT(NUnicode::CharType(ch)) & type_bits) != 0;
     }
-}
+} // namespace NUnicode
 
 // all usefull properties
 
@@ -401,8 +401,9 @@ inline bool IsPrint(wchar32 ch) {
 }
 
 inline bool IsRomanDigit(wchar32 ch) {
-    if (NUnicode::CharHasType(ch, SHIFT(Nl_LETTER)) && 0x2160 <= ch && ch <= 0x2188)
+    if (NUnicode::CharHasType(ch, SHIFT(Nl_LETTER)) && 0x2160 <= ch && ch <= 0x2188) {
         return true;
+    }
     if (ch < 127) {
         switch (static_cast<char>(::ToLower(ch))) {
             case 'i':
diff --git a/util/charset/utf8.cpp b/util/charset/utf8.cpp
index efe3a52f615..07fbff0ed48 100644
--- a/util/charset/utf8.cpp
+++ b/util/charset/utf8.cpp
@@ -35,8 +35,9 @@ namespace {
             }
             cNew = ConvertChar(conversion, c);
 
-            if (cNew != c)
+            if (cNew != c) {
                 break;
+            }
             p += cLen;
         }
         if (p == end) {
@@ -80,6 +81,29 @@ namespace {
         Y_ASSERT(false);
         return false;
     }
+
+    // return longest valid utf-8 prefix size in bytes that is less than or equal to |size|
+    size_t GetLongestUtf8PrefixSize(TStringBuf sb, size_t size, bool robust) {
+        const unsigned char* beg = reinterpret_cast<const unsigned char*>(sb.data());
+        const unsigned char* end = reinterpret_cast<const unsigned char*>(sb.data() + sb.size());
+        const unsigned char* cur = beg;
+        while (cur < end && static_cast<size_t>(cur - beg) < size) {
+            size_t runeLen;
+            if (RECODE_OK != GetUTF8CharLen(runeLen, cur, end)) {
+                if (robust) {
+                    break;
+                } else {
+                    ythrow yexception() << "invalid UTF-8 char at pos " << (cur - beg);
+                }
+            }
+            if ((cur - beg) + runeLen > size) {
+                break;
+            }
+            cur += runeLen;
+        }
+        return cur - beg;
+    }
+
 } // namespace
 
 extern const wchar32 BROKEN_RUNE = 0xFFFD;
@@ -99,7 +123,7 @@ static const char* SkipUTF8Chars(const char* begin, const char* end, size_t numC
     return begin;
 }
 
-TStringBuf SubstrUTF8(const TStringBuf str, size_t pos, size_t len) {
+TStringBuf SubstrUTF8(const TStringBuf str Y_LIFETIME_BOUND, size_t pos, size_t len) {
     const char* start = SkipUTF8Chars(str.begin(), str.end(), pos);
     const char* end = SkipUTF8Chars(start, str.end(), len);
     return TStringBuf(start, end - start);
@@ -168,3 +192,25 @@ TString ToUpperUTF8(TStringBuf s) {
 TString ToUpperUTF8(const char* s) {
     return ToUpperUTF8(TStringBuf(s));
 }
+
+void Utf8TruncateInplace(TString& s, size_t size) {
+    const size_t prefixSize = GetLongestUtf8PrefixSize(TStringBuf{s}, size, false);
+    if (prefixSize != s.size()) {
+        s.resize(prefixSize);
+    }
+}
+
+void Utf8TruncateInplaceRobust(TString& s, size_t size) {
+    const size_t prefixSize = GetLongestUtf8PrefixSize(TStringBuf{s}, size, true);
+    if (prefixSize != s.size()) {
+        s.resize(prefixSize);
+    }
+}
+
+TStringBuf Utf8Truncate(TStringBuf sb Y_LIFETIME_BOUND, size_t size) {
+    return sb.substr(0, GetLongestUtf8PrefixSize(sb, size, false));
+}
+
+TStringBuf Utf8TruncateRobust(TStringBuf sb Y_LIFETIME_BOUND, size_t size) noexcept {
+    return sb.substr(0, GetLongestUtf8PrefixSize(sb, size, true));
+}
diff --git a/util/charset/utf8.h b/util/charset/utf8.h
index 76c1f94078a..1e3ac3edf73 100644
--- a/util/charset/utf8.h
+++ b/util/charset/utf8.h
@@ -16,39 +16,40 @@ inline unsigned char UTF8LeadByteMask(size_t utf8_rune_len) {
 }
 
 inline size_t UTF8RuneLen(const unsigned char lead_byte) {
-    //b0XXXXXXX
+    // b0XXXXXXX
     if ((lead_byte & 0x80) == 0x00) {
         return 1;
     }
-    //b110XXXXX
+    // b110XXXXX
     if ((lead_byte & 0xe0) == 0xc0) {
         return 2;
     }
-    //b1110XXXX
+    // b1110XXXX
     if ((lead_byte & 0xf0) == 0xe0) {
         return 3;
     }
-    //b11110XXX
+    // b11110XXX
     if ((lead_byte & 0xf8) == 0xf0) {
         return 4;
     }
-    //b10XXXXXX
+    // b10XXXXXX
     return 0;
 }
 
 inline size_t UTF8RuneLenByUCS(wchar32 rune) {
-    if (rune < 0x80)
+    if (rune < 0x80) {
         return 1U;
-    else if (rune < 0x800)
+    } else if (rune < 0x800) {
         return 2U;
-    else if (rune < 0x10000)
+    } else if (rune < 0x10000) {
         return 3U;
-    else if (rune < 0x200000)
+    } else if (rune < 0x200000) {
         return 4U;
-    else if (rune < 0x4000000)
+    } else if (rune < 0x4000000) {
         return 5U;
-    else
+    } else {
         return 6U;
+    }
 }
 
 inline void PutUTF8LeadBits(wchar32& rune, unsigned char c, size_t len) {
@@ -66,14 +67,14 @@ inline bool IsUTF8ContinuationByte(unsigned char c) {
 }
 
 //! returns length of the current UTF8 character
-//! @param n    length of the current character, it is assigned in case of valid UTF8 byte sequence
-//! @param p    pointer to the current character
-//! @param e    end of the character sequence
+//! @param[out] n   length of the current character, it is assigned in case of valid UTF8 byte sequence
+//! @param p        pointer to the current character
+//! @param e        end of the character sequence
 inline RECODE_RESULT GetUTF8CharLen(size_t& n, const unsigned char* p, const unsigned char* e) {
     Y_ASSERT(p < e); // since p < e then we will check RECODE_EOINPUT only for n > 1 (see calls of this functions)
     switch (UTF8RuneLen(*p)) {
         case 0:
-            return RECODE_BROKENSYMBOL; //[BROKENSYMBOL] in first byte
+            return RECODE_BROKENSYMBOL; // [BROKENSYMBOL] in first byte
 
         case 1:
             n = 1;
@@ -110,9 +111,9 @@ inline RECODE_RESULT GetUTF8CharLen(size_t& n, const unsigned char* p, const uns
 }
 
 //! returns number of characters in UTF8 encoded text, stops immediately if UTF8 byte sequence is wrong
-//! @param text     UTF8 encoded text
-//! @param len      the length of the text in bytes
-//! @param number   number of encoded symbols in the text
+//! @param text         UTF8 encoded text
+//! @param len          the length of the text in bytes
+//! @param[out] number  number of encoded symbols in the text
 inline bool GetNumberOfUTF8Chars(const char* text, size_t len, size_t& number) {
     const unsigned char* cur = reinterpret_cast<const unsigned char*>(text);
     const unsigned char* const last = cur + len;
@@ -182,10 +183,10 @@ inline bool IsValidUTF8Rune<4, StrictUTF8::No>(wchar32 rune) {
 }
 
 //! reads one unicode symbol from a character sequence encoded UTF8 and checks for overlong encoding
-//! @param rune      value of the current character
-//! @param rune_len  length of the UTF8 bytes sequence that has been read
-//! @param s         pointer to the current character
-//! @param end       the end of the character sequence
+//! @param[out] rune        value of the current character
+//! @param[out] rune_len    length of the UTF8 bytes sequence that has been read
+//! @param s                pointer to the current character
+//! @param end              the end of the character sequence
 template <StrictUTF8 strictMode = StrictUTF8::No>
 inline RECODE_RESULT SafeReadUTF8Char(wchar32& rune, size_t& rune_len, const unsigned char* s, const unsigned char* end) {
     rune = BROKEN_RUNE;
@@ -193,37 +194,45 @@ inline RECODE_RESULT SafeReadUTF8Char(wchar32& rune, size_t& rune_len, const uns
     wchar32 _rune;
 
     size_t _len = UTF8RuneLen(*s);
-    if (s + _len > end)
-        return RECODE_EOINPUT; //[EOINPUT]
-    if (_len == 0)
-        return RECODE_BROKENSYMBOL; //[BROKENSYMBOL] in first byte
-    _rune = *s++;                   //[00000000 0XXXXXXX]
+    if (s + _len > end) {
+        return RECODE_EOINPUT; // [EOINPUT]
+    }
+    if (_len == 0) {
+        return RECODE_BROKENSYMBOL; // [BROKENSYMBOL] in first byte
+    }
+    _rune = *s++; // [00000000 0XXXXXXX]
 
     if (_len > 1) {
         _rune &= UTF8LeadByteMask(_len);
         unsigned char ch = *s++;
-        if (!IsUTF8ContinuationByte(ch))
-            return RECODE_BROKENSYMBOL; //[BROKENSYMBOL] in second byte
-        PutUTF8SixBits(_rune, ch);      //[00000XXX XXYYYYYY]
+        if (!IsUTF8ContinuationByte(ch)) {
+            return RECODE_BROKENSYMBOL; // [BROKENSYMBOL] in second byte
+        }
+        PutUTF8SixBits(_rune, ch); // [00000XXX XXYYYYYY]
         if (_len > 2) {
             ch = *s++;
-            if (!IsUTF8ContinuationByte(ch))
-                return RECODE_BROKENSYMBOL; //[BROKENSYMBOL] in third byte
-            PutUTF8SixBits(_rune, ch);      //[XXXXYYYY YYZZZZZZ]
+            if (!IsUTF8ContinuationByte(ch)) {
+                return RECODE_BROKENSYMBOL; // [BROKENSYMBOL] in third byte
+            }
+            PutUTF8SixBits(_rune, ch); // [XXXXYYYY YYZZZZZZ]
             if (_len > 3) {
                 ch = *s;
-                if (!IsUTF8ContinuationByte(ch))
-                    return RECODE_BROKENSYMBOL; //[BROKENSYMBOL] in fourth byte
-                PutUTF8SixBits(_rune, ch);      //[XXXYY YYYYZZZZ ZZQQQQQQ]
-                if (!IsValidUTF8Rune<4, strictMode>(_rune))
+                if (!IsUTF8ContinuationByte(ch)) {
+                    return RECODE_BROKENSYMBOL; // [BROKENSYMBOL] in fourth byte
+                }
+                PutUTF8SixBits(_rune, ch); // [XXXYY YYYYZZZZ ZZQQQQQQ]
+                if (!IsValidUTF8Rune<4, strictMode>(_rune)) {
                     return RECODE_BROKENSYMBOL;
+                }
             } else {
-                if (!IsValidUTF8Rune<3, strictMode>(_rune))
+                if (!IsValidUTF8Rune<3, strictMode>(_rune)) {
                     return RECODE_BROKENSYMBOL;
+                }
             }
         } else {
-            if (!IsValidUTF8Rune<2, strictMode>(_rune))
+            if (!IsValidUTF8Rune<2, strictMode>(_rune)) {
                 return RECODE_BROKENSYMBOL;
+            }
         }
     }
     rune_len = _len;
@@ -232,19 +241,19 @@ inline RECODE_RESULT SafeReadUTF8Char(wchar32& rune, size_t& rune_len, const uns
 }
 
 //! reads one unicode symbol from a character sequence encoded UTF8 and moves pointer to the next character
-//! @param c    value of the current character
-//! @param p    pointer to the current character, it will be changed in case of valid UTF8 byte sequence
-//! @param e    the end of the character sequence
+//! @param[out] rune    value of the current character
+//! @param[inout] p     pointer to the current character, it will be changed in case of valid UTF8 byte sequence
+//! @param e            the end of the character sequence
 template <StrictUTF8 strictMode = StrictUTF8::No>
 Y_FORCE_INLINE RECODE_RESULT ReadUTF8CharAndAdvance(wchar32& rune, const unsigned char*& p, const unsigned char* e) noexcept {
     Y_ASSERT(p < e); // since p < e then we will check RECODE_EOINPUT only for n > 1 (see calls of this functions)
     switch (UTF8RuneLen(*p)) {
         case 0:
             rune = BROKEN_RUNE;
-            return RECODE_BROKENSYMBOL; //[BROKENSYMBOL] in first byte
+            return RECODE_BROKENSYMBOL; // [BROKENSYMBOL] in first byte
 
         case 1:
-            rune = *p; //[00000000 0XXXXXXX]
+            rune = *p; // [00000000 0XXXXXXX]
             ++p;
             return RECODE_OK;
 
@@ -255,8 +264,8 @@ Y_FORCE_INLINE RECODE_RESULT ReadUTF8CharAndAdvance(wchar32& rune, const unsigne
                 rune = BROKEN_RUNE;
                 return RECODE_BROKENSYMBOL;
             } else {
-                PutUTF8LeadBits(rune, *p++, 2); //[00000000 000XXXXX]
-                PutUTF8SixBits(rune, *p++);     //[00000XXX XXYYYYYY]
+                PutUTF8LeadBits(rune, *p++, 2); // [00000000 000XXXXX]
+                PutUTF8SixBits(rune, *p++);     // [00000XXX XXYYYYYY]
                 if (!IsValidUTF8Rune<2, strictMode>(rune)) {
                     p -= 2;
                     rune = BROKEN_RUNE;
@@ -271,9 +280,9 @@ Y_FORCE_INLINE RECODE_RESULT ReadUTF8CharAndAdvance(wchar32& rune, const unsigne
                 rune = BROKEN_RUNE;
                 return RECODE_BROKENSYMBOL;
             } else {
-                PutUTF8LeadBits(rune, *p++, 3); //[00000000 0000XXXX]
-                PutUTF8SixBits(rune, *p++);     //[000000XX XXYYYYYY]
-                PutUTF8SixBits(rune, *p++);     //[XXXXYYYY YYZZZZZZ]
+                PutUTF8LeadBits(rune, *p++, 3); // [00000000 0000XXXX]
+                PutUTF8SixBits(rune, *p++);     // [000000XX XXYYYYYY]
+                PutUTF8SixBits(rune, *p++);     // [XXXXYYYY YYZZZZZZ]
                 // check for overlong encoding and surrogates
                 if (!IsValidUTF8Rune<3, strictMode>(rune)) {
                     p -= 3;
@@ -289,10 +298,10 @@ Y_FORCE_INLINE RECODE_RESULT ReadUTF8CharAndAdvance(wchar32& rune, const unsigne
                 rune = BROKEN_RUNE;
                 return RECODE_BROKENSYMBOL;
             } else {
-                PutUTF8LeadBits(rune, *p++, 4); //[00000000 00000000 00000XXX]
-                PutUTF8SixBits(rune, *p++);     //[00000000 0000000X XXYYYYYY]
-                PutUTF8SixBits(rune, *p++);     //[00000000 0XXXYYYY YYZZZZZZ]
-                PutUTF8SixBits(rune, *p++);     //[000XXXYY YYYYZZZZ ZZQQQQQQ]
+                PutUTF8LeadBits(rune, *p++, 4); // [00000000 00000000 00000XXX]
+                PutUTF8SixBits(rune, *p++);     // [00000000 0000000X XXYYYYYY]
+                PutUTF8SixBits(rune, *p++);     // [00000000 0XXXYYYY YYZZZZZZ]
+                PutUTF8SixBits(rune, *p++);     // [000XXXYY YYYYZZZZ ZZQQQQQQ]
                 if (!IsValidUTF8Rune<4, strictMode>(rune)) {
                     p -= 4;
                     rune = BROKEN_RUNE;
@@ -308,30 +317,33 @@ Y_FORCE_INLINE RECODE_RESULT ReadUTF8CharAndAdvance(wchar32& rune, const unsigne
 
 //! writes one unicode symbol into a character sequence encoded UTF8
 //! checks for end of the buffer and returns the result of encoding
-//! @param rune      value of the current character
-//! @param rune_len  length of the UTF8 byte sequence that has been written
-//! @param s         pointer to the output buffer
-//! @param tail      available size of the buffer
+//! @param rune           value of the current character
+//! @param[out] rune_len  length of the UTF8 byte sequence that has been written
+//! @param[out] s         pointer to the output buffer
+//! @param tail           available size of the buffer
 inline RECODE_RESULT SafeWriteUTF8Char(wchar32 rune, size_t& rune_len, unsigned char* s, size_t tail) {
     rune_len = 0;
     if (rune < 0x80) {
-        if (tail <= 0)
+        if (tail <= 0) {
             return RECODE_EOOUTPUT;
+        }
         *s = static_cast<unsigned char>(rune);
         rune_len = 1;
         return RECODE_OK;
     }
     if (rune < 0x800) {
-        if (tail <= 1)
+        if (tail <= 1) {
             return RECODE_EOOUTPUT;
+        }
         *s++ = static_cast<unsigned char>(0xC0 | (rune >> 6));
         *s = static_cast<unsigned char>(0x80 | (rune & 0x3F));
         rune_len = 2;
         return RECODE_OK;
     }
     if (rune < 0x10000) {
-        if (tail <= 2)
+        if (tail <= 2) {
             return RECODE_EOOUTPUT;
+        }
         *s++ = static_cast<unsigned char>(0xE0 | (rune >> 12));
         *s++ = static_cast<unsigned char>(0x80 | ((rune >> 6) & 0x3F));
         *s = static_cast<unsigned char>(0x80 | (rune & 0x3F));
@@ -339,8 +351,9 @@ inline RECODE_RESULT SafeWriteUTF8Char(wchar32 rune, size_t& rune_len, unsigned
         return RECODE_OK;
     }
     /*if (rune < 0x200000)*/ {
-        if (tail <= 3)
+        if (tail <= 3) {
             return RECODE_EOOUTPUT;
+        }
         *s++ = static_cast<unsigned char>(0xF0 | ((rune >> 18) & 0x07));
         *s++ = static_cast<unsigned char>(0x80 | ((rune >> 12) & 0x3F));
         *s++ = static_cast<unsigned char>(0x80 | ((rune >> 6) & 0x3F));
@@ -355,11 +368,11 @@ inline RECODE_RESULT SafeWriteUTF8Char(wchar32 rune, size_t& rune_len, unsigned
 }
 
 //! writes one unicode symbol into a character sequence encoded UTF8
-//! @attention       this function works as @c SafeWriteUTF8Char it does not check
-//!                  the size of the output buffer, it supposes that buffer is long enough
-//! @param rune      value of the current character
-//! @param rune_len  length of the UTF8 byte sequence that has been written
-//! @param s         pointer to the output buffer
+//! @attention            this function works as @c SafeWriteUTF8Char it does not check
+//!                       the size of the output buffer, it supposes that buffer is long enough
+//! @param rune           value of the current character
+//! @param[out] rune_len  length of the UTF8 byte sequence that has been written
+//! @param[out] s         pointer to the output buffer
 inline void WriteUTF8Char(wchar32 rune, size_t& rune_len, unsigned char* s) {
     if (rune < 0x80) {
         *s = static_cast<unsigned char>(rune);
@@ -388,7 +401,7 @@ inline void WriteUTF8Char(wchar32 rune, size_t& rune_len, unsigned char* s) {
     }
 }
 
-TStringBuf SubstrUTF8(const TStringBuf str, size_t pos, size_t len);
+TStringBuf SubstrUTF8(const TStringBuf str Y_LIFETIME_BOUND, size_t pos, size_t len);
 
 enum EUTF8Detect {
     NotUTF8,
@@ -429,3 +442,11 @@ bool ToUpperUTF8Impl(const char* beg, size_t n, TString& newString);
 TString ToUpperUTF8(const TString& s);
 TString ToUpperUTF8(TStringBuf s);
 TString ToUpperUTF8(const char* s);
+
+//! cut utf-8 string to fit into |size| bytes
+void Utf8TruncateInplace(TString& s, size_t size);
+//! cut on a valid utf-8 sequence less or equal |size|
+void Utf8TruncateInplaceRobust(TString& s, size_t size);
+[[nodiscard]] TStringBuf Utf8Truncate(TStringBuf sb Y_LIFETIME_BOUND, size_t size);
+//! on error returns the longest valid utf8 sequence
+[[nodiscard]] TStringBuf Utf8TruncateRobust(TStringBuf sb Y_LIFETIME_BOUND, size_t size) noexcept;
diff --git a/util/charset/utf8_ut.cpp b/util/charset/utf8_ut.cpp
index 9e68881cca2..8996ea2fb67 100644
--- a/util/charset/utf8_ut.cpp
+++ b/util/charset/utf8_ut.cpp
@@ -27,17 +27,17 @@ Y_UNIT_TEST_SUITE(TUtfUtilTest) {
 
         {
             const char* weird = "\xC8\xBE"; // 'Ⱦ', U+023E. strlen(weird)==2, strlen(tolower_utf8(weird)) is 3
-            const char* turkI = "İ";        //strlen("İ") == 2, strlen(tolower_utf8("İ") == 1
+            const char* turkI = "İ";        // strlen("İ") == 2, strlen(tolower_utf8("İ") == 1
             TStringBuf chars[] = {"f", "F", "Б", "б", weird, turkI};
             const int N = Y_ARRAY_SIZE(chars);
-            //try all combinations of these letters.
+            // try all combinations of these letters.
             int numberOfVariants = 1;
             for (int len = 0; len <= 4; ++len) {
                 for (int i = 0; i < numberOfVariants; ++i) {
                     TString s;
                     int k = i;
                     for (int j = 0; j < len; ++j) {
-                        //Treat 'i' like number in base-N system with digits from 'chars'-array
+                        // Treat 'i' like number in base-N system with digits from 'chars'-array
                         s += chars[k % N];
                         k /= N;
                     }
@@ -67,17 +67,17 @@ Y_UNIT_TEST_SUITE(TUtfUtilTest) {
 
         {
             const char* weird = "\xC8\xBE"; // 'Ⱦ', U+023E. strlen(weird)==2, strlen(ToUpper_utf8(weird)) is 3
-            const char* turkI = "İ";        //strlen("İ") == 2, strlen(ToUpper_utf8("İ") == 1
+            const char* turkI = "İ";        // strlen("İ") == 2, strlen(ToUpper_utf8("İ") == 1
             TStringBuf chars[] = {"F", "f", "б", "Б", turkI, weird};
             const int N = Y_ARRAY_SIZE(chars);
-            //try all combinations of these letters.
+            // try all combinations of these letters.
             int numberOfVariants = 1;
             for (int len = 0; len <= 4; ++len) {
                 for (int i = 0; i < numberOfVariants; ++i) {
                     TString s;
                     int k = i;
                     for (int j = 0; j < len; ++j) {
-                        //Treat 'i' like number in base-N system with digits from 'chars'-array
+                        // Treat 'i' like number in base-N system with digits from 'chars'-array
                         s += chars[k % N];
                         k /= N;
                     }
@@ -123,4 +123,52 @@ Y_UNIT_TEST_SUITE(TUtfUtilTest) {
         wtextScalar.remove(wtextSSE.size());
         UNIT_ASSERT(wtextScalar == wtextSSE);
     }
-}
+
+    Y_UNIT_TEST(TestUtf8TruncateInplace) {
+        TString s = "Съешь ещё этих мягких французских булок, да выпей же чаю.";
+        Utf8TruncateInplace(s, 0u);
+        UNIT_ASSERT_EQUAL(s, "");
+
+        s = "Съешь ещё этих мягких французских булок, да выпей же чаю.";
+        Utf8TruncateInplace(s, 10u);
+        UNIT_ASSERT_EQUAL(s, "Съешь");
+
+        s = "Съешь ещё этих мягких французских булок, да выпей же чаю.";
+        TString s_copy = s;
+        Utf8TruncateInplace(s, s.size());
+        UNIT_ASSERT_EQUAL(s, s_copy);
+
+        Utf8TruncateInplace(s, Max());
+        UNIT_ASSERT_EQUAL(s, s_copy);
+    }
+
+    Y_UNIT_TEST(TestUtf8TruncateCorrupted) {
+        const TString s = "Съешь ещё этих мягких французских булок, да выпей же чаю.";
+        TStringBuf corrupted{s, 0u, 21u};
+        UNIT_ASSERT_EXCEPTION_CONTAINS(Y_UNUSED(Utf8Truncate(corrupted, 21u)), yexception, "invalid UTF-8 char");
+        UNIT_ASSERT_NO_EXCEPTION(Y_UNUSED(Utf8TruncateRobust(corrupted, 21u)));
+        TStringBuf fixed = Utf8TruncateRobust(corrupted, 21u);
+        UNIT_ASSERT_LE(fixed.size(), 21u);
+        UNIT_ASSERT_EQUAL(fixed, "Съешь ещё э");
+    }
+
+    Y_UNIT_TEST(TestUtf8CutInvalidSuffixInplace) {
+        TString s = "Съешь ещё этих мягких французских булок, да выпей же чаю.";
+        s.resize(21);
+        UNIT_ASSERT_UNEQUAL(s, "Съешь ещё э");
+        Utf8TruncateInplaceRobust(s, s.size());
+        UNIT_ASSERT_EQUAL(s, "Съешь ещё э");
+    }
+
+    Y_UNIT_TEST(TestUtf8CutInvalidSuffix) {
+        TStringBuf sb = "Съешь ещё этих мягких французских булок, да выпей же чаю."sv;
+        UNIT_ASSERT_EQUAL(Utf8TruncateRobust(sb, sb.size()), sb);
+        UNIT_ASSERT_EQUAL(Utf8TruncateRobust(sb.substr(0, 21), sb.size()), "Съешь ещё э"sv);
+    }
+
+    Y_UNIT_TEST(TestUtf8TruncateCornerCases) {
+        UNIT_ASSERT_EQUAL(Utf8Truncate("①②③"sv, 4).size(), 3);
+        UNIT_ASSERT_VALUES_EQUAL(Utf8Truncate("foobar"sv, Max()), "foobar"sv);
+    }
+
+} // Y_UNIT_TEST_SUITE(TUtfUtilTest)
diff --git a/util/charset/wide.cpp b/util/charset/wide.cpp
index a287438ddde..535e8ef10f8 100644
--- a/util/charset/wide.cpp
+++ b/util/charset/wide.cpp
@@ -23,13 +23,14 @@ namespace {
             case '\"':
                 return Y_ARRAY_SIZE(QUOT);
             default:
-                if (insertBr && (c == '\r' || c == '\n'))
+                if (insertBr && (c == '\r' || c == '\n')) {
                     return Y_ARRAY_SIZE(BR);
-                else
+                } else {
                     return 1;
+                }
         }
     }
-}
+} // namespace
 
 void Collapse(TUtf16String& w) {
     CollapseImpl(w, w, 0, IsWhitespace);
@@ -579,11 +580,13 @@ void EscapeHtmlChars(TUtf16String& str) {
 
     const TUtf16String& cs = str;
 
-    for (size_t i = 0; i < cs.size(); ++i)
+    for (size_t i = 0; i < cs.size(); ++i) {
         escapedLen += EscapedLen<insertBr>(cs[i]);
+    }
 
-    if (escapedLen == cs.size())
+    if (escapedLen == cs.size()) {
         return;
+    }
 
     TUtf16String res;
     res.reserve(escapedLen);
@@ -609,8 +612,9 @@ void EscapeHtmlChars(TUtf16String& str) {
                 if (insertBr && (cs[i] == '\r' || cs[i] == '\n')) {
                     ent = &br;
                     break;
-                } else
+                } else {
                     continue;
+                }
         }
 
         res.append(cs.begin() + start, cs.begin() + i);
diff --git a/util/charset/wide.h b/util/charset/wide.h
index 2b52bb4f12c..9616375c259 100644
--- a/util/charset/wide.h
+++ b/util/charset/wide.h
@@ -61,7 +61,7 @@ namespace NDetail {
     template <class T>
     inline void WriteSurrogatePair(wchar32 s, T& dest) noexcept;
 
-}
+} // namespace NDetail
 
 inline wchar16* SkipSymbol(wchar16* begin, const wchar16* end) noexcept {
     return begin + W16SymbolSize(begin, end);
@@ -81,8 +81,9 @@ inline const wchar32* SkipSymbol(const wchar32* begin, const wchar32* end) noexc
 inline wchar32 ReadSymbol(const wchar16* begin, const wchar16* end) noexcept {
     Y_ASSERT(begin < end);
     if (IsW16SurrogateLead(*begin)) {
-        if (begin + 1 < end && IsW16SurrogateTail(*(begin + 1)))
+        if (begin + 1 < end && IsW16SurrogateTail(*(begin + 1))) {
             return ::NDetail::ReadSurrogatePair(begin);
+        }
 
         return BROKEN_RUNE;
     } else if (IsW16SurrogateTail(*begin)) {
@@ -210,8 +211,9 @@ inline bool WriteSymbol(wchar32 s, wchar16*& dest, const wchar16* destEnd) noexc
             return true;
         }
 
-        if (dest + 2 > destEnd)
+        if (dest + 2 > destEnd) {
             return false;
+        }
 
         ::NDetail::WriteSurrogatePair(s, dest);
     } else {
@@ -333,7 +335,7 @@ namespace NDetail {
     void UTF8ToWideImplSSE41(const unsigned char*& cur, const unsigned char* last, wchar16*& dest) noexcept;
 
     void UTF8ToWideImplSSE41(const unsigned char*& cur, const unsigned char* last, wchar32*& dest) noexcept;
-}
+} // namespace NDetail
 
 //! @return len if robust and position where encoding stopped if not
 template <bool robust, typename TCharType>
@@ -341,7 +343,7 @@ inline size_t UTF8ToWideImpl(const char* text, size_t len, TCharType* dest, size
     const unsigned char* cur = reinterpret_cast<const unsigned char*>(text);
     const unsigned char* last = cur + len;
     TCharType* p = dest;
-#ifdef _sse_ //can't check for sse4, as we build most of arcadia without sse4 support even on platforms that support it
+#ifdef _sse_ // can't check for sse4, as we build most of arcadia without sse4 support even on platforms that support it
     if (cur + 16 <= last && NX86::CachedHaveSSE41()) {
         ::NDetail::UTF8ToWideImplSSE41(cur, last, p);
     }
@@ -362,8 +364,9 @@ inline TUtf16String UTF8ToWide(const char* text, size_t len) {
     TUtf16String w = TUtf16String::Uninitialized(len);
     size_t written;
     size_t pos = UTF8ToWideImpl<robust>(text, len, w.begin(), written);
-    if (pos != len)
+    if (pos != len) {
         ythrow yexception() << "failed to decode UTF-8 string at pos " << pos << ::NDetail::InStringMsg(text, len);
+    }
     Y_ASSERT(w.size() >= written);
     w.remove(written);
     return w;
@@ -465,6 +468,16 @@ inline TString WideToUTF8(const wchar16* text, size_t len) {
     return s;
 }
 
+#if defined(_win_)
+inline TString WideToUTF8(const wchar_t* text, size_t len) {
+    return WideToUTF8(reinterpret_cast<const wchar16*>(text), len);
+}
+
+inline std::string WideToUTF8(std::wstring_view text) {
+    return WideToUTF8(text.data(), text.size()).ConstRef();
+}
+#endif
+
 inline TString WideToUTF8(const wchar32* text, size_t len) {
     TString s = TString::Uninitialized(WideToUTF8BufferSize(len));
     size_t written = 0;
@@ -596,7 +609,7 @@ namespace NDetail {
 
 #ifdef _sse2_
     inline bool DoIsStringASCIISSE(const unsigned char* first, const unsigned char* last) {
-        //scalar version for short strings
+        // scalar version for short strings
         if (first + 8 > last) {
             return ::NDetail::DoIsStringASCIISlow(first, last);
         }
@@ -627,9 +640,9 @@ namespace NDetail {
 
         return ::NDetail::DoIsStringASCIISlow(first, last);
     }
-#endif //_sse2_
+#endif // _sse2_
 
-}
+} // namespace NDetail
 
 //! returns @c true if character sequence has no symbols with value greater than 0x7F
 template <typename TChar>
@@ -697,15 +710,17 @@ inline TUtf32String ASCIIToUTF32(const TStringBuf s) {
 
 //! returns @c true if string contains whitespace characters only
 inline bool IsSpace(const wchar16* s, size_t n) {
-    if (n == 0)
+    if (n == 0) {
         return false;
+    }
 
     Y_ASSERT(s);
 
     const wchar16* const e = s + n;
     for (const wchar16* p = s; p != e; ++p) {
-        if (!IsWhitespace(*p))
+        if (!IsWhitespace(*p)) {
             return false;
+        }
     }
     return true;
 }
@@ -760,37 +775,69 @@ bool IsTitleWord(const TWtringBuf text) noexcept;
 bool IsLower(const TWtringBuf text) noexcept;
 bool IsUpper(const TWtringBuf text) noexcept;
 
-/* Lowercase/uppercase given string inplace. Any alphabetic symbol will be converted to a proper
+/**
+ * Lowercase given string inplace. Any alphabetic symbol will be converted to a proper
  * case, the rest of the symbols will be kept the same. It is expected that `text` is a correct
  * UTF-16 string.
  *
  * For example `ToLower("heLLo")` will return `"hello"`.
  *
- * @param text      String to modify
- * @param pos       Position of the first character to modify
- * @param count     Length of the substring
- * @returns         `true` if `text` was changed
+ * @param[inout] text   String to modify
+ * @param pos           Position of the first character to modify
+ * @param count         Length of the substring
+ * @returns             `true` if `text` was changed
  *
  * NOTE: `pos` and `count` are measured in `wchar16`, not in codepoints.
  */
 bool ToLower(TUtf16String& text, size_t pos = 0, size_t count = TUtf16String::npos);
+
+/**
+ * Uppercase given string inplace. Any alphabetic symbol will be converted to a proper
+ * case, the rest of the symbols will be kept the same. It is expected that `text` is a correct
+ * UTF-16 string.
+ *
+ * For example `ToUpper("heLLo")` will return `"HELLO"`.
+ *
+ * @param[inout] text   String to modify
+ * @param pos           Position of the first character to modify
+ * @param count         Length of the substring
+ * @returns             `true` if `text` was changed
+ *
+ * NOTE: `pos` and `count` are measured in `wchar16`, not in codepoints.
+ */
 bool ToUpper(TUtf16String& text, size_t pos = 0, size_t count = TUtf16String::npos);
 
-/* Lowercase/uppercase given string inplace. Any alphabetic symbol will be converted to a proper
+/**
+ * Lowercase given string inplace. Any alphabetic symbol will be converted to a proper
  * case, the rest of the symbols will be kept the same. It is expected that `text` is a correct
  * UTF-32 string.
  *
  * For example `ToLower("heLLo")` will return `"hello"`.
  *
- * @param text      String to modify
- * @param pos       Position of the first character to modify
- * @param count     Length of the substring
- * @returns         `true` if `text` was changed
+ * @param[inout] text   String to modify
+ * @param pos           Position of the first character to modify
+ * @param count         Length of the substring
+ * @returns             `true` if `text` was changed
  *
  * NOTE: `pos` and `count` are measured in `wchar16`, not in codepoints.
  */
-bool ToLower(TUtf32String& /*text*/, size_t /*pos*/ = 0, size_t /*count*/ = TUtf16String::npos);
-bool ToUpper(TUtf32String& /*text*/, size_t /*pos*/ = 0, size_t /*count*/ = TUtf16String::npos);
+bool ToLower(TUtf32String& /*text*/, size_t /*pos*/ = 0, size_t /*count*/ = TUtf32String::npos);
+
+/**
+ * Uppercase given string inplace. Any alphabetic symbol will be converted to a proper
+ * case, the rest of the symbols will be kept the same. It is expected that `text` is a correct
+ * UTF-32 string.
+ *
+ * For example `ToUpper("heLLo")` will return `"HELLO"`.
+ *
+ * @param[inout] text   String to modify
+ * @param pos           Position of the first character to modify
+ * @param count         Length of the substring
+ * @returns             `true` if `text` was changed
+ *
+ * NOTE: `pos` and `count` are measured in `wchar16`, not in codepoints.
+ */
+bool ToUpper(TUtf32String& /*text*/, size_t /*pos*/ = 0, size_t /*count*/ = TUtf32String::npos);
 
 /* Titlecase first symbol and lowercase the rest, see `ToLower` for more details.
  */
@@ -798,11 +845,12 @@ bool ToTitle(TUtf16String& text, size_t pos = 0, size_t count = TUtf16String::np
 
 /* Titlecase first symbol and lowercase the rest, see `ToLower` for more details.
  */
-bool ToTitle(TUtf32String& /*text*/, size_t /*pos*/ = 0, size_t /*count*/ = TUtf16String::npos);
+bool ToTitle(TUtf32String& /*text*/, size_t /*pos*/ = 0, size_t /*count*/ = TUtf32String::npos);
 
-/* @param text      Pointer to the string to modify
+/**
+ * @param text      String to modify
  * @param length    Length of the string to modify
- * @param out       Pointer to the character array to write to
+ * @param[out] out  Pointer to the character array to write to
  *
  * NOTE: [text, text+length) and [out, out+length) should not interleave.
  *
@@ -810,24 +858,43 @@ bool ToTitle(TUtf32String& /*text*/, size_t /*pos*/ = 0, size_t /*count*/ = TUtf
  * overload.
  */
 bool ToLower(const wchar16* text, size_t length, wchar16* out) noexcept;
+
+//! @copydoc ToLower(const wchar16*,size_t,wchar16*)
 bool ToUpper(const wchar16* text, size_t length, wchar16* out) noexcept;
+
+//! @copydoc ToLower(const wchar16*,size_t,wchar16*)
 bool ToTitle(const wchar16* text, size_t length, wchar16* out) noexcept;
 
+//! @copydoc ToLower(const wchar16*,size_t,wchar16*)
 bool ToLower(const wchar32* text, size_t length, wchar32* out) noexcept;
+
+//! @copydoc ToLower(const wchar16*,size_t,wchar16*)
 bool ToUpper(const wchar32* text, size_t length, wchar32* out) noexcept;
+
+//! @copydoc ToLower(const wchar16*,size_t,wchar16*)
 bool ToTitle(const wchar32* text, size_t length, wchar32* out) noexcept;
 
-/* @param text      Pointer to the string to modify
- * @param length    Length of the string to modify
+/**
+ * @param[inout] text   Pointer to the string to modify
+ * @param length        Length of the string to modify
  *
  * TODO(yazevnul): replace these functions with `bool(const TArrayRef<wchar16>)` overload.
  */
 bool ToLower(wchar16* text, size_t length) noexcept;
+
+//! @copydoc ToLower(wchar16*,size_t)
 bool ToUpper(wchar16* text, size_t length) noexcept;
+
+//! @copydoc ToLower(wchar16*,size_t)
 bool ToTitle(wchar16* text, size_t length) noexcept;
 
+//! @copydoc ToLower(wchar16*,size_t)
 bool ToLower(wchar32* text, size_t length) noexcept;
+
+//! @copydoc ToLower(wchar16*,size_t)
 bool ToUpper(wchar32* text, size_t length) noexcept;
+
+//! @copydoc ToLower(wchar16*,size_t)
 bool ToTitle(wchar32* text, size_t length) noexcept;
 
 /* Convenience wrappers for `ToLower`, `ToUpper` and `ToTitle`.
@@ -840,9 +907,9 @@ TUtf16String ToLowerRet(const TWtringBuf text, size_t pos = 0, size_t count = TW
 TUtf16String ToUpperRet(const TWtringBuf text, size_t pos = 0, size_t count = TWtringBuf::npos) Y_WARN_UNUSED_RESULT;
 TUtf16String ToTitleRet(const TWtringBuf text, size_t pos = 0, size_t count = TWtringBuf::npos) Y_WARN_UNUSED_RESULT;
 
-TUtf32String ToLowerRet(const TUtf32StringBuf text, size_t pos = 0, size_t count = TWtringBuf::npos) Y_WARN_UNUSED_RESULT;
-TUtf32String ToUpperRet(const TUtf32StringBuf text, size_t pos = 0, size_t count = TWtringBuf::npos) Y_WARN_UNUSED_RESULT;
-TUtf32String ToTitleRet(const TUtf32StringBuf text, size_t pos = 0, size_t count = TWtringBuf::npos) Y_WARN_UNUSED_RESULT;
+TUtf32String ToLowerRet(const TUtf32StringBuf text, size_t pos = 0, size_t count = TUtf32StringBuf::npos) Y_WARN_UNUSED_RESULT;
+TUtf32String ToUpperRet(const TUtf32StringBuf text, size_t pos = 0, size_t count = TUtf32StringBuf::npos) Y_WARN_UNUSED_RESULT;
+TUtf32String ToTitleRet(const TUtf32StringBuf text, size_t pos = 0, size_t count = TUtf32StringBuf::npos) Y_WARN_UNUSED_RESULT;
 
 //! replaces the '<', '>' and '&' characters in string with '&lt;', '&gt;' and '&amp;' respectively
 // insertBr=true - replace '\r' and '\n' with "<BR>"
@@ -869,8 +936,9 @@ inline bool IsValidUTF16(const wchar16* b, const wchar16* e) {
     Y_ENSURE(b <= e, TStringBuf("invalid iterators"));
     while (b < e) {
         wchar32 symbol = ReadSymbolAndAdvance(b, e);
-        if (symbol == BROKEN_RUNE)
+        if (symbol == BROKEN_RUNE) {
             return false;
+        }
     }
     return true;
 }
diff --git a/util/charset/wide_sse41.cpp b/util/charset/wide_sse41.cpp
index d1f2a74851e..8aefadfddd5 100644
--- a/util/charset/wide_sse41.cpp
+++ b/util/charset/wide_sse41.cpp
@@ -8,7 +8,7 @@ namespace NDetail {
     }
     void UTF8ToWideImplSSE41(const unsigned char*&, const unsigned char*, wchar32*&) noexcept {
     }
-}
+} // namespace NDetail
 
 #else
 
@@ -18,17 +18,17 @@ namespace NDetail {
     #include <emmintrin.h>
     #include <smmintrin.h>
 
-//processes to the first error, or until less then 16 bytes left
-//most code taken from https://woboq.com/blog/utf-8-processing-using-simd.html
+// processes to the first error, or until less then 16 bytes left
+// most code taken from https://woboq.com/blog/utf-8-processing-using-simd.html
 
-//return dstAdvance 0 in case of problems
+// return dstAdvance 0 in case of problems
 static Y_FORCE_INLINE ui32 Unpack16BytesIntoUtf16IfNoSurrogats(const unsigned char*& cur, __m128i& utf16Low, __m128i& utf16High) {
     unsigned char curAligned[16];
 
     memcpy(curAligned, cur, sizeof(__m128i));
     __m128i chunk = _mm_load_si128(reinterpret_cast<const __m128i*>(curAligned));
 
-    //only ascii characters - simple copy
+    // only ascii characters - simple copy
     if (!_mm_movemask_epi8(chunk)) {
         utf16Low = _mm_unpacklo_epi8(chunk, _mm_setzero_si128());
         utf16High = _mm_unpackhi_epi8(chunk, _mm_setzero_si128());
@@ -50,9 +50,9 @@ static Y_FORCE_INLINE ui32 Unpack16BytesIntoUtf16IfNoSurrogats(const unsigned ch
     __m128i chunkLow, chunkHigh;
 
     if (Y_LIKELY(!_mm_movemask_epi8(cond3))) {
-        //main case: no bloks of size 3 or 4
+        // main case: no bloks of size 3 or 4
 
-        //rune len for start of multi-byte sequences (0 for b0... and b10..., 2 for b110..., etc.)
+        // rune len for start of multi-byte sequences (0 for b0... and b10..., 2 for b110..., etc.)
         __m128i count = _mm_and_si128(state, _mm_set1_epi8(0x7));
 
         __m128i countSub1 = _mm_subs_epu8(count, _mm_set1_epi8(0x1));
@@ -68,7 +68,7 @@ static Y_FORCE_INLINE ui32 Unpack16BytesIntoUtf16IfNoSurrogats(const unsigned ch
         __m128i isBeginMultibyteMask = _mm_cmpgt_epi8(count, _mm_set1_epi8(0));
         __m128i needNoContinuationMask = _mm_cmpeq_epi8(continuation1, _mm_set1_epi8(0));
         __m128i isBeginMask = _mm_add_epi8(isBeginMultibyteMask, isAsciiMask);
-        //each symbol should be exactly one of ascii, continuation or begin
+        // each symbol should be exactly one of ascii, continuation or begin
         __m128i okMask = _mm_cmpeq_epi8(isBeginMask, needNoContinuationMask);
 
         if (_mm_movemask_epi8(okMask) != 0xFFFF) {
@@ -114,7 +114,7 @@ static Y_FORCE_INLINE ui32 Unpack16BytesIntoUtf16IfNoSurrogats(const unsigned ch
             return 0;
         }
 
-        //rune len for start of multi-byte sequences (0 for b0... and b10..., 2 for b110..., etc.)
+        // rune len for start of multi-byte sequences (0 for b0... and b10..., 2 for b110..., etc.)
         __m128i count = _mm_and_si128(state, _mm_set1_epi8(0x7));
 
         __m128i countSub1 = _mm_subs_epu8(count, _mm_set1_epi8(0x1));
@@ -132,7 +132,7 @@ static Y_FORCE_INLINE ui32 Unpack16BytesIntoUtf16IfNoSurrogats(const unsigned ch
         __m128i isBeginMultibyteMask = _mm_cmpgt_epi8(count, _mm_set1_epi8(0));
         __m128i needNoContinuationMask = _mm_cmpeq_epi8(continuationsRunelen, _mm_set1_epi8(0));
         __m128i isBeginMask = _mm_add_epi8(isBeginMultibyteMask, isAsciiMask);
-        //each symbol should be exactly one of ascii, continuation or begin
+        // each symbol should be exactly one of ascii, continuation or begin
         __m128i okMask = _mm_cmpeq_epi8(isBeginMask, needNoContinuationMask);
 
         if (_mm_movemask_epi8(okMask) != 0xFFFF) {
@@ -209,7 +209,7 @@ namespace NDetail {
             memcpy(dest, destAligned, sizeof(__m128i) * 2);
             dest += dstAdvance;
         }
-        //The rest will be handled sequencially.
+        // The rest will be handled sequencially.
         // Possible improvement: go back to the vectorized processing after the error or the 4 byte sequence
     }
 
@@ -225,7 +225,7 @@ namespace NDetail {
                 break;
             }
 
-            //NOTE: we only work in case without surrogat pairs, so we can make simple copying with zeroes in 2 high bytes
+            // NOTE: we only work in case without surrogat pairs, so we can make simple copying with zeroes in 2 high bytes
             __m128i utf32_lowlow = _mm_unpacklo_epi16(utf16Low, _mm_set1_epi8(0));
             __m128i utf32_lowhigh = _mm_unpackhi_epi16(utf16Low, _mm_set1_epi8(0));
             __m128i utf32_highlow = _mm_unpacklo_epi16(utf16High, _mm_set1_epi8(0));
@@ -239,9 +239,9 @@ namespace NDetail {
             memcpy(dest, destAligned, sizeof(__m128i) * 4);
             dest += dstAdvance;
         }
-        //The rest will be handled sequencially.
+        // The rest will be handled sequencially.
         // Possible improvement: go back to the vectorized processing after the error or the 4 byte sequence
     }
-}
+} // namespace NDetail
 
 #endif
diff --git a/util/charset/wide_ut.cpp b/util/charset/wide_ut.cpp
index b33dd0c0de9..e221ec4ad66 100644
--- a/util/charset/wide_ut.cpp
+++ b/util/charset/wide_ut.cpp
@@ -111,16 +111,16 @@ namespace {
     }
 
     //! use this function to dump UTF8 text into a file in case of any changes
-    //    void DumpUTF8Text() {
-    //        TString s = WideToUTF8(UnicodeText);
-    //        std::ofstream f("utf8.txt");
-    //        f << std::hex;
-    //        for (int i = 0; i < (int)s.size(); ++i) {
-    //            f << "0x" << std::setw(2) << std::setfill('0') << (int)(ui8)s[i] << ", ";
-    //            if ((i + 1) % 16 == 0)
-    //                f << std::endl;
-    //        }
-    //    }
+    // void DumpUTF8Text() {
+    //     TString s = WideToUTF8(UnicodeText);
+    //     std::ofstream f("utf8.txt");
+    //     f << std::hex;
+    //     for (int i = 0; i < (int)s.size(); ++i) {
+    //         f << "0x" << std::setw(2) << std::setfill('0') << (int)(ui8)s[i] << ", ";
+    //         if ((i + 1) % 16 == 0)
+    //             f << std::endl;
+    //     }
+    // }
 
     template <StrictUTF8 strictMode = StrictUTF8::No>
     void CheckRecodeOK(wchar32 expected, unsigned char* first, size_t n) {
@@ -160,7 +160,7 @@ namespace {
         UNIT_ASSERT(n == len);
         UNIT_ASSERT(r == result);
     }
-}
+} // namespace
 
 class TConversionTest: public TTestBase {
 private:
diff --git a/util/datetime/base.cpp b/util/datetime/base.cpp
index 83a17660fdf..e3bc1442cf4 100644
--- a/util/datetime/base.cpp
+++ b/util/datetime/base.cpp
@@ -112,7 +112,8 @@ namespace {
         if (GetTimeZoneInformation(&tz) == TIME_ZONE_ID_INVALID) {
             ythrow TSystemError() << "Failed to get the system time zone";
         }
-        i64 utcOffsetInMinutes = -tz.Bias;
+        const LONG seasonalBias = localTime.tm_isdst > 0 ? tz.DaylightBias : tz.StandardBias;
+        i64 utcOffsetInMinutes = -(tz.Bias + seasonalBias);
 #endif
         if (utcOffsetInMinutes == 0) {
             os << 'Z';
@@ -130,7 +131,7 @@ namespace {
             os << Pad<2>(utcOffsetInMinutes % 60);
         }
     }
-}
+} // namespace
 
 template <>
 void Out<TDuration>(IOutputStream& os, TTypeTraits<TDuration>::TFuncParam duration) {
diff --git a/util/datetime/base.h b/util/datetime/base.h
index a0fc71bab4f..f5e9c3ff147 100644
--- a/util/datetime/base.h
+++ b/util/datetime/base.h
@@ -93,6 +93,50 @@ TString DateToString(time_t when, long* sec = nullptr);
 TString YearToString(const struct tm& theTm);
 TString YearToString(time_t when);
 
+namespace NDateTimeHelpers {
+    template <typename T>
+    struct TPrecisionHelper {
+        using THighPrecision = ui64;
+    };
+
+    template <>
+    struct TPrecisionHelper<float> {
+        using THighPrecision = double;
+    };
+
+    template <>
+    struct TPrecisionHelper<double> {
+        using THighPrecision = double;
+    };
+
+    template <ui64 b, typename T>
+    static constexpr ui64 MulWithSaturation(T a) = delete;
+
+    template <ui64 b>
+    constexpr ui64 MulWithSaturation(ui64 a) {
+        constexpr ui64 maxMultiplicand = Max<ui64>() / b;
+#if defined(__GNUC__) && defined(__cpp_lib_is_constant_evaluated)
+        if (!std::is_constant_evaluated()) {
+            if constexpr (std::is_same<ui64, unsigned long>::value) {
+                unsigned long r = 0;
+                return __builtin_umull_overflow(a, b, &r) ? Max<ui64>() : r;
+            }
+            if constexpr (std::is_same<ui64, unsigned long long>::value) {
+                unsigned long long r = 0;
+                return __builtin_umulll_overflow(a, b, &r) ? Max<ui64>() : r;
+            }
+        }
+#endif
+        return a <= maxMultiplicand ? a * b : Max<ui64>();
+    }
+
+    template <ui64 b>
+    constexpr ui64 MulWithSaturation(double a) {
+        double r = a * b;
+        return r < 0 ? 0 : (r <= MaxFloor<ui64>() ? static_cast<ui64>(r) : Max<ui64>());
+    }
+} // namespace NDateTimeHelpers
+
 template <class S>
 class TTimeBase {
 public:
@@ -172,25 +216,32 @@ class TTimeBase {
     }
 
 protected:
-    TValue Value_; // microseconds count
-};
+    /* noexcept(false) as conversion from T might throw, for example FromString("abc") */
+    template <typename T>
+    static constexpr S MilliSecondsConvertFrom(T milliseconds) noexcept(false) {
+        auto ms = typename NDateTimeHelpers::TPrecisionHelper<T>::THighPrecision(milliseconds);
+        return S::MicroSeconds(NDateTimeHelpers::MulWithSaturation<ui64(1'000)>(ms));
+    }
 
-namespace NDateTimeHelpers {
+    /* noexcept(false) as conversion from T might throw, for example FromString("abc") */
     template <typename T>
-    struct TPrecisionHelper {
-        using THighPrecision = ui64;
-    };
+    static constexpr S SecondsConvertFrom(T seconds) noexcept(false) {
+        auto s = typename NDateTimeHelpers::TPrecisionHelper<T>::THighPrecision(seconds);
+        if constexpr (std::is_same_v<decltype(s), double>) {
+            return MilliSecondsConvertFrom(s * 1000);
+        }
+        return S::MicroSeconds(NDateTimeHelpers::MulWithSaturation<ui64(1'000'000)>(s));
+    }
 
-    template <>
-    struct TPrecisionHelper<float> {
-        using THighPrecision = double;
-    };
+    static constexpr S Minutes(ui64 m) noexcept;
 
-    template <>
-    struct TPrecisionHelper<double> {
-        using THighPrecision = double;
-    };
-}
+    static constexpr S Hours(ui64 h) noexcept;
+
+    static constexpr S Days(ui64 d) noexcept;
+
+protected:
+    TValue Value_; // microseconds count
+};
 
 class TDuration: public TTimeBase<TDuration> {
     using TBase = TTimeBase<TDuration>;
@@ -217,14 +268,14 @@ class TDuration: public TTimeBase<TDuration> {
      * TDuration is compatible with std::chrono::duration:
      *   it can be constructed and compared with std::chrono::duration.
      * But there are two significant and dangerous differences between them:
-     *   1) TDuration is never negative and use saturation between 0 and maximum value.
+     *   1) TDuration is never negative and uses saturation between 0 and the maximum value.
      *      std::chrono::duration can be negative and can overflow.
-     *   2) TDuration uses integer number of microseconds.
-     *      std::chrono::duration is flexible, can be integer of floating point,
+     *   2) TDuration uses an integer number of microseconds.
+     *      std::chrono::duration is flexible, can be an integer of a floating point,
      *      can have different precisions.
-     * So when casted from std::chrono::duration to TDuration value is clamped and rounded.
+     * So when casted from std::chrono::duration to TDuration its value is clamped and rounded.
      * In arithmetic operations std::chrono::duration argument is only rounded,
-     *   result is TDuration and it clamped and rounded.
+     *   result is TDuration and it is clamped and rounded.
      * In comparisons std::chrono::duration argument is rounded.
      */
     template <typename T, typename TRatio>
@@ -232,8 +283,8 @@ class TDuration: public TTimeBase<TDuration> {
         static_assert(
             std::ratio_greater_equal<TRatio, std::micro>::value &&
                 (!std::is_floating_point<T>::value || std::ratio_greater<TRatio, std::micro>::value),
-            "Extremely likely it is loss of precision, because TDuration stores microseconds. "
-            "Cast you duration explicitly to microseconds if you really need it.");
+            "Extremely likely it is a loss of precision, because TDuration stores microseconds. "
+            "Cast 'duration' explicitly to microseconds if you really need it.");
 
         if (duration.count() < 0) {
             *this = TDuration::Zero(); // clamp from the bottom
@@ -267,7 +318,7 @@ class TDuration: public TTimeBase<TDuration> {
     /* noexcept(false) as conversion from T might throw, for example FromString("abc") */
     template <typename T>
     static constexpr TDuration MilliSeconds(T ms) noexcept(false) {
-        return MicroSeconds((ui64)(typename NDateTimeHelpers::TPrecisionHelper<T>::THighPrecision(ms) * 1000));
+        return TBase::MilliSecondsConvertFrom(std::move(ms));
     }
 
     using TBase::Days;
@@ -277,6 +328,12 @@ class TDuration: public TTimeBase<TDuration> {
     using TBase::Minutes;
     using TBase::Seconds;
 
+    /// Base class static methods:
+    ///
+    /// static constexpr TDuration Minutes(ui64 m) noexcept;
+    /// static constexpr TDuration Hours(ui64 h) noexcept;
+    /// static constexpr TDuration Days(ui64 d) noexcept;
+
     /// DeadLineFromTimeOut
     inline TInstant ToDeadLine() const;
     constexpr TInstant ToDeadLine(TInstant now) const;
@@ -292,19 +349,7 @@ class TDuration: public TTimeBase<TDuration> {
     /* noexcept(false) as conversion from T might throw, for example FromString("abc") */
     template <typename T>
     static constexpr TDuration Seconds(T s) noexcept(false) {
-        return MilliSeconds(typename NDateTimeHelpers::TPrecisionHelper<T>::THighPrecision(s) * 1000);
-    }
-
-    static constexpr TDuration Minutes(ui64 m) noexcept {
-        return Seconds(m * 60);
-    }
-
-    static constexpr TDuration Hours(ui64 h) noexcept {
-        return Minutes(h * 60);
-    }
-
-    static constexpr TDuration Days(ui64 d) noexcept {
-        return Hours(d * 24);
+        return TBase::SecondsConvertFrom(std::move(s));
     }
 
     /// parses strings like 10s, 15ms, 15.05s, 20us, or just 25 (s). See parser_ut.cpp for details
@@ -346,7 +391,7 @@ struct THash<TDuration> {
     }
 };
 
-/// TInstant and TDuration are guaranteed to have same precision
+/// TInstant and TDuration are guaranteed to have the same precision
 class TInstant: public TTimeBase<TInstant> {
     using TBase = TTimeBase<TInstant>;
 
@@ -396,30 +441,26 @@ class TInstant: public TTimeBase<TInstant> {
         return TInstant(us);
     }
 
-    /// ms since epoch
+    /// milliseconds since epoch
     static constexpr TInstant MilliSeconds(ui64 ms) noexcept {
-        return MicroSeconds(ms * 1000);
+        return TBase::MilliSecondsConvertFrom(ms);
     }
 
     /// seconds since epoch
     static constexpr TInstant Seconds(ui64 s) noexcept {
-        return MilliSeconds(s * 1000);
+        return TBase::SecondsConvertFrom(s);
     }
 
+    /// Base class static methods:
+    ///
     /// minutes since epoch
-    static constexpr TInstant Minutes(ui64 m) noexcept {
-        return Seconds(m * 60);
-    }
-
+    /// static constexpr TInstant Minutes(ui64 m) noexcept;
+    ///
     /// hours since epoch
-    static constexpr TInstant Hours(ui64 h) noexcept {
-        return Minutes(h * 60);
-    }
-
+    /// static constexpr TInstant Hours(ui64 h) noexcept;
+    ///
     /// days since epoch
-    static constexpr TInstant Days(ui64 d) noexcept {
-        return Hours(d * 24);
-    }
+    /// static constexpr TInstant Days(ui64 d) noexcept;
 
     constexpr time_t TimeT() const noexcept {
         return (time_t)Seconds();
@@ -476,7 +517,7 @@ class TInstant: public TTimeBase<TInstant> {
     /**
      * Formats the instant using the system time zone, with microsecond precision.
      *
-     * @returns A semi-ISO 8601 formatted string with timezone without colon,
+     * @returns A semi-ISO 8601 formatted string with a timezone without a colon,
      * e.g. '2015-11-22T04:30:27.991669+0500'.
      */
     TString ToStringLocal() const;
@@ -499,7 +540,7 @@ class TInstant: public TTimeBase<TInstant> {
     /**
      * Formats the instant using the system time zone, with second precision.
      *
-     * @returns A semi-ISO 8601 formatted string with timezone without colon,
+     * @returns A semi-ISO 8601 formatted string with a timezone without a colon,
      * e.g. '2015-11-22T04:30:27+0500'.
      */
     TString ToStringLocalUpToSeconds() const;
@@ -518,22 +559,22 @@ class TInstant: public TTimeBase<TInstant> {
 
     /// ISO 8601 Representation of Dates and Times
     ///
-    /// @link https://www.iso.org/standard/40874.html Description of format.
+    /// @link https://www.iso.org/standard/40874.html Description of the format.
     static bool TryParseIso8601(TStringBuf input, TInstant& instant);
 
     /// RFC 822 Date and Time specification
     ///
-    /// @link https://tools.ietf.org/html/rfc822#section-5 Description of format.
+    /// @link https://tools.ietf.org/html/rfc822#section-5 Description of the format.
     static bool TryParseRfc822(TStringBuf input, TInstant& instant);
 
     /// RFC 2616 3.3.1 Full Date
     ///
-    /// @link https://tools.ietf.org/html/rfc2616#section-3.3.1 Description of format.
+    /// @link https://tools.ietf.org/html/rfc2616#section-3.3.1 Description of the format.
     static bool TryParseHttp(TStringBuf input, TInstant& instant);
 
     /// X.509 certificate validity time (see rfc5280 4.1.2.5.*)
     ///
-    /// @link https://tools.ietf.org/html/rfc5280#section-4.1.2.5 Description of format.
+    /// @link https://tools.ietf.org/html/rfc5280#section-4.1.2.5 Description of the format.
     static bool TryParseX509(TStringBuf input, TInstant& instant);
 
     static TInstant ParseIso8601Deprecated(TStringBuf);
@@ -576,7 +617,7 @@ namespace NPrivate {
         {
         }
     };
-}
+} // namespace NPrivate
 
 /** @name Helpers for printing local times to `IOutputStream`s.
  *        The FormatLocal* functions create an opaque object that, when written to
@@ -645,7 +686,7 @@ namespace NDateTimeHelpers {
 
         return a < b ? 0 : a - b;
     }
-}
+} // namespace NDateTimeHelpers
 
 constexpr TDuration operator-(const TInstant& l, const TInstant& r) noexcept {
     return TDuration::FromValue(::NDateTimeHelpers::DiffWithSaturation(l.GetValue(), r.GetValue()));
@@ -818,6 +859,21 @@ static inline TInstant Now() noexcept {
     return TInstant::Now();
 }
 
+template <class S>
+constexpr S TTimeBase<S>::Minutes(ui64 m) noexcept {
+    return S::MicroSeconds(NDateTimeHelpers::MulWithSaturation<ui64(1'000'000) * 60>(m));
+}
+
+template <class S>
+constexpr S TTimeBase<S>::Hours(ui64 h) noexcept {
+    return S::MicroSeconds(NDateTimeHelpers::MulWithSaturation<ui64(1'000'000) * 60 * 60>(h));
+}
+
+template <class S>
+constexpr S TTimeBase<S>::Days(ui64 d) noexcept {
+    return S::MicroSeconds(NDateTimeHelpers::MulWithSaturation<ui64(1'000'000) * 60 * 60 * 24>(d));
+}
+
 #ifdef _MSC_VER
     #pragma warning(pop)
 #endif // _MSC_VER
diff --git a/util/datetime/base.pxd b/util/datetime/base.pxd
index 1d863b1bd84..ab9fc83fc2e 100644
--- a/util/datetime/base.pxd
+++ b/util/datetime/base.pxd
@@ -10,25 +10,23 @@ cdef extern from "<util/datetime/base.h>" nogil:
 
     cdef cppclass TTimeBase:
         TTimeBase()
-        TTimeBase(uint64_t)
 
         uint64_t GetValue()
         double SecondsFloat()
-        uint64_t MicroSeconds()
-        uint64_t MilliSeconds()
-        uint64_t Seconds()
-        uint64_t Minutes()
-        uint64_t Hours()
-        uint64_t Days()
-        uint64_t NanoSeconds()
-        uint32_t MicroSecondsOfSecond()
-        uint32_t MilliSecondsOfSecond()
-        uint32_t NanoSecondsOfSecond()
+        uint64_t GetMicroSeconds "TTimeBase::MicroSeconds" ()
+        uint64_t GetMilliSeconds "TTimeBase::MilliSeconds" ()
+        uint64_t GetSeconds "TTimeBase::Seconds" ()
+        uint64_t GetMinutes "TTimeBase::Minutes" ()
+        uint64_t GetHours "TTimeBase::Hours" ()
+        uint64_t GetDays "TTimeBase::Days" ()
+        uint64_t GetNanoSeconds "TTimeBase::NanoSeconds" ()
+        uint32_t GetMicroSecondsOfSecond "TTimeBase::MicroSecondsOfSecond" ()
+        uint32_t GetMilliSecondsOfSecond "TTimeBase::MilliSecondsOfSecond" ()
+        uint32_t GetNanoSecondsOfSecond "TTimeBase::NanoSecondsOfSecond"()
 
 
     cdef cppclass TInstant(TTimeBase):
         TInstant()
-        TInstant(uint64_t)
 
         @staticmethod
         TInstant Now() except +
@@ -97,7 +95,6 @@ cdef extern from "<util/datetime/base.h>" nogil:
 
     cdef cppclass TDuration(TTimeBase):
         TDuration()
-        TDuration(uint64_t)
 
         @staticmethod
         TDuration MicroSeconds(uint64_t)
diff --git a/util/datetime/base_ut.cpp b/util/datetime/base_ut.cpp
index 5ada0794b70..ed437da4e8f 100644
--- a/util/datetime/base_ut.cpp
+++ b/util/datetime/base_ut.cpp
@@ -45,7 +45,7 @@ namespace {
             *buf = '\0';
         }
     }
-}
+} // namespace
 
 Y_UNIT_TEST_SUITE(TestSprintDate) {
     Y_UNIT_TEST(Year9999) {
@@ -148,7 +148,7 @@ Y_UNIT_TEST_SUITE(TestSprintDate) {
 
         UNIT_ASSERT_VALUES_EQUAL(expectedYear, YearToString(timestamp));
     }
-}
+} // Y_UNIT_TEST_SUITE(TestSprintDate)
 
 Y_UNIT_TEST_SUITE(TDateTimeTest) {
     Y_UNIT_TEST(Test8601) {
@@ -207,8 +207,8 @@ Y_UNIT_TEST_SUITE(TDateTimeTest) {
 
         UNIT_ASSERT(mlsecB + 90 < mlsecA);
         UNIT_ASSERT((mcrsecB + 90000 < mcrsecA));
-        //UNIT_ASSERT(ToMicroSeconds(&tvB) + 90000 < ToMicroSeconds(&tvA));
-        //UNIT_ASSERT(TVdiff(tvB, tvA) == long(ToMicroSeconds(&tvA) - ToMicroSeconds(&tvB)));
+        // UNIT_ASSERT(ToMicroSeconds(&tvB) + 90000 < ToMicroSeconds(&tvA));
+        // UNIT_ASSERT(TVdiff(tvB, tvA) == long(ToMicroSeconds(&tvA) - ToMicroSeconds(&tvB)));
     }
 
     Y_UNIT_TEST(TestCompatFuncs) {
@@ -310,10 +310,8 @@ Y_UNIT_TEST_SUITE(TDateTimeTest) {
                && true;
     }
 
-    Y_UNIT_TEST(TestGmTimeR) {
-        time_t starttime = static_cast<time_t>(Max<i64>(-12244089600LL, Min<time_t>())); // 1-Jan-1582
-        time_t finishtime = static_cast<time_t>(Min<i64>(0xFFFFFFFF * 20, Max<time_t>()));
-        time_t step = (finishtime - starttime) / 25;
+    void TestGmTimeR(time_t starttime, time_t finishtime, int steps) {
+        time_t step = (finishtime - starttime) / steps;
         struct tm tms0, tms1;
         struct tm* ptm0 = nullptr;
         struct tm* ptm1 = nullptr;
@@ -336,7 +334,19 @@ Y_UNIT_TEST_SUITE(TDateTimeTest) {
             UNIT_ASSERT(CompareTMFull(ptm0, ptm1));
         }
     }
-}
+
+    Y_UNIT_TEST(TestGmTimeRLongRange) {
+        time_t starttime = static_cast<time_t>(-86397839500LL); // 29-Jan-2668 B.C.
+        time_t finishtime = static_cast<time_t>(0xFFFFFFFF * 20);
+        TestGmTimeR(starttime, finishtime, 101);
+    }
+
+    Y_UNIT_TEST(TestGmTimeRNowdays) {
+        time_t starttime = static_cast<time_t>(0);             // 1970
+        time_t finishtime = static_cast<time_t>(6307200000LL); // 2170
+        TestGmTimeR(starttime, finishtime, 303);
+    }
+} // Y_UNIT_TEST_SUITE(TDateTimeTest)
 
 Y_UNIT_TEST_SUITE(DateTimeTest) {
     Y_UNIT_TEST(TestDurationFromFloat) {
@@ -403,6 +413,11 @@ Y_UNIT_TEST_SUITE(DateTimeTest) {
         }
     }
 
+    Y_UNIT_TEST(TestFromConverableType) {
+        std::atomic<ui64> timestamp{42};
+        UNIT_ASSERT_EQUAL(TInstant::Seconds(42), TInstant::Seconds(timestamp));
+    }
+
     Y_UNIT_TEST(TestSleep) {
         // check does not throw
         Sleep(TDuration::Seconds(0));
@@ -534,7 +549,6 @@ Y_UNIT_TEST_SUITE(DateTimeTest) {
     }
 
     Y_UNIT_TEST(TestTDurationConstructorFromStdChronoDuration) {
-
         UNIT_ASSERT_VALUES_EQUAL(TDuration::Zero(), TDuration(0ms));
         UNIT_ASSERT_VALUES_EQUAL(TDuration::MicroSeconds(42), TDuration(42us));
         UNIT_ASSERT_VALUES_EQUAL(TDuration::MicroSeconds(42000000000000L), TDuration(42000000000000us));
@@ -573,6 +587,45 @@ Y_UNIT_TEST_SUITE(DateTimeTest) {
                                                        static_cast<float>(::Max<ui64>()) / 1000 + 0.1}));
     }
 
+    template <class T>
+    void TestDurationCurationConstructorFunctionSaturation() {
+        const ui64 maxMilliseconds = ::Max<ui64>() / T::MilliSeconds(1).GetValue();
+        const ui64 maxSeconds = ::Max<ui64>() / T::Seconds(1).GetValue();
+        const ui64 maxMinutes = ::Max<ui64>() / T::Minutes(1).GetValue();
+        const ui64 maxHours = ::Max<ui64>() / T::Hours(1).GetValue();
+        const ui64 maxDays = ::Max<ui64>() / T::Days(1).GetValue();
+
+        auto test = [](ui64 maxValue, T (*constructor)(ui64), TStringBuf name) {
+            UNIT_ASSERT_VALUES_UNEQUAL_C(constructor(maxValue), T::Max(), LabeledOutput(name));
+            UNIT_ASSERT_VALUES_EQUAL_C(constructor(Max<ui64>()), T::Max(), LabeledOutput(name));
+            for (ui64 v = maxValue + 1; v != Max<ui64>(); v = std::midpoint(Max<ui64>(), v)) {
+                UNIT_ASSERT_VALUES_EQUAL_C(constructor(v), T::Max(), LabeledOutput(name, v));
+            }
+            for (ui64 v = maxValue; v != 0; v = std::midpoint(ui64(0), v)) {
+                UNIT_ASSERT_VALUES_UNEQUAL_C(constructor(v), T::Max(), LabeledOutput(name, v));
+            }
+        };
+        test(maxMilliseconds, &T::MilliSeconds, "MilliSeconds");
+        test(maxSeconds, &T::Seconds, "Seconds");
+        test(maxMinutes, &T::Minutes, "Minutes");
+        test(maxHours, &T::Hours, "Hours");
+        test(maxDays, &T::Days, "Days");
+    }
+
+    Y_UNIT_TEST(TestDurationCurationConstructorFunctionSaturation) {
+        UNIT_ASSERT_VALUES_EQUAL(TDuration::Seconds(-5.f), TDuration::Zero());
+        UNIT_ASSERT_VALUES_EQUAL(TDuration::MilliSeconds(-5.f), TDuration::Zero());
+        UNIT_ASSERT_VALUES_EQUAL(TDuration::MilliSeconds(0x1p63), TDuration::Max());
+        UNIT_ASSERT_VALUES_EQUAL(TDuration::Seconds(0x1p45), TDuration::Max());
+        UNIT_ASSERT_VALUES_UNEQUAL(TDuration::Seconds(0x1p44), TDuration::Max());
+
+        TestDurationCurationConstructorFunctionSaturation<TDuration>();
+    }
+
+    Y_UNIT_TEST(TestInstantCurationConstructorFunctionSaturation) {
+        TestDurationCurationConstructorFunctionSaturation<TInstant>();
+    }
+
     Y_UNIT_TEST(TestTDurationCompareWithStdChronoDuration) {
         UNIT_ASSERT(TDuration::Zero() == 0ms);
         UNIT_ASSERT(TDuration::Seconds(42) == 42s);
@@ -653,4 +706,4 @@ Y_UNIT_TEST_SUITE(DateTimeTest) {
         static_assert(TDuration::Zero() + 1s == 1s);
         static_assert(TInstant::Seconds(1) + 1s == TInstant::Seconds(2));
     }
-}
+} // Y_UNIT_TEST_SUITE(DateTimeTest)
diff --git a/util/datetime/benchmark/gmtime_r/main.cpp b/util/datetime/benchmark/gmtime_r/main.cpp
index a3356d780c3..32dc1413857 100644
--- a/util/datetime/benchmark/gmtime_r/main.cpp
+++ b/util/datetime/benchmark/gmtime_r/main.cpp
@@ -3,42 +3,84 @@
 #include <util/datetime/base.h>
 #include <util/random/fast.h>
 
-void BM_GmTimeR(benchmark::State& state) {
-    time_t now = TInstant::Now().TimeT();
-    struct tm buf {};
+using TRandomEngine = TFastRng<ui64>;
 
-    for (auto _ : state) {
-        Y_DO_NOT_OPTIMIZE_AWAY(GmTimeR(&now, &buf));
-    }
-}
+namespace {
 
-void BM_gmtime_r(benchmark::State& state) {
-    time_t now = TInstant::Now().TimeT();
-    struct tm buf {};
+    class TTimeRange {
+    public:
+        TTimeRange(TInstant base, TDuration spread)
+            : TTimeRange(base.Seconds(), spread.Seconds())
+        {
+        }
+
+        TTimeRange(time_t base, time_t spread)
+            : Base_(base)
+            , Spread_(spread)
+        {
+            Y_ASSERT(Spread_ >= 0);
+        }
+
+        time_t Next(TRandomEngine& gen) const {
+            if (Spread_ <= 1) {
+                return Base_;
+            }
+            time_t offset = gen.GenRand() % Spread_;
+            return Base_ + offset;
+        }
 
-    for (auto _ : state) {
-        Y_DO_NOT_OPTIMIZE_AWAY(gmtime_r(&now, &buf));
+    private:
+        time_t Base_;
+        time_t Spread_;
+    };
+
+    // change base date after `BATCH_SIZE` iterations to reduce the effect of changing the benchmark's speed depending on the day it was launched
+    const TDuration FOUR_YEARS = TDuration::Days(1461); // the interval length should be at least four years so that the probability of choosing a leap day/year is not greatly skewed
+    const TTimeRange BASE_TIME{TInstant::Now(), FOUR_YEARS};
+    const size_t BATCH_SIZE = 5'000;
+
+} // namespace
+
+void BM_GmTimeR(benchmark::State& state, TDuration window) {
+    struct tm buf {};
+    TRandomEngine rng(2);
+    const time_t range = window.Seconds();
+    while (state.KeepRunningBatch(BATCH_SIZE)) {
+        const TTimeRange time{BASE_TIME.Next(rng) - range, range};
+        for (size_t i = 0; i < BATCH_SIZE; ++i) {
+            time_t v = time.Next(rng);
+            Y_DO_NOT_OPTIMIZE_AWAY(GmTimeR(&v, &buf));
+        }
     }
 }
 
-void BM_GmTimeRRandom(benchmark::State& state, TDuration window) {
-    time_t now = TInstant::Now().TimeT();
+void BM_gmtime_r(benchmark::State& state, TDuration window) {
     struct tm buf {};
-
-    TFastRng<ui32> rng(2);
-    const size_t range = window.Seconds();
-    for (auto _ : state) {
-        size_t offset = rng.GenRand() % range;
-        time_t v = now - offset;
-        Y_DO_NOT_OPTIMIZE_AWAY(GmTimeR(&v, &buf));
+    TRandomEngine rng(2);
+    const time_t range = window.Seconds();
+    while (state.KeepRunningBatch(BATCH_SIZE)) {
+        const TTimeRange time{BASE_TIME.Next(rng) - range, range};
+        for (size_t i = 0; i < BATCH_SIZE; ++i) {
+            time_t v = time.Next(rng);
+            Y_DO_NOT_OPTIMIZE_AWAY(gmtime_r(&v, &buf));
+        }
     }
 }
 
-BENCHMARK(BM_GmTimeR);
-BENCHMARK(BM_gmtime_r);
-BENCHMARK_CAPTURE(BM_GmTimeRRandom, last_hour, TDuration::Hours(1));
-BENCHMARK_CAPTURE(BM_GmTimeRRandom, last_day, TDuration::Days(1));
-BENCHMARK_CAPTURE(BM_GmTimeRRandom, last_mount, TDuration::Days(31));
-BENCHMARK_CAPTURE(BM_GmTimeRRandom, last_year, TDuration::Days(365));
-BENCHMARK_CAPTURE(BM_GmTimeRRandom, last_decade, TDuration::Days(3653));
-BENCHMARK_CAPTURE(BM_GmTimeRRandom, last_half_centry, TDuration::Days(18262));
+BENCHMARK_CAPTURE(BM_GmTimeR, now, TDuration::Seconds(0));
+BENCHMARK_CAPTURE(BM_GmTimeR, last_hour, TDuration::Hours(1));
+BENCHMARK_CAPTURE(BM_GmTimeR, last_day, TDuration::Days(1));
+BENCHMARK_CAPTURE(BM_GmTimeR, last_month, TDuration::Days(31));
+BENCHMARK_CAPTURE(BM_GmTimeR, last_year, TDuration::Days(365));
+BENCHMARK_CAPTURE(BM_GmTimeR, last_decade, TDuration::Days(3653));
+BENCHMARK_CAPTURE(BM_GmTimeR, last_half_century, TDuration::Days(18262));
+BENCHMARK_CAPTURE(BM_GmTimeR, last_century, TDuration::Days(36525));
+
+BENCHMARK_CAPTURE(BM_gmtime_r, now, TDuration::Seconds(0));
+BENCHMARK_CAPTURE(BM_gmtime_r, last_hour, TDuration::Hours(1));
+BENCHMARK_CAPTURE(BM_gmtime_r, last_day, TDuration::Days(1));
+BENCHMARK_CAPTURE(BM_gmtime_r, last_month, TDuration::Days(31));
+BENCHMARK_CAPTURE(BM_gmtime_r, last_year, TDuration::Days(365));
+BENCHMARK_CAPTURE(BM_gmtime_r, last_decade, TDuration::Days(3653));
+BENCHMARK_CAPTURE(BM_gmtime_r, last_half_century, TDuration::Days(18262));
+BENCHMARK_CAPTURE(BM_gmtime_r, last_century, TDuration::Days(36525));
diff --git a/util/datetime/cputimer_ut.cpp b/util/datetime/cputimer_ut.cpp
index 21a657d5c74..65f64123fb1 100644
--- a/util/datetime/cputimer_ut.cpp
+++ b/util/datetime/cputimer_ut.cpp
@@ -7,4 +7,4 @@ Y_UNIT_TEST_SUITE(TestCpuTimerSuite) {
         ui64 cycles = DurationToCyclesSafe(TDuration::Hours(24));
         UNIT_ASSERT_VALUES_EQUAL(24, CyclesToDurationSafe(cycles).Hours());
     }
-}
+} // Y_UNIT_TEST_SUITE(TestCpuTimerSuite)
diff --git a/util/datetime/parser.h b/util/datetime/parser.h
index f0c1b4a0c78..eaffa038180 100644
--- a/util/datetime/parser.h
+++ b/util/datetime/parser.h
@@ -21,49 +21,60 @@ struct TDateTimeFields {
     i32 ZoneOffsetMinutes;
 
     void SetLooseYear(ui32 year) {
-        if (year < 60)
+        if (year < 60) {
             year += 100;
-        if (year < 160)
+        }
+        if (year < 160) {
             year += 1900;
+        }
         Year = year;
     }
 
     bool IsOk() const noexcept {
-        if (Year < 1970)
+        if (Year < 1970) {
             return false;
-        if (Month < 1 || Month > 12)
+        }
+        if (Month < 1 || Month > 12) {
             return false;
+        }
 
         unsigned int maxMonthDay = 31;
         if (Month == 4 || Month == 6 || Month == 9 || Month == 11) {
             maxMonthDay = 30;
         } else if (Month == 2) {
-            if (Year % 4 == 0 && (Year % 100 != 0 || Year % 400 == 0))
+            if (Year % 4 == 0 && (Year % 100 != 0 || Year % 400 == 0)) {
                 // leap year
                 maxMonthDay = 29;
-            else
+            } else {
                 maxMonthDay = 28;
+            }
         }
-        if (Day > maxMonthDay)
+        if (Day > maxMonthDay) {
             return false;
+        }
 
-        if (Hour > 23)
+        if (Hour > 23) {
             return false;
+        }
 
-        if (Minute > 59)
+        if (Minute > 59) {
             return false;
+        }
 
         // handle leap second which is explicitly allowed by ISO 8601:2004(E) $2.2.2
         // https://datatracker.ietf.org/doc/html/rfc3339#section-5.6
-        if (Second > 60)
+        if (Second > 60) {
             return false;
+        }
 
-        if (MicroSecond > 999999)
+        if (MicroSecond > 999999) {
             return false;
+        }
 
         if (Year == 1970 && Month == 1 && Day == 1) {
-            if ((i64)(3600 * Hour + 60 * Minute + Second) < (60 * ZoneOffsetMinutes))
+            if ((i64)(3600 * Hour + 60 * Minute + Second) < (60 * ZoneOffsetMinutes)) {
                 return false;
+            }
         }
 
         return true;
@@ -71,14 +82,16 @@ struct TDateTimeFields {
 
     TInstant ToInstant(TInstant defaultValue) const {
         time_t tt = ToTimeT(-1);
-        if (tt == -1)
+        if (tt == -1) {
             return defaultValue;
+        }
         return TInstant::Seconds(tt) + TDuration::MicroSeconds(MicroSecond);
     }
 
     time_t ToTimeT(time_t defaultValue) const {
-        if (!IsOk())
+        if (!IsOk()) {
             return defaultValue;
+        }
         struct tm tm;
         Zero(tm);
         tm.tm_year = Year - 1900;
@@ -88,8 +101,9 @@ struct TDateTimeFields {
         tm.tm_min = Minute;
         tm.tm_sec = Second;
         time_t tt = TimeGM(&tm);
-        if (tt == -1)
+        if (tt == -1) {
             return defaultValue;
+        }
         return tt - ZoneOffsetMinutes * 60;
     }
 };
@@ -102,7 +116,7 @@ class TDateTimeParserBase {
 
 protected:
     TDateTimeFields DateTimeFields;
-    int cs; //for ragel
+    int cs; // for ragel
     int Sign;
     int I;
     int Dc;
@@ -118,8 +132,9 @@ class TDateTimeParserBase {
     }
 
     inline TInstant GetResult(int firstFinalState, TInstant defaultValue) const {
-        if (cs < firstFinalState)
+        if (cs < firstFinalState) {
             return defaultValue;
+        }
         return DateTimeFields.ToInstant(defaultValue);
     }
 };
@@ -177,47 +192,58 @@ struct TDateTimeFieldsDeprecated {
     i32 ZoneOffsetMinutes;
 
     void SetLooseYear(ui32 year) {
-        if (year < 60)
+        if (year < 60) {
             year += 100;
-        if (year < 160)
+        }
+        if (year < 160) {
             year += 1900;
+        }
         Year = year;
     }
 
     bool IsOk() const noexcept {
-        if (Year < 1970)
+        if (Year < 1970) {
             return false;
-        if (Month < 1 || Month > 12)
+        }
+        if (Month < 1 || Month > 12) {
             return false;
+        }
 
         unsigned int maxMonthDay = 31;
         if (Month == 4 || Month == 6 || Month == 9 || Month == 11) {
             maxMonthDay = 30;
         } else if (Month == 2) {
-            if (Year % 4 == 0 && (Year % 100 != 0 || Year % 400 == 0))
+            if (Year % 4 == 0 && (Year % 100 != 0 || Year % 400 == 0)) {
                 // leap year
                 maxMonthDay = 29;
-            else
+            } else {
                 maxMonthDay = 28;
+            }
         }
-        if (Day > maxMonthDay)
+        if (Day > maxMonthDay) {
             return false;
+        }
 
-        if (Hour > 23)
+        if (Hour > 23) {
             return false;
+        }
 
-        if (Minute > 59)
+        if (Minute > 59) {
             return false;
+        }
 
-        if (Second > 60)
+        if (Second > 60) {
             return false;
+        }
 
-        if (MicroSecond > 999999)
+        if (MicroSecond > 999999) {
             return false;
+        }
 
         if (Year == 1970 && Month == 1 && Day == 1) {
-            if ((i64)(3600 * Hour + 60 * Minute + Second) < (60 * ZoneOffsetMinutes))
+            if ((i64)(3600 * Hour + 60 * Minute + Second) < (60 * ZoneOffsetMinutes)) {
                 return false;
+            }
         }
 
         return true;
@@ -225,14 +251,16 @@ struct TDateTimeFieldsDeprecated {
 
     TInstant ToInstant(TInstant defaultValue) const {
         time_t tt = ToTimeT(-1);
-        if (tt == -1)
+        if (tt == -1) {
             return defaultValue;
+        }
         return TInstant::Seconds(tt) + TDuration::MicroSeconds(MicroSecond);
     }
 
     time_t ToTimeT(time_t defaultValue) const {
-        if (!IsOk())
+        if (!IsOk()) {
             return defaultValue;
+        }
         struct tm tm;
         Zero(tm);
         tm.tm_year = Year - 1900;
@@ -242,8 +270,9 @@ struct TDateTimeFieldsDeprecated {
         tm.tm_min = Minute;
         tm.tm_sec = Second;
         time_t tt = TimeGM(&tm);
-        if (tt == -1)
+        if (tt == -1) {
             return defaultValue;
+        }
         return tt - ZoneOffsetMinutes * 60;
     }
 };
@@ -256,7 +285,7 @@ class TDateTimeParserBaseDeprecated {
 
 protected:
     TDateTimeFieldsDeprecated DateTimeFields;
-    int cs; //for ragel
+    int cs; // for ragel
     int Sign;
     int I;
     int Dc;
@@ -272,8 +301,9 @@ class TDateTimeParserBaseDeprecated {
     }
 
     inline TInstant GetResult(int firstFinalState, TInstant defaultValue) const {
-        if (cs < firstFinalState)
+        if (cs < firstFinalState) {
             return defaultValue;
+        }
         return DateTimeFields.ToInstant(defaultValue);
     }
 };
diff --git a/util/datetime/parser_deprecated_ut.cpp b/util/datetime/parser_deprecated_ut.cpp
index 6ad9f885b1c..9a3600598db 100644
--- a/util/datetime/parser_deprecated_ut.cpp
+++ b/util/datetime/parser_deprecated_ut.cpp
@@ -518,7 +518,7 @@ Y_UNIT_TEST_SUITE(TDateTimeParseTestDeprecated) {
             UNIT_ASSERT(!TInstant::TryParseX509Deprecated(s, iTry));
         }
     }
-}
+} // Y_UNIT_TEST_SUITE(TDateTimeParseTestDeprecated)
 
 Y_UNIT_TEST_SUITE(TDurationParseTestDeprecated) {
     Y_UNIT_TEST(TestParseDeprecated) {
@@ -573,4 +573,4 @@ Y_UNIT_TEST_SUITE(TDurationParseTestDeprecated) {
 
         UNIT_ASSERT_EQUAL(TDuration(), TDuration::Parse("10ns")); // TDuration has 1us precision.
     }
-}
+} // Y_UNIT_TEST_SUITE(TDurationParseTestDeprecated)
diff --git a/util/datetime/parser_ut.cpp b/util/datetime/parser_ut.cpp
index 6f5c3002280..f7f4c6a01c6 100644
--- a/util/datetime/parser_ut.cpp
+++ b/util/datetime/parser_ut.cpp
@@ -575,10 +575,12 @@ Y_UNIT_TEST_SUITE(TDateTimeParseTest) {
             UNIT_ASSERT(!TInstant::TryParseX509(s, iTry));
         }
     }
-}
+} // Y_UNIT_TEST_SUITE(TDateTimeParseTest)
 
 Y_UNIT_TEST_SUITE(TDurationParseTest) {
     Y_UNIT_TEST(TestParse) {
+        UNIT_ASSERT_VALUES_EQUAL(TDuration::Parse("3600"), TDuration::Seconds(3600));
+
         UNIT_ASSERT_VALUES_EQUAL(TDuration::Seconds(60 * 60 * 24 * 7), TDuration::Parse("1w"));
         UNIT_ASSERT_VALUES_EQUAL(TDuration::Seconds(60), TDuration::Parse("1m"));
         UNIT_ASSERT_VALUES_EQUAL(TDuration::Seconds(90), TDuration::Parse("1.5m"));
@@ -631,4 +633,4 @@ Y_UNIT_TEST_SUITE(TDurationParseTest) {
 
         UNIT_ASSERT_EQUAL(TDuration(), TDuration::Parse("10ns")); // TDuration has 1us precision.
     }
-}
+} // Y_UNIT_TEST_SUITE(TDurationParseTest)
diff --git a/util/datetime/process_uptime_ut.cpp b/util/datetime/process_uptime_ut.cpp
index 4ef95e4323a..11c23ebe220 100644
--- a/util/datetime/process_uptime_ut.cpp
+++ b/util/datetime/process_uptime_ut.cpp
@@ -14,4 +14,4 @@ Y_UNIT_TEST_SUITE(TestProcessUptimeSuite) {
         auto t2 = ProcessUptime();
         UNIT_ASSERT(t2 >= t1);
     }
-}
+} // Y_UNIT_TEST_SUITE(TestProcessUptimeSuite)
diff --git a/util/datetime/systime.cpp b/util/datetime/systime.cpp
index fe1d7b99d6e..8bd20c35ff0 100644
--- a/util/datetime/systime.cpp
+++ b/util/datetime/systime.cpp
@@ -75,7 +75,7 @@ char* ctime_r(const time_t* clock, char* buf) {
 namespace {
     constexpr int STRUCT_TM_BASE_YEAR = 1900;
     constexpr int UNIX_TIME_BASE_YEAR = 1970;
-    constexpr long SECONDS_PER_DAY = (24L * 60L * 60L);
+    constexpr ui64 SECONDS_PER_DAY = (24L * 60L * 60L);
 
     constexpr bool IsLeapYear(int year) {
         if (year % 4 != 0) {
@@ -94,7 +94,29 @@ namespace {
         return IsLeapYear(year) ? DAYS_IN_LEAP_YEAR : DAYS_IN_YEAR;
     }
 
-    constexpr ui64 FOUR_CENTURIES = (400 * 365 + 100 - 3);
+    constexpr ui32 FOUR_CENTURY_YEARS = 400;
+
+    constexpr ui32 LeapYearCount(ui32 years) {
+        return years / 4 - years / 100 + years / 400;
+    }
+
+    constexpr ui32 FOUR_CENTURY_DAYS = FOUR_CENTURY_YEARS * DAYS_IN_YEAR + LeapYearCount(FOUR_CENTURY_YEARS);
+
+    constexpr int FindYearWithin4Centuries(ui32& dayno) {
+        Y_ASSERT(dayno < FOUR_CENTURY_DAYS);
+        ui32 years = dayno / DAYS_IN_YEAR;
+
+        const ui32 diff = years * DAYS_IN_YEAR + LeapYearCount(years);
+
+        if (diff <= dayno) {
+            dayno -= diff;
+        } else {
+            dayno -= diff - YearSize(static_cast<int>(years));
+            --years;
+        }
+
+        return static_cast<int>(years);
+    }
 
     constexpr ui16 MONTH_TO_DAYS[12] = {
         0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334};
@@ -102,105 +124,56 @@ namespace {
     constexpr ui16 MONTH_TO_DAYS_LEAP[12] = {
         0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335};
 
-    template <ui8 DaysInFeb>
-    constexpr int DayOfYearToMonth(ui64& day) {
-        Y_ASSERT(day >= 0);
-        Y_ASSERT(day < 366);
-
-        constexpr ui8 JanDays = 31;
-        constexpr ui8 FebDays = JanDays + DaysInFeb;
-        constexpr ui8 MarDays = FebDays + 31;
-        constexpr ui8 AprDays = MarDays + 30;
-        constexpr ui8 MayDays = AprDays + 31;
-        constexpr ui8 JunDays = MayDays + 30;
-        constexpr ui8 JulDays = JunDays + 31;
-        constexpr ui16 AugDays = JulDays + 31;
-        constexpr ui16 SepDays = AugDays + 30;
-        constexpr ui16 OctDays = SepDays + 31;
-        constexpr ui16 NovDays = OctDays + 30;
-
-        // hard-coded binary search
-        // this approach is faster that lookup in array using std::lower_bound()
-        // GmTimeR takes ~40 cycles vs ~60 cycles using std::lower_bound version
-        if (day < JunDays) {
-            if (day < MarDays) {
-                if (day < JanDays) {
-                    return 0;
-                } else if (day < FebDays) {
-                    day -= JanDays;
-                    return 1;
-                } else {
-                    day -= FebDays;
-                    return 2;
-                }
-            } else {
-                if (day < AprDays) {
-                    day -= MarDays;
-                    return 3;
-                } else if (day < MayDays) {
-                    day -= AprDays;
-                    return 4;
-                } else {
-                    day -= MayDays;
-                    return 5;
-                }
-            }
-        } else {
-            if (day < SepDays) {
-                if (day < JulDays) {
-                    day -= JunDays;
-                    return 6;
-                } else if (day < AugDays) {
-                    day -= JulDays;
-                    return 7;
-                } else {
-                    day -= AugDays;
-                    return 8;
-                }
-            } else {
-                if (day < OctDays) {
-                    day -= SepDays;
-                    return 9;
-                } else if (day < NovDays) {
-                    day -= OctDays;
-                    return 10;
-                } else {
-                    day -= NovDays;
-                    return 11;
-                }
-            }
+    constexpr int DayOfYearToMonth(ui32& yearDay, const bool leapYear) {
+        if (yearDay >= 31 + 28 + leapYear) {
+            yearDay += 2 - leapYear;
         }
+        const ui32 month = (yearDay * 67 + 35) >> 11;
+        yearDay -= (month * 489 + 8) >> 4;
+        return static_cast<int>(month);
     }
 
     class TDayNoToYearLookupTable {
-    private:
         static constexpr int TableSize = 128;
-        // lookup table for years in [1970, 1970 + 128 = 2098] range
+        // lookup table for years in [StartYear, StartYear + TableSize] range
         ui16 DaysSinceEpoch[TableSize] = {};
 
     public:
+        static constexpr int StartYear = 1970;
+        static constexpr int StartDays = (StartYear - UNIX_TIME_BASE_YEAR) * DAYS_IN_YEAR + LeapYearCount(StartYear - 1) - LeapYearCount(UNIX_TIME_BASE_YEAR - 1);
+        static constexpr i64 MinTimestamp = StartDays * static_cast<i64>(SECONDS_PER_DAY);
+        static constexpr i64 MaxTimestamp = MinTimestamp + static_cast<i64>(TableSize) * DAYS_IN_LEAP_YEAR * SECONDS_PER_DAY - 1;
         constexpr TDayNoToYearLookupTable() {
-            DaysSinceEpoch[0] = YearSize(UNIX_TIME_BASE_YEAR);
+            ui16 daysAccumulated = 0;
 
-            for (int year = UNIX_TIME_BASE_YEAR + 1; year < UNIX_TIME_BASE_YEAR + TableSize; ++year) {
-                DaysSinceEpoch[year - UNIX_TIME_BASE_YEAR] = DaysSinceEpoch[year - UNIX_TIME_BASE_YEAR - 1] + YearSize(year);
+            for (int year = StartYear; year < StartYear + TableSize; ++year) {
+                daysAccumulated += YearSize(year);
+                DaysSinceEpoch[year - StartYear] = daysAccumulated;
             }
         }
 
         // lookup year by days since epoch, decrement day counter to the corresponding amount of days.
         // The method returns the last year in the table, if year is too big
-        int GetYear(ui64& days) const {
-            size_t year = std::upper_bound(DaysSinceEpoch, Y_ARRAY_END(DaysSinceEpoch), days) - Y_ARRAY_BEGIN(DaysSinceEpoch);
-            if (year > 0) {
-                days -= DaysSinceEpoch[year - 1];
+        int FindYear(ui32& days) const {
+            const ui32 yearIndex = days / DAYS_IN_LEAP_YEAR;
+
+            // we can miss by at most 1 year
+            Y_ASSERT(yearIndex < TableSize);
+            if (const auto diff = DaysSinceEpoch[yearIndex]; diff <= days) {
+                days -= diff;
+                return static_cast<int>(yearIndex + StartYear + 1);
             }
 
-            return year + UNIX_TIME_BASE_YEAR;
+            if (yearIndex > 0) {
+                days -= DaysSinceEpoch[yearIndex - 1];
+            }
+
+            return static_cast<int>(yearIndex + StartYear);
         }
     };
 
     constexpr TDayNoToYearLookupTable DAYS_TO_YEAR_LOOKUP;
-}
+} // namespace
 
 //! Inverse of gmtime: converts struct tm to time_t, assuming the data
 //! in tm is UTC rather than local timezone. This implementation
@@ -235,55 +208,72 @@ time_t TimeGM(const struct tm* t) {
 
 struct tm* GmTimeR(const time_t* timer, struct tm* tmbuf) {
     i64 time = static_cast<i64>(*timer);
+    tm* resut = tmbuf;
+    int dayClock;
+    ui32 daysRemaining;
+    bool isLeapYear;
+
+    if (time >= TDayNoToYearLookupTable::MinTimestamp && time <= TDayNoToYearLookupTable::MaxTimestamp)
+    {
+        dayClock = static_cast<int>(time % SECONDS_PER_DAY);
+        daysRemaining = time / SECONDS_PER_DAY;
+        tmbuf->tm_wday = static_cast<int>((daysRemaining + 4) % 7); // Day 0 was a thursday
+        daysRemaining -= TDayNoToYearLookupTable::StartDays;
+        const int year = DAYS_TO_YEAR_LOOKUP.FindYear(daysRemaining);
+        isLeapYear = IsLeapYear(year);
+        tmbuf->tm_year = year - STRUCT_TM_BASE_YEAR;
+    } else {
+        i64 year = UNIX_TIME_BASE_YEAR;
 
-    ui64 dayclock, dayno;
-    int year = UNIX_TIME_BASE_YEAR;
-
-    if (Y_UNLIKELY(time < 0)) {
-        ui64 shift = (ui64)(-time - 1) / (FOUR_CENTURIES * SECONDS_PER_DAY) + 1;
-        time += shift * (FOUR_CENTURIES * SECONDS_PER_DAY);
-        year -= shift * 400;
-    }
+        if (Y_UNLIKELY(time < 0)) {
+            const ui64 shift = (ui64)(-time - 1) / (static_cast<ui64>(FOUR_CENTURY_DAYS) * SECONDS_PER_DAY) + 1;
+            time += static_cast<i64>(shift * FOUR_CENTURY_DAYS * SECONDS_PER_DAY);
+            year -= static_cast<i64>(shift * FOUR_CENTURY_YEARS);
+        }
 
-    dayclock = (ui64)time % SECONDS_PER_DAY;
-    dayno = (ui64)time / SECONDS_PER_DAY;
+        dayClock = static_cast<int>(time % SECONDS_PER_DAY);
+        ui64 dayNo = (ui64)time / SECONDS_PER_DAY;
+        tmbuf->tm_wday = (dayNo + 4) % 7; // Day 0 was a thursday
 
-    if (Y_UNLIKELY(dayno >= FOUR_CENTURIES)) {
-        year += 400 * (dayno / FOUR_CENTURIES);
-        dayno = dayno % FOUR_CENTURIES;
-    }
+        if (int shiftYears = (year - 1) % FOUR_CENTURY_YEARS; shiftYears != 0) {
+            if (shiftYears < 0) {
+                shiftYears += FOUR_CENTURY_YEARS;
+            }
+            year -= shiftYears;
+            dayNo += shiftYears * DAYS_IN_YEAR + LeapYearCount(shiftYears);
+        }
 
-    tmbuf->tm_sec = dayclock % 60;
-    tmbuf->tm_min = (dayclock % 3600) / 60;
-    tmbuf->tm_hour = dayclock / 3600;
-    tmbuf->tm_wday = (dayno + 4) % 7; // Day 0 was a thursday
+        if (Y_UNLIKELY(dayNo >= FOUR_CENTURY_DAYS)) {
+            year += FOUR_CENTURY_YEARS * (dayNo / FOUR_CENTURY_DAYS);
+            dayNo = dayNo % FOUR_CENTURY_DAYS;
+        }
 
-    if (Y_LIKELY(year == UNIX_TIME_BASE_YEAR)) {
-        year = DAYS_TO_YEAR_LOOKUP.GetYear(dayno);
-    }
+        daysRemaining = dayNo;
+        const int yearDiff = FindYearWithin4Centuries(daysRemaining);
+        year += yearDiff;
+        isLeapYear = IsLeapYear(yearDiff + 1);
+        tmbuf->tm_year = static_cast<int>(year - STRUCT_TM_BASE_YEAR);
 
-    for (;;) {
-        const ui16 yearSize = YearSize(year);
-        if (dayno < yearSize) {
-            break;
+        // check year overflow
+        if (Y_UNLIKELY(year - STRUCT_TM_BASE_YEAR != tmbuf->tm_year)) {
+            resut = nullptr;
         }
-        dayno -= yearSize;
-        ++year;
     }
 
-    tmbuf->tm_year = year - STRUCT_TM_BASE_YEAR;
-    tmbuf->tm_yday = dayno;
-    tmbuf->tm_mon = IsLeapYear(year)
-                        ? DayOfYearToMonth<29>(dayno)
-                        : DayOfYearToMonth<28>(dayno);
-    tmbuf->tm_mday = dayno + 1;
+    tmbuf->tm_sec = dayClock % 60;
+    tmbuf->tm_min = (dayClock % 3600) / 60;
+    tmbuf->tm_hour = dayClock / 3600;
+
+    tmbuf->tm_yday = static_cast<int>(daysRemaining);
+    tmbuf->tm_mon = DayOfYearToMonth(daysRemaining, isLeapYear);
+    tmbuf->tm_mday = static_cast<int>(daysRemaining + 1);
     tmbuf->tm_isdst = 0;
 #ifndef _win_
     tmbuf->tm_gmtoff = 0;
     tmbuf->tm_zone = (char*)"UTC";
 #endif
 
-    return tmbuf;
+    return resut;
 }
 
 TString CTimeR(const time_t* timer) {
diff --git a/util/datetime/systime.h b/util/datetime/systime.h
index 760c28d6e67..7810ec5f363 100644
--- a/util/datetime/systime.h
+++ b/util/datetime/systime.h
@@ -5,26 +5,29 @@
 
 #include <ctime>
 
-// timegm and gmtime_r versions that don't need access to filesystem or a big stack
+// timegm and gmtime_r versions that don't need access to the file system or a large stack
 time_t TimeGM(const struct tm* t);
+
+// the same as gmtime_r, but 3–5 times faster
 struct tm* GmTimeR(const time_t* timer, struct tm* tmbuf);
-// safe version of ctime, convinient version of ctime_r
+
+// safe version of ctime, convenient version of ctime_r
 TString CTimeR(const time_t* timer);
 
 #ifdef _win_
     #include <util/system/winint.h>
     #include <winsock2.h>
 
-// Convert FILETIME to timeval - seconds and microseconds.
+// Convert FILETIME to timeval: seconds and microseconds.
 void FileTimeToTimeval(const FILETIME* ft, struct timeval* tv);
 
-// Convert FILETIME to timespec - seconds and nanoseconds.
+// Convert FILETIME to timespec: seconds and nanoseconds.
 void FileTimeToTimespec(const FILETIME& ft, struct timespec* ts);
 
-// obtains the current time, expressed as seconds and microseconds since 00:00 UTC, January 1, 1970
+// Obtain the current time, expressed as seconds and microseconds since 00:00 UTC, January 1, 1970
 int gettimeofday(struct timeval* tp, void*);
 
-// thou should not mix these with non-_r functions
+// You should not mix these with non-_r functions
 tm* localtime_r(const time_t* clock, tm* result);
 tm* gmtime_r(const time_t* clock, tm* result);
 char* ctime_r(const time_t* clock, char* buf);
diff --git a/util/datetime/uptime.cpp b/util/datetime/uptime.cpp
index d2e1191c84f..bee67ab1a72 100644
--- a/util/datetime/uptime.cpp
+++ b/util/datetime/uptime.cpp
@@ -5,11 +5,11 @@
 #elif defined(_linux_)
     #include <util/stream/file.h>
     #include <util/string/cast.h>
-#elif defined(_darwin_)
+#elif defined(_darwin_) || defined(_freebsd_)
     #include <sys/sysctl.h>
 #endif
 
-#if defined(_darwin_)
+#if defined(_darwin_) || defined(_freebsd_)
 namespace {
     TInstant GetBootTime() {
         struct timeval timeSinceBoot;
@@ -21,7 +21,7 @@ namespace {
         return TInstant::MicroSeconds(timeSinceBoot.tv_sec * 1'000'000 + timeSinceBoot.tv_usec);
     }
 
-    TDuration GetDarwinUptime() {
+    TDuration GetBSDUptime() {
         TInstant beforeNow;
         TInstant afterNow;
         TInstant now;
@@ -36,22 +36,19 @@ namespace {
 
         return now - beforeNow;
     }
-}
+} // namespace
 #endif // _darwin_
 
 TDuration Uptime() {
 #if defined(_win_)
     return TDuration::MilliSeconds(GetTickCount64());
 #elif defined(_linux_)
-    TUnbufferedFileInput in("/proc/uptime");
-    TString uptimeStr = in.ReadLine();
-    double up, idle;
-    if (sscanf(uptimeStr.data(), "%lf %lf", &up, &idle) < 2) {
-        ythrow yexception() << "cannot read values from /proc/uptime";
-    }
-    return TDuration::MilliSeconds(up * 1000.0);
-#elif defined(_darwin_)
-    return GetDarwinUptime();
+    struct timespec ts;
+    int ret = clock_gettime(CLOCK_BOOTTIME, &ts);
+    Y_ENSURE_EX(ret != -1, TSystemError() << "Failed to read the CLOCK_BOOTTIME timer");
+    return TDuration::Seconds(ts.tv_sec) + TDuration::MicroSeconds(ts.tv_nsec / 1000);
+#elif defined(_darwin_) || defined(_freebsd_)
+    return GetBSDUptime();
 #elif defined(_emscripten_)
     ythrow yexception() << "unimplemented";
 #else
diff --git a/util/datetime/uptime_ut.cpp b/util/datetime/uptime_ut.cpp
index 7f5ecc482c8..8628a048a30 100644
--- a/util/datetime/uptime_ut.cpp
+++ b/util/datetime/uptime_ut.cpp
@@ -9,4 +9,4 @@ Y_UNIT_TEST_SUITE(TestUptimeSuite) {
         auto t2 = Uptime();
         UNIT_ASSERT(t2 > t1);
     }
-}
+} // Y_UNIT_TEST_SUITE(TestUptimeSuite)
diff --git a/util/digest/city.cpp b/util/digest/city.cpp
index c0c7c1a2e93..09761694475 100644
--- a/util/digest/city.cpp
+++ b/util/digest/city.cpp
@@ -28,6 +28,7 @@
 // compromising on hash quality.
 
 #include "city.h"
+#include "city_streaming.h"
 
 using uint8 = ui8;
 using uint32 = ui32;
@@ -307,3 +308,64 @@ uint128 CityHash128(const char* s, size_t len) noexcept {
         return CityHash128WithSeed(s, len, uint128(k0, k1));
     }
 }
+
+TStreamingCityHash64::TStreamingCityHash64(size_t len, const char *head64, const char *tail64) {
+    Y_ASSERT(len > 64);
+    x = UNALIGNED_LOAD64(head64);
+    y = UNALIGNED_LOAD64(tail64 + 48) ^ k1;
+    z = UNALIGNED_LOAD64(tail64 + 8) ^ k0;
+    v = WeakHashLen32WithSeeds(tail64, len, y);
+    w = WeakHashLen32WithSeeds(tail64 + 32, len * k1, k0);
+    z += ShiftMix(v.second) * k1;
+    x = Rotate(z + x, 39) * k1;
+    y = Rotate(y, 33) * k1;
+    Rest64_ = (len - 1) / 64;
+    UnalignBufSz_ = 0;
+}
+
+void TStreamingCityHash64::Process(const char *s, size_t avail) {
+    if (Y_UNLIKELY(!Rest64_)) return;
+    if (UnalignBufSz_) {
+        if (UnalignBufSz_ + avail < 64) {
+            memcpy(&UnalignBuf_[UnalignBufSz_], s, avail);
+            UnalignBufSz_ += avail;
+            return;
+        } else {
+            memcpy(&UnalignBuf_[UnalignBufSz_], s, 64 - UnalignBufSz_);
+            x = Rotate(x + y + v.first + UNALIGNED_LOAD64(UnalignBuf_ + 16), 37) * k1;
+            y = Rotate(y + v.second + UNALIGNED_LOAD64(UnalignBuf_ + 48), 42) * k1;
+            x ^= w.second;
+            y ^= v.first;
+            z = Rotate(z ^ w.first, 33);
+            v = WeakHashLen32WithSeeds(UnalignBuf_, v.second * k1, x + w.first);
+            w = WeakHashLen32WithSeeds(UnalignBuf_ + 32, z + w.second, y);
+            DoSwap(z, x);
+            s += 64 - UnalignBufSz_;
+            avail -= 64 - UnalignBufSz_;
+            Rest64_--;
+            UnalignBufSz_ = 0;
+        }
+    }
+    while(Rest64_ && avail >= 64) {
+        x = Rotate(x + y + v.first + UNALIGNED_LOAD64(s + 16), 37) * k1;
+        y = Rotate(y + v.second + UNALIGNED_LOAD64(s + 48), 42) * k1;
+        x ^= w.second;
+        y ^= v.first;
+        z = Rotate(z ^ w.first, 33);
+        v = WeakHashLen32WithSeeds(s, v.second * k1, x + w.first);
+        w = WeakHashLen32WithSeeds(s + 32, z + w.second, y);
+        DoSwap(z, x);
+        s += 64;
+        avail -= 64;
+        Rest64_--;
+    }
+    if (Rest64_ && avail) {
+        memcpy(UnalignBuf_, s, avail);
+        UnalignBufSz_ = avail;
+    }
+}
+
+uint64 TStreamingCityHash64::operator() () {
+    return HashLen16(HashLen16(v.first, w.first) + ShiftMix(y) * k1 + z,
+                    HashLen16(v.second, w.second) + x);
+}
diff --git a/util/digest/city.h b/util/digest/city.h
index 675a798074f..31d7dc73d3e 100644
--- a/util/digest/city.h
+++ b/util/digest/city.h
@@ -50,7 +50,7 @@ namespace NPrivateCityHash {
         static_assert(std::is_integral<std::remove_reference_t<decltype(*str.data())>>::value, "invalid type passed to hash function");
         return TStringBuf(reinterpret_cast<const char*>(str.data()), (str.size()) * sizeof(*str.data()));
     }
-}
+} // namespace NPrivateCityHash
 
 template <class TStringType>
 inline ui64 CityHash64(const TStringType& str) {
diff --git a/util/digest/city_streaming.h b/util/digest/city_streaming.h
new file mode 100644
index 00000000000..f9c5209e0a8
--- /dev/null
+++ b/util/digest/city_streaming.h
@@ -0,0 +1,21 @@
+#pragma once
+#include <util/digest/city.h>
+
+/**
+ *   (partially) streaming version of CityHash64 for large data.
+ *   You need to know length and first/last 64 bytes.
+ *   Those bytes should be passed twice: in constructor and thru process().
+ *   Length must be STRICTLY larger than 64 bytes.
+ *   XXX: Dont use CityHash64 if you can use something else and need streaming
+ */
+class TStreamingCityHash64 {
+    ui64 x, y, z;
+    std::pair<ui64, ui64> v, w;
+    char UnalignBuf_[64];
+    size_t UnalignBufSz_, Rest64_;
+
+public:
+    TStreamingCityHash64(size_t len, const char* head64, const char* tail64);
+    void Process(const char* s, size_t avail);
+    ui64 operator()();
+};
diff --git a/util/digest/city_ut.cpp b/util/digest/city_ut.cpp
index 972091c2c3d..a5e5644ea1c 100644
--- a/util/digest/city_ut.cpp
+++ b/util/digest/city_ut.cpp
@@ -12,4 +12,4 @@ Y_UNIT_TEST_SUITE(TCityTest) {
         CityHash128WithSeed(s, uint128(1, 2));
         UNIT_ASSERT(s.empty());
     }
-}
+} // Y_UNIT_TEST_SUITE(TCityTest)
diff --git a/util/digest/fnv.h b/util/digest/fnv.h
index 87b41a3de7e..186e6b4f45b 100644
--- a/util/digest/fnv.h
+++ b/util/digest/fnv.h
@@ -43,7 +43,7 @@ namespace NFnvPrivate {
     DEF_FNV(64)
 
 #undef DEF_FNV
-}
+} // namespace NFnvPrivate
 
 template <class T, class It>
 static constexpr T FnvHash(It b, It e, T init) {
diff --git a/util/digest/fnv_ut.cpp b/util/digest/fnv_ut.cpp
index 039e110eaa9..3c1588bbad3 100644
--- a/util/digest/fnv_ut.cpp
+++ b/util/digest/fnv_ut.cpp
@@ -20,4 +20,4 @@ Y_UNIT_TEST_SUITE(TFnvTest) {
         UNIT_ASSERT_EQUAL(FnvHash<ui64>(nullptr, 0), FNV64INIT);
         UNIT_ASSERT_EQUAL(FnvHash<ui64>(TStringBuf()), FNV64INIT);
     }
-}
+} // Y_UNIT_TEST_SUITE(TFnvTest)
diff --git a/util/digest/murmur.cpp b/util/digest/murmur.cpp
index ebaad592203..ef9c8f8a43c 100644
--- a/util/digest/murmur.cpp
+++ b/util/digest/murmur.cpp
@@ -124,6 +124,6 @@ namespace NMurmurPrivate {
 
         return h;
     }
-}
+} // namespace NMurmurPrivate
 
 template size_t MurmurHash<size_t>(const void* buf, size_t len) noexcept;
diff --git a/util/digest/murmur.h b/util/digest/murmur.h
index a54902006c4..60b9f82dd6a 100644
--- a/util/digest/murmur.h
+++ b/util/digest/murmur.h
@@ -27,7 +27,7 @@ namespace NMurmurPrivate {
     DEF_MUR(64)
 
 #undef DEF_MUR
-}
+} // namespace NMurmurPrivate
 
 template <class T>
 inline T MurmurHash(const void* buf, size_t len, T init) noexcept {
diff --git a/util/draft/date_ut.cpp b/util/draft/date_ut.cpp
index 8c33a6c1cfd..3b7042cdee9 100644
--- a/util/draft/date_ut.cpp
+++ b/util/draft/date_ut.cpp
@@ -33,4 +33,4 @@ Y_UNIT_TEST_SUITE(TDateTest) {
             UNIT_ASSERT_EQUAL(d.GetStartUTC(), 1297728000);
         }
     }
-}
+} // Y_UNIT_TEST_SUITE(TDateTest)
diff --git a/util/draft/datetime.cpp b/util/draft/datetime.cpp
index d290021d5e2..43ce7c4b6d1 100644
--- a/util/draft/datetime.cpp
+++ b/util/draft/datetime.cpp
@@ -12,13 +12,13 @@
 
 namespace NDatetime {
     const ui32 MonthDays[2][12] = {
-        {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}, //nleap
-        {31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}  //leap
+        {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}, // nleap
+        {31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}  // leap
     };
 
     const ui32 MonthDaysNewYear[2][13] = {
-        {0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365}, //nleap
-        {0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366}  //leap
+        {0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365}, // nleap
+        {0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366}  // leap
     };
 
     void YDayToMonthAndDay(ui32 yday, bool isleap, ui32* month, ui32* mday) {
@@ -211,7 +211,7 @@ namespace NDatetime {
 #endif
         return t;
     }
-}
+} // namespace NDatetime
 
 template <>
 void In<TMonth>(IInputStream& in, TMonth& t) {
diff --git a/util/draft/datetime.h b/util/draft/datetime.h
index 7301e32e501..677de685a4f 100644
--- a/util/draft/datetime.h
+++ b/util/draft/datetime.h
@@ -15,7 +15,7 @@ namespace NDatetime {
     extern const ui32 MonthDaysNewYear[2][13]; // !leapYear; !!leapYear
 
     inline ui32 YearDaysAD(ui32 year) {
-        year = Max<ui32>(year, 1) - 1; //1 AD comes straight after 1 BC, no 0 AD
+        year = Max<ui32>(year, 1) - 1; // 1 AD comes straight after 1 BC, no 0 AD
         return year * 365 + year / 4 - year / 100 + year / 400;
     }
 
@@ -131,7 +131,7 @@ namespace NDatetime {
             return s != t;
         }
     };
-}
+} // namespace NDatetime
 
 inline TString date2str(const time_t date) {
     struct tm dateTm;
diff --git a/util/draft/datetime_ut.cpp b/util/draft/datetime_ut.cpp
index a5e065ef6e8..840f69cab42 100644
--- a/util/draft/datetime_ut.cpp
+++ b/util/draft/datetime_ut.cpp
@@ -84,7 +84,7 @@ Y_UNIT_TEST_SUITE(TSimpleTMTest) {
 
         tzset();
 
-        TSimpleTM::New(-1); //should not die here
+        TSimpleTM::New(-1); // should not die here
 
         UNIT_ASSERT_VALUES_EQUAL((ui32)0, (ui32)TSimpleTM::New(0));
         UNIT_ASSERT((ui32)TSimpleTM::New(0).IsUTC());
@@ -95,7 +95,7 @@ Y_UNIT_TEST_SUITE(TSimpleTMTest) {
             Zero(tmt);
             gmtime_r(&t, &tmt);
             UNIT_ASSERT_VALUES_EQUAL_C((i64)t, (i64)TSimpleTM::New(t).AsTimeT(), ToString(t));   // time_t ->   gmt tm -> time_t
-            UNIT_ASSERT_VALUES_EQUAL_C((i64)t, (i64)TSimpleTM::New(tmt).AsTimeT(), ToString(t)); //   gmt tm -> time_t
+            UNIT_ASSERT_VALUES_EQUAL_C((i64)t, (i64)TSimpleTM::New(tmt).AsTimeT(), ToString(t)); // gmt tm -> time_t
             AssertStructTmEqual(PrintMarker("UTC:time_t", __LINE__, t),
                                 tmt, TSimpleTM::New(t));
             AssertStructTmEqual(PrintMarker("UTC:tm", __LINE__, t),
@@ -228,4 +228,4 @@ Y_UNIT_TEST_SUITE(TSimpleTMTest) {
                            tt, 1449828548, 2015, 12, 11, 10, 9, 8);
         }
     }
-}
+} // Y_UNIT_TEST_SUITE(TSimpleTMTest)
diff --git a/util/draft/enum.h b/util/draft/enum.h
index 18002b7df20..e33cfea02c7 100644
--- a/util/draft/enum.h
+++ b/util/draft/enum.h
@@ -21,18 +21,22 @@ class TEnumNotFoundException: public yexception {
 
 template <class K1, class K2, class V>
 const V* FindEnumFromStringImpl(K1 key, const std::pair<K2, V>* entries, size_t arraySize) {
-    for (size_t i = 0; i < arraySize; i++)
-        if (entries[i].first == key)
+    for (size_t i = 0; i < arraySize; i++) {
+        if (entries[i].first == key) {
             return &entries[i].second;
+        }
+    }
     return nullptr;
 }
 
 // special version for const char*
 template <class V>
 const V* FindEnumFromStringImpl(const char* key, const std::pair<const char*, V>* entries, size_t arraySize) {
-    for (size_t i = 0; i < arraySize; i++)
-        if (entries[i].first && key && !strcmp(entries[i].first, key))
+    for (size_t i = 0; i < arraySize; i++) {
+        if (entries[i].first && key && !strcmp(entries[i].first, key)) {
             return &entries[i].second;
+        }
+    }
     return nullptr;
 }
 
@@ -40,8 +44,9 @@ template <class K, class V>
 TString PrintEnumItemsImpl(const std::pair<K, V>* entries, size_t arraySize) {
     TString result;
     TStringOutput out(result);
-    for (size_t i = 0; i < arraySize; i++)
+    for (size_t i = 0; i < arraySize; i++) {
         out << (i ? ", " : "") << "'" << entries[i].first << "'";
+    }
     return result;
 }
 
@@ -50,30 +55,35 @@ template <class V>
 TString PrintEnumItemsImpl(const std::pair<const char*, V>* entries, size_t arraySize) {
     TString result;
     TStringOutput out(result);
-    for (size_t i = 0; i < arraySize; i++)
+    for (size_t i = 0; i < arraySize; i++) {
         out << (i ? ", " : "") << "'" << (entries[i].first ? entries[i].first : "<null>") << "'";
+    }
     return result;
 }
 
 template <class K1, class K2, class V>
 const V* EnumFromStringImpl(K1 key, const std::pair<K2, V>* entries, size_t arraySize) {
     const V* res = FindEnumFromStringImpl(key, entries, arraySize);
-    if (res)
+    if (res) {
         return res;
+    }
 
     ythrow TEnumNotFoundException() << "Key '" << key << "' not found in enum. Valid options are: " << PrintEnumItemsImpl(entries, arraySize) << ". ";
 }
 
 template <class K, class V>
 const K* EnumToStringImpl(V value, const std::pair<K, V>* entries, size_t arraySize) {
-    for (size_t i = 0; i < arraySize; i++)
-        if (entries[i].second == value)
+    for (size_t i = 0; i < arraySize; i++) {
+        if (entries[i].second == value) {
             return &entries[i].first;
+        }
+    }
 
     TEnumNotFoundException exc;
     exc << "Value '" << int(value) << "' not found in enum. Valid values are: ";
-    for (size_t i = 0; i < arraySize; i++)
+    for (size_t i = 0; i < arraySize; i++) {
         exc << (i ? ", " : "") << int(entries[i].second);
+    }
     exc << ". ";
     ythrow exc;
 }
@@ -128,8 +138,9 @@ inline void SetEnumFlags(TStringBuf optSpec, std::bitset<B>& flags, bool allIfEm
         flags.reset();
         for (const auto& it : StringSplitter(optSpec).Split(',')) {
             E e;
-            if (!TryFromString(it.Token(), e))
+            if (!TryFromString(it.Token(), e)) {
                 ythrow yexception() << "Unknown enum value '" << it.Token() << "'";
+            }
             flags.set((size_t)e);
         }
     }
diff --git a/util/draft/holder_vector.h b/util/draft/holder_vector.h
index 1c62055bd95..3e31b54a910 100644
--- a/util/draft/holder_vector.h
+++ b/util/draft/holder_vector.h
@@ -20,8 +20,9 @@ class THolderVector: public TVector<T*>, public TNonCopyable {
 
     void Clear() {
         for (typename TBase::iterator it = TBase::begin(); it != TBase::end(); ++it) {
-            if (*it)
+            if (*it) {
                 D::Destroy(*it);
+            }
         }
         TBase::clear();
     }
@@ -35,8 +36,9 @@ class THolderVector: public TVector<T*>, public TNonCopyable {
         try {
             TBase::push_back(t);
         } catch (...) {
-            if (t)
+            if (t) {
                 D::Destroy(t);
+            }
             throw;
         }
     }
diff --git a/util/draft/holder_vector_ut.cpp b/util/draft/holder_vector_ut.cpp
index f64393860af..54783970e7d 100644
--- a/util/draft/holder_vector_ut.cpp
+++ b/util/draft/holder_vector_ut.cpp
@@ -66,4 +66,4 @@ Y_UNIT_TEST_SUITE(THolderVectorTest) {
         UNIT_ASSERT(v.Size() == 1);
         UNIT_ASSERT(str.get() == nullptr);
     }
-}
+} // Y_UNIT_TEST_SUITE(THolderVectorTest)
diff --git a/util/draft/matrix.h b/util/draft/matrix.h
index 154d00b35ea..f6d7f1ad15f 100644
--- a/util/draft/matrix.h
+++ b/util/draft/matrix.h
@@ -96,8 +96,9 @@ class TMatrix: TNonCopyable {
     }
 
     void Fill(T value) {
-        for (T *p = Arr, *end = Arr + M * N; p < end; ++p)
+        for (T *p = Arr, *end = Arr + M * N; p < end; ++p) {
             *p = value;
+        }
     }
 
 private:
diff --git a/util/draft/memory.h b/util/draft/memory.h
index 0a9722bb36e..c39cf1b5ef7 100644
--- a/util/draft/memory.h
+++ b/util/draft/memory.h
@@ -15,8 +15,9 @@ template <size_t Size>
 inline bool IsZero(const char* p) {
     size_t sizeInUI64 = Size / 8;
     const char* pEndUi64 = p + sizeInUI64 * 8;
-    if (sizeInUI64 && !IsZero<ui64>((const ui64*)p, (const ui64*)pEndUi64))
+    if (sizeInUI64 && !IsZero<ui64>((const ui64*)p, (const ui64*)pEndUi64)) {
         return false;
+    }
     return IsZero(pEndUi64, p + Size);
 }
 
diff --git a/util/draft/memory_ut.cpp b/util/draft/memory_ut.cpp
index 76bee30549f..f1aa4a03a23 100644
--- a/util/draft/memory_ut.cpp
+++ b/util/draft/memory_ut.cpp
@@ -66,4 +66,4 @@ Y_UNIT_TEST_SUITE(TUtilDraftMemoryTest) {
         ss3.A.C = -789;
         UNIT_ASSERT(!IsZero(ss3));
     }
-}
+} // Y_UNIT_TEST_SUITE(TUtilDraftMemoryTest)
diff --git a/util/folder/dirent_win.c b/util/folder/dirent_win.c
index 7e6db74ce53..8eed4801c7a 100644
--- a/util/folder/dirent_win.c
+++ b/util/folder/dirent_win.c
@@ -30,7 +30,7 @@ struct DIR* opendir(const char* dirname) {
     dir->readdir_buf = NULL;
 
     int len = strlen(dirname);
-    //Remove trailing slashes
+    // Remove trailing slashes
     while (len && (dirname[len - 1] == '\\' || dirname[len - 1] == '/')) {
         --len;
     }
@@ -59,8 +59,9 @@ struct DIR* opendir(const char* dirname) {
 }
 
 int closedir(struct DIR* dir) {
-    if (dir->sh != INVALID_HANDLE_VALUE)
+    if (dir->sh != INVALID_HANDLE_VALUE) {
         FindClose(dir->sh);
+    }
     free(dir->fff_templ);
     free(dir->readdir_buf);
     free(dir);
@@ -109,8 +110,9 @@ struct dirent* readdir(struct DIR* dir) {
     struct dirent* res;
     if (!dir->readdir_buf) {
         dir->readdir_buf = (struct dirent*)malloc(sizeof(struct dirent));
-        if (dir->readdir_buf == 0)
+        if (dir->readdir_buf == 0) {
             return 0;
+        }
     }
     readdir_r(dir, dir->readdir_buf, &res);
     return res;
@@ -122,4 +124,4 @@ void rewinddir(struct DIR* dir) {
     dir->file_no = 0;
 }
 
-#endif //_win_
+#endif // _win_
diff --git a/util/folder/dirut.cpp b/util/folder/dirut.cpp
index ffc9b09f967..a3e804f1e85 100644
--- a/util/folder/dirut.cpp
+++ b/util/folder/dirut.cpp
@@ -12,15 +12,18 @@
 #include <util/system/yassert.h>
 
 void SlashFolderLocal(TString& folder) {
-    if (!folder)
+    if (!folder) {
         return;
+    }
 #ifdef _win32_
     size_t pos;
-    while ((pos = folder.find('/')) != TString::npos)
+    while ((pos = folder.find('/')) != TString::npos) {
         folder.replace(pos, 1, LOCSLASH_S);
+    }
 #endif
-    if (folder[folder.size() - 1] != LOCSLASH_C)
+    if (folder[folder.size() - 1] != LOCSLASH_C) {
         folder.append(LOCSLASH_S);
+    }
 }
 
 #ifndef _win32_
@@ -36,8 +39,9 @@ bool resolvepath(TString& folder, const TString& home) {
     }
     // may be from windows
     char* ptr = folder.begin();
-    while ((ptr = strchr(ptr, '\\')) != nullptr)
+    while ((ptr = strchr(ptr, '\\')) != nullptr) {
         *ptr = '/';
+    }
 
     if (folder.at(0) == '~') {
         if (folder.length() == 1 || folder.at(1) == '/') {
@@ -46,14 +50,16 @@ bool resolvepath(TString& folder, const TString& home) {
             char* buf = (char*)alloca(folder.length() + 1);
             strcpy(buf, folder.data() + 1);
             char* p = strchr(buf, '/');
-            if (p)
+            if (p) {
                 *p++ = 0;
+            }
             passwd* pw = getpwnam(buf);
             if (pw) {
                 folder = pw->pw_dir;
                 folder += "/";
-                if (p)
+                if (p) {
                     folder += p;
+                }
             } else {
                 return false; // unknown user
             }
@@ -75,8 +81,9 @@ bool resolvepath(TString& folder, const TString& home) {
     for (char* s = path; s;) {
         pp[i++] = s;
         s = strchr(s, '/');
-        if (s)
+        if (s) {
             *s++ = 0;
+        }
     }
 
     for (int j = 1; j < i;) {
@@ -108,8 +115,9 @@ bool resolvepath(TString& folder, const TString& home) {
                     --j;
                 }
             }
-        } else
+        } else {
             ++j;
+        }
     }
 
     char* s = newpath;
@@ -160,24 +168,31 @@ static int next_dir(T*& ptr) {
                 ++has_ctrl;
                 break;
             default:
-                if (c == 127 || c < ' ')
+                if (c == 127 || c < ' ') {
                     ++has_ctrl;
-                else
+                } else {
                     ++has_letter;
+                }
         }
     }
-    if (*ptr)
+    if (*ptr) {
         ++ptr;
-    if (has_ctrl)
+    }
+    if (has_ctrl) {
         return dt_error;
-    if (has_letter)
+    }
+    if (has_letter) {
         return dt_dir;
-    if (has_dot && has_blank)
+    }
+    if (has_dot && has_blank) {
         return dt_error;
-    if (has_dot == 1)
+    }
+    if (has_dot == 1) {
         return dt_empty;
-    if (has_dot == 2)
+    }
+    if (has_dot == 2) {
         return dt_up;
+    }
     return dt_error;
 }
 
@@ -193,15 +208,18 @@ using disk_type = enum {
 template <typename T>
 static int skip_disk(T*& ptr) {
     int result = dk_noflags;
-    if (!*ptr)
+    if (!*ptr) {
         return result;
+    }
     if (ptr[0] == '\\' && ptr[1] == '\\') {
         result |= dk_unc | dk_fromroot;
         ptr += 2;
-        if (next_dir(ptr) != dt_dir)
+        if (next_dir(ptr) != dt_dir) {
             return dk_error; // has no host name
-        if (next_dir(ptr) != dt_dir)
+        }
+        if (next_dir(ptr) != dt_dir) {
             return dk_error; // has no share name
+        }
     } else {
         if (*ptr && *(ptr + 1) == ':') {
             result |= dk_hasdrive;
@@ -225,12 +243,14 @@ int correctpath(char* cpath, const char* path) {
     int counter = 0;
     while (*ptr) {
         char c = *ptr;
-        if (c == '/')
+        if (c == '/') {
             c = '\\';
-        if (c == '\\')
+        }
+        if (c == '\\') {
             ++counter;
-        else
+        } else {
             counter = 0;
+        }
         if (counter <= 1) {
             *cptr = c;
             ++cptr;
@@ -241,8 +261,9 @@ int correctpath(char* cpath, const char* path) {
     // replace '/' by '\'
     int dk = skip_disk(cpath);
 
-    if (dk == dk_error)
+    if (dk == dk_error) {
         return 0;
+    }
 
     char* ptr1 = ptr = cpath;
     int level = 0;
@@ -260,10 +281,11 @@ int correctpath(char* cpath, const char* path) {
                 if (level >= 0) {
                     *--ptr1 = 0;
                     ptr1 = strrchr(cpath, '\\');
-                    if (!ptr1)
+                    if (!ptr1) {
                         ptr1 = cpath;
-                    else
+                    } else {
                         ++ptr1;
+                    }
                     memmove(ptr1, ptr, strlen(ptr) + 1);
                     ptr = ptr1;
                     break;
@@ -273,8 +295,9 @@ int correctpath(char* cpath, const char* path) {
                         return 1;
                     }
                 }
-                if (dk & dk_fromroot)
+                if (dk & dk_fromroot) {
                     return 0;
+                }
                 break;
             case dt_error:
             default:
@@ -283,8 +306,9 @@ int correctpath(char* cpath, const char* path) {
         ptr1 = ptr;
     }
 
-    if ((ptr > cpath || ptr == cpath && dk & dk_unc) && *(ptr - 1) == '\\')
+    if ((ptr > cpath || ptr == cpath && dk & dk_unc) && *(ptr - 1) == '\\') {
         *(ptr - 1) = 0;
+    }
     return 1;
 }
 
@@ -294,54 +318,63 @@ static inline int normchar(unsigned char c) {
 
 static inline char* strslashcat(char* a, const char* b) {
     size_t len = strlen(a);
-    if (len && a[len - 1] != '\\')
+    if (len && a[len - 1] != '\\') {
         a[len++] = '\\';
+    }
     strcpy(a + len, b);
     return a;
 }
 
 int resolvepath(char* apath, const char* rpath, const char* cpath) {
     const char* redisk = rpath;
-    if (!rpath || !*rpath)
+    if (!rpath || !*rpath) {
         return 0;
+    }
     int rdt = skip_disk(redisk);
-    if (rdt == dk_error)
+    if (rdt == dk_error) {
         return 0;
+    }
     if (rdt & dk_unc || rdt & dk_hasdrive && rdt & dk_fromroot) {
         return correctpath(apath, rpath);
     }
 
     const char* cedisk = cpath;
-    if (!cpath || !*cpath)
+    if (!cpath || !*cpath) {
         return 0;
+    }
     int cdt = skip_disk(cedisk);
-    if (cdt == dk_error)
+    if (cdt == dk_error) {
         return 0;
+    }
 
     char* tpath = (char*)alloca(strlen(rpath) + strlen(cpath) + 3);
 
     // rdt&dk_hasdrive && !rdt&dk_fromroot
     if (rdt & dk_hasdrive) {
-        if (!(cdt & dk_fromroot))
+        if (!(cdt & dk_fromroot)) {
             return 0;
-        if (cdt & dk_hasdrive && normchar(*rpath) != normchar(*cpath))
+        }
+        if (cdt & dk_hasdrive && normchar(*rpath) != normchar(*cpath)) {
             return 0;
+        }
         memcpy(tpath, rpath, 2);
         memcpy(tpath + 2, cedisk, strlen(cedisk) + 1);
         strslashcat(tpath, redisk);
 
         // !rdt&dk_hasdrive && rdt&dk_fromroot
     } else if (rdt & dk_fromroot) {
-        if (!(cdt & dk_hasdrive) && !(cdt & dk_unc))
+        if (!(cdt & dk_hasdrive) && !(cdt & dk_unc)) {
             return 0;
+        }
         memcpy(tpath, cpath, cedisk - cpath);
         tpath[cedisk - cpath] = 0;
         strslashcat(tpath, redisk);
 
         // !rdt&dk_hasdrive && !rdt&dk_fromroot
     } else {
-        if (!(cdt & dk_fromroot) || !(cdt & dk_hasdrive) && !(cdt & dk_unc))
+        if (!(cdt & dk_fromroot) || !(cdt & dk_hasdrive) && !(cdt & dk_unc)) {
             return 0;
+        }
         strslashcat(strcpy(tpath, cpath), redisk);
     }
 
@@ -388,8 +421,9 @@ void RemoveDirWithContents(TString dirName) {
             case FTS_DP:
             case FTS_SL:
             case FTS_SLNONE:
-                if (!NFs::Remove(it->fts_path))
+                if (!NFs::Remove(it->fts_path)) {
                     ythrow TSystemError() << "error while removing " << it->fts_path;
+                }
                 break;
         }
     }
@@ -404,7 +438,7 @@ int mkpath(char* path, int mode) {
 // if it does not). Use RealLocation if that behaviour is required.
 TString RealPath(const TString& path) {
     TTempBuf result;
-    Y_ASSERT(result.Size() > MAX_PATH); //TMP_BUF_LEN > MAX_PATH
+    Y_ASSERT(result.Size() > MAX_PATH); // TMP_BUF_LEN > MAX_PATH
 #ifdef _win_
     if (GetFullPathName(path.data(), result.Size(), result.Data(), nullptr) == 0)
 #else
@@ -415,11 +449,13 @@ TString RealPath(const TString& path) {
 }
 
 TString RealLocation(const TString& path) {
-    if (NFs::Exists(path))
+    if (NFs::Exists(path)) {
         return RealPath(path);
+    }
     TString dirpath = GetDirName(path);
-    if (NFs::Exists(dirpath))
+    if (NFs::Exists(dirpath)) {
         return RealPath(dirpath) + GetDirectorySeparatorS() + GetFileNameComponent(path.data());
+    }
     ythrow TFileError() << "RealLocation failed \"" << path << "\"";
 }
 
@@ -437,14 +473,18 @@ int MakeTempDir(char path[/*FILENAME_MAX*/], const char* prefix) {
         prefix = sysTmp.data();
     }
 
-    if ((ret = ResolvePath(prefix, nullptr, path, 1)) != 0)
+    if ((ret = ResolvePath(prefix, nullptr, path, 1)) != 0) {
         return ret;
-    if (!TFileStat(path).IsDir())
+    }
+    if (!TFileStat(path).IsDir()) {
         return ENOENT;
-    if ((strlcat(path, "tmpXXXXXX", FILENAME_MAX) > FILENAME_MAX - 100))
+    }
+    if ((strlcat(path, "tmpXXXXXX", FILENAME_MAX) > FILENAME_MAX - 100)) {
         return EINVAL;
-    if (!(mkdtemp(path)))
+    }
+    if (!(mkdtemp(path))) {
         return errno ? errno : EINVAL;
+    }
     strcat(path, LOCSLASH_S);
     return 0;
 }
@@ -459,13 +499,14 @@ TString GetHomeDir() {
 #ifndef _win32_
         passwd* pw = nullptr;
         s = getenv("USER");
-        if (s)
+        if (s) {
             pw = getpwnam(s.data());
-        else
+        } else {
             pw = getpwuid(getuid());
-        if (pw)
+        }
+        if (pw) {
             s = pw->pw_dir;
-        else
+        } else
 #endif
         {
             char* cur_dir = getcwd(nullptr, 0);
@@ -494,8 +535,9 @@ const char* GetFileNameComponent(const char* f) {
 #ifdef _win_
     // "/" is also valid char separator on Windows
     const char* p2 = strrchr(f, '/');
-    if (p2 > p)
+    if (p2 > p) {
         p = p2;
+    }
 #endif
 
     if (p) {
@@ -561,20 +603,24 @@ int ResolvePath(const char* rel, const char* abs, char res[/*MAXPATHLEN*/], bool
     size_t len;
 
     *res = 0;
-    if (!rel || !*rel)
+    if (!rel || !*rel) {
         return EINVAL;
+    }
     if (!IsAbsolutePath(rel) && IsAbsolutePath(abs)) {
         len = strlcpy(t, abs, sizeof(t));
-        if (len >= sizeof(t) - 3)
+        if (len >= sizeof(t) - 3) {
             return EINVAL;
-        if (t[len - 1] != LOCSLASH_C)
+        }
+        if (t[len - 1] != LOCSLASH_C) {
             t[len++] = LOCSLASH_C;
+        }
         len += strlcpy(t + len, rel, sizeof(t) - len);
     } else {
         len = strlcpy(t, rel, sizeof(t));
     }
-    if (len >= sizeof(t) - 3)
+    if (len >= sizeof(t) - 3) {
         return EINVAL;
+    }
     if (isdir && t[len - 1] != LOCSLASH_C) {
         t[len++] = LOCSLASH_C;
         t[len] = 0;
@@ -603,8 +649,9 @@ int ResolvePath(const char* rel, const char* abs, char res[/*MAXPATHLEN*/], bool
 
 TString ResolvePath(const char* rel, const char* abs, bool isdir) {
     char buf[PATH_MAX];
-    if (ResolvePath(rel, abs, buf, isdir))
+    if (ResolvePath(rel, abs, buf, isdir)) {
         ythrow yexception() << "cannot resolve path: \"" << rel << "\"";
+    }
     return buf;
 }
 
diff --git a/util/folder/dirut.h b/util/folder/dirut.h
index 2537027b12d..ccdfc94ed85 100644
--- a/util/folder/dirut.h
+++ b/util/folder/dirut.h
@@ -105,12 +105,14 @@ class TExistenceChecker {
     }
 
     const char* Check(const char* fname) const {
-        if (!fname || !*fname)
+        if (!fname || !*fname) {
             return nullptr;
+        }
         if (Strict) {
             NFs::EnsureExists(fname);
-        } else if (!NFs::Exists(fname))
+        } else if (!NFs::Exists(fname)) {
             fname = nullptr;
+        }
         return fname;
     }
 
diff --git a/util/folder/dirut_ut.cpp b/util/folder/dirut_ut.cpp
index dbfabdd059c..58390af15b0 100644
--- a/util/folder/dirut_ut.cpp
+++ b/util/folder/dirut_ut.cpp
@@ -129,4 +129,4 @@ Y_UNIT_TEST_SUITE(TDirutTest) {
 
         RemoveDirWithContents(tmpDir);
     }
-}
+} // Y_UNIT_TEST_SUITE(TDirutTest)
diff --git a/util/folder/fts.h b/util/folder/fts.h
index f3c799e8c88..d7105a4945c 100644
--- a/util/folder/fts.h
+++ b/util/folder/fts.h
@@ -15,7 +15,7 @@ typedef unsigned short u_short;
 typedef unsigned int nlink_t;
 typedef struct _stat64 stat_struct;
     #define STAT_FUNC stat64UTF
-    //TODO: remove from global scope stat64UTF stat64UTF
+    // TODO: remove from global scope stat64UTF stat64UTF
     #ifdef __cplusplus
 int stat64UTF(const char* path, struct _stat64* _Stat);
 int stat64UTF(dird path, struct _stat64* _Stat);
diff --git a/util/folder/fts_ut.cpp b/util/folder/fts_ut.cpp
index c5d59e35f42..3a8cced44e7 100644
--- a/util/folder/fts_ut.cpp
+++ b/util/folder/fts_ut.cpp
@@ -24,7 +24,7 @@ void MakeFile(const char* path) {
     TFile(path, CreateAlways);
 }
 
-//There potentially could be problems in listing order on different platforms
+// There potentially could be problems in listing order on different platforms
 int FtsCmp(const FTSENT** ent1, const FTSENT** ent2) {
     return strcmp((*ent1)->fts_accpath, (*ent2)->fts_accpath);
 }
diff --git a/util/folder/iterator.h b/util/folder/iterator.h
index c79d56c6543..932d0fc844e 100644
--- a/util/folder/iterator.h
+++ b/util/folder/iterator.h
@@ -6,6 +6,7 @@
 #include <util/generic/ptr.h>
 #include <util/generic/iterator.h>
 #include <util/generic/yexception.h>
+#include <util/generic/ylimits.h>
 
 /// Note this magic API traverses directory hierarchy
 
diff --git a/util/folder/iterator_ut.cpp b/util/folder/iterator_ut.cpp
index c54cde55c81..cb3534c70fa 100644
--- a/util/folder/iterator_ut.cpp
+++ b/util/folder/iterator_ut.cpp
@@ -177,7 +177,7 @@ class TDirIteratorTest: public TTestBase {
         TDirHier dh;
         const TString dir("tmpdir");
 
-        //prepare fs
+        // prepare fs
         {
             TMersenne<ui32> rnd;
             const TString prefixes[] = {
diff --git a/util/folder/path.cpp b/util/folder/path.cpp
index 940f6dffe0d..321776cb0c8 100644
--- a/util/folder/path.cpp
+++ b/util/folder/path.cpp
@@ -406,8 +406,7 @@ void TFsPath::DeleteIfExists() const {
         return;
     }
 
-    ::unlink(this->c_str());
-    ::rmdir(this->c_str());
+    NFs::Remove(GetPath());
     if (Exists()) {
         ythrow TIoException() << "failed to delete " << Path_;
     }
@@ -441,7 +440,7 @@ void TFsPath::ForceDelete() const {
         return;
     }
 
-    TFileStat stat(GetPath().c_str(), true);
+    TFileStat stat(GetPath(), true);
     if (stat.IsNull()) {
         const int err = LastSystemError();
 #ifdef _win_
@@ -455,19 +454,15 @@ void TFsPath::ForceDelete() const {
         }
     }
 
-    bool succ;
     if (stat.IsDir()) {
         TVector<TFsPath> children;
         List(children);
         for (auto& i : children) {
             i.ForceDelete();
         }
-        succ = ::rmdir(this->c_str()) == 0;
-    } else {
-        succ = ::unlink(this->c_str()) == 0;
     }
 
-    if (!succ && LastSystemError()) {
+    if (!NFs::Remove(GetPath())) {
         ythrow TIoException() << "failed to delete " << Path_;
     }
 }
diff --git a/util/folder/path.h b/util/folder/path.h
index 9f6642d5cb8..c1a262bed1e 100644
--- a/util/folder/path.h
+++ b/util/folder/path.h
@@ -225,7 +225,7 @@ namespace NPrivate {
         fsPath /= TFsPath(arg);
         AppendToFsPath(fsPath, std::forward<Ts>(args)...);
     }
-}
+} // namespace NPrivate
 
 template <class... Ts>
 TString JoinFsPaths(Ts&&... args) {
diff --git a/util/folder/path_ut.cpp b/util/folder/path_ut.cpp
index bb0656ddbc5..095969f3bb4 100644
--- a/util/folder/path_ut.cpp
+++ b/util/folder/path_ut.cpp
@@ -52,7 +52,7 @@ namespace {
     TTestDirectory::~TTestDirectory() {
         Path_.ForceDelete();
     }
-}
+} // namespace
 
 Y_UNIT_TEST_SUITE(TFsPathTests) {
     Y_UNIT_TEST(TestMkDirs) {
@@ -259,7 +259,7 @@ Y_UNIT_TEST_SUITE(TFsPathTests) {
         // mkdir(2) places umask(2) on mode argument.
         const int mask = Umask(0);
         Umask(mask);
-        UNIT_ASSERT_VALUES_EQUAL(stat.Mode& MODE0777, mode & ~mask);
+        UNIT_ASSERT_VALUES_EQUAL(stat.Mode & MODE0777, mode & ~mask);
     }
 #endif
 
@@ -663,7 +663,7 @@ Y_UNIT_TEST_SUITE(TFsPathTests) {
     };
 #endif
 
-    Y_UNIT_TEST(TestForceDeleteErrorUnlink) {
+    Y_UNIT_TEST(TestForceDeleteErrorRemove) {
         TTempDir tempDir;
 
         const TFsPath testDir = TFsPath(tempDir()).Child("dir");
@@ -680,14 +680,17 @@ Y_UNIT_TEST_SUITE(TFsPathTests) {
         Y_DEFER {
             Chmod(testFile.c_str(), MODE0777);
         };
+        // Checks that dir/file with readonly attribute will be deleted
+        // on Windows
+        UNIT_ASSERT_NO_EXCEPTION(testFile.ForceDelete());
 #else
         Chmod(testDir.c_str(), S_IRUSR | S_IXUSR);
         Y_DEFER {
             Chmod(testDir.c_str(), MODE0777);
         };
+        UNIT_ASSERT_EXCEPTION_CONTAINS(testFile.ForceDelete(), TIoException,
+                                       "failed to delete");
 #endif
-
-        UNIT_ASSERT_EXCEPTION_CONTAINS(testFile.ForceDelete(), TIoException, "failed to delete");
     }
 
     Y_UNIT_TEST(TestForceDeleteErrorRmdir) {
@@ -698,6 +701,10 @@ Y_UNIT_TEST_SUITE(TFsPathTests) {
         MakePathIfNotExist(testSubdir.c_str());
 
 #ifdef _win_
+        if (IsWine()) {
+            // Broken since f8699c0a71a528d287b84cd0bc5b5bb7cec924f0 (5.11 wine-version)
+            return;
+        }
         Chmod(testSubdir.c_str(), 0);
         Y_DEFER {
             Chmod(testSubdir.c_str(), MODE0777);
@@ -894,4 +901,4 @@ Y_UNIT_TEST_SUITE(TFsPathTests) {
             UNIT_ASSERT_VALUES_EQUAL(split2.at(1), DIR_B);
         }
     }
-}
+} // Y_UNIT_TEST_SUITE(TFsPathTests)
diff --git a/util/folder/pathsplit.cpp b/util/folder/pathsplit.cpp
index 816f6960245..fd002b143a3 100644
--- a/util/folder/pathsplit.cpp
+++ b/util/folder/pathsplit.cpp
@@ -132,7 +132,7 @@ TString JoinPaths(const TPathSplit& p1, const TPathSplit& p2) {
     return TPathSplit(p1).AppendMany(p2.begin(), p2.end()).Reconstruct();
 }
 
-TStringBuf CutExtension(const TStringBuf fileName) {
+TStringBuf CutExtension(const TStringBuf fileName Y_LIFETIME_BOUND) {
     if (fileName.empty()) {
         return fileName;
     }
diff --git a/util/folder/pathsplit.h b/util/folder/pathsplit.h
index d134338e35d..d4eedfbbc59 100644
--- a/util/folder/pathsplit.h
+++ b/util/folder/pathsplit.h
@@ -5,7 +5,7 @@
 #include <util/generic/string.h>
 #include <util/string/ascii.h>
 
-//do not own any data
+// do not own any data
 struct TPathSplitStore: public TVector<TStringBuf> {
     TStringBuf Drive;
     bool IsAbsolute = false;
@@ -110,4 +110,4 @@ using TPathSplitWindows = TPathSplitBase<TPathSplitTraitsWindows>;
 
 TString JoinPaths(const TPathSplit& p1, const TPathSplit& p2);
 
-TStringBuf CutExtension(const TStringBuf fileName);
+TStringBuf CutExtension(const TStringBuf fileName Y_LIFETIME_BOUND);
diff --git a/util/folder/pathsplit_ut.cpp b/util/folder/pathsplit_ut.cpp
index 1310ba15d08..b028a618769 100644
--- a/util/folder/pathsplit_ut.cpp
+++ b/util/folder/pathsplit_ut.cpp
@@ -437,7 +437,7 @@ Y_UNIT_TEST_SUITE(PSUF(PathSplit)) {
         UNIT_ASSERT_STRINGS_EQUAL(ps.Reconstruct(), "../path");
     #endif
     }
-}
+} // Y_UNIT_TEST_SUITE(PSUF(PathSplit)
 
 Y_UNIT_TEST_SUITE(PSUF(PathSplitTraits)) {
     Y_UNIT_TEST(IsPathSep) {
@@ -475,7 +475,7 @@ Y_UNIT_TEST_SUITE(PSUF(PathSplitTraits)) {
         UNIT_ASSERT_EQUAL(PSUF_LOCAL(TPathSplitTraits)::IsAbsolutePath("#:\\somepath"), false);
         UNIT_ASSERT_EQUAL(PSUF_LOCAL(TPathSplitTraits)::IsAbsolutePath("#:/somepath"), false);
     }
-}
+} // Y_UNIT_TEST_SUITE(PSUF(PathSplitTraits)
 
     #undef TRUE_ONLY_WIN
 
diff --git a/util/folder/tempdir.cpp b/util/folder/tempdir.cpp
index 6fdf8f753c1..44ee4a6f635 100644
--- a/util/folder/tempdir.cpp
+++ b/util/folder/tempdir.cpp
@@ -5,11 +5,19 @@
 #include <util/system/fs.h>
 #include <util/system/maxlen.h>
 
+#include <utility>
+
 TTempDir::TTempDir()
     : TTempDir(nullptr, TCreationToken{})
 {
 }
 
+TTempDir::TTempDir(TTempDir&& other)
+    : TempDir(std::move(other.TempDir))
+    , Remove(std::exchange(other.Remove, false))
+{
+}
+
 TTempDir::TTempDir(const char* prefix, TCreationToken)
     : TempDir()
     , Remove(true)
diff --git a/util/folder/tempdir.h b/util/folder/tempdir.h
index ff458f83b9b..7a329ec70fe 100644
--- a/util/folder/tempdir.h
+++ b/util/folder/tempdir.h
@@ -12,6 +12,12 @@ class TTempDir {
     /// Create new directory with this fixed name. If it already exists, clear it.
     TTempDir(const TString& tempDir);
 
+    TTempDir(const TTempDir&) = delete;
+    TTempDir(TTempDir&& other);
+
+    TTempDir& operator=(const TTempDir&) = delete;
+    TTempDir& operator=(TTempDir&& other) = delete;
+
     ~TTempDir();
 
     /// Create new directory in given folder.
diff --git a/util/folder/tempdir_ut.cpp b/util/folder/tempdir_ut.cpp
new file mode 100644
index 00000000000..46330b760a2
--- /dev/null
+++ b/util/folder/tempdir_ut.cpp
@@ -0,0 +1,13 @@
+#include "tempdir.h"
+
+#include <library/cpp/testing/common/env.h>
+#include <library/cpp/testing/unittest/registar.h>
+
+#include <util/generic/maybe.h>
+
+Y_UNIT_TEST_SUITE(TTempDirTests) {
+    Y_UNIT_TEST(TestMoveCtor) {
+        TMaybe<TTempDir> dir{TTempDir::NewTempDir(GetWorkPath())};
+        UNIT_ASSERT_NO_EXCEPTION(dir.Clear());
+    }
+} // Y_UNIT_TEST_SUITE(TTempDirTests)
diff --git a/util/generic/adaptor.h b/util/generic/adaptor.h
index b88a65fc81e..b353a5b3fd3 100644
--- a/util/generic/adaptor.h
+++ b/util/generic/adaptor.h
@@ -119,7 +119,7 @@ namespace NPrivate {
             return end(Base());
         }
     };
-}
+} // namespace NPrivate
 
 /**
  * Provides a reverse view into the provided container.
@@ -131,7 +131,7 @@ namespace NPrivate {
  * }
  * @endcode
  *
- * @param cont                          Container to provide a view into. Must be an lvalue.
+ * @param range                         Container to provide a view into. Must be an lvalue.
  * @returns                             A reverse view into the provided container.
  */
 template <class Range>
diff --git a/util/generic/adaptor_ut.cpp b/util/generic/adaptor_ut.cpp
index 721f849f934..3ccd1b84bce 100644
--- a/util/generic/adaptor_ut.cpp
+++ b/util/generic/adaptor_ut.cpp
@@ -121,4 +121,4 @@ Y_UNIT_TEST_SUITE(TReverseAdaptor) {
             UNIT_ASSERT_VALUES_EQUAL(etalon2[idx++], x);
         }
     }
-}
+} // Y_UNIT_TEST_SUITE(TReverseAdaptor)
diff --git a/util/generic/algorithm.h b/util/generic/algorithm.h
index 70efc506092..fcddff61831 100644
--- a/util/generic/algorithm.h
+++ b/util/generic/algorithm.h
@@ -21,17 +21,17 @@ namespace NPrivate {
         auto bestValue = func(*begin);
         auto bestPos = begin;
 
-        for (auto i = ++begin; i != end; ++i) {
-            auto curValue = func(*i);
+        for (++begin; begin != end; ++begin) {
+            auto curValue = func(*begin);
             if (pred(curValue, bestValue)) {
-                bestValue = curValue;
-                bestPos = i;
+                bestValue = std::move(curValue);
+                bestPos = begin;
             }
         }
 
         return bestPos;
     }
-}
+} // namespace NPrivate
 
 template <class T>
 constexpr void Sort(T f, T l) {
@@ -207,25 +207,15 @@ constexpr size_t FindIndexIf(C&& c, P p) {
     return it == end(c) ? NPOS : (it - begin(c));
 }
 
-//EqualToOneOf(x, "apple", "orange") means (x == "apple" || x == "orange")
-template <typename T>
-constexpr bool EqualToOneOf(const T&) {
-    return false;
-}
-
-template <typename T, typename U, typename... Other>
-constexpr bool EqualToOneOf(const T& x, const U& y, const Other&... other) {
-    return x == y || EqualToOneOf(x, other...);
-}
-
-template <typename T>
-constexpr size_t CountOf(const T&) {
-    return 0;
+// EqualToOneOf(x, "apple", "orange") means (x == "apple" || x == "orange")
+template <typename T, typename... Other>
+constexpr bool EqualToOneOf(const T& x, const Other&... values) {
+    return (... || (x == values));
 }
 
-template <typename T, typename U, typename... Other>
-constexpr size_t CountOf(const T& x, const U& y, const Other&... other) {
-    return static_cast<size_t>(x == y) + CountOf(x, other...);
+template <typename T, typename... Other>
+constexpr size_t CountOf(const T& x, const Other&... values) {
+    return (0 + ... + static_cast<size_t>(x == values));
 }
 
 template <class I>
@@ -351,7 +341,11 @@ template <class C, class P>
 void EraseNodesIf(C& c, P p) {
     for (auto iter = c.begin(), last = c.end(); iter != last;) {
         if (p(*iter)) {
-            c.erase(iter++);
+            if constexpr (std::is_same_v<decltype(iter), decltype(c.erase(iter))>) {
+                iter = c.erase(iter);
+            } else {
+                c.erase(iter++);
+            }
         } else {
             ++iter;
         }
@@ -595,7 +589,7 @@ namespace NPrivate {
         ::ApplyToMany(std::forward<TOp>(op), std::get<Is>(std::forward<T>(t))...);
 #endif
     }
-}
+} // namespace NPrivate
 
 // check that TOp return true for all of element from tuple T
 template <class T, class TOp>
@@ -733,7 +727,7 @@ namespace NPrivate {
     constexpr TForwardIterator AdjacentFindBy(TForwardIterator begin, TForwardIterator end, const TGetKey& getKey) {
         return std::adjacent_find(begin, end, [&](auto&& left, auto&& right) { return getKey(left) == getKey(right); });
     }
-}
+} // namespace NPrivate
 
 template <class TContainer, class TGetKey>
 constexpr auto AdjacentFindBy(TContainer&& c, const TGetKey& getKey) {
@@ -780,7 +774,7 @@ constexpr TO CopyIf(TI begin, TI end, TO to, P pred) {
 }
 
 template <class T>
-constexpr std::pair<const T&, const T&> MinMax(const T& first, const T& second) {
+constexpr std::pair<const T&, const T&> MinMax(const T& first Y_LIFETIME_BOUND, const T& second Y_LIFETIME_BOUND) {
     return std::minmax(first, second);
 }
 
diff --git a/util/generic/algorithm_ut.cpp b/util/generic/algorithm_ut.cpp
index 09c5824cd9b..ee918233da8 100644
--- a/util/generic/algorithm_ut.cpp
+++ b/util/generic/algorithm_ut.cpp
@@ -111,7 +111,7 @@ Y_UNIT_TEST_SUITE(TAlgorithm) {
         UNIT_ASSERT(0 == EqualToOneOf(1, 2));
         UNIT_ASSERT(0 == EqualToOneOf(3));
 
-        //test, that EqualToOneOf can compare different types, and don't copy objects:
+        // test, that EqualToOneOf can compare different types, and don't copy objects:
         TStrokaNoCopy x("x");
         TStrokaNoCopy y("y");
         TStrokaNoCopy z("z");
@@ -169,7 +169,7 @@ Y_UNIT_TEST_SUITE(TAlgorithm) {
         int array[3] = {1, 2, 3};
         const int array_const[3] = {1, 2, 3};
 
-        //test (const, non-const) * (iterator, vector, array) * (found, not found) variants.
+        // test (const, non-const) * (iterator, vector, array) * (found, not found) variants.
         // value '3' is in container, value '4' is not
         for (int j = 3; j <= 4; ++j) {
             TestFindPtrFoundValue<int*>(j, FindPtr(v, j));
@@ -191,7 +191,7 @@ Y_UNIT_TEST_SUITE(TAlgorithm) {
         int array[3] = {1, 2, 3};
         const int array_const[3] = {1, 2, 3};
 
-        //test (const, non-const) * (iterator, vector, array) * (found, not found) variants.
+        // test (const, non-const) * (iterator, vector, array) * (found, not found) variants.
         // search, that 2*2 == 4, but there is no value 'x' in array that (x*x == 3)
         for (int j = 3; j <= 4; ++j) {
             TestFindIfPtrFoundValue<int*>(j, FindIfPtr(v, [j](int i) { return i * i == j; }));
@@ -752,6 +752,18 @@ Y_UNIT_TEST_SUITE(TAlgorithm) {
         MinElementBy(empty, functor);
     }
 
+    Y_UNIT_TEST(MinMaxElementMovableKeys) {
+        const TString strings[] = {"one", "two", "three", "four"};
+        struct TMoveOnlyKey
+            : TString,
+              TMoveOnly {
+            using TString::TString;
+        };
+        auto keyFn = [](TString s) { return TMoveOnlyKey{std::move(s)}; };
+        UNIT_ASSERT_STRINGS_EQUAL(*MaxElementBy(strings, keyFn), "two");
+        UNIT_ASSERT_STRINGS_EQUAL(*MinElementBy(strings, keyFn), "four");
+    }
+
     Y_UNIT_TEST(TestApplyToMany) {
         int res = 0;
         ApplyToMany([&res](auto v) { res += v; }, 1, 2, 3, 4, 5);
@@ -903,4 +915,4 @@ Y_UNIT_TEST_SUITE(TAlgorithm) {
         std::vector<int> v = {1, 2, 777};
         UNIT_ASSERT_VALUES_EQUAL(TString("begin;1;2;777"), Accumulate(v, TString("begin"), [](auto&& a, auto& b) { return a + ";" + ToString(b); }));
     }
-}
+} // Y_UNIT_TEST_SUITE(TAlgorithm)
diff --git a/util/generic/array_ref.h b/util/generic/array_ref.h
index 83d225c6ff7..fd8011b2300 100644
--- a/util/generic/array_ref.h
+++ b/util/generic/array_ref.h
@@ -1,10 +1,12 @@
 #pragma once
 
+#include <util/generic/iterator.h>
 #include <util/generic/yexception.h>
 
 #include <algorithm>
 #include <initializer_list>
 #include <iterator>
+#include <type_traits>
 
 /**
  * `TArrayRef` works pretty much like `std::span` with dynamic extent, presenting
@@ -41,43 +43,54 @@ class TArrayRef {
     {
     }
 
-    constexpr inline TArrayRef(T* data, size_t len) noexcept
+    constexpr inline TArrayRef(T* data Y_LIFETIME_BOUND, size_t len) noexcept
         : T_(data)
         , S_(len)
     {
     }
 
-    constexpr inline TArrayRef(T* begin, T* end) noexcept
+    template <class TT, typename = std::enable_if_t<std::is_convertible_v<TT*, T*>>>
+    constexpr inline TArrayRef(TT* data Y_LIFETIME_BOUND, size_t len) noexcept
+        : TArrayRef(static_cast<T*>(data), len)
+    {
+        static_assert(
+            sizeof(TT) == sizeof(T),
+            "Attempt to create TArrayRef from an array of elements of a derived class with a different size");
+    }
+
+    constexpr inline TArrayRef(T* begin Y_LIFETIME_BOUND, T* end Y_LIFETIME_BOUND) noexcept
         : T_(begin)
-        , S_(end - begin)
+        , S_(NonNegativeDistance(begin, end))
     {
     }
 
-    constexpr inline TArrayRef(std::initializer_list<T> list) noexcept
+    template <class TT, typename = std::enable_if_t<std::is_convertible_v<TT*, T*>>>
+    constexpr inline TArrayRef(TT* begin Y_LIFETIME_BOUND, TT* end Y_LIFETIME_BOUND) noexcept
+        : TArrayRef(begin, NonNegativeDistance(begin, end))
+    {
+    }
+
+    constexpr inline TArrayRef(std::initializer_list<T> list Y_LIFETIME_BOUND) noexcept
         : T_(list.begin())
         , S_(list.size())
     {
     }
 
-    template <class Container>
-    constexpr inline TArrayRef(Container&& container, decltype(std::declval<T*&>() = container.data(), nullptr) = nullptr) noexcept
-        : T_(container.data())
-        , S_(container.size())
+    template <class Container, typename = std::enable_if_t<std::is_convertible_v<decltype(std::declval<Container>().data()), T*>>>
+    constexpr inline TArrayRef(Container&& container) noexcept
+        : TArrayRef(container.data(), container.size())
     {
-        static_assert(
-            sizeof(decltype(*container.data())) == sizeof(T),
-            "Attempt to create TArrayRef from a container of elements with a different size");
     }
 
     template <size_t N>
-    constexpr inline TArrayRef(T (&array)[N]) noexcept
+    constexpr inline TArrayRef(T (&array Y_LIFETIME_BOUND)[N]) noexcept
         : T_(array)
         , S_(N)
     {
     }
 
     template <class TT, typename = std::enable_if_t<std::is_same<std::remove_const_t<T>, std::remove_const_t<TT>>::value>>
-    bool operator==(const TArrayRef<TT>& other) const noexcept {
+    bool operator==(const TArrayRef<TT>& other) const {
         return (S_ == other.size()) && std::equal(begin(), end(), other.begin());
     }
 
@@ -130,6 +143,8 @@ class TArrayRef {
     }
 
     constexpr inline reference front() const noexcept {
+        Y_ASSERT(S_ > 0);
+
         return *T_;
     }
 
@@ -178,24 +193,39 @@ class TArrayRef {
     }
 
     /**
-     * Obtains a ref that is a view over the `count` elements of this TArrayRef starting at `offset`.
+     * Obtains a ref that is a view over the elements of this TArrayRef starting at `offset`.
      *
-     * The behavior is undefined in either offset or count is out of range.
+     * The behavior is undefined if `offset` is greater than the size of this TArrayRef.
      */
     TArrayRef subspan(size_t offset) const {
         Y_ASSERT(offset <= size());
         return TArrayRef(data() + offset, size() - offset);
     }
 
+    /**
+     * Obtains a ref that is a view over the `count` elements of this TArrayRef starting at `offset`.
+     *
+     * The behavior is undefined if `offset` + `count` is greater than the size of this TArrayRef.
+     */
     TArrayRef subspan(size_t offset, size_t count) const {
         Y_ASSERT(offset + count <= size());
         return TArrayRef(data() + offset, count);
     }
 
+    /**
+     * Obtains a ref that is a view over the elements of this TArrayRef starting at `offset`.
+     *
+     * The behavior is undefined if `offset` is greater than the size of this TArrayRef.
+     */
     TArrayRef Slice(size_t offset) const {
         return subspan(offset);
     }
 
+    /**
+     * Obtains a ref that is a view over the `size` elements of this TArrayRef starting at `offset`.
+     *
+     * The behavior is undefined if `offset` + `size` is greater than the size of this TArrayRef.
+     */
     TArrayRef Slice(size_t offset, size_t size) const {
         return subspan(offset, size);
     }
@@ -207,7 +237,7 @@ class TArrayRef {
      *
      * DEPRECATED. DO NOT USE.
      */
-    TArrayRef SubRegion(size_t offset, size_t size) const {
+    TArrayRef SubRegion(size_t offset, size_t size) const noexcept {
         if (size == 0 || offset >= S_) {
             return TArrayRef();
         }
@@ -219,6 +249,7 @@ class TArrayRef {
         return TArrayRef(T_ + offset, size);
     }
 
+    // DEPRECATED. DO NOT USE.
     constexpr inline yssize_t ysize() const noexcept {
         return static_cast<yssize_t>(this->size());
     }
@@ -234,7 +265,7 @@ class TArrayRef {
  * Named as its std counterparts, std::as_bytes.
  */
 template <typename T>
-TArrayRef<const char> as_bytes(TArrayRef<T> arrayRef) noexcept {
+TArrayRef<const char> as_bytes(TArrayRef<T> arrayRef Y_LIFETIME_BOUND) noexcept {
     return TArrayRef<const char>(
         reinterpret_cast<const char*>(arrayRef.data()),
         arrayRef.size_bytes());
@@ -246,38 +277,38 @@ TArrayRef<const char> as_bytes(TArrayRef<T> arrayRef) noexcept {
  * Named as its std counterparts, std::as_writable_bytes.
  */
 template <typename T>
-TArrayRef<char> as_writable_bytes(TArrayRef<T> arrayRef) noexcept {
+TArrayRef<char> as_writable_bytes(TArrayRef<T> arrayRef Y_LIFETIME_BOUND) noexcept {
     return TArrayRef<char>(
         reinterpret_cast<char*>(arrayRef.data()),
         arrayRef.size_bytes());
 }
 
 template <class Range>
-constexpr TArrayRef<const typename Range::value_type> MakeArrayRef(const Range& range) {
+constexpr TArrayRef<const typename Range::value_type> MakeArrayRef(const Range& range) noexcept {
     return TArrayRef<const typename Range::value_type>(range);
 }
 
 template <class Range>
-constexpr TArrayRef<typename Range::value_type> MakeArrayRef(Range& range) {
+constexpr TArrayRef<typename Range::value_type> MakeArrayRef(Range& range) noexcept {
     return TArrayRef<typename Range::value_type>(range);
 }
 
 template <class Range>
-constexpr TArrayRef<const typename Range::value_type> MakeConstArrayRef(const Range& range) {
+constexpr TArrayRef<const typename Range::value_type> MakeConstArrayRef(const Range& range) noexcept {
     return TArrayRef<const typename Range::value_type>(range);
 }
 
 template <class Range>
-constexpr TArrayRef<const typename Range::value_type> MakeConstArrayRef(Range& range) {
+constexpr TArrayRef<const typename Range::value_type> MakeConstArrayRef(Range& range) noexcept {
     return TArrayRef<const typename Range::value_type>(range);
 }
 
 template <class T>
-constexpr TArrayRef<T> MakeArrayRef(T* data, size_t size) {
+constexpr TArrayRef<T> MakeArrayRef(T* data Y_LIFETIME_BOUND, size_t size) noexcept {
     return TArrayRef<T>(data, size);
 }
 
 template <class T>
-constexpr TArrayRef<T> MakeArrayRef(T* begin, T* end) {
+constexpr TArrayRef<T> MakeArrayRef(T* begin Y_LIFETIME_BOUND, T* end Y_LIFETIME_BOUND) noexcept {
     return TArrayRef<T>(begin, end);
 }
diff --git a/util/generic/array_ref_ut.cpp b/util/generic/array_ref_ut.cpp
index 4c8eaf7135a..cebf4968889 100644
--- a/util/generic/array_ref_ut.cpp
+++ b/util/generic/array_ref_ut.cpp
@@ -24,6 +24,46 @@ Y_UNIT_TEST_SUITE(TestArrayRef) {
         UNIT_ASSERT_VALUES_EQUAL(constRef[0], 100);
     }
 
+    // The following commented code should cause compilation errors
+    /*
+        struct TBase {
+            int X;
+        };
+
+        struct TDerived : public TBase {
+            int Y;
+        };
+
+        Y_UNIT_TEST(TestConstructorFromPtrSizeNonCompile) {
+            TDerived x[] = {{{10}, 1}, {{20}, 2}, {{30}, 3}};
+            TArrayRef<TBase> ref(x, 3);
+
+            TArrayRef<const TBase> constRef(x, 3);
+        }
+
+        Y_UNIT_TEST(TestConstructorFromPtrsNonCompile) {
+            TDerived x[] = {{{10}, 1}, {{20}, 2}, {{30}, 3}};
+            TArrayRef<TBase> ref(std::begin(x), std::end(x));
+
+            TArrayRef<const TBase> constRef(std::begin(x), std::end(x));
+        }
+
+
+        Y_UNIT_TEST(TestConstructorFromUnrelatedPtrSizeNonCompile) {
+            float x[] = {10.0f, 20.0f, 30.0f};
+            TArrayRef<i32> ref(x, std::size(x));
+
+            TArrayRef<const i32> constRef(x, std::size(x));
+        }
+
+        Y_UNIT_TEST(TestConstructorFromUnrelatedPtrsNonCompile) {
+            float x[] = {10.0f, 20.0f, 30.0f};
+            TArrayRef<i32> ref(std::begin(x), std::end(x));
+
+            TArrayRef<const i32> constRef(std::begin(x), std::end(x));
+        }
+    */
+
     Y_UNIT_TEST(TestAccessingElements) {
         int a[]{1, 2, 3};
         TArrayRef<int> ref(a);
@@ -34,7 +74,7 @@ Y_UNIT_TEST_SUITE(TestArrayRef) {
         ref[0] = 5;
         UNIT_ASSERT_VALUES_EQUAL(a[0], 5);
 
-        //FIXME: size checks are implemented via Y_ASSERT, hence there is no way to test them
+        // FIXME: size checks are implemented via Y_ASSERT, hence there is no way to test them
     }
 
     Y_UNIT_TEST(TestFrontBack) {
@@ -165,7 +205,7 @@ Y_UNIT_TEST_SUITE(TestArrayRef) {
 
         TArrayRef<int> bSubRef(b, size - 1);
 
-        //Testing if operator== compares values, not pointers
+        // Testing if operator== compares values, not pointers
         UNIT_ASSERT_EQUAL(cRef, bSubRef);
     }
 
@@ -210,7 +250,7 @@ Y_UNIT_TEST_SUITE(TestArrayRef) {
         UNIT_ASSERT_VALUES_EQUAL(s1.size(), 1);
         UNIT_ASSERT_VALUES_EQUAL(s1[0], 3);
 
-        //FIXME: size checks are implemented via Y_ASSERT, hence there is no way to test them
+        // FIXME: size checks are implemented via Y_ASSERT, hence there is no way to test them
     }
 
     Y_UNIT_TEST(SubRegion) {
@@ -240,8 +280,8 @@ Y_UNIT_TEST_SUITE(TestArrayRef) {
             bytesRef,
             MakeArrayRef(std::vector<char>{0x01, 0x00, 0x02, 0x00, 0x03, 0x00}));
 
-        //should not compile
-        //as_writable_bytes(constRef);
+        // should not compile
+        // as_writable_bytes(constRef);
     }
 
     Y_UNIT_TEST(TestAsWritableBytes) {
@@ -319,4 +359,4 @@ Y_UNIT_TEST_SUITE(TestArrayRef) {
         const TVector<int> constData;
         Foo(MakeConstArrayRef(constData));
     }
-}
+} // Y_UNIT_TEST_SUITE(TestArrayRef)
diff --git a/util/generic/array_size.h b/util/generic/array_size.h
index 4d5f18ce631..16ecc036462 100644
--- a/util/generic/array_size.h
+++ b/util/generic/array_size.h
@@ -19,6 +19,6 @@ namespace NArraySizePrivate {
             Result = N
         };
     };
-}
+} // namespace NArraySizePrivate
 
 #define Y_ARRAY_SIZE(arr) ((size_t)::NArraySizePrivate::TArraySize<decltype(arr)>::Result)
diff --git a/util/generic/array_size_ut.cpp b/util/generic/array_size_ut.cpp
index 13f45903c51..14283c16102 100644
--- a/util/generic/array_size_ut.cpp
+++ b/util/generic/array_size_ut.cpp
@@ -19,4 +19,4 @@ Y_UNIT_TEST_SUITE(ArraySizeTest) {
 
         UNIT_ASSERT_VALUES_EQUAL(Y_ARRAY_SIZE(x), 1);
     }
-}
+} // Y_UNIT_TEST_SUITE(ArraySizeTest)
diff --git a/util/generic/bitmap.h b/util/generic/bitmap.h
index dfac88e4b8d..e687cdf7519 100644
--- a/util/generic/bitmap.h
+++ b/util/generic/bitmap.h
@@ -13,7 +13,7 @@
 #include <util/ysaveload.h>
 
 namespace NBitMapPrivate {
-    // Returns number of bits set; result is in most significatnt byte
+    // Returns the number of bits set; result is in the most significant byte
     inline ui64 ByteSums(ui64 x) {
         ui64 byteSums = x - ((x & 0xAAAAAAAAAAAAAAAAULL) >> 1);
 
@@ -199,7 +199,7 @@ namespace NBitMapPrivate {
     };
 
     // Dynamically expanded storage.
-    // It uses "on stack" realization with no allocation for one chunk spaces
+    // It uses the "on stack" implementation with no allocation for one chunk spaces
     template <typename TChunkType>
     struct TDynamicStorage {
         using TChunk = TChunkType;
@@ -294,7 +294,7 @@ namespace NBitMapPrivate {
         static constexpr size_t Value = 0;
     };
 
-}
+} // namespace NBitMapPrivate
 
 template <size_t BitCount, typename TChunkType>
 struct TFixedBitMapTraits {
@@ -327,7 +327,7 @@ class TBitMapOps {
 
     using TStorage = typename TTraits::TStorage;
 
-    // The smallest unsigned type, which can be used in bit ops
+    // The smallest unsigned type that can be used in bit ops
     using TIntType = std::conditional_t<sizeof(TChunk) < sizeof(unsigned int), unsigned int, TChunk>;
 
     TStorage Mask;
@@ -350,19 +350,21 @@ class TBitMapOps {
         ~TReference() = default;
 
         Y_FORCE_INLINE TReference& operator=(bool val) {
-            if (val)
+            if (val) {
                 *Chunk |= static_cast<TChunk>(1) << Offset;
-            else
+            } else {
                 *Chunk &= ~(static_cast<TChunk>(1) << Offset);
+            }
 
             return *this;
         }
 
         Y_FORCE_INLINE TReference& operator=(const TReference& ref) {
-            if (ref)
+            if (ref) {
                 *Chunk |= static_cast<TChunk>(1) << Offset;
-            else
+            } else {
                 *Chunk &= ~(static_cast<TChunk>(1) << Offset);
+            }
 
             return *this;
         }
@@ -407,8 +409,9 @@ class TBitMapOps {
             TChunk updateMask = FullChunk << bitOffset;
             if (chunk == endChunk) {
                 updateMask ^= FullChunk << endBitOffset;
-                if (!updateMask)
+                if (!updateMask) {
                     break;
+                }
             }
             Mask.Data[chunk] = TUpdateOp::Op(Mask.Data[chunk], updateMask);
             bitOffset = 0;
@@ -570,19 +573,21 @@ class TBitMapOps {
         static_assert(std::is_unsigned<TTo>::value, "expect std::is_unsigned<TTo>::value");
         to = 0;
         size_t chunkpos = pos >> DivCount;
-        if (chunkpos >= Mask.GetChunkCapacity())
+        if (chunkpos >= Mask.GetChunkCapacity()) {
             return;
+        }
         if ((pos & ModMask) == 0) {
-            if (sizeof(TChunk) >= sizeof(TTo))
+            if (sizeof(TChunk) >= sizeof(TTo)) {
                 to = (TTo)Mask.Data[chunkpos];
-            else //if (sizeof(TChunk) < sizeof(TTo))
+            } else { // if (sizeof(TChunk) < sizeof(TTo))
                 NBitMapPrivate::CopyData(&to, 1, Mask.Data + chunkpos, Min(((sizeof(TTo) * 8) >> DivCount), Mask.GetChunkCapacity() - chunkpos));
-        } else if ((pos & (sizeof(TTo) * 8 - 1)) == 0 && sizeof(TChunk) >= 2 * sizeof(TTo))
+            }
+        } else if ((pos & (sizeof(TTo) * 8 - 1)) == 0 && sizeof(TChunk) >= 2 * sizeof(TTo)) {
             to = (TTo)(Mask.Data[chunkpos] >> (pos & ModMask));
-        else {
+        } else {
             static constexpr size_t copyToSize = (sizeof(TChunk) >= sizeof(TTo)) ? (sizeof(TChunk) / sizeof(TTo)) + 2 : 3;
             TTo temp[copyToSize] = {0, 0};
-            //or use non defined by now TBitmap<copyToSize, TTo>::CopyData,RShift(pos & ModMask),Export(0,to)
+            // or use non defined by now TBitmap<copyToSize, TTo>::CopyData,RShift(pos & ModMask),Export(0,to)
             NBitMapPrivate::CopyData(temp, copyToSize, Mask.Data + chunkpos, Min((sizeof(TTo) / sizeof(TChunk)) + 1, Mask.GetChunkCapacity() - chunkpos));
             to = (temp[0] >> (pos & ModMask)) | (temp[1] << (8 * sizeof(TTo) - (pos & ModMask)));
         }
@@ -602,7 +607,7 @@ class TBitMapOps {
         return RShift(1), val;
     }
 
-    // Clear entire bitmap. Current capacity is kept unchanged
+    // Clear the entire bitmap. Current capacity is kept unchanged
     Y_FORCE_INLINE TThis& Clear() {
         for (size_t i = 0; i < Mask.GetChunkCapacity(); ++i) {
             Mask.Data[i] = 0;
@@ -621,17 +626,20 @@ class TBitMapOps {
 
     Y_FORCE_INLINE size_t ValueBitCount() const {
         size_t nonZeroChunk = Mask.GetChunkCapacity() - 1;
-        while (nonZeroChunk != 0 && !Mask.Data[nonZeroChunk])
+        while (nonZeroChunk != 0 && !Mask.Data[nonZeroChunk]) {
             --nonZeroChunk;
+        }
         return nonZeroChunk || Mask.Data[nonZeroChunk]
                    ? nonZeroChunk * BitsPerChunk + GetValueBitCount(TIntType(Mask.Data[nonZeroChunk]))
                    : 0;
     }
 
     Y_PURE_FUNCTION Y_FORCE_INLINE bool Empty() const {
-        for (size_t i = 0; i < Mask.GetChunkCapacity(); ++i)
-            if (Mask.Data[i])
+        for (size_t i = 0; i < Mask.GetChunkCapacity(); ++i) {
+            if (Mask.Data[i]) {
                 return false;
+            }
+        }
         return true;
     }
 
@@ -677,13 +685,15 @@ class TBitMapOps {
     }
 
     TThis& And(const TThis& bitmap) {
-        // Don't expand capacity here, because resulting bits in positions,
-        // which are greater then size of one of these bitmaps, will be zero
-        for (size_t i = 0; i < Min(bitmap.Mask.GetChunkCapacity(), Mask.GetChunkCapacity()); ++i)
+        // Don't expand capacity here, because resulting bits in positions
+        // that are greater than the size of one of these bitmaps will be zero
+        for (size_t i = 0; i < Min(bitmap.Mask.GetChunkCapacity(), Mask.GetChunkCapacity()); ++i) {
             Mask.Data[i] &= bitmap.Mask.Data[i];
-        // Clear bits if current bitmap size is greater than AND-ed one
-        for (size_t i = bitmap.Mask.GetChunkCapacity(); i < Mask.GetChunkCapacity(); ++i)
+        }
+        // Clear bits if the current bitmap size is greater than AND-ed one
+        for (size_t i = bitmap.Mask.GetChunkCapacity(); i < Mask.GetChunkCapacity(); ++i) {
             Mask.Data[i] = 0;
+        }
         return *this;
     }
 
@@ -694,8 +704,9 @@ class TBitMapOps {
 
     Y_FORCE_INLINE TThis& And(const TChunk& val) {
         Mask.Data[0] &= val;
-        for (size_t i = 1; i < Mask.GetChunkCapacity(); ++i)
+        for (size_t i = 1; i < Mask.GetChunkCapacity(); ++i) {
             Mask.Data[i] = 0;
+        }
         return *this;
     }
 
@@ -704,8 +715,9 @@ class TBitMapOps {
         if (valueBitCount) {
             // Memory optimization: expand size only for non-zero bits
             Reserve(valueBitCount);
-            for (size_t i = 0; i < Min(bitmap.Mask.GetChunkCapacity(), Mask.GetChunkCapacity()); ++i)
+            for (size_t i = 0; i < Min(bitmap.Mask.GetChunkCapacity(), Mask.GetChunkCapacity()); ++i) {
                 Mask.Data[i] |= bitmap.Mask.Data[i];
+            }
         }
         return *this;
     }
@@ -723,8 +735,9 @@ class TBitMapOps {
 
     TThis& Xor(const TThis& bitmap) {
         Reserve(bitmap.Size());
-        for (size_t i = 0; i < bitmap.Mask.GetChunkCapacity(); ++i)
+        for (size_t i = 0; i < bitmap.Mask.GetChunkCapacity(); ++i) {
             Mask.Data[i] ^= bitmap.Mask.Data[i];
+        }
         return *this;
     }
 
@@ -740,8 +753,9 @@ class TBitMapOps {
     }
 
     TThis& SetDifference(const TThis& bitmap) {
-        for (size_t i = 0; i < Min(bitmap.Mask.GetChunkCapacity(), Mask.GetChunkCapacity()); ++i)
+        for (size_t i = 0; i < Min(bitmap.Mask.GetChunkCapacity(), Mask.GetChunkCapacity()); ++i) {
             Mask.Data[i] &= ~bitmap.Mask.Data[i];
+        }
         return *this;
     }
 
@@ -756,8 +770,9 @@ class TBitMapOps {
     }
 
     Y_FORCE_INLINE TThis& Flip() {
-        for (size_t i = 0; i < Mask.GetChunkCapacity(); ++i)
+        for (size_t i = 0; i < Mask.GetChunkCapacity(); ++i) {
             Mask.Data[i] = ~Mask.Data[i];
+        }
         Mask.Sanitize();
         return *this;
     }
@@ -765,13 +780,13 @@ class TBitMapOps {
     TThis& LShift(size_t shift) {
         if (shift != 0) {
             const size_t valueBitCount = ValueBitCount();
-            // Do nothing for empty bitmap
+            // Do nothing for the empty bitmap
             if (valueBitCount != 0) {
                 const size_t eshift = shift / BitsPerChunk;
                 const size_t offset = shift % BitsPerChunk;
                 const size_t subOffset = BitsPerChunk - offset;
 
-                // Don't verify expand result, so l-shift of fixed bitmap will work in the same way as for unsigned integer.
+                // Don't verify expand result, so l-shift of a fixed bitmap will work in the same way as for an unsigned integer.
                 Mask.ExpandBitSize(valueBitCount + shift);
 
                 if (offset == 0) {
@@ -779,13 +794,16 @@ class TBitMapOps {
                         Mask.Data[i] = Mask.Data[i - eshift];
                     }
                 } else {
-                    for (size_t i = Mask.GetChunkCapacity() - 1; i > eshift; --i)
+                    for (size_t i = Mask.GetChunkCapacity() - 1; i > eshift; --i) {
                         Mask.Data[i] = (Mask.Data[i - eshift] << offset) | (Mask.Data[i - eshift - 1] >> subOffset);
-                    if (eshift < Mask.GetChunkCapacity())
+                    }
+                    if (eshift < Mask.GetChunkCapacity()) {
                         Mask.Data[eshift] = Mask.Data[0] << offset;
+                    }
                 }
-                for (size_t i = 0; i < Min(eshift, Mask.GetChunkCapacity()); ++i)
+                for (size_t i = 0; i < Min(eshift, Mask.GetChunkCapacity()); ++i) {
                     Mask.Data[i] = 0;
+                }
 
                 // Cleanup extra high bits in the storage
                 Mask.Sanitize();
@@ -810,24 +828,27 @@ class TBitMapOps {
                     }
                 } else {
                     const size_t subOffset = BitsPerChunk - offset;
-                    for (size_t i = 0; i < limit; ++i)
+                    for (size_t i = 0; i < limit; ++i) {
                         Mask.Data[i] = (Mask.Data[i + eshift] >> offset) | (Mask.Data[i + eshift + 1] << subOffset);
+                    }
                     Mask.Data[limit] = Mask.Data[Mask.GetChunkCapacity() - 1] >> offset;
                 }
 
-                for (size_t i = limit + 1; i < Mask.GetChunkCapacity(); ++i)
+                for (size_t i = limit + 1; i < Mask.GetChunkCapacity(); ++i) {
                     Mask.Data[i] = 0;
+                }
             }
         }
         return *this;
     }
 
     // Applies bitmap at the specified offset using OR operator.
-    // This method is optimized combination of Or() and LShift(), which allows reducing memory allocation
+    // This method is an optimized combination of Or() and LShift(), which allows reducing memory allocation
     // when combining long dynamic bitmaps.
     TThis& Or(const TThis& bitmap, size_t offset) {
-        if (0 == offset)
+        if (0 == offset) {
             return Or(bitmap);
+        }
 
         const size_t otherValueBitCount = bitmap.ValueBitCount();
         // Continue only if OR-ed bitmap have non-zero bits
@@ -848,8 +869,9 @@ class TBitMapOps {
                 for (; i < Min(bitmap.Mask.GetChunkCapacity() + chunkShift, Mask.GetChunkCapacity()); ++i) {
                     Mask.Data[i] |= (bitmap.Mask.Data[i - chunkShift] << subShift) | (bitmap.Mask.Data[i - chunkShift - 1] >> subOffset);
                 }
-                if (i < Mask.GetChunkCapacity())
+                if (i < Mask.GetChunkCapacity()) {
                     Mask.Data[i] |= bitmap.Mask.Data[i - chunkShift - 1] >> subOffset;
+                }
             }
         }
 
@@ -859,19 +881,22 @@ class TBitMapOps {
     bool Equal(const TThis& bitmap) const {
         if (Mask.GetChunkCapacity() > bitmap.Mask.GetChunkCapacity()) {
             for (size_t i = bitmap.Mask.GetChunkCapacity(); i < Mask.GetChunkCapacity(); ++i) {
-                if (0 != Mask.Data[i])
+                if (0 != Mask.Data[i]) {
                     return false;
+                }
             }
         } else if (Mask.GetChunkCapacity() < bitmap.Mask.GetChunkCapacity()) {
             for (size_t i = Mask.GetChunkCapacity(); i < bitmap.Mask.GetChunkCapacity(); ++i) {
-                if (0 != bitmap.Mask.Data[i])
+                if (0 != bitmap.Mask.Data[i]) {
                     return false;
+                }
             }
         }
         size_t size = Min(Mask.GetChunkCapacity(), bitmap.Mask.GetChunkCapacity());
         for (size_t i = 0; i < size; ++i) {
-            if (Mask.Data[i] != bitmap.Mask.Data[i])
+            if (Mask.Data[i] != bitmap.Mask.Data[i]) {
                 return false;
+            }
         }
         return true;
     }
@@ -884,18 +909,21 @@ class TBitMapOps {
     int Compare(const TThis& bitmap) const {
         size_t size = Min(Mask.GetChunkCapacity(), bitmap.Mask.GetChunkCapacity());
         int res = ::memcmp(Mask.Data, bitmap.Mask.Data, size * sizeof(TChunk));
-        if (0 != res || Mask.GetChunkCapacity() == bitmap.Mask.GetChunkCapacity())
+        if (0 != res || Mask.GetChunkCapacity() == bitmap.Mask.GetChunkCapacity()) {
             return res;
+        }
 
         if (Mask.GetChunkCapacity() > bitmap.Mask.GetChunkCapacity()) {
             for (size_t i = bitmap.Mask.GetChunkCapacity(); i < Mask.GetChunkCapacity(); ++i) {
-                if (0 != Mask.Data[i])
+                if (0 != Mask.Data[i]) {
                     return 1;
+                }
             }
         } else {
             for (size_t i = Mask.GetChunkCapacity(); i < bitmap.Mask.GetChunkCapacity(); ++i) {
-                if (0 != bitmap.Mask.Data[i])
+                if (0 != bitmap.Mask.Data[i]) {
                     return -1;
+                }
             }
         }
         return 0;
@@ -953,8 +981,9 @@ class TBitMapOps {
 
     Y_FORCE_INLINE size_t Count() const {
         size_t count = 0;
-        for (size_t i = 0; i < Mask.GetChunkCapacity(); ++i)
+        for (size_t i = 0; i < Mask.GetChunkCapacity(); ++i) {
             count += ::NBitMapPrivate::CountBitsPrivate(Mask.Data[i]);
+        }
         return count;
     }
 
diff --git a/util/generic/bitmap_ut.cpp b/util/generic/bitmap_ut.cpp
index 087d34a8dcc..e7b4ecba7b1 100644
--- a/util/generic/bitmap_ut.cpp
+++ b/util/generic/bitmap_ut.cpp
@@ -594,4 +594,4 @@ Y_UNIT_TEST_SUITE(TBitMapTest) {
             UNIT_ASSERT_VALUES_EQUAL(bm.Get(k), k >= 1 && k < 2048 ? 0 : 1);
         }
     }
-}
+} // Y_UNIT_TEST_SUITE(TBitMapTest)
diff --git a/util/generic/bitops.cpp b/util/generic/bitops.cpp
index db5667a21f6..e719b160402 100644
--- a/util/generic/bitops.cpp
+++ b/util/generic/bitops.cpp
@@ -137,5 +137,5 @@ namespace NBitOps {
             ~0x7FFFFFFFFFFFFFFFULL,
             ~0xFFFFFFFFFFFFFFFFULL,
         };
-    }
-}
+    } // namespace NPrivate
+} // namespace NBitOps
diff --git a/util/generic/bitops.h b/util/generic/bitops.h
index 2db15fc59b6..601daf7a309 100644
--- a/util/generic/bitops.h
+++ b/util/generic/bitops.h
@@ -197,8 +197,8 @@ namespace NBitOps {
         }
     #endif
 #endif
-    }
-}
+    } // namespace NPrivate
+} // namespace NBitOps
 
 /**
  * Computes the next power of 2 higher or equal to the integer parameter `t`.
@@ -276,13 +276,16 @@ Y_FORCE_INLINE ui64 MostSignificantBit(ui64 v) {
     ui64 res = v ? (63 - __builtin_clzll(v)) : 0;
 #elif defined(_MSC_VER) && defined(_64_)
     unsigned long res = 0;
-    if (v)
+    if (v) {
         _BitScanReverse64(&res, v);
+    }
 #else
     ui64 res = 0;
-    if (v)
-        while (v >>= 1)
+    if (v) {
+        while (v >>= 1) {
             ++res;
+        }
+    }
 #endif
     return res;
 }
@@ -295,8 +298,9 @@ Y_FORCE_INLINE ui64 LeastSignificantBit(ui64 v) {
     ui64 res = v ? __builtin_ffsll(v) - 1 : 0;
 #elif defined(_MSC_VER) && defined(_64_)
     unsigned long res = 0;
-    if (v)
+    if (v) {
         _BitScanForward64(&res, v);
+    }
 #else
     ui64 res = 0;
     if (v) {
diff --git a/util/generic/bt_exception.cpp b/util/generic/bt_exception.cpp
deleted file mode 100644
index 609870c4c00..00000000000
--- a/util/generic/bt_exception.cpp
+++ /dev/null
@@ -1 +0,0 @@
-#include "bt_exception.h"
diff --git a/util/generic/bt_exception.h b/util/generic/bt_exception.h
deleted file mode 100644
index 018d2bc89a1..00000000000
--- a/util/generic/bt_exception.h
+++ /dev/null
@@ -1,24 +0,0 @@
-#pragma once
-
-#include <utility>
-#include "yexception.h"
-
-#include <util/system/backtrace.h>
-
-template <class T>
-class TWithBackTrace: public T {
-public:
-    template <typename... Args>
-    inline TWithBackTrace(Args&&... args)
-        : T(std::forward<Args>(args)...)
-    {
-        BT_.Capture();
-    }
-
-    const TBackTrace* BackTrace() const noexcept override {
-        return &BT_;
-    }
-
-private:
-    TBackTrace BT_;
-};
diff --git a/util/generic/buffer.cpp b/util/generic/buffer.cpp
index b92697e1d00..2ca44b785d1 100644
--- a/util/generic/buffer.cpp
+++ b/util/generic/buffer.cpp
@@ -97,3 +97,8 @@ void TBuffer::AsString(TString& s) {
     s.assign(Data(), Size());
     Clear();
 }
+
+void TBuffer::AsString(std::string& s) {
+    s.assign(Data(), Size());
+    Clear();
+}
diff --git a/util/generic/buffer.h b/util/generic/buffer.h
index a5efe398ce7..653e5fa2a05 100644
--- a/util/generic/buffer.h
+++ b/util/generic/buffer.h
@@ -1,5 +1,6 @@
 #pragma once
 
+#include "iterator.h"
 #include "utility.h"
 
 #include <util/generic/fwd.h>
@@ -57,7 +58,7 @@ class TBuffer {
     }
 
     inline void Assign(const char* b, const char* e) {
-        Assign(b, e - b);
+        Assign(b, NonNegativeDistance(b, e));
     }
 
     inline char* Data() noexcept {
@@ -96,7 +97,7 @@ class TBuffer {
     void Append(const char* buf, size_t len);
 
     inline void Append(const char* b, const char* e) {
-        Append(b, e - b);
+        Append(b, NonNegativeDistance(b, e));
     }
 
     inline void Append(char ch) {
@@ -132,7 +133,7 @@ class TBuffer {
     }
 
     inline void Proceed(size_t pos) {
-        //Y_ASSERT(pos <= Len_); // see discussion in REVIEW:29021
+        // Y_ASSERT(pos <= Len_); // see discussion in REVIEW:29021
         Resize(pos);
     }
 
@@ -204,6 +205,7 @@ class TBuffer {
      * after this call buffer becomes empty
      */
     void AsString(TString& s);
+    void AsString(std::string& s);
 
     /*
      * iterator-like interface
diff --git a/util/generic/buffer_ut.cpp b/util/generic/buffer_ut.cpp
index 437d7122ec2..faaa8c5b248 100644
--- a/util/generic/buffer_ut.cpp
+++ b/util/generic/buffer_ut.cpp
@@ -202,4 +202,22 @@ Y_UNIT_TEST(TestSpeed) {
         UNIT_ASSERT(buf2 == buf1);
     }
 
-}
+    Y_UNIT_TEST(AsString) {
+        const TStringBuf originalString = "abc";
+
+        {
+            TBuffer buf(originalString.data(), originalString.size());
+            TString str;
+            buf.AsString(str);
+            UNIT_ASSERT_VALUES_EQUAL(str, originalString);
+        }
+
+        {
+            TBuffer buf(originalString.data(), originalString.size());
+            std::string str;
+            buf.AsString(str);
+            UNIT_ASSERT_VALUES_EQUAL(str, originalString);
+        }
+    }
+
+} // Y_UNIT_TEST_SUITE(TBufferTest)
diff --git a/util/generic/cast.h b/util/generic/cast.h
index f827bde5cb4..69c9471be82 100644
--- a/util/generic/cast.h
+++ b/util/generic/cast.h
@@ -32,7 +32,7 @@ namespace NPrivate {
     static T DynamicCast(F f) {
         return dynamic_cast<T>(f);
     }
-}
+} // namespace NPrivate
 
 /*
  * replacement for dynamic_cast(dynamic_cast in debug mode, else static_cast)
@@ -104,7 +104,15 @@ namespace NPrivate {
                                        ((std::is_signed<TSmallInt>::value == std::is_signed<TLargeInt>::value && sizeof(TSmallInt) >= sizeof(TLargeInt)) ||
                                         (std::is_signed<TSmallInt>::value && sizeof(TSmallInt) > sizeof(TLargeInt)));
     };
-}
+
+    template <class TLargeInt>
+    [[noreturn]] void ThrowBadIntegerCast(const TLargeInt largeInt, const std::type_info& smallIntType, const TStringBuf reason) {
+        ythrow TBadCastException() << "Conversion '" << TypeName<TLargeInt>() << '{' << largeInt << "}' to '"
+                                   << TypeName(smallIntType)
+                                   << "', " << reason;
+    }
+
+} // namespace NPrivate
 
 template <class TSmallInt, class TLargeInt>
 constexpr std::enable_if_t<::NPrivate::TSafelyConvertible<TSmallInt, TLargeInt>::Result, TSmallInt> SafeIntegerCast(TLargeInt largeInt) noexcept {
@@ -116,27 +124,22 @@ inline std::enable_if_t<!::NPrivate::TSafelyConvertible<TSmall, TLarge>::Result,
     using TSmallInt = ::NPrivate::TUnderlyingTypeOrSelf<TSmall>;
     using TLargeInt = ::NPrivate::TUnderlyingTypeOrSelf<TLarge>;
 
-    if (std::is_unsigned<TSmallInt>::value && std::is_signed<TLargeInt>::value) {
+    if constexpr (std::is_unsigned<TSmallInt>::value && std::is_signed<TLargeInt>::value) {
         if (IsNegative(largeInt)) {
-            ythrow TBadCastException() << "Conversion '" << TypeName<TLarge>() << '{' << TLargeInt(largeInt) << "}' to '"
-                                       << TypeName<TSmallInt>()
-                                       << "', negative value converted to unsigned";
+            ::NPrivate::ThrowBadIntegerCast(TLargeInt(largeInt), typeid(TSmallInt), "negative value converted to unsigned"sv);
         }
     }
 
     TSmallInt smallInt = TSmallInt(largeInt);
 
-    if (std::is_signed<TSmallInt>::value && std::is_unsigned<TLargeInt>::value) {
+    if constexpr (std::is_signed<TSmallInt>::value && std::is_unsigned<TLargeInt>::value) {
         if (IsNegative(smallInt)) {
-            ythrow TBadCastException() << "Conversion '" << TypeName<TLarge>() << '{' << TLargeInt(largeInt) << "}' to '"
-                                       << TypeName<TSmallInt>()
-                                       << "', positive value converted to negative";
+            ::NPrivate::ThrowBadIntegerCast(TLargeInt(largeInt), typeid(TSmallInt), "positive value converted to negative"sv);
         }
     }
 
     if (TLargeInt(smallInt) != largeInt) {
-        ythrow TBadCastException() << "Conversion '" << TypeName<TLarge>() << '{' << TLargeInt(largeInt) << "}' to '"
-                                   << TypeName<TSmallInt>() << "', loss of data";
+        ::NPrivate::ThrowBadIntegerCast(TLargeInt(largeInt), typeid(TSmallInt), "loss of data"sv);
     }
 
     return static_cast<TSmall>(smallInt);
diff --git a/util/generic/deque.h b/util/generic/deque.h
index 2dabaf3177d..860b5964da7 100644
--- a/util/generic/deque.h
+++ b/util/generic/deque.h
@@ -15,6 +15,7 @@ class TDeque: public std::deque<T, TReboundAllocator<A, T>> {
 public:
     using TBase::TBase;
 
+    // DEPRECATED. DO NOT USE.
     inline yssize_t ysize() const noexcept {
         return (yssize_t)this->size();
     }
diff --git a/util/generic/deque_ut.cpp b/util/generic/deque_ut.cpp
index 38c421c7c79..3ede8dbc256 100644
--- a/util/generic/deque_ut.cpp
+++ b/util/generic/deque_ut.cpp
@@ -88,7 +88,7 @@ void TDequeTest::TestDeque1() {
     UNIT_ASSERT(d[1] == 9);
     UNIT_ASSERT(d[2] == 25);
 
-    //Some compile time tests:
+    // Some compile time tests:
     TDeque<int>::iterator dit = d.begin();
     TDeque<int>::const_iterator cdit(d.begin());
 
@@ -109,67 +109,67 @@ void TDequeTest::TestInsert() {
 
     TDeque<int>::iterator dit;
 
-    //Insertion before begin:
+    // Insertion before begin:
     dit = d.insert(d.begin(), 3);
     UNIT_ASSERT(dit != d.end());
     UNIT_ASSERT(*dit == 3);
     UNIT_ASSERT(d.size() == 4);
     UNIT_ASSERT(d[0] == 3);
 
-    //Insertion after begin:
+    // Insertion after begin:
     dit = d.insert(d.begin() + 1, 4);
     UNIT_ASSERT(dit != d.end());
     UNIT_ASSERT(*dit == 4);
     UNIT_ASSERT(d.size() == 5);
     UNIT_ASSERT(d[1] == 4);
 
-    //Insertion at end:
+    // Insertion at end:
     dit = d.insert(d.end(), 5);
     UNIT_ASSERT(dit != d.end());
     UNIT_ASSERT(*dit == 5);
     UNIT_ASSERT(d.size() == 6);
     UNIT_ASSERT(d[5] == 5);
 
-    //Insertion before last element:
+    // Insertion before last element:
     dit = d.insert(d.end() - 1, 6);
     UNIT_ASSERT(dit != d.end());
     UNIT_ASSERT(*dit == 6);
     UNIT_ASSERT(d.size() == 7);
     UNIT_ASSERT(d[5] == 6);
 
-    //Insertion of several elements before begin
+    // Insertion of several elements before begin
     d.insert(d.begin(), 2, 7);
     UNIT_ASSERT(d.size() == 9);
     UNIT_ASSERT(d[0] == 7);
     UNIT_ASSERT(d[1] == 7);
 
-    //Insertion of several elements after begin
-    //There is more elements to insert than elements before insertion position
+    // Insertion of several elements after begin
+    // There is more elements to insert than elements before insertion position
     d.insert(d.begin() + 1, 2, 8);
     UNIT_ASSERT(d.size() == 11);
     UNIT_ASSERT(d[1] == 8);
     UNIT_ASSERT(d[2] == 8);
 
-    //There is less elements to insert than elements before insertion position
+    // There is less elements to insert than elements before insertion position
     d.insert(d.begin() + 3, 2, 9);
     UNIT_ASSERT(d.size() == 13);
     UNIT_ASSERT(d[3] == 9);
     UNIT_ASSERT(d[4] == 9);
 
-    //Insertion of several elements at end:
+    // Insertion of several elements at end:
     d.insert(d.end(), 2, 10);
     UNIT_ASSERT(d.size() == 15);
     UNIT_ASSERT(d[14] == 10);
     UNIT_ASSERT(d[13] == 10);
 
-    //Insertion of several elements before last:
-    //There is more elements to insert than elements after insertion position
+    // Insertion of several elements before last:
+    // There is more elements to insert than elements after insertion position
     d.insert(d.end() - 1, 2, 11);
     UNIT_ASSERT(d.size() == 17);
     UNIT_ASSERT(d[15] == 11);
     UNIT_ASSERT(d[14] == 11);
 
-    //There is less elements to insert than elements after insertion position
+    // There is less elements to insert than elements after insertion position
     d.insert(d.end() - 3, 2, 12);
     UNIT_ASSERT(d.size() == 19);
     UNIT_ASSERT(d[15] == 12);
diff --git a/util/generic/enum_cast.cpp b/util/generic/enum_cast.cpp
new file mode 100644
index 00000000000..8db625ef440
--- /dev/null
+++ b/util/generic/enum_cast.cpp
@@ -0,0 +1,12 @@
+#include "enum_cast.h"
+
+#include <util/generic/yexception.h>
+#include <util/system/type_name.h>
+
+namespace NPrivate {
+
+    [[noreturn]] void OnSafeCastToEnumUnexpectedValue(const std::type_info& valueTypeInfo) {
+        ythrow TBadCastException() << "Unexpected enum " << TypeName(valueTypeInfo) << " value";
+    }
+
+} // namespace NPrivate
diff --git a/util/generic/enum_cast.h b/util/generic/enum_cast.h
new file mode 100644
index 00000000000..59dee47e889
--- /dev/null
+++ b/util/generic/enum_cast.h
@@ -0,0 +1,46 @@
+#pragma once
+
+#include <util/generic/cast.h>
+#include <util/generic/serialized_enum.h>
+
+#include <optional>
+#include <type_traits>
+#include <typeinfo>
+
+namespace NPrivate {
+
+    [[noreturn]] void OnSafeCastToEnumUnexpectedValue(const std::type_info& valueTypeInfo);
+
+} // namespace NPrivate
+
+/**
+ * Safely cast an integer value to the enum value.
+ * @throw yexception is case of unknown enum underlying type value
+ *
+ * @tparam TEnum     enum type
+ */
+template <typename TEnum, typename TInteger, typename = std::enable_if_t<std::is_enum_v<TEnum>>>
+TEnum SafeCastToEnum(TInteger integerValue) {
+    using TUnderlyingEnumType = std::underlying_type_t<TEnum>;
+
+    std::optional<TUnderlyingEnumType> value;
+    try {
+        value = SafeIntegerCast<TUnderlyingEnumType>(integerValue);
+    } catch (const TBadCastException&) {
+        // SafeIntegerCast throws TBadCastException when TInteger cannot be cast
+        // to TUnderlyingEnumType but the exception message is about integer
+        // value cast being unsafe.
+        // SafeCastToEnum must throw TBadCastException with its own exception
+        // message even if integer cast fails.
+    }
+
+    if (value.has_value()) {
+        for (TEnum enumValue : GetEnumAllValues<TEnum>()) {
+            if (static_cast<TUnderlyingEnumType>(enumValue) == *value) {
+                return enumValue;
+            }
+        }
+    }
+
+    NPrivate::OnSafeCastToEnumUnexpectedValue(typeid(TEnum));
+}
diff --git a/util/generic/enum_cast_ut.cpp b/util/generic/enum_cast_ut.cpp
new file mode 100644
index 00000000000..0b96235bcaf
--- /dev/null
+++ b/util/generic/enum_cast_ut.cpp
@@ -0,0 +1,49 @@
+#include "enum_cast.h"
+
+#include "enum_cast_ut.h"
+
+#include <library/cpp/testing/unittest/registar.h>
+
+Y_UNIT_TEST_SUITE(TestEnumCast) {
+    Y_UNIT_TEST(SafeCastToEnumTest) {
+        UNIT_ASSERT_VALUES_EQUAL(SafeCastToEnum<EIntEnum>(0), EIntEnum::Zero);
+        UNIT_ASSERT_VALUES_EQUAL(SafeCastToEnum<EIntEnum>(1), EIntEnum::One);
+        UNIT_ASSERT_VALUES_EQUAL(SafeCastToEnum<EIntEnum>(2), EIntEnum::Two);
+        UNIT_ASSERT_EXCEPTION(SafeCastToEnum<EIntEnum>(3), TBadCastException);
+
+        UNIT_ASSERT_VALUES_EQUAL(SafeCastToEnum<EUcharEnum>(0), EUcharEnum::Zero);
+        UNIT_ASSERT_VALUES_EQUAL(SafeCastToEnum<EUcharEnum>(1), EUcharEnum::One);
+        UNIT_ASSERT_VALUES_EQUAL(SafeCastToEnum<EUcharEnum>(2), EUcharEnum::Two);
+        UNIT_ASSERT_EXCEPTION_CONTAINS(
+            SafeCastToEnum<EUcharEnum>(3), TBadCastException,
+            "Unexpected enum");
+        int val1 = 256;
+        UNIT_ASSERT_EXCEPTION_CONTAINS(
+            SafeCastToEnum<EUcharEnum>(val1), TBadCastException,
+            "Unexpected enum");
+        int val2 = -1;
+        UNIT_ASSERT_EXCEPTION_CONTAINS(
+            SafeCastToEnum<EUcharEnum>(val2), TBadCastException,
+            "Unexpected enum");
+        int val3 = 2;
+        UNIT_ASSERT_VALUES_EQUAL(SafeCastToEnum<EUcharEnum>(val3), EUcharEnum::Two);
+
+        UNIT_ASSERT_VALUES_EQUAL(SafeCastToEnum<EBoolEnum>(false), EBoolEnum::False);
+        UNIT_ASSERT_VALUES_EQUAL(SafeCastToEnum<EBoolEnum>(true), EBoolEnum::True);
+
+        UNIT_ASSERT_VALUES_EQUAL(SafeCastToEnum<EUnscopedIntEnum>(2), UIE_TWO);
+        UNIT_ASSERT_EXCEPTION_CONTAINS(
+            SafeCastToEnum<EUnscopedIntEnum>(3), TBadCastException,
+            "Unexpected enum");
+        UNIT_ASSERT_EXCEPTION_CONTAINS(
+            SafeCastToEnum<EUnscopedIntEnum>(9), TBadCastException,
+            "Unexpected enum");
+
+        UNIT_ASSERT_VALUES_EQUAL(SafeCastToEnum<ECharEnum>(static_cast<unsigned int>(0)), ECharEnum::Zero);
+        UNIT_ASSERT_VALUES_EQUAL(SafeCastToEnum<ECharEnum>(static_cast<short>(-1)), ECharEnum::MinusOne);
+        UNIT_ASSERT_VALUES_EQUAL(SafeCastToEnum<ECharEnum>(static_cast<int>(-2)), ECharEnum::MinusTwo);
+        UNIT_ASSERT_EXCEPTION_CONTAINS(
+            SafeCastToEnum<ECharEnum>(static_cast<int>(2)), TBadCastException,
+            "Unexpected enum");
+    }
+} // Y_UNIT_TEST_SUITE(TestEnumCast)
diff --git a/util/generic/enum_cast_ut.h b/util/generic/enum_cast_ut.h
new file mode 100644
index 00000000000..c0fb52864aa
--- /dev/null
+++ b/util/generic/enum_cast_ut.h
@@ -0,0 +1,28 @@
+#pragma once
+
+enum class EIntEnum: int {
+    Zero = 0,
+    One = 1,
+    Two = 2
+};
+
+enum class EUcharEnum: unsigned char {
+    Zero = 0,
+    One = 1,
+    Two = 2
+};
+
+enum class ECharEnum: signed char {
+    Zero = 0,
+    MinusOne = -1,
+    MinusTwo = -2
+};
+
+enum class EBoolEnum: bool {
+    False = false,
+    True = true
+};
+
+enum EUnscopedIntEnum {
+    UIE_TWO = 2,
+};
diff --git a/util/generic/enum_range.cpp b/util/generic/enum_range.cpp
deleted file mode 100644
index c0a97177fe3..00000000000
--- a/util/generic/enum_range.cpp
+++ /dev/null
@@ -1 +0,0 @@
-#include "enum_range.h"
diff --git a/util/generic/enum_range.h b/util/generic/enum_range.h
deleted file mode 100644
index a9f78a291e8..00000000000
--- a/util/generic/enum_range.h
+++ /dev/null
@@ -1,72 +0,0 @@
-#pragma once
-
-#include <type_traits>
-
-// This tiny header is to define value ranges at compile time in enums and enum class/struct types.
-//
-// enum class E1 {
-//     A,
-//     B,
-//     C,
-// };
-// Y_DEFINE_ENUM_MINMAX(E1, A, C);
-//
-//     or
-//
-// enum class E2 {
-//     A,
-//     B,
-//     C,
-// };
-// Y_DEFINE_ENUM_MAX(E2, C);
-//
-//     Notes:
-//         * use Y_DEFINE_ENUM_MINMAX / Y_DEFINE_ENUM_MINMAX if your enum is defined in a namespace
-//         * use Y_DEFINE_ENUM_MINMAX_F / Y_DEFINE_ENUM_MINMAX_F if your enum is defined in a class/struct
-//         * use shortened version Y_DEFINE_ENUM_MAX / Y_DEFINE_ENUM_MAX_F if enum begin is 0
-//         * add Y_DEFINE_xxx macro immediately after enum definition
-//
-//     Usage examples:
-//         TEnumRange<E>::Min               // min value of range in enum type
-//         TEnumRange<E>::Max               // max value of range in enum type
-//         TEnumRange<E>::UnderlyingMin     // min value of range in underlying type
-//         TEnumRange<E>::UnderlyingMax     // max value of range in underlying type
-
-void _YRegisterEnumRange(...);
-
-namespace NDetail::NEnumRange {
-
-    template <typename E, E _Min, E _Max>
-    struct TEnumRange {
-        static_assert(std::is_enum_v<E>, "");
-
-        using TEnum = E;
-        using TUnderlying = std::underlying_type_t<TEnum>;
-
-        static constexpr TEnum Min = _Min;
-        static constexpr TEnum Max = _Max;
-
-        static constexpr TUnderlying UnderlyingMin = static_cast<TUnderlying>(Min);
-        static constexpr TUnderlying UnderlyingMax = static_cast<TUnderlying>(Max);
-
-        static_assert(UnderlyingMin <= UnderlyingMax, "Invalid enum range");
-    };
-}
-
-#define Y_DEFINE_ENUM_MINMAX_IMPL(PREFIX, E, Min, Max) \
-    PREFIX ::NDetail::NEnumRange::TEnumRange<E, Min, Max> _YRegisterEnumRange(const E*)
-
-#define Y_DEFINE_ENUM_MINMAX(E, Min, Max) \
-    Y_DEFINE_ENUM_MINMAX_IMPL([[maybe_unused]], E, E::Min, E::Max)
-
-#define Y_DEFINE_ENUM_MAX(E, Max) \
-    Y_DEFINE_ENUM_MINMAX_IMPL([[maybe_unused]], E, E{}, E::Max)
-
-#define Y_DEFINE_ENUM_MINMAX_FRIEND(E, Min, Max) \
-    Y_DEFINE_ENUM_MINMAX_IMPL(friend, E, E::Min, E::Max)
-
-#define Y_DEFINE_ENUM_MAX_FRIEND(E, Max) \
-    Y_DEFINE_ENUM_MINMAX_IMPL(friend, E, E{}, E::Max)
-
-template <typename E>
-using TEnumRange = decltype(_YRegisterEnumRange(static_cast<E*>(nullptr)));
diff --git a/util/generic/enum_range_ut.cpp b/util/generic/enum_range_ut.cpp
deleted file mode 100644
index 38caeae61b6..00000000000
--- a/util/generic/enum_range_ut.cpp
+++ /dev/null
@@ -1,237 +0,0 @@
-#include "enum_range.h"
-
-#include <util/stream/output.h>
-#include <util/system/defaults.h>
-#include <library/cpp/testing/unittest/registar.h>
-
-class TEnumRangeTest: public TTestBase {
-    UNIT_TEST_SUITE(TEnumRangeTest);
-    UNIT_TEST(TestGlobalEnumRange)
-    UNIT_TEST(TestNamedNamespaceEnumRange)
-    UNIT_TEST(TestAnonNamespaceEnumRange)
-    UNIT_TEST(TestMemberEnumRange)
-    UNIT_TEST_SUITE_END();
-
-protected:
-    void TestGlobalEnumRange();
-    void TestNamedNamespaceEnumRange();
-    void TestAnonNamespaceEnumRange();
-    void TestMemberEnumRange();
-};
-
-UNIT_TEST_SUITE_REGISTRATION(TEnumRangeTest);
-
-#define Y_DEFINE_ENUM_SERIALIZATION(Enum, Prefix)        \
-    Y_DECLARE_OUT_SPEC(inline, Enum, stream, value) {    \
-        switch (value) {                                 \
-            using enum Enum;                             \
-            case Y_CAT(Prefix, 1):                       \
-                stream << Y_STRINGIZE(Y_CAT(Prefix, 1)); \
-            case Y_CAT(Prefix, 2):                       \
-                stream << Y_STRINGIZE(Y_CAT(Prefix, 2)); \
-            case Y_CAT(Prefix, 3):                       \
-                stream << Y_STRINGIZE(Y_CAT(Prefix, 3)); \
-        }                                                \
-    }
-
-///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-enum class EGlobal1 {
-    G11,
-    G12,
-    G13
-};
-Y_DEFINE_ENUM_MINMAX(EGlobal1, G11, G13);
-
-enum EGlobal2 {
-    G21 = 5,
-    G22,
-    G23 = 9
-};
-Y_DEFINE_ENUM_MINMAX(EGlobal2, G21, G23);
-
-enum class EGlobal3 {
-    G31,
-    G32,
-    G33
-};
-Y_DEFINE_ENUM_MAX(EGlobal3, G33);
-
-enum EGlobal4 {
-    G41,
-    G42,
-    G43
-};
-Y_DEFINE_ENUM_MAX(EGlobal4, G43);
-
-Y_DEFINE_ENUM_SERIALIZATION(EGlobal1, G1);
-Y_DEFINE_ENUM_SERIALIZATION(EGlobal2, G2);
-Y_DEFINE_ENUM_SERIALIZATION(EGlobal3, G3);
-Y_DEFINE_ENUM_SERIALIZATION(EGlobal4, G4);
-
-void TEnumRangeTest::TestGlobalEnumRange() {
-    UNIT_ASSERT_VALUES_EQUAL(EGlobal1::G11, TEnumRange<EGlobal1>::Min);
-    UNIT_ASSERT_VALUES_EQUAL(EGlobal1::G13, TEnumRange<EGlobal1>::Max);
-    UNIT_ASSERT_VALUES_EQUAL(EGlobal2::G21, TEnumRange<EGlobal2>::Min);
-    UNIT_ASSERT_VALUES_EQUAL(EGlobal2::G23, TEnumRange<EGlobal2>::Max);
-    UNIT_ASSERT_VALUES_EQUAL(EGlobal3::G31, TEnumRange<EGlobal3>::Min);
-    UNIT_ASSERT_VALUES_EQUAL(EGlobal3::G33, TEnumRange<EGlobal3>::Max);
-    UNIT_ASSERT_VALUES_EQUAL(EGlobal4::G41, TEnumRange<EGlobal4>::Min);
-    UNIT_ASSERT_VALUES_EQUAL(EGlobal4::G43, TEnumRange<EGlobal4>::Max);
-    UNIT_ASSERT_VALUES_EQUAL(0, TEnumRange<EGlobal1>::UnderlyingMin);
-    UNIT_ASSERT_VALUES_EQUAL(2, TEnumRange<EGlobal1>::UnderlyingMax);
-    UNIT_ASSERT_VALUES_EQUAL(5, TEnumRange<EGlobal2>::UnderlyingMin);
-    UNIT_ASSERT_VALUES_EQUAL(9, TEnumRange<EGlobal2>::UnderlyingMax);
-    UNIT_ASSERT_VALUES_EQUAL(0, TEnumRange<EGlobal3>::UnderlyingMin);
-    UNIT_ASSERT_VALUES_EQUAL(2, TEnumRange<EGlobal3>::UnderlyingMax);
-    UNIT_ASSERT_VALUES_EQUAL(0, TEnumRange<EGlobal4>::UnderlyingMin);
-    UNIT_ASSERT_VALUES_EQUAL(2, TEnumRange<EGlobal4>::UnderlyingMax);
-}
-
-namespace NNamespace {
-    enum class ENamed1 {
-        N11,
-        N12,
-        N13
-    };
-    Y_DEFINE_ENUM_MINMAX(ENamed1, N11, N13);
-
-    enum ENamed2 {
-        N21 = 5,
-        N22,
-        N23 = 9
-    };
-    Y_DEFINE_ENUM_MINMAX(ENamed2, N21, N23);
-
-    enum class ENamed3 {
-        N31,
-        N32,
-        N33
-    };
-    Y_DEFINE_ENUM_MAX(ENamed3, N33);
-
-    enum ENamed4 {
-        N41,
-        N42,
-        N43
-    };
-    Y_DEFINE_ENUM_MAX(ENamed4, N43);
-}
-
-Y_DEFINE_ENUM_SERIALIZATION(NNamespace::ENamed1, N1);
-Y_DEFINE_ENUM_SERIALIZATION(NNamespace::ENamed2, N2);
-Y_DEFINE_ENUM_SERIALIZATION(NNamespace::ENamed3, N3);
-Y_DEFINE_ENUM_SERIALIZATION(NNamespace::ENamed4, N4);
-
-void TEnumRangeTest::TestNamedNamespaceEnumRange() {
-    UNIT_ASSERT_VALUES_EQUAL(NNamespace::ENamed1::N11, TEnumRange<NNamespace::ENamed1>::Min);
-    UNIT_ASSERT_VALUES_EQUAL(NNamespace::ENamed1::N13, TEnumRange<NNamespace::ENamed1>::Max);
-    UNIT_ASSERT_VALUES_EQUAL(NNamespace::ENamed2::N21, TEnumRange<NNamespace::ENamed2>::Min);
-    UNIT_ASSERT_VALUES_EQUAL(NNamespace::ENamed2::N23, TEnumRange<NNamespace::ENamed2>::Max);
-    UNIT_ASSERT_VALUES_EQUAL(NNamespace::ENamed3::N31, TEnumRange<NNamespace::ENamed3>::Min);
-    UNIT_ASSERT_VALUES_EQUAL(NNamespace::ENamed3::N33, TEnumRange<NNamespace::ENamed3>::Max);
-    UNIT_ASSERT_VALUES_EQUAL(NNamespace::ENamed4::N41, TEnumRange<NNamespace::ENamed4>::Min);
-    UNIT_ASSERT_VALUES_EQUAL(NNamespace::ENamed4::N43, TEnumRange<NNamespace::ENamed4>::Max);
-    UNIT_ASSERT_VALUES_EQUAL(0, TEnumRange<NNamespace::ENamed1>::UnderlyingMin);
-    UNIT_ASSERT_VALUES_EQUAL(2, TEnumRange<NNamespace::ENamed1>::UnderlyingMax);
-    UNIT_ASSERT_VALUES_EQUAL(5, TEnumRange<NNamespace::ENamed2>::UnderlyingMin);
-    UNIT_ASSERT_VALUES_EQUAL(9, TEnumRange<NNamespace::ENamed2>::UnderlyingMax);
-    UNIT_ASSERT_VALUES_EQUAL(0, TEnumRange<NNamespace::ENamed3>::UnderlyingMin);
-    UNIT_ASSERT_VALUES_EQUAL(2, TEnumRange<NNamespace::ENamed3>::UnderlyingMax);
-    UNIT_ASSERT_VALUES_EQUAL(0, TEnumRange<NNamespace::ENamed4>::UnderlyingMin);
-    UNIT_ASSERT_VALUES_EQUAL(2, TEnumRange<NNamespace::ENamed4>::UnderlyingMax);
-}
-
-namespace {
-    enum class EAnon1 {
-        A11,
-        A12,
-        A13
-    };
-    Y_DEFINE_ENUM_MINMAX(EAnon1, A11, A13);
-
-    enum EAnon2 {
-        A21 = 5,
-        A22,
-        A23 = 9
-    };
-    Y_DEFINE_ENUM_MINMAX(EAnon2, A21, A23);
-
-    enum class EAnon3 {
-        A31,
-        A32,
-        A33
-    };
-    Y_DEFINE_ENUM_MAX(EAnon3, A33);
-
-    enum EAnon4 {
-        A41,
-        A42,
-        A43
-    };
-    Y_DEFINE_ENUM_MAX(EAnon4, A43);
-}
-
-void TEnumRangeTest::TestAnonNamespaceEnumRange() {
-    UNIT_ASSERT_VALUES_EQUAL(0, TEnumRange<EAnon1>::UnderlyingMin);
-    UNIT_ASSERT_VALUES_EQUAL(2, TEnumRange<EAnon1>::UnderlyingMax);
-    UNIT_ASSERT_VALUES_EQUAL(5, TEnumRange<EAnon2>::UnderlyingMin);
-    UNIT_ASSERT_VALUES_EQUAL(9, TEnumRange<EAnon2>::UnderlyingMax);
-    UNIT_ASSERT_VALUES_EQUAL(0, TEnumRange<EAnon3>::UnderlyingMin);
-    UNIT_ASSERT_VALUES_EQUAL(2, TEnumRange<EAnon3>::UnderlyingMax);
-    UNIT_ASSERT_VALUES_EQUAL(0, TEnumRange<EAnon4>::UnderlyingMin);
-    UNIT_ASSERT_VALUES_EQUAL(2, TEnumRange<EAnon4>::UnderlyingMax);
-}
-
-struct TTestStruct {
-    enum class EMember1 {
-        M11,
-        M12,
-        M13
-    };
-    Y_DEFINE_ENUM_MINMAX_FRIEND(EMember1, M11, M13);
-
-    enum EMember2 {
-        M21 = 5,
-        M22,
-        M23 = 9
-    };
-    Y_DEFINE_ENUM_MINMAX_FRIEND(EMember2, M21, M23);
-
-    enum class EMember3 {
-        M31,
-        M32,
-        M33
-    };
-    Y_DEFINE_ENUM_MAX_FRIEND(EMember3, M33);
-
-    enum EMember4 {
-        M41,
-        M42,
-        M43
-    };
-    Y_DEFINE_ENUM_MAX_FRIEND(EMember4, M43);
-};
-
-Y_DEFINE_ENUM_SERIALIZATION(TTestStruct::EMember1, M1);
-Y_DEFINE_ENUM_SERIALIZATION(TTestStruct::EMember2, M2);
-Y_DEFINE_ENUM_SERIALIZATION(TTestStruct::EMember3, M3);
-Y_DEFINE_ENUM_SERIALIZATION(TTestStruct::EMember4, M4);
-
-void TEnumRangeTest::TestMemberEnumRange() {
-    UNIT_ASSERT_VALUES_EQUAL(TTestStruct::EMember1::M11, TEnumRange<TTestStruct::EMember1>::Min);
-    UNIT_ASSERT_VALUES_EQUAL(TTestStruct::EMember1::M13, TEnumRange<TTestStruct::EMember1>::Max);
-    UNIT_ASSERT_VALUES_EQUAL(TTestStruct::EMember2::M21, TEnumRange<TTestStruct::EMember2>::Min);
-    UNIT_ASSERT_VALUES_EQUAL(TTestStruct::EMember2::M23, TEnumRange<TTestStruct::EMember2>::Max);
-    UNIT_ASSERT_VALUES_EQUAL(TTestStruct::EMember3::M31, TEnumRange<TTestStruct::EMember3>::Min);
-    UNIT_ASSERT_VALUES_EQUAL(TTestStruct::EMember3::M33, TEnumRange<TTestStruct::EMember3>::Max);
-    UNIT_ASSERT_VALUES_EQUAL(TTestStruct::EMember4::M41, TEnumRange<TTestStruct::EMember4>::Min);
-    UNIT_ASSERT_VALUES_EQUAL(TTestStruct::EMember4::M43, TEnumRange<TTestStruct::EMember4>::Max);
-    UNIT_ASSERT_VALUES_EQUAL(0, TEnumRange<TTestStruct::EMember1>::UnderlyingMin);
-    UNIT_ASSERT_VALUES_EQUAL(2, TEnumRange<TTestStruct::EMember1>::UnderlyingMax);
-    UNIT_ASSERT_VALUES_EQUAL(5, TEnumRange<TTestStruct::EMember2>::UnderlyingMin);
-    UNIT_ASSERT_VALUES_EQUAL(9, TEnumRange<TTestStruct::EMember2>::UnderlyingMax);
-    UNIT_ASSERT_VALUES_EQUAL(0, TEnumRange<TTestStruct::EMember3>::UnderlyingMin);
-    UNIT_ASSERT_VALUES_EQUAL(2, TEnumRange<TTestStruct::EMember3>::UnderlyingMax);
-    UNIT_ASSERT_VALUES_EQUAL(0, TEnumRange<TTestStruct::EMember4>::UnderlyingMin);
-    UNIT_ASSERT_VALUES_EQUAL(2, TEnumRange<TTestStruct::EMember4>::UnderlyingMax);
-}
diff --git a/util/generic/explicit_type.h b/util/generic/explicit_type.h
index 34e269f1551..41f85f52a0c 100644
--- a/util/generic/explicit_type.h
+++ b/util/generic/explicit_type.h
@@ -24,7 +24,7 @@ template <class T>
 class TExplicitType {
 public:
     template <class OtherT>
-    TExplicitType(const OtherT& value, std::enable_if_t<std::is_same<OtherT, T>::value>* = nullptr) noexcept
+    TExplicitType(const OtherT& value Y_LIFETIME_BOUND, std::enable_if_t<std::is_same<OtherT, T>::value>* = nullptr) noexcept
         : Value_(value)
     {
     }
diff --git a/util/generic/explicit_type_ut.cpp b/util/generic/explicit_type_ut.cpp
index 0d443b35895..ace81be987b 100644
--- a/util/generic/explicit_type_ut.cpp
+++ b/util/generic/explicit_type_ut.cpp
@@ -51,4 +51,4 @@ Y_UNIT_TEST_SUITE(TestExplicitType) {
         UNIT_ASSERT_VALUES_EQUAL(static_cast<bool>(TCallable<TExplicitlyCallable<IntConstructible>, IntConvertible>::Result), false);
         UNIT_ASSERT_VALUES_EQUAL(static_cast<bool>(TCallable<TExplicitlyCallable<IntConstructible>, int>::Result), false);
     }
-}
+} // Y_UNIT_TEST_SUITE(TestExplicitType)
diff --git a/util/generic/flags.h b/util/generic/flags.h
index e11163a2f45..b263230479c 100644
--- a/util/generic/flags.h
+++ b/util/generic/flags.h
@@ -9,7 +9,7 @@
 class IOutputStream;
 namespace NPrivate {
     void PrintFlags(IOutputStream& stream, ui64 value, size_t size);
-}
+} // namespace NPrivate
 
 /**
  * `TFlags` wrapper provides a type-safe mechanism for storing OR combinations
@@ -190,7 +190,7 @@ class TFlags {
         return *this;
     }
 
-    friend IOutputStream& operator<<(IOutputStream& stream, const TFlags& flags) {
+    friend IOutputStream& operator<<(IOutputStream& stream Y_LIFETIME_BOUND, const TFlags& flags) {
         ::NPrivate::PrintFlags(stream, static_cast<ui64>(flags.Value_), sizeof(TInt));
         return stream;
     }
diff --git a/util/generic/flags_ut.cpp b/util/generic/flags_ut.cpp
index fa2d4464c94..25f6f4eba94 100644
--- a/util/generic/flags_ut.cpp
+++ b/util/generic/flags_ut.cpp
@@ -29,7 +29,7 @@ namespace {
                             Three = 3 };
     Y_DECLARE_FLAGS(ETestFlags3, ETestFlag3);
     Y_DECLARE_OPERATORS_FOR_FLAGS(ETestFlags3);
-}
+} // namespace
 
 Y_UNIT_TEST_SUITE(TFlagsTest) {
     template <class Enum>
@@ -114,9 +114,9 @@ Y_UNIT_TEST_SUITE(TFlagsTest) {
     Y_UNIT_TEST(TestBaseType) {
         ui16 goodValue = 7;
         auto goodFlags = ETest1::FromBaseType(goodValue);
-        UNIT_ASSERT(goodFlags& ETestFlag1::Test1);
-        UNIT_ASSERT(goodFlags& ETestFlag1::Test2);
-        UNIT_ASSERT(goodFlags& ETestFlag1::Test4);
+        UNIT_ASSERT(goodFlags & ETestFlag1::Test1);
+        UNIT_ASSERT(goodFlags & ETestFlag1::Test2);
+        UNIT_ASSERT(goodFlags & ETestFlag1::Test4);
         UNIT_ASSERT_VALUES_EQUAL(goodValue, goodFlags.ToBaseType());
 
         // Passed value is not checked, but preserved as is
@@ -124,4 +124,4 @@ Y_UNIT_TEST_SUITE(TFlagsTest) {
         auto badFlags = ETest1::FromBaseType(badValue);
         UNIT_ASSERT_VALUES_EQUAL(badValue, badFlags.ToBaseType());
     }
-}
+} // Y_UNIT_TEST_SUITE(TFlagsTest)
diff --git a/util/generic/function.h b/util/generic/function.h
index 859cc3f8493..654b0a4a338 100644
--- a/util/generic/function.h
+++ b/util/generic/function.h
@@ -1,6 +1,5 @@
 #pragma once
 
-#include "typetraits.h"
 #include "typelist.h"
 
 #include <functional>
@@ -64,10 +63,9 @@ namespace NPrivate {
 
     template <class R, typename... Args>
     struct TFuncInfo<R(Args...)> {
-        using TResult = R;
         typedef R TSignature(Args...);
     };
-}
+} // namespace NPrivate
 
 template <class C>
 using TFunctionSignature = typename ::NPrivate::TFuncInfo<::NPrivate::TRemoveClass<std::remove_reference_t<std::remove_pointer_t<C>>>>::TSignature;
@@ -97,22 +95,3 @@ struct TFunctionArgImpl {
 
 template <typename C, size_t N>
 using TFunctionArg = typename TFunctionArgImpl<C, N>::TResult;
-
-// temporary before std::apply appearance
-
-template <typename F, typename Tuple, size_t... I>
-auto ApplyImpl(F&& f, Tuple&& t, std::index_sequence<I...>) {
-    return f(std::get<I>(std::forward<Tuple>(t))...);
-}
-
-// change to std::apply after c++ 17
-template <typename F, typename Tuple>
-auto Apply(F&& f, Tuple&& t) {
-    return ApplyImpl(f, t, std::make_index_sequence<std::tuple_size<std::decay_t<Tuple>>::value>{});
-}
-
-// change to std::apply after c++ 17
-template <typename F>
-auto Apply(F&& f, std::tuple<>) {
-    return f();
-}
diff --git a/util/generic/function_ref_ut.cpp b/util/generic/function_ref_ut.cpp
index 59f9ae35cd8..171671d7eae 100644
--- a/util/generic/function_ref_ut.cpp
+++ b/util/generic/function_ref_ut.cpp
@@ -20,8 +20,9 @@ Y_UNIT_TEST_SUITE(TestFunctionRef) {
     }
 
     int F1(bool x) {
-        if (x)
+        if (x) {
             throw 19;
+        }
         return 42;
     }
 
@@ -147,4 +148,4 @@ Y_UNIT_TEST_SUITE(TestFunctionRef) {
         ref(std::make_unique<int>(5), x);
         UNIT_ASSERT_EQUAL(x, 'a');
     }
-}
+} // Y_UNIT_TEST_SUITE(TestFunctionRef)
diff --git a/util/generic/function_ut.cpp b/util/generic/function_ut.cpp
index f46188aa2a2..d53cabe4fd8 100644
--- a/util/generic/function_ut.cpp
+++ b/util/generic/function_ut.cpp
@@ -135,4 +135,4 @@ Y_UNIT_TEST_SUITE(TestFunctionSignature) {
         TestCT<decltype(fffn)>();
         TestCT<decltype(fffcn)>();
     }
-}
+} // Y_UNIT_TEST_SUITE(TestFunctionSignature)
diff --git a/util/generic/fwd.h b/util/generic/fwd.h
index a70e9bb6c3b..9b380564492 100644
--- a/util/generic/fwd.h
+++ b/util/generic/fwd.h
@@ -18,10 +18,10 @@ using TStringBuf = TBasicStringBuf<char>;
 using TWtringBuf = TBasicStringBuf<wchar16>;
 using TUtf32StringBuf = TBasicStringBuf<wchar32>;
 
-//misc
+// misc
 class TBuffer;
 
-//functors
+// functors
 template <class T = void>
 struct TLess;
 
@@ -34,7 +34,7 @@ struct TEqualTo;
 template <class T>
 struct THash;
 
-//intrusive containers
+// intrusive containers
 struct TIntrusiveListDefaultTag;
 template <class T, class Tag = TIntrusiveListDefaultTag>
 class TIntrusiveList;
@@ -45,13 +45,7 @@ class TIntrusiveListWithAutoDelete;
 template <class T, class Tag = TIntrusiveListDefaultTag>
 class TIntrusiveSList;
 
-template <class T, class C>
-class TAvlTree;
-
-template <class TValue, class TCmp>
-class TRbTree;
-
-//containers
+// containers
 template <class T, class A = std::allocator<T>>
 class TVector;
 
@@ -97,7 +91,7 @@ class TStack;
 template <size_t BitCount, typename TChunkType = ui64>
 class TBitMap;
 
-//autopointers
+// autopointers
 class TDelete;
 class TDeleteArray;
 class TFree;
@@ -107,7 +101,7 @@ template <class T, class D = TDelete>
 class TAutoPtr;
 
 template <class T, class D = TDelete>
-class THolder;
+class Y_TRIVIAL_ABI THolder;
 
 template <class T, class C, class D = TDelete>
 class TRefCounted;
@@ -151,10 +145,10 @@ using TArrayPtr = TAutoPtr<T, TDeleteArray>;
 template <typename T>
 using TMallocPtr = TAutoPtr<T, TFree>;
 
-//maybe
+// maybe
 namespace NMaybe {
     struct TPolicyUndefinedExcept;
-}
+} // namespace NMaybe
 
 template <class T, class Policy = ::NMaybe::TPolicyUndefinedExcept>
 class TMaybe;
@@ -166,3 +160,5 @@ class TArrayRef;
 
 template <class T>
 using TConstArrayRef = TArrayRef<const T>;
+
+class TBlob;
diff --git a/util/generic/guid.cpp b/util/generic/guid.cpp
index 8b907457bc6..0d20c467ccb 100644
--- a/util/generic/guid.cpp
+++ b/util/generic/guid.cpp
@@ -14,7 +14,7 @@ namespace {
             c = AsciiToLower(c);
         }
     }
-}
+} // namespace
 
 TString TGUID::AsGuidString() const {
     TStringBuilder s;
diff --git a/util/generic/guid_ut.cpp b/util/generic/guid_ut.cpp
index 82347941e60..f6a155b89e3 100644
--- a/util/generic/guid_ut.cpp
+++ b/util/generic/guid_ut.cpp
@@ -3,7 +3,7 @@
 #include "guid.h"
 
 Y_UNIT_TEST_SUITE(TGuidTest) {
-    //TODO - make real constructor
+    // TODO - make real constructor
     static TGUID Construct(ui32 d1, ui32 d2, ui32 d3, ui32 d4) {
         TGUID ret;
 
@@ -66,7 +66,7 @@ Y_UNIT_TEST_SUITE(TGuidTest) {
     }
 
     Y_UNIT_TEST(Test3) {
-        //if this test failed, please, fix buffer size in GetGuidAsString()
+        // if this test failed, please, fix buffer size in GetGuidAsString()
         TGUID max = Construct(Max<ui32>(), Max<ui32>(), Max<ui32>(), Max<ui32>());
 
         UNIT_ASSERT_EQUAL(GetGuidAsString(max).length(), 35);
@@ -125,4 +125,4 @@ Y_UNIT_TEST_SUITE(TGuidTest) {
         UNIT_ASSERT(!guid.empty());
         UNIT_ASSERT_EQUAL(guid[14], '1');
     }
-}
+} // Y_UNIT_TEST_SUITE(TGuidTest)
diff --git a/util/generic/hash.h b/util/generic/hash.h
index 8b4666f5667..6e6e3d34f7f 100644
--- a/util/generic/hash.h
+++ b/util/generic/hash.h
@@ -3,6 +3,7 @@
 #include "fwd.h"
 
 #include "hash_table.h"
+#include "mapfindptr.h"
 
 template <class Key, class T, class HashFcn, class EqualKey, class Alloc>
 class THashMap: public TMapOps<THashMap<Key, T, HashFcn, EqualKey, Alloc>> {
@@ -107,6 +108,7 @@ class THashMap: public TMapOps<THashMap<Key, T, HashFcn, EqualKey, Alloc>> {
     size_type size() const noexcept {
         return rep.size();
     }
+    // DEPRECATED. DO NOT USE.
     yssize_t ysize() const noexcept {
         return (yssize_t)rep.size();
     }
diff --git a/util/generic/hash.pxd b/util/generic/hash.pxd
index 385c10d805f..027e87d9683 100644
--- a/util/generic/hash.pxd
+++ b/util/generic/hash.pxd
@@ -5,7 +5,6 @@ cdef extern from "util/generic/hash.h" nogil:
         cppclass iterator:
             pair[T, U]& operator*()
             iterator operator++()
-            iterator operator--()
             bint operator==(iterator)
             bint operator!=(iterator)
 
@@ -15,7 +14,6 @@ cdef extern from "util/generic/hash.h" nogil:
         cppclass reverse_iterator:
             pair[T, U]& operator*()
             iterator operator++()
-            iterator operator--()
             bint operator==(reverse_iterator)
             bint operator!=(reverse_iterator)
 
@@ -29,10 +27,6 @@ cdef extern from "util/generic/hash.h" nogil:
 
         bint operator==(THashMap&)
         bint operator!=(THashMap&)
-        bint operator<(THashMap&)
-        bint operator>(THashMap&)
-        bint operator<=(THashMap&)
-        bint operator>=(THashMap&)
 
         U& at(T&) except +
         iterator begin()
@@ -54,13 +48,7 @@ cdef extern from "util/generic/hash.h" nogil:
         size_t max_size()
         size_t size()
         void swap(THashMap&)
-        iterator lower_bound(T&)
-        const_iterator const_lower_bound "lower_bound"(T&)
         reverse_iterator rbegin()
         const_reverse_iterator const_rbegin "rbegin"()
         reverse_iterator rend()
         const_reverse_iterator const_rend "rend"()
-        iterator upper_bound(T&)
-        const_iterator const_upper_bound "upper_bound"(T&)
-        void max_load_factor(float)
-        float max_load_factor()
diff --git a/util/generic/hash_multi_map.h b/util/generic/hash_multi_map.h
index 6b027073cb0..6949ac73d9b 100644
--- a/util/generic/hash_multi_map.h
+++ b/util/generic/hash_multi_map.h
@@ -16,6 +16,7 @@ class THashMultiMap {
     using key_equal = typename ht::key_equal;
     using mapped_type = T;
     using allocator_type = typename ht::allocator_type;
+    using node_allocator_type = typename ht::node_allocator_type;
 
     using size_type = typename ht::size_type;
     using difference_type = typename ht::difference_type;
@@ -99,6 +100,7 @@ class THashMultiMap {
     size_type size() const {
         return rep.size();
     }
+    // DEPRECATED. DO NOT USE.
     yssize_t ysize() const {
         return (yssize_t)rep.size();
     }
diff --git a/util/generic/hash_primes.cpp b/util/generic/hash_primes.cpp
index 656d31e0464..5b9723d98f2 100644
--- a/util/generic/hash_primes.cpp
+++ b/util/generic/hash_primes.cpp
@@ -2,6 +2,8 @@
 #include "array_size.h"
 #include "algorithm.h"
 
+#include <functional>
+
 /// Order of fields: reciprocal, reciprocal shift, adjacent hint, divisor
 #if defined(_32_)
 static constexpr ::NPrivate::THashDivisor PRIME_DIVISORS_HOLDER[]{
diff --git a/util/generic/hash_primes.h b/util/generic/hash_primes.h
index 4dc2da0b8f0..fe9b829acd4 100644
--- a/util/generic/hash_primes.h
+++ b/util/generic/hash_primes.h
@@ -129,7 +129,7 @@ namespace NPrivate {
     using THashDivisor = ::NPrivate::TNaiveDivisor<ui32, ui64>;
     #endif
 #endif
-}
+} // namespace NPrivate
 
 Y_CONST_FUNCTION
 ::NPrivate::THashDivisor HashBucketCountExt(unsigned long elementCount);
diff --git a/util/generic/hash_primes_ut.cpp b/util/generic/hash_primes_ut.cpp
index 7b5bf8b5c9a..f0117934c8e 100644
--- a/util/generic/hash_primes_ut.cpp
+++ b/util/generic/hash_primes_ut.cpp
@@ -77,4 +77,4 @@ Y_UNIT_TEST_SUITE(TestHashPrimes) {
             }
         }
     }
-}
+} // Y_UNIT_TEST_SUITE(TestHashPrimes)
diff --git a/util/generic/hash_set.h b/util/generic/hash_set.h
index cb86b72106e..513df23ce0f 100644
--- a/util/generic/hash_set.h
+++ b/util/generic/hash_set.h
@@ -267,8 +267,9 @@ inline bool operator==(const THashSet<Value, HashFcn, EqualKey, Alloc>& hs1, con
     if (hs1.size() != hs2.size()) {
         return false;
     }
-    for (const auto& it : hs1) {
-        if (!hs2.contains(it)) {
+    for (const auto& value : hs1) {
+        auto it2 = hs2.find(value);
+        if (it2 == hs2.end() || !(value == *it2)) {
             return false;
         }
     }
@@ -470,16 +471,21 @@ inline bool operator==(const THashMultiSet<Val, HashFcn, EqualKey, Alloc>& hs1,
     if (hs1.size() != hs2.size()) {
         return false;
     }
-    EqualKey equalKey;
-    auto it = hs1.begin();
-    while (it != hs1.end()) {
-        const auto& value = *it;
-        size_t count = 0;
-        for (; (it != hs1.end()) && (equalKey(*it, value)); ++it, ++count) {
+    EqualKey equalKey = hs1.key_eq();
+    auto it1Begin = hs1.begin();
+    while (it1Begin != hs1.end()) {
+        const auto& value = *it1Begin;
+        auto it1End = it1Begin;
+        typename THashMultiSet<Val, HashFcn, EqualKey, Alloc>::difference_type distance1 = 1;
+        for (++it1End; (it1End != hs1.end()) && (equalKey(*it1End, value)); ++it1End) {
+            ++distance1;
         }
-        if (hs2.count(value) != count) {
+        auto&& [it2Begin, it2End] = hs2.equal_range(value);
+        if (distance1 != std::distance(it2Begin, it2End) ||
+            !std::is_permutation(it1Begin, it1End, it2Begin)) {
             return false;
         }
+        it1Begin = it1End;
     }
     return true;
 }
diff --git a/util/generic/hash_set.pxd b/util/generic/hash_set.pxd
index d28d90cbe77..37da2a9da40 100644
--- a/util/generic/hash_set.pxd
+++ b/util/generic/hash_set.pxd
@@ -5,7 +5,6 @@ cdef extern from "util/generic/hash_set.h" nogil:
         cppclass iterator:
             T& operator*()
             iterator operator++()
-            iterator operator--()
             bint operator==(iterator)
             bint operator!=(iterator)
 
@@ -14,15 +13,10 @@ cdef extern from "util/generic/hash_set.h" nogil:
 
         THashSet() except +
         THashSet(THashSet&) except +
-        THashSet(T* t) except +
         THashSet& operator=(THashSet&)
 
         bint operator==(THashSet&)
         bint operator!=(THashSet&)
-        bint operator<(THashSet&)
-        bint operator>(THashSet&)
-        bint operator<=(THashSet&)
-        bint operator>=(THashSet&)
 
         iterator begin()
         const_iterator const_begin "begin"()
diff --git a/util/generic/hash_table.h b/util/generic/hash_table.h
index 0fbbef67892..bc07621139c 100644
--- a/util/generic/hash_table.h
+++ b/util/generic/hash_table.h
@@ -1,7 +1,6 @@
 #pragma once
 
 #include "fwd.h"
-#include "mapfindptr.h"
 
 #include <util/memory/alloc.h>
 #include <util/system/compiler.h>
@@ -9,16 +8,11 @@
 #include <util/system/yassert.h>
 #include <util/str_stl.h>
 #include "yexception.h"
-#include "typetraits.h"
 #include "utility.h"
 
 #include <algorithm>
-#include <initializer_list>
 #include <memory>
 #include <tuple>
-#include <utility>
-
-#include <cstdlib>
 
 #include "hash_primes.h"
 
@@ -32,7 +26,7 @@ struct TSelect1st {
 template <class Value>
 struct __yhashtable_node {
     /** If the first bit is not set, then this is a pointer to the next node in
-     * the list of nodes for the current bucket. Otherwise this is a pointer of
+     * the list of nodes for the current bucket. Otherwise, this is a pointer of
      * type __yhashtable_node**, pointing back into the buckets array.
      *
      * This trick makes it possible to use only one node pointer in a hash table
@@ -348,7 +342,7 @@ class _yhashtable_buckets: private _allocator_base<Alloc> {
  * Note that there are no specializations for the case when only one or two
  * of the functors are empty as this is a case that's just way too rare.
  */
-template <class HashFcn, class ExtractKey, class EqualKey, class Alloc, bool IsEmpty = std::is_empty<HashFcn>::value&& std::is_empty<ExtractKey>::value&& std::is_empty<EqualKey>::value>
+template <class HashFcn, class ExtractKey, class EqualKey, class Alloc, bool IsEmpty = std::is_empty<HashFcn>::value && std::is_empty<ExtractKey>::value && std::is_empty<EqualKey>::value>
 class _yhashtable_base: public _allocator_base<Alloc> {
     using base_type = _allocator_base<Alloc>;
 
@@ -634,9 +628,11 @@ class THashTable: private _yhashtable_traits<Value, Key, HashFcn, ExtractKey, Eq
     }
 
     iterator begin() {
-        for (size_type n = 0; n < buckets.size(); ++n) /*y*/
-            if (buckets[n])
+        for (size_type n = 0; n < buckets.size(); ++n) { /*y*/
+            if (buckets[n]) {
                 return iterator(buckets[n]); /*y*/
+            }
+        }
         return end();
     }
 
@@ -645,9 +641,11 @@ class THashTable: private _yhashtable_traits<Value, Key, HashFcn, ExtractKey, Eq
     } /*y*/
 
     const_iterator begin() const {
-        for (size_type n = 0; n < buckets.size(); ++n) /*y*/
-            if (buckets[n])
+        for (size_type n = 0; n < buckets.size(); ++n) { /*y*/
+            if (buckets[n]) {
                 return const_iterator(buckets[n]); /*y*/
+            }
+        }
         return end();
     }
 
@@ -662,9 +660,11 @@ class THashTable: private _yhashtable_traits<Value, Key, HashFcn, ExtractKey, Eq
 
     size_type bucket_size(size_type bucket) const {
         size_type result = 0;
-        if (const node* cur = buckets[bucket])
-            for (; !((uintptr_t)cur & 1); cur = cur->next)
+        if (const node* cur = buckets[bucket]) {
+            for (; !((uintptr_t)cur & 1); cur = cur->next) {
                 result += 1;
+            }
+        }
         return result;
     }
 
@@ -731,14 +731,16 @@ class THashTable: private _yhashtable_traits<Value, Key, HashFcn, ExtractKey, Eq
 
     template <class InputIterator>
     void insert_unique(InputIterator f, InputIterator l, std::input_iterator_tag) {
-        for (; f != l; ++f)
+        for (; f != l; ++f) {
             insert_unique(*f);
+        }
     }
 
     template <class InputIterator>
     void insert_equal(InputIterator f, InputIterator l, std::input_iterator_tag) {
-        for (; f != l; ++f)
+        for (; f != l; ++f) {
             insert_equal(*f);
+        }
     }
 
     template <class ForwardIterator>
@@ -746,8 +748,9 @@ class THashTable: private _yhashtable_traits<Value, Key, HashFcn, ExtractKey, Eq
         difference_type n = std::distance(f, l);
 
         reserve(num_elements + n);
-        for (; n > 0; --n, ++f)
+        for (; n > 0; --n, ++f) {
             insert_unique_noresize(*f);
+        }
     }
 
     template <class ForwardIterator>
@@ -755,8 +758,9 @@ class THashTable: private _yhashtable_traits<Value, Key, HashFcn, ExtractKey, Eq
         difference_type n = std::distance(f, l);
 
         reserve(num_elements + n);
-        for (; n > 0; --n, ++f)
+        for (; n > 0; --n, ++f) {
             emplace_equal_noresize(*f);
+        }
     }
 
     template <class OtherValue>
@@ -794,10 +798,13 @@ class THashTable: private _yhashtable_traits<Value, Key, HashFcn, ExtractKey, Eq
         const size_type n = bkt_num_key(key);
         size_type result = 0;
 
-        if (const node* cur = buckets[n])
-            for (; !((uintptr_t)cur & 1); cur = cur->next)
-                if (equals(get_key(cur->val), key))
+        if (const node* cur = buckets[n]) {
+            for (; !((uintptr_t)cur & 1); cur = cur->next) {
+                if (equals(get_key(cur->val), key)) {
                     ++result;
+                }
+            }
+        }
         return result;
     }
 
@@ -834,8 +841,9 @@ class THashTable: private _yhashtable_traits<Value, Key, HashFcn, ExtractKey, Eq
      * the nodes at once.
      */
     void release_nodes() {
-        if (empty())
+        if (empty()) {
             return; /* Need this check because empty buckets may reside in read-only memory. */
+        }
 
         clear_buckets(buckets);
         num_elements = 0;
@@ -877,8 +885,9 @@ class THashTable: private _yhashtable_traits<Value, Key, HashFcn, ExtractKey, Eq
      * downsizing.
      */
     Y_REINITIALIZES_OBJECT void clear() {
-        if (num_elements)
+        if (num_elements) {
             clear((num_elements * 2 + buckets.size()) / 3);
+        }
     }
 
 private:
@@ -964,8 +973,9 @@ __yhashtable_iterator<V>& __yhashtable_iterator<V>::operator++() {
     cur = cur->next;
     if ((uintptr_t)cur & 1) {
         node** bucket = (node**)((uintptr_t)cur & ~1);
-        while (*bucket == nullptr)
+        while (*bucket == nullptr) {
             ++bucket;
+        }
         Y_ASSERT(*bucket != nullptr);
         cur = (node*)((uintptr_t)*bucket & ~1);
     }
@@ -985,8 +995,9 @@ __yhashtable_const_iterator<V>& __yhashtable_const_iterator<V>::operator++() {
     cur = cur->next;
     if ((uintptr_t)cur & 1) {
         node** bucket = (node**)((uintptr_t)cur & ~1);
-        while (*bucket == nullptr)
+        while (*bucket == nullptr) {
             ++bucket;
+        }
         Y_ASSERT(*bucket != nullptr);
         cur = (node*)((uintptr_t)*bucket & ~1);
     }
@@ -1010,10 +1021,13 @@ std::pair<typename THashTable<V, K, HF, Ex, Eq, A>::iterator, bool> THashTable<V
     const size_type n = bkt_num(tmp->val);
     node* first = buckets[n];
 
-    if (first)                                                          /*y*/
-        for (node* cur = first; !((uintptr_t)cur & 1); cur = cur->next) /*y*/
-            if (equals(get_key(cur->val), get_key(tmp->val)))
+    if (first) {                                                          /*y*/
+        for (node* cur = first; !((uintptr_t)cur & 1); cur = cur->next) { /*y*/
+            if (equals(get_key(cur->val), get_key(tmp->val))) {
                 return std::pair<iterator, bool>(iterator(cur), false); /*y*/
+            }
+        }
+    }
 
     guard.release();
     tmp->next = first ? first : (node*)((uintptr_t)&buckets[n + 1] | 1); /*y*/
@@ -1028,10 +1042,13 @@ std::pair<typename THashTable<V, K, HF, Ex, Eq, A>::iterator, bool> THashTable<V
     const size_type n = bkt_num(obj);
     node* first = buckets[n];
 
-    if (first)                                                          /*y*/
-        for (node* cur = first; !((uintptr_t)cur & 1); cur = cur->next) /*y*/
-            if (equals(get_key(cur->val), get_key(obj)))
+    if (first) {                                                          /*y*/
+        for (node* cur = first; !((uintptr_t)cur & 1); cur = cur->next) { /*y*/
+            if (equals(get_key(cur->val), get_key(obj))) {
                 return std::pair<iterator, bool>(iterator(cur), false); /*y*/
+            }
+        }
+    }
 
     node* tmp = new_node(obj);
     tmp->next = first ? first : (node*)((uintptr_t)&buckets[n + 1] | 1); /*y*/
@@ -1049,8 +1066,8 @@ __yhashtable_iterator<V> THashTable<V, K, HF, Ex, Eq, A>::emplace_equal_noresize
     const size_type n = bkt_num(tmp->val);
     node* first = buckets[n];
 
-    if (first)                                                          /*y*/
-        for (node* cur = first; !((uintptr_t)cur & 1); cur = cur->next) /*y*/
+    if (first) {                                                          /*y*/
+        for (node* cur = first; !((uintptr_t)cur & 1); cur = cur->next) { /*y*/
             if (equals(get_key(cur->val), get_key(tmp->val))) {
                 guard.release();
                 tmp->next = cur->next;
@@ -1058,6 +1075,8 @@ __yhashtable_iterator<V> THashTable<V, K, HF, Ex, Eq, A>::emplace_equal_noresize
                 ++num_elements;
                 return iterator(tmp); /*y*/
             }
+        }
+    }
 
     guard.release();
     tmp->next = first ? first : (node*)((uintptr_t)&buckets[n + 1] | 1); /*y*/
@@ -1074,10 +1093,13 @@ typename THashTable<V, K, HF, Ex, Eq, A>::reference THashTable<V, K, HF, Ex, Eq,
     size_type n = bkt_num_key(get_key(v));
     node* first = buckets[n];
 
-    if (first)                                                          /*y*/
-        for (node* cur = first; !((uintptr_t)cur & 1); cur = cur->next) /*y*/
-            if (equals(get_key(cur->val), get_key(v)))
+    if (first) {                                                          /*y*/
+        for (node* cur = first; !((uintptr_t)cur & 1); cur = cur->next) { /*y*/
+            if (equals(get_key(cur->val), get_key(v))) {
                 return cur->val;
+            }
+        }
+    }
 
     node* tmp = new_node(v);
     tmp->next = first ? first : (node*)((uintptr_t)&buckets[n + 1] | 1); /*y*/
@@ -1093,10 +1115,13 @@ __yhashtable_iterator<V> THashTable<V, K, HF, Ex, Eq, A>::find_i(const OtherKey&
     ins = &buckets[n];
     node* first = buckets[n];
 
-    if (first)                                                          /*y*/
-        for (node* cur = first; !((uintptr_t)cur & 1); cur = cur->next) /*y*/
-            if (equals(get_key(cur->val), key))
+    if (first) {                                                          /*y*/
+        for (node* cur = first; !((uintptr_t)cur & 1); cur = cur->next) { /*y*/
+            if (equals(get_key(cur->val), key)) {
                 return iterator(cur); /*y*/
+            }
+        }
+    }
     return end();
 }
 
@@ -1115,19 +1140,24 @@ std::pair<__yhashtable_iterator<V>, __yhashtable_iterator<V>> THashTable<V, K, H
     ins = &buckets[n];
     node* first = buckets[n];
 
-    if (first)                                                 /*y*/
+    if (first) {                                               /*y*/
         for (; !((uintptr_t)first & 1); first = first->next) { /*y*/
             if (equals(get_key(first->val), key)) {
-                for (node* cur = first->next; !((uintptr_t)cur & 1); cur = cur->next)
-                    if (!equals(get_key(cur->val), key))
+                for (node* cur = first->next; !((uintptr_t)cur & 1); cur = cur->next) {
+                    if (!equals(get_key(cur->val), key)) {
                         return pii(iterator(first), iterator(cur)); /*y*/
-                for (size_type m = n + 1; m < buckets.size(); ++m)  /*y*/
-                    if (buckets[m])
+                    }
+                }
+                for (size_type m = n + 1; m < buckets.size(); ++m) { /*y*/
+                    if (buckets[m]) {
                         return pii(iterator(first),       /*y*/
                                    iterator(buckets[m])); /*y*/
-                return pii(iterator(first), end());       /*y*/
+                    }
+                }
+                return pii(iterator(first), end()); /*y*/
             }
         }
+    }
     return pii(end(), end());
 }
 
@@ -1138,20 +1168,25 @@ std::pair<__yhashtable_const_iterator<V>, __yhashtable_const_iterator<V>> THashT
     const size_type n = bkt_num_key(key);
     const node* first = buckets[n];
 
-    if (first)                                                 /*y*/
+    if (first) {                                               /*y*/
         for (; !((uintptr_t)first & 1); first = first->next) { /*y*/
             if (equals(get_key(first->val), key)) {
-                for (const node* cur = first->next; !((uintptr_t)cur & 1); cur = cur->next)
-                    if (!equals(get_key(cur->val), key))
-                        return pii(const_iterator(first),          /*y*/
-                                   const_iterator(cur));           /*y*/
-                for (size_type m = n + 1; m < buckets.size(); ++m) /*y*/
-                    if (buckets[m])
+                for (const node* cur = first->next; !((uintptr_t)cur & 1); cur = cur->next) {
+                    if (!equals(get_key(cur->val), key)) {
+                        return pii(const_iterator(first), /*y*/
+                                   const_iterator(cur));  /*y*/
+                    }
+                }
+                for (size_type m = n + 1; m < buckets.size(); ++m) { /*y*/
+                    if (buckets[m]) {
                         return pii(const_iterator(first /*y*/),
                                    const_iterator(buckets[m] /*y*/));
+                    }
+                }
                 return pii(const_iterator(first /*y*/), end());
             }
         }
+    }
     return pii(end(), end());
 }
 
@@ -1249,16 +1284,18 @@ void THashTable<V, K, HF, Ex, Eq, A>::erase(iterator first, iterator last) {
     size_type f_bucket = first.cur ? bkt_num(first.cur->val) : buckets.size(); /*y*/
     size_type l_bucket = last.cur ? bkt_num(last.cur->val) : buckets.size();   /*y*/
 
-    if (first.cur == last.cur)
+    if (first.cur == last.cur) {
         return;
-    else if (f_bucket == l_bucket)
+    } else if (f_bucket == l_bucket) {
         erase_bucket(f_bucket, first.cur, last.cur);
-    else {
+    } else {
         erase_bucket(f_bucket, first.cur, nullptr);
-        for (size_type n = f_bucket + 1; n < l_bucket; ++n)
+        for (size_type n = f_bucket + 1; n < l_bucket; ++n) {
             erase_bucket(n, nullptr);
-        if (l_bucket != buckets.size()) /*y*/
+        }
+        if (l_bucket != buckets.size()) { /*y*/
             erase_bucket(l_bucket, last.cur);
+        }
     }
 }
 
@@ -1277,8 +1314,9 @@ template <class V, class K, class HF, class Ex, class Eq, class A>
 bool THashTable<V, K, HF, Ex, Eq, A>::reserve(size_type num_elements_hint) {
     const size_type old_n = buckets.size(); /*y*/
     if (num_elements_hint + 1 > old_n) {
-        if (old_n != 1 && num_elements_hint <= old_n) // TODO: this if is for backwards compatibility down to order-in-buckets level. Can be safely removed.
+        if (old_n != 1 && num_elements_hint <= old_n) { // TODO: this if is for backwards compatibility down to order-in-buckets level. Can be safely removed.
             return false;
+        }
 
         const TBucketDivisor n = HashBucketCountExt(num_elements_hint + 1, buckets.BucketDivisorHint() + 1);
         if (n() > old_n) {
@@ -1325,9 +1363,9 @@ bool THashTable<V, K, HF, Ex, Eq, A>::reserve(size_type num_elements_hint) {
 template <class V, class K, class HF, class Ex, class Eq, class A>
 void THashTable<V, K, HF, Ex, Eq, A>::erase_bucket(const size_type n, node* first, node* last) {
     node* cur = buckets[n];
-    if (cur == first)
+    if (cur == first) {
         erase_bucket(n, last);
-    else {
+    } else {
         node* next;
         for (next = cur->next; next != first; cur = next, next = cur->next)
             ;
@@ -1431,7 +1469,7 @@ namespace NPrivate {
     }
 
     [[noreturn]] void ThrowKeyNotFoundInHashTableException(const TStringBuf keyRepresentation);
-}
+} // namespace NPrivate
 
 // Cannot name it just 'Hash' because it clashes with too many class members in the code.
 template <class T>
diff --git a/util/generic/hash_ut.cpp b/util/generic/hash_ut.cpp
index 78fc5657ce9..19fd073d3bb 100644
--- a/util/generic/hash_ut.cpp
+++ b/util/generic/hash_ut.cpp
@@ -3,12 +3,14 @@
 #include "vector.h"
 #include "hash_set.h"
 
+#include <library/cpp/case_insensitive_string/case_insensitive_string.h>
 #include <library/cpp/testing/common/probe.h>
 #include <library/cpp/testing/unittest/registar.h>
 
 #include <utility>
 #include <util/str_stl.h>
 #include <util/digest/multi.h>
+#include <util/string/join.h>
 
 static const char star = 42;
 
@@ -17,7 +19,9 @@ class THashTest: public TTestBase {
     UNIT_TEST(TestHMapConstructorsAndAssignments);
     UNIT_TEST(TestHMap1);
     UNIT_TEST(TestHMapEqualityOperator);
+    UNIT_TEST(TestHMapEqualityOperatorWithCustomPred);
     UNIT_TEST(TestHMMapEqualityOperator);
+    UNIT_TEST(TestHMMapEqualityOperatorWithCustomPred);
     UNIT_TEST(TestHMMapConstructorsAndAssignments);
     UNIT_TEST(TestHMMap1);
     UNIT_TEST(TestHMMapHas);
@@ -25,10 +29,12 @@ class THashTest: public TTestBase {
     UNIT_TEST(TestHSetSize);
     UNIT_TEST(TestHSet2);
     UNIT_TEST(TestHSetEqualityOperator);
+    UNIT_TEST(TestHSetEqualityOperatorWithCustomPred);
     UNIT_TEST(TestHMSetConstructorsAndAssignments);
     UNIT_TEST(TestHMSetSize);
     UNIT_TEST(TestHMSet1);
     UNIT_TEST(TestHMSetEqualityOperator);
+    UNIT_TEST(TestHMSetEqualityOperatorWithCustomPred);
     UNIT_TEST(TestHMSetEmplace);
     UNIT_TEST(TestInsertErase);
     UNIT_TEST(TestResizeOnInsertSmartPtrBug)
@@ -57,6 +63,7 @@ class THashTest: public TTestBase {
     UNIT_TEST(TestAt);
     UNIT_TEST(TestHMapInitializerList);
     UNIT_TEST(TestHMMapInitializerList);
+    UNIT_TEST(TestHMapStringKeyTransparency);
     UNIT_TEST(TestHSetInitializerList);
     UNIT_TEST(TestHMSetInitializerList);
     UNIT_TEST(TestHSetInsertInitializerList);
@@ -71,7 +78,9 @@ class THashTest: public TTestBase {
     void TestHMapConstructorsAndAssignments();
     void TestHMap1();
     void TestHMapEqualityOperator();
+    void TestHMapEqualityOperatorWithCustomPred();
     void TestHMMapEqualityOperator();
+    void TestHMMapEqualityOperatorWithCustomPred();
     void TestHMMapConstructorsAndAssignments();
     void TestHMMap1();
     void TestHMMapHas();
@@ -79,10 +88,12 @@ class THashTest: public TTestBase {
     void TestHSetSize();
     void TestHSet2();
     void TestHSetEqualityOperator();
+    void TestHSetEqualityOperatorWithCustomPred();
     void TestHMSetConstructorsAndAssignments();
     void TestHMSetSize();
     void TestHMSet1();
     void TestHMSetEqualityOperator();
+    void TestHMSetEqualityOperatorWithCustomPred();
     void TestHMSetEmplace();
     void TestInsertErase();
     void TestResizeOnInsertSmartPtrBug();
@@ -111,6 +122,7 @@ class THashTest: public TTestBase {
     void TestAt();
     void TestHMapInitializerList();
     void TestHMMapInitializerList();
+    void TestHMapStringKeyTransparency();
     void TestHSetInitializerList();
     void TestHMSetInitializerList();
     void TestHSetInsertInitializerList();
@@ -121,6 +133,47 @@ class THashTest: public TTestBase {
 
 UNIT_TEST_SUITE_REGISTRATION(THashTest);
 
+template <class TContainer, class T, class... TLHSParams, class... TRHSParams>
+static void TestStringEquality(
+    const TStringBuf testSubCaseName,
+    const bool expected,
+    const std::initializer_list<T>& lhsList,
+    const std::initializer_list<T>& rhsList,
+    const std::tuple<TLHSParams...>& lhsParams = std::tuple<>{},
+    const std::tuple<TRHSParams...>& rhsParams = std::tuple<>{})
+{
+    auto make = [](const std::initializer_list<T>& list, const auto& params) {
+        TContainer r = std::make_from_tuple<TContainer>(params);
+        for (const auto& v : list) {
+            r.emplace(v);
+        }
+        return r;
+    };
+    auto makeRepr = [](const TContainer& c) -> TString {
+        TStringBuilder sb;
+        for (const auto& v : c) {
+            if (sb) {
+                sb << ", "sv;
+            }
+            if constexpr (requires {v.first; v.second; }) {
+                sb << "{" << v.first.Quote() << "," << v.second << "}"sv;
+            } else {
+                sb << v.Quote();
+            }
+        }
+        return '{' + std::move(sb) + '}';
+    };
+
+    const TContainer lhs = make(lhsList, lhsParams);
+    const TContainer rhs = make(rhsList, rhsParams);
+
+    const bool eq = (lhs == rhs);
+    const TStringBuf expectedStr = expected ? "=="sv : "!="sv;
+
+    UNIT_ASSERT_C(eq == expected, (TStringBuilder() << "case '" << testSubCaseName << "' failed: "
+                                                    << makeRepr(lhs) << expectedStr << makeRepr(rhs)));
+}
+
 void THashTest::TestHMapConstructorsAndAssignments() {
     using container = THashMap<TString, int>;
 
@@ -232,6 +285,16 @@ void THashTest::TestHMapEqualityOperator() {
     UNIT_ASSERT(c3 != base);
 }
 
+void THashTest::TestHMapEqualityOperatorWithCustomPred() {
+    using container = THashMap<TString, int, THash<TCaseInsensitiveStringBuf>, TEqualTo<TCaseInsensitiveStringBuf>>;
+    using containerCI = THashMap<TCaseInsensitiveString, int, THash<TCaseInsensitiveStringBuf>, TEqualTo<TCaseInsensitiveStringBuf>>;
+
+    TestStringEquality<container, std::pair<const TStringBuf, int>>("idenitity_1", true, {{"one", 1}, {"two", 2}}, {{"one", 1}, {"two", 2}});
+    TestStringEquality<containerCI, std::pair<const TStringBuf, int>>("idenitity_2", true, {{"one", 1}, {"two", 2}}, {{"ONE", 1}, {"TWO", 2}});
+    TestStringEquality<container, std::pair<const TStringBuf, int>>("idenitity_1", false, {{"one", 1}, {"two", 2}}, {{"ONE", 1}, {"two", 2}});
+    TestStringEquality<container, std::pair<const TStringBuf, int>>("idenitity_1", false, {{"one", 1}, {"two", 2}}, {{"onw", 0}, {"two", 2}});
+}
+
 void THashTest::TestHMMapEqualityOperator() {
     using container = THashMultiMap<TString, int>;
     using value = container::value_type;
@@ -267,6 +330,17 @@ void THashTest::TestHMMapEqualityOperator() {
     UNIT_ASSERT(c3 != base);
 }
 
+void THashTest::TestHMMapEqualityOperatorWithCustomPred() {
+    using container = THashMultiMap<TString, int, THash<TCaseInsensitiveStringBuf>, TEqualTo<TCaseInsensitiveStringBuf>>;
+
+    TestStringEquality<container, std::pair<const TStringBuf, int>>("idenitity", true, {{"string1", 1}, {"string2", -2}, {"string2", 2}}, {{"string1", 1}, {"string2", -2}, {"string2", 2}});
+    TestStringEquality<container, std::pair<const TStringBuf, int>>("case2", false, {{"string1", 1}, {"string2", -2}, {"string2", 2}}, {{"string1", 1}, {"string1", -1}, {"string2", 2}});
+    TestStringEquality<container, std::pair<const TStringBuf, int>>("case3", false, {{"string1", 1}, {"string2", -2}, {"string2", 2}}, {{"string1", 1}, {"STRING2", -2}, {"STRING2", 2}});
+    TestStringEquality<container, std::pair<const TStringBuf, int>>("case4", false, {{"string1", 1}, {"string2", -2}, {"string2", 2}}, {{"string1", 1}, {"STRING2", -2}, {"string2", 2}});
+    TestStringEquality<container, std::pair<const TStringBuf, int>>("case5", false, {{"string1", 1}, {"string2", -2}, {"string2", 2}}, {{"string1", 1}, {"string2", 2}, {"STRING2", -2}});
+    TestStringEquality<container, std::pair<const TStringBuf, int>>("case6", true, {{"string1", 1}, {"STRING2", -2}, {"string2", 2}}, {{"string1", 1}, {"string2", 2}, {"STRING2", -2}});
+}
+
 void THashTest::TestHMMapConstructorsAndAssignments() {
     using container = THashMultiMap<TString, int>;
 
@@ -464,6 +538,16 @@ void THashTest::TestHSetEqualityOperator() {
     UNIT_ASSERT(c3 != base);
 }
 
+void THashTest::TestHSetEqualityOperatorWithCustomPred() {
+    using container = THashSet<TString, THash<TCaseInsensitiveStringBuf>, TEqualTo<TCaseInsensitiveStringBuf>>;
+    using containerCI = THashSet<TCaseInsensitiveString, THash<TCaseInsensitiveStringBuf>, TEqualTo<TCaseInsensitiveStringBuf>>;
+
+    TestStringEquality<container>("idenitity", true, {"string1", "string2"}, {"string1", "string2"});
+    TestStringEquality<container>("not_inserted", true, {"string1", "string2"}, {"string1", "string2", "STRING1"});
+    TestStringEquality<container>("different_values", false, {"string1", "string2"}, {"STRING1", "string2"});
+    TestStringEquality<containerCI>("same_values", true, {"string1", "string2"}, {"STRING1", "string2"});
+}
+
 void THashTest::TestHMSetConstructorsAndAssignments() {
     using container = THashMultiSet<int>;
 
@@ -561,6 +645,19 @@ void THashTest::TestHMSetEqualityOperator() {
     UNIT_ASSERT(!(c3 == base));
 }
 
+void THashTest::TestHMSetEqualityOperatorWithCustomPred() {
+    using container = THashMultiSet<TString, THash<TCaseInsensitiveStringBuf>, TEqualTo<TCaseInsensitiveStringBuf>>;
+    using containerCI = THashMultiSet<TCaseInsensitiveString, THash<TCaseInsensitiveStringBuf>, TEqualTo<TCaseInsensitiveStringBuf>>;
+
+    TestStringEquality<container>("idenitity", true, {"string1", "string2", "string2"}, {"string1", "string2", "string2"});
+    TestStringEquality<container>("diff_cardinality_1", false, {"string1", "string2", "string2"}, {"string1", "string2", "string2", "string2"});
+    TestStringEquality<container>("diff_cardinality_2", false, {"string1", "string2", "string2"}, {"string1", "string2", "string1"});
+    TestStringEquality<container>("different_values_1", false, {"string1", "string2", "string2"}, {"STRING1", "string2", "string2"});
+    TestStringEquality<container>("different_values_2", false, {"string1", "string2", "string2"}, {"string1", "STRING2", "string2"});
+    TestStringEquality<containerCI>("same_values", true, {"string1", "string2", "string2"}, {"string1", "STRING2", "string2"});
+    TestStringEquality<container>("permutation", true, {"string1", "string2", "STRING2", "STRING2"}, {"string1", "STRING2", "string2", "STRING2"});
+}
+
 void THashTest::TestHMSetEmplace() {
     class TKey: public NTesting::TProbe {
     public:
@@ -683,7 +780,7 @@ namespace {
             return **it;
         }
     };
-}
+} // namespace
 
 void THashTest::TestResizeOnInsertSmartPtrBug() {
     TItemMap map;
@@ -1215,6 +1312,21 @@ void THashTest::TestHMapInitializerList() {
     UNIT_ASSERT_EQUAL(h1, h2);
 }
 
+void THashTest::TestHMapStringKeyTransparency() {
+    auto test = [](auto m) {
+        // Check transparency (is_transparent).
+        m["foo"] = "bar";
+        m[TStringBuf{"foo"}] = "bar";
+        m[std::string_view{"foo"}] = "bar";
+        m[std::string{"foo"}] = "bar";
+
+        UNIT_ASSERT_EQUAL(m["foo"], "bar");
+    };
+
+    test(THashMap<TString, TString>());
+    test(THashMap<std::string, std::string>());
+}
+
 void THashTest::TestHMMapInitializerList() {
     THashMultiMap<TString, TString> h1 = {
         {"foo", "bar"},
@@ -1255,7 +1367,7 @@ namespace {
             return A == o.A && B == o.B;
         }
     };
-}
+} // namespace
 
 template <>
 struct THash<TFoo> {
diff --git a/util/generic/intrlist.h b/util/generic/intrlist.h
index 2982e3a2815..8ca240a6d9d 100644
--- a/util/generic/intrlist.h
+++ b/util/generic/intrlist.h
@@ -126,6 +126,20 @@ class TIntrusiveListItem {
         Prev_ = Next_;
     }
 
+    TIntrusiveListItem(TIntrusiveListItem&& rhs) noexcept
+        : Next_(this)
+        , Prev_(Next_)
+    {
+        LinkBeforeNoUnlink(&rhs);
+        rhs.Unlink();
+    }
+
+    TIntrusiveListItem& operator=(TIntrusiveListItem&& rhs) noexcept {
+        LinkBefore(&rhs);
+        rhs.Unlink();
+        return *this;
+    }
+
 private:
     inline TIntrusiveListItem(const TIntrusiveListItem&) = delete;
     inline TIntrusiveListItem& operator=(const TIntrusiveListItem&) = delete;
@@ -818,7 +832,7 @@ class TIntrusiveSList {
         return End();
     }
 
-    //compat methods
+    // compat methods
     inline iterator begin() noexcept {
         return Begin();
     }
diff --git a/util/generic/intrlist_ut.cpp b/util/generic/intrlist_ut.cpp
index eff7cdf2eee..fbf706c85c7 100644
--- a/util/generic/intrlist_ut.cpp
+++ b/util/generic/intrlist_ut.cpp
@@ -2,6 +2,7 @@
 
 #include <library/cpp/testing/unittest/registar.h>
 
+#include <util/generic/algorithm.h>
 #include <util/stream/output.h>
 
 class TListTest: public TTestBase {
@@ -21,6 +22,8 @@ class TListTest: public TTestBase {
     UNIT_TEST(TestListWithAutoDeleteMoveOpEq);
     UNIT_TEST(TestListWithAutoDeleteClear);
     UNIT_TEST(TestSecondTag);
+    UNIT_TEST(TestItemMoveCtor);
+    UNIT_TEST(TestItemMoveAssign);
     UNIT_TEST_SUITE_END();
 
 private:
@@ -39,6 +42,8 @@ class TListTest: public TTestBase {
     void TestListWithAutoDeleteMoveOpEq();
     void TestListWithAutoDeleteClear();
     void TestSecondTag();
+    void TestItemMoveCtor();
+    void TestItemMoveAssign();
 };
 
 UNIT_TEST_SUITE_REGISTRATION(TListTest);
@@ -82,10 +87,10 @@ class TMyList: public TIntrusiveList<TInt> {
         }
     }
 
-    //TMyList(const TMyList& rhs) = default;
+    // TMyList(const TMyList& rhs) = default;
     TMyList(TMyList&& rhs) noexcept = default;
 
-    //operator=(const TMyList& rhs) = default;
+    // operator=(const TMyList& rhs) = default;
     TMyList& operator=(TMyList&& rhs) noexcept = default;
 
     inline ~TMyList() {
@@ -510,3 +515,117 @@ void TListTest::TestSecondTag() {
     UNIT_ASSERT_EQUAL(*second.Front(), 1);
     UNIT_ASSERT_EQUAL(*first.Back(), 0);
 }
+
+namespace {
+    struct TStringItem: public TIntrusiveListItem<TStringItem> {
+        explicit TStringItem(TString s)
+            : Value(std::move(s))
+        {
+        }
+
+        TString Value;
+
+        friend bool operator<(const TStringItem& lhs, const TStringItem& rhs) noexcept {
+            return lhs.Value < rhs.Value;
+        }
+
+        friend bool operator==(const TStringItem& lhs, const TStringItem& rhs) noexcept {
+            return lhs.Value == rhs.Value;
+        }
+
+        friend bool operator==(const TStringItem& lhs, const TString& rhs) noexcept {
+            return lhs.Value == rhs;
+        }
+    };
+} // namespace
+
+template <>
+void Out<TStringItem>(IOutputStream& out, const TStringItem& item) {
+    out << item.Value;
+}
+
+void TListTest::TestItemMoveCtor() {
+    {
+        TStringItem a("foobar");
+        TIntrusiveList<TStringItem> list;
+        list.PushBack(&a);
+        for (const TStringItem& i : list) {
+            UNIT_ASSERT_VALUES_EQUAL("foobar", i);
+        }
+        TStringItem b(std::move(a));
+        UNIT_ASSERT_VALUES_EQUAL("foobar", b);
+        for (const TStringItem& i : list) {
+            UNIT_ASSERT_VALUES_EQUAL("foobar", i);
+        }
+    }
+
+    {
+        TVector<TStringItem> array;
+        TIntrusiveList<TStringItem> list;
+        for (int i = 0; i < 1000; ++i) {
+            array.emplace_back(TString(i, '-'));
+            list.PushBack(&array.back());
+        }
+
+        int expected = 0;
+        for (const TStringItem& i : list) {
+            UNIT_ASSERT_EQUAL(TString(expected, '-'), i);
+            ++expected;
+        }
+    }
+}
+
+void TListTest::TestItemMoveAssign() {
+    TVector<TStringItem> array;
+    TVector<TString> ref;
+    TIntrusiveList<TStringItem> list;
+
+    for (int i = 0; i < 5000; ++i) {
+        array.emplace_back(ToString(i));
+        ref.emplace_back(ToString(i));
+        list.PushBack(&array.back());
+    }
+
+    UNIT_ASSERT(Equal(array.begin(), array.end(), ref.begin(), ref.end()));
+    UNIT_ASSERT(Equal(array.begin(), array.end(), list.begin(), list.end()));
+    Sort(array);
+    UNIT_ASSERT(!Equal(array.begin(), array.end(), ref.begin(), ref.end())); // array is shuffled
+    UNIT_ASSERT(Equal(ref.begin(), ref.end(), list.begin(), list.end()));    // but list keeps the original order
+    UNIT_ASSERT(!Equal(array.begin(), array.end(), list.begin(), list.end()));
+    SortBy(array, [](const TStringItem& item) { return FromString<int>(item.Value); });
+    UNIT_ASSERT(Equal(array.begin(), array.end(), ref.begin(), ref.end()));
+    UNIT_ASSERT(Equal(ref.begin(), ref.end(), list.begin(), list.end())); // list still keeps the original order
+    UNIT_ASSERT(Equal(array.begin(), array.end(), list.begin(), list.end()));
+
+    {
+        TStringItem a("foo");
+        TStringItem b("bar");
+        TIntrusiveList<TStringItem> list;
+        list.PushBack(&b);
+        a = std::move(b);
+        UNIT_ASSERT_VALUES_EQUAL(a, "bar");
+        for (const TStringItem& i : list) {
+            UNIT_ASSERT_VALUES_EQUAL(i, "bar");
+        }
+        UNIT_ASSERT_VALUES_EQUAL(list.Size(), 1);
+
+        TStringItem& aa = a;
+        aa = std::move(a);
+        UNIT_ASSERT_LE(list.Size(), 1); // self-move assignment results in a valid but unspecified state
+    }
+
+    {
+        TStringItem a("adjacent node 1");
+        TStringItem b("adjacent node 2");
+        TIntrusiveList<TStringItem> list;
+        list.PushBack(&a);
+        list.PushBack(&b);
+        a = std::move(b);
+        UNIT_ASSERT_VALUES_EQUAL(a, "adjacent node 2");
+        for (const TStringItem& i : list) {
+            UNIT_ASSERT_VALUES_EQUAL(i, "adjacent node 2");
+        }
+        UNIT_ASSERT_VALUES_EQUAL(list.Size(), 1);
+        UNIT_ASSERT(b.Empty());
+    }
+}
diff --git a/util/generic/is_in.h b/util/generic/is_in.h
index 643edba5964..d1b786c4f9a 100644
--- a/util/generic/is_in.h
+++ b/util/generic/is_in.h
@@ -34,7 +34,7 @@ namespace NIsInHelper {
             return c.find(e) != c.end();
         }
     };
-}
+} // namespace NIsInHelper
 
 template <class I, class T>
 constexpr bool IsIn(I f, I l, const T& v) {
diff --git a/util/generic/is_in_ut.cpp b/util/generic/is_in_ut.cpp
index 763018a0885..9bb2de2b129 100644
--- a/util/generic/is_in_ut.cpp
+++ b/util/generic/is_in_ut.cpp
@@ -114,4 +114,4 @@ Y_UNIT_TEST_SUITE(TIsIn) {
         UNIT_ASSERT(!IsIn(array, "c"));
         UNIT_ASSERT(IsIn(array, TStringBuf("d")));
     }
-}
+} // Y_UNIT_TEST_SUITE(TIsIn)
diff --git a/util/generic/iterator.h b/util/generic/iterator.h
index 19e9d20976d..fc46a36454f 100644
--- a/util/generic/iterator.h
+++ b/util/generic/iterator.h
@@ -1,5 +1,7 @@
 #pragma once
 
+#include <util/system/yassert.h>
+
 #include <iterator>
 #include <utility>
 
@@ -137,3 +139,9 @@ template <class TIterator>
 auto ToForwardIterator(TIterator iter) {
     return std::next(iter).base();
 }
+
+template <class T>
+constexpr inline size_t NonNegativeDistance(T* b, T* e) noexcept {
+    Y_ASSERT(e >= b);
+    return e - b;
+}
diff --git a/util/generic/iterator_range_ut.cpp b/util/generic/iterator_range_ut.cpp
index a7e3670ae10..277097ef2d7 100644
--- a/util/generic/iterator_range_ut.cpp
+++ b/util/generic/iterator_range_ut.cpp
@@ -95,4 +95,4 @@ Y_UNIT_TEST_SUITE(IteratorRange) {
         // we should be able to use TIteratorRange as a container parameter for standard algorithms
         UNIT_ASSERT(AllOf(range, [](int x) { return x > 0; }));
     }
-}
+} // Y_UNIT_TEST_SUITE(IteratorRange)
diff --git a/util/generic/iterator_ut.cpp b/util/generic/iterator_ut.cpp
index 00be19e10ec..87aec40afde 100644
--- a/util/generic/iterator_ut.cpp
+++ b/util/generic/iterator_ut.cpp
@@ -8,7 +8,7 @@ Y_UNIT_TEST_SUITE(TIterator) {
         UNIT_ASSERT_VALUES_EQUAL(*std::prev(x.end()), *ToForwardIterator(x.rbegin()));
         UNIT_ASSERT_VALUES_EQUAL(*ToForwardIterator(std::prev(x.rend())), *x.begin());
     }
-}
+} // Y_UNIT_TEST_SUITE(TIterator)
 
 Y_UNIT_TEST_SUITE(TInputRangeAdaptor) {
     class TSquaresGenerator: public TInputRangeAdaptor<TSquaresGenerator> {
@@ -60,4 +60,4 @@ Y_UNIT_TEST_SUITE(TInputRangeAdaptor) {
         }
         UNIT_ASSERT(expected_part == expected.end());
     }
-}
+} // Y_UNIT_TEST_SUITE(TInputRangeAdaptor)
diff --git a/util/generic/lazy_value.h b/util/generic/lazy_value.h
index e54cdb31d0d..8dd53b763d8 100644
--- a/util/generic/lazy_value.h
+++ b/util/generic/lazy_value.h
@@ -19,18 +19,18 @@ class TLazyValueBase {
         return ValueHolder.Defined();
     }
 
-    const T& GetRef() const {
+    const T& GetRef() const Y_LIFETIME_BOUND {
         if (!WasLazilyInitialized()) {
             InitDefault();
         }
         return *ValueHolder;
     }
 
-    const T& operator*() const {
+    const T& operator*() const Y_LIFETIME_BOUND {
         return GetRef();
     }
 
-    const T* operator->() const {
+    const T* operator->() const Y_LIFETIME_BOUND {
         return &GetRef();
     }
 
diff --git a/util/generic/lazy_value_ut.cpp b/util/generic/lazy_value_ut.cpp
index ff5a0156c53..aafbcb44933 100644
--- a/util/generic/lazy_value_ut.cpp
+++ b/util/generic/lazy_value_ut.cpp
@@ -154,4 +154,4 @@ Y_UNIT_TEST_SUITE(TLazyValueTestSuite) {
         UNIT_ASSERT(lv.GetRef() == 100500);
         UNIT_ASSERT(lv.WasLazilyInitialized());
     }
-}
+} // Y_UNIT_TEST_SUITE(TLazyValueTestSuite)
diff --git a/util/generic/list_ut.cpp b/util/generic/list_ut.cpp
index 9e60ecf01b4..f9e6a5cb6b8 100644
--- a/util/generic/list_ut.cpp
+++ b/util/generic/list_ut.cpp
@@ -11,4 +11,4 @@ Y_UNIT_TEST_SUITE(TYListSuite) {
         expected.push_back(6);
         UNIT_ASSERT_VALUES_EQUAL(l, expected);
     }
-}
+} // Y_UNIT_TEST_SUITE(TYListSuite)
diff --git a/util/generic/map_ut.cpp b/util/generic/map_ut.cpp
index 79e832b024f..4f698c9612e 100644
--- a/util/generic/map_ut.cpp
+++ b/util/generic/map_ut.cpp
@@ -161,7 +161,7 @@ Y_UNIT_TEST_SUITE(TYMapTest) {
         {
             mmap::iterator ite(m.begin());
             mmap::const_iterator cite(m.begin());
-            //test compare between const_iterator and iterator
+            // test compare between const_iterator and iterator
             UNIT_ASSERT(ite == cite);
             UNIT_ASSERT(!(ite != cite));
             UNIT_ASSERT(cite == ite);
@@ -493,4 +493,4 @@ Y_UNIT_TEST_SUITE(TYMapTest) {
         UNIT_ASSERT(movedM.contains(0));
         UNIT_ASSERT_VALUES_EQUAL(1, movedM[0]);
     }
-}
+} // Y_UNIT_TEST_SUITE(TYMapTest)
diff --git a/util/generic/mapfindptr_ut.cpp b/util/generic/mapfindptr_ut.cpp
index 4178f3a0cc1..21dd007bf8c 100644
--- a/util/generic/mapfindptr_ut.cpp
+++ b/util/generic/mapfindptr_ut.cpp
@@ -18,14 +18,14 @@ Y_UNIT_TEST_SUITE(TMapFindPtrTest) {
         UNIT_ASSERT_EQUAL(*a.FindPtr(42), "cat");
         UNIT_ASSERT_EQUAL(a.FindPtr(0), nullptr);
 
-        //test mutation
+        // test mutation
         if (TString* p = a.FindPtr(42)) {
             *p = "dog";
         }
         UNIT_ASSERT(a.FindPtr(42));
         UNIT_ASSERT_EQUAL(*a.FindPtr(42), "dog");
 
-        //test const-overloaded functions too
+        // test const-overloaded functions too
         const TTestMap& b = a;
         UNIT_ASSERT(b.FindPtr(42) && *b.FindPtr(42) == "dog");
         UNIT_ASSERT_EQUAL(b.FindPtr(0), nullptr);
@@ -65,4 +65,4 @@ Y_UNIT_TEST_SUITE(TMapFindPtrTest) {
         UNIT_ASSERT_VALUES_EQUAL(a.ValueRef(2, str123), "123");
         UNIT_ASSERT_VALUES_EQUAL(a.ValueRef(3, str1234), "1234");
     }
-}
+} // Y_UNIT_TEST_SUITE(TMapFindPtrTest)
diff --git a/util/generic/maybe.h b/util/generic/maybe.h
index ba15c7d7e44..f096fd36c67 100644
--- a/util/generic/maybe.h
+++ b/util/generic/maybe.h
@@ -18,9 +18,9 @@ namespace NMaybe {
     struct TPolicyUndefinedFail {
         [[noreturn]] static void OnEmpty(const std::type_info& valueTypeInfo);
     };
-}
+} // namespace NMaybe
 
-struct TNothing {
+struct [[nodiscard]] TNothing {
     explicit constexpr TNothing(int) noexcept {
     }
 };
@@ -36,7 +36,7 @@ constexpr bool operator==(TNothing, TNothing) noexcept {
 }
 
 template <class T, class Policy /*= ::NMaybe::TPolicyUndefinedExcept*/>
-class TMaybe: private TMaybeBase<T> {
+class TMaybe: private TMaybeBase<T>, private NMaybe::TMaybeSFINAEConstructorBase<T> {
 public:
     using TInPlace = NMaybe::TInPlace;
 
@@ -288,7 +288,7 @@ class TMaybe: private TMaybeBase<T> {
     std::enable_if_t<TMoveAssignable<U>::value,
                      TMaybe&>
     operator=(TMaybe<U, Policy>&& right) noexcept(
-        std::is_nothrow_assignable<T&, U&&>::value&& std::is_nothrow_constructible<T, U&&>::value)
+        std::is_nothrow_assignable<T&, U&&>::value && std::is_nothrow_constructible<T, U&&>::value)
     {
         if (right.Defined()) {
             if (Defined()) {
@@ -303,8 +303,30 @@ class TMaybe: private TMaybeBase<T> {
         return *this;
     }
 
-    template <typename... Args>
-    T& ConstructInPlace(Args&&... args) {
+    template <typename... Args, class = std::enable_if_t<std::is_constructible_v<T, Args...>>>
+    T& GetOrEmplace(Args&&... args) Y_LIFETIME_BOUND {
+        if (!Defined()) {
+            Init(std::forward<Args>(args)...);
+        }
+        return *Data();
+    }
+
+    template <typename... Args, class = std::enable_if_t<std::is_constructible_v<T, Args...>>>
+    T& Emplace(Args&&... args) Y_LIFETIME_BOUND {
+        Clear();
+        Init(std::forward<Args>(args)...);
+        return *Data();
+    }
+
+    template <typename... Args, class = std::enable_if_t<std::is_constructible_v<T, Args...>>>
+    T& emplace(Args&&... args) Y_LIFETIME_BOUND {
+        Clear();
+        Init(std::forward<Args>(args)...);
+        return *Data();
+    }
+
+    template <typename... Args, class = std::enable_if_t<std::is_constructible_v<T, Args...>>>
+    T& ConstructInPlace(Args&&... args) Y_LIFETIME_BOUND {
         Clear();
         Init(std::forward<Args>(args)...);
         return *Data();
@@ -858,7 +880,7 @@ constexpr bool operator>=(const U& value, const TMaybe<T, TPolicy>& maybe) {
 class IOutputStream;
 
 template <class T, class TPolicy>
-inline IOutputStream& operator<<(IOutputStream& out, const TMaybe<T, TPolicy>& maybe) {
+inline IOutputStream& operator<<(IOutputStream& out Y_LIFETIME_BOUND, const TMaybe<T, TPolicy>& maybe) {
     if (maybe.Defined()) {
         out << *maybe;
     } else {
diff --git a/util/generic/maybe_traits.h b/util/generic/maybe_traits.h
index 702912c8fa1..11202903bdc 100644
--- a/util/generic/maybe_traits.h
+++ b/util/generic/maybe_traits.h
@@ -162,8 +162,8 @@ namespace NMaybe {
         constexpr TMoveAssignBase(TMoveAssignBase&&) = default;
         TMoveAssignBase& operator=(const TMoveAssignBase&) = default;
         TMoveAssignBase& operator=(TMoveAssignBase&& rhs) noexcept(
-            std::is_nothrow_move_assignable<T>::value&&
-                std::is_nothrow_move_constructible<T>::value)
+            std::is_nothrow_move_assignable<T>::value &&
+            std::is_nothrow_move_constructible<T>::value)
         {
             if (this->Defined_) {
                 if (rhs.Defined_) {
@@ -179,7 +179,38 @@ namespace NMaybe {
             return *this;
         }
     };
-}
+
+    template <bool CanCopy, bool CanMove>
+    struct TMaybeSFINAEConstructorBaseImpl {};
+
+    template <>
+    struct TMaybeSFINAEConstructorBaseImpl<false, false> {
+        TMaybeSFINAEConstructorBaseImpl() = default;
+        TMaybeSFINAEConstructorBaseImpl(const TMaybeSFINAEConstructorBaseImpl&) = delete;
+        TMaybeSFINAEConstructorBaseImpl(TMaybeSFINAEConstructorBaseImpl&&) = delete;
+        TMaybeSFINAEConstructorBaseImpl& operator=(const TMaybeSFINAEConstructorBaseImpl&) = default;
+        TMaybeSFINAEConstructorBaseImpl& operator=(TMaybeSFINAEConstructorBaseImpl&&) = default;
+    };
+    template <>
+    struct TMaybeSFINAEConstructorBaseImpl<true, false> {
+        TMaybeSFINAEConstructorBaseImpl() = default;
+        TMaybeSFINAEConstructorBaseImpl(const TMaybeSFINAEConstructorBaseImpl&) = default;
+        TMaybeSFINAEConstructorBaseImpl(TMaybeSFINAEConstructorBaseImpl&&) = delete;
+        TMaybeSFINAEConstructorBaseImpl& operator=(const TMaybeSFINAEConstructorBaseImpl&) = default;
+        TMaybeSFINAEConstructorBaseImpl& operator=(TMaybeSFINAEConstructorBaseImpl&&) = default;
+    };
+    template <>
+    struct TMaybeSFINAEConstructorBaseImpl<false, true> {
+        TMaybeSFINAEConstructorBaseImpl() = default;
+        TMaybeSFINAEConstructorBaseImpl(const TMaybeSFINAEConstructorBaseImpl&) = delete;
+        TMaybeSFINAEConstructorBaseImpl(TMaybeSFINAEConstructorBaseImpl&&) = default;
+        TMaybeSFINAEConstructorBaseImpl& operator=(const TMaybeSFINAEConstructorBaseImpl&) = default;
+        TMaybeSFINAEConstructorBaseImpl& operator=(TMaybeSFINAEConstructorBaseImpl&&) = default;
+    };
+
+    template <class T>
+    using TMaybeSFINAEConstructorBase = TMaybeSFINAEConstructorBaseImpl<std::is_copy_constructible<T>::value, std::is_move_constructible<T>::value>;
+} // namespace NMaybe
 
 template <class T>
 using TMaybeBase = NMaybe::TMoveAssignBase<T>;
diff --git a/util/generic/maybe_ut.cpp b/util/generic/maybe_ut.cpp
index 84964b8e8b1..fbcf1a63687 100644
--- a/util/generic/maybe_ut.cpp
+++ b/util/generic/maybe_ut.cpp
@@ -37,6 +37,10 @@ Y_UNIT_TEST_SUITE(TMaybeTest) {
         using T4 = TMaybe<TString>;
         static_assert(!std::is_trivially_copy_constructible<T4>::value, "");
         static_assert(!std::is_trivially_destructible<T4>::value, "");
+
+        using T5 = TMaybe<TMoveOnly>;
+        static_assert(!std::is_copy_constructible<T5>::value);
+        static_assert(std::is_move_constructible<T5>::value);
     }
 
     Y_UNIT_TEST(TestWarning) {
@@ -155,6 +159,12 @@ Y_UNIT_TEST_SUITE(TMaybeTest) {
         UNIT_ASSERT(m == 2);
         x = 7;
         UNIT_ASSERT(m == 7);
+
+        m.emplace(4);
+        UNIT_ASSERT(m == 4);
+        UNIT_ASSERT(m.GetOrEmplace(3) == 4);
+        m.Clear();
+        UNIT_ASSERT(m.GetOrEmplace(4) == 4);
     }
 
     Y_UNIT_TEST(TestMove) {
@@ -1123,4 +1133,4 @@ Y_UNIT_TEST_SUITE(TMaybeTest) {
         TMaybe<TStringBuf> v;
         UNIT_ASSERT_EXCEPTION_CONTAINS(v.GetRef(), yexception, "StringBuf");
     }
-}
+} // Y_UNIT_TEST_SUITE(TMaybeTest)
diff --git a/util/generic/mem_copy.h b/util/generic/mem_copy.h
index b68c852953a..dad969fdc2a 100644
--- a/util/generic/mem_copy.h
+++ b/util/generic/mem_copy.h
@@ -45,7 +45,7 @@ static inline TIfNotPOD<T> MemMove(T* to, const T* from, size_t n) {
         return MemCopy(to, from, n);
     }
 
-    //copy backwards
+    // copy backwards
     while (n) {
         to[n - 1] = from[n - 1];
         --n;
diff --git a/util/generic/mem_copy_ut.cpp b/util/generic/mem_copy_ut.cpp
index 8b55a11cf68..133d9deddcb 100644
--- a/util/generic/mem_copy_ut.cpp
+++ b/util/generic/mem_copy_ut.cpp
@@ -16,7 +16,7 @@ namespace {
 
     struct TC: public TB {
     };
-}
+} // namespace
 
 Y_DECLARE_PODTYPE(TB);
 
@@ -110,4 +110,4 @@ Y_UNIT_TEST_SUITE(TestMemCopy) {
         UNIT_ASSERT(MemCopy(tmp, tmp, 0) == nullptr);
         UNIT_ASSERT(MemMove(tmp, tmp, 0) == nullptr);
     }
-}
+} // Y_UNIT_TEST_SUITE(TestMemCopy)
diff --git a/util/generic/noncopyable.h b/util/generic/noncopyable.h
index c007934133b..81e33b56825 100644
--- a/util/generic/noncopyable.h
+++ b/util/generic/noncopyable.h
@@ -32,7 +32,7 @@ namespace NNonCopyable { // protection from unintended ADL
         TMoveOnly() = default;
         ~TMoveOnly() = default;
     };
-}
+} // namespace NNonCopyable
 
 using TNonCopyable = NNonCopyable::TNonCopyable;
 using TMoveOnly = NNonCopyable::TMoveOnly;
diff --git a/util/generic/objects_counter_ut.cpp b/util/generic/objects_counter_ut.cpp
index 4d5da37a56f..0fa50b8d7fc 100644
--- a/util/generic/objects_counter_ut.cpp
+++ b/util/generic/objects_counter_ut.cpp
@@ -33,4 +33,4 @@ Y_UNIT_TEST_SUITE(ObjectsCounter) {
         }
         UNIT_ASSERT_EQUAL(TObjectCounter<TObject>::ObjectCount(), 1);
     }
-}
+} // Y_UNIT_TEST_SUITE(ObjectsCounter)
diff --git a/util/generic/overloaded.h b/util/generic/overloaded.h
index 96a97e44bc8..06bb0879adc 100644
--- a/util/generic/overloaded.h
+++ b/util/generic/overloaded.h
@@ -6,7 +6,7 @@
  * Typically used with lambdas to construct type-matching visitors for e.g. std::variant:
  * ```
  * std::variant<int, void*, TString> var;
- * Visit(TOverloaded{
+ * std::visit(TOverloaded{
  *     [](int val) { Cerr << "int: " << val; },
  *     [](void* val) { Cerr << "ptr: " << val; },
  *     [](const TString& val) { Cerr << "str: " << val; },
@@ -23,7 +23,7 @@
  * double:
  * ```
  * std::variant<int, double, char> var;
- * Visit(TOverloaded{
+ * std::visit(TOverloaded{
  *     [](double val) { Cerr << "dbl: " << val; },
  * }, var);
  * ```
@@ -32,7 +32,7 @@
  * a verbose `if constexpr`-based version would be preferred:
  * ```
  * std::variant<int, double, char> var;
- * Visit([](auto&& val) {
+ * std::visit([](auto&& val) {
  *     using T = std::decay_t<decltype(val)>;
  *     if constexpr (std::is_same_v<T, int>) {
  *         Cerr << "int: " << val;
diff --git a/util/generic/overloaded_ut.cpp b/util/generic/overloaded_ut.cpp
index f3d73895ad9..34bef66f90c 100644
--- a/util/generic/overloaded_ut.cpp
+++ b/util/generic/overloaded_ut.cpp
@@ -11,7 +11,7 @@ namespace {
     struct TType1 {};
     struct TType2 {};
     struct TType3 {};
-}
+} // namespace
 
 Y_UNIT_TEST_SUITE(TOverloadedTest) {
     Y_UNIT_TEST(StaticTest) {
@@ -79,4 +79,4 @@ Y_UNIT_TEST_SUITE(TOverloadedTest) {
         UNIT_ASSERT_VALUES_EQUAL(matchAsDouble(TTestVariant{12345}), 12345.0);
         UNIT_ASSERT_VALUES_EQUAL(matchAsDouble(TTestVariant{'X'}), 88.0);
     }
-}
+} // Y_UNIT_TEST_SUITE(TOverloadedTest)
diff --git a/util/generic/ptr.cpp b/util/generic/ptr.cpp
index b29baebc175..963dcd5160c 100644
--- a/util/generic/ptr.cpp
+++ b/util/generic/ptr.cpp
@@ -1,4 +1,5 @@
 #include "ptr.h"
+#include "yexception.h"
 
 #include <util/system/defaults.h>
 #include <util/memory/alloc.h>
@@ -15,3 +16,7 @@ void TDelete::Destroy(void* t) noexcept {
 }
 
 TThrRefBase::~TThrRefBase() = default;
+
+[[noreturn]] void NDetail::NullDerefenceThrowImpl() {
+    ythrow yexception{} << "nullptr dereference";
+}
diff --git a/util/generic/ptr.h b/util/generic/ptr.h
index cc2e3c0f519..7219a1c85ca 100644
--- a/util/generic/ptr.h
+++ b/util/generic/ptr.h
@@ -95,22 +95,43 @@ class TFree {
 
 private:
     /*
-     * we do not want dependancy on cstdlib here...
+     * we do not want a dependency on cstdlib here...
      */
     static void DoDestroy(void* t) noexcept;
 };
 
+namespace NDetail {
+    [[noreturn]] void NullDerefenceThrowImpl();
+} // namespace NDetail
+
 template <class Base, class T>
 class TPointerCommon {
 public:
     using TValueType = T;
 
+    /*
+     * for compatibility with std:: smart pointers.
+     */
+    using element_type = T;
+
     inline T* operator->() const noexcept {
         T* ptr = AsT();
         Y_ASSERT(ptr);
         return ptr;
     }
 
+    inline typename std::add_lvalue_reference<T>::type GetRef() const {
+        T* ptr = AsT();
+        if (Y_UNLIKELY(!ptr)) {
+            NDetail::NullDerefenceThrowImpl();
+        }
+        if constexpr (std::is_void<T>::value) {
+            return;
+        } else {
+            return *ptr;
+        }
+    }
+
 #ifndef __cpp_impl_three_way_comparison
     template <class C>
     inline bool operator==(const C& p) const noexcept {
@@ -156,7 +177,7 @@ class TPointerBase: public TPointerCommon<Base, T> {
 };
 
 /*
- * void*-like pointers does not have operator*
+ * void*-like pointers do not have operator*
  */
 template <class Base>
 class TPointerBase<Base, void>: public TPointerCommon<Base, void> {
@@ -214,6 +235,13 @@ class TAutoPtr: public TPointerBase<TAutoPtr<T, D>, T> {
         return T_;
     }
 
+    /*
+     * for compatibility with std:: smart pointers.
+     */
+    inline T* get() const noexcept {
+        return T_;
+    }
+
 #ifdef __cpp_impl_three_way_comparison
     template <class Other>
     inline bool operator==(const Other& p) const noexcept {
@@ -232,7 +260,7 @@ class TAutoPtr: public TPointerBase<TAutoPtr<T, D>, T> {
 };
 
 template <class T, class D>
-class THolder: public TPointerBase<THolder<T, D>, T> {
+class Y_TRIVIAL_ABI THolder: public TPointerBase<THolder<T, D>, T> {
 public:
     constexpr THolder() noexcept
         : T_(nullptr)
@@ -309,6 +337,13 @@ class THolder: public TPointerBase<THolder<T, D>, T> {
         return T_;
     }
 
+    /*
+     * for compatibility with std:: smart pointers.
+     */
+    inline T* get() const noexcept {
+        return T_;
+    }
+
     inline operator TAutoPtr<T, D>() noexcept {
         return Release();
     }
@@ -346,7 +381,7 @@ class THolder: public TPointerBase<THolder<T, D>, T> {
     T* T_;
 };
 
-template <typename T, typename... Args>
+template <typename T, typename... Args, class = std::enable_if_t<std::is_constructible_v<T, Args...>>>
 [[nodiscard]] THolder<T> MakeHolder(Args&&... args) {
     return THolder<T>(new T(std::forward<Args>(args)...));
 }
@@ -370,13 +405,11 @@ class TRefCounted {
     inline void Ref(intptr_t d) noexcept {
         auto resultCount = Counter_.Add(d);
         Y_ASSERT(resultCount >= d);
-        (void)resultCount;
     }
 
     inline void Ref() noexcept {
         auto resultCount = Counter_.Inc();
         Y_ASSERT(resultCount != 0);
-        (void)resultCount;
     }
 
     inline void UnRef(intptr_t d) noexcept {
@@ -398,7 +431,6 @@ class TRefCounted {
     inline void DecRef() noexcept {
         auto resultCount = Counter_.Dec();
         Y_ASSERT(resultCount >= 0);
-        (void)resultCount;
     }
 
     TRefCounted(const TRefCounted&)
@@ -560,6 +592,13 @@ class TIntrusivePtr: public TPointerBase<TIntrusivePtr<T, Ops>, T> {
         return T_;
     }
 
+    /*
+     * for compatibility with std:: smart pointers.
+     */
+    inline T* get() const noexcept {
+        return T_;
+    }
+
     inline void Swap(TIntrusivePtr& r) noexcept {
         DoSwap(T_, r.T_);
     }
@@ -680,6 +719,13 @@ class TIntrusiveConstPtr: public TPointerBase<TIntrusiveConstPtr<T, Ops>, const
         return T_;
     }
 
+    /*
+     * for compatibility with std:: smart pointers.
+     */
+    inline const T* get() const noexcept {
+        return T_;
+    }
+
     inline void Swap(TIntrusiveConstPtr& r) noexcept {
         DoSwap(T_, r.T_);
     }
@@ -883,6 +929,13 @@ class TSharedPtr: public TPointerBase<TSharedPtr<T, C, D>, T> {
         return T_;
     }
 
+    /*
+     * for compatibility with std:: smart pointers.
+     */
+    inline T* get() const noexcept {
+        return T_;
+    }
+
     inline C* ReferenceCounter() const noexcept {
         return C_;
     }
@@ -976,17 +1029,17 @@ using TAtomicSharedPtr = TSharedPtr<T, TAtomicCounter, D>;
 template <class T, class D = TDelete>
 using TSimpleSharedPtr = TSharedPtr<T, TSimpleCounter, D>;
 
-template <typename T, typename C, typename... Args>
+template <typename T, typename C, typename... Args, class = std::enable_if_t<std::is_constructible_v<T, Args...>>>
 [[nodiscard]] TSharedPtr<T, C> MakeShared(Args&&... args) {
     return new T{std::forward<Args>(args)...};
 }
 
-template <typename T, typename... Args>
+template <typename T, typename... Args, class = std::enable_if_t<std::is_constructible_v<T, Args...>>>
 [[nodiscard]] inline TAtomicSharedPtr<T> MakeAtomicShared(Args&&... args) {
     return MakeShared<T, TAtomicCounter>(std::forward<Args>(args)...);
 }
 
-template <typename T, typename... Args>
+template <typename T, typename... Args, class = std::enable_if_t<std::is_constructible_v<T, Args...>>>
 [[nodiscard]] inline TSimpleSharedPtr<T> MakeSimpleShared(Args&&... args) {
     return MakeShared<T, TSimpleCounter>(std::forward<Args>(args)...);
 }
@@ -995,8 +1048,9 @@ class TCopyClone {
 public:
     template <class T>
     static inline T* Copy(T* t) {
-        if (t)
+        if (t) {
             return t->Clone();
+        }
         return nullptr;
     }
 };
@@ -1005,8 +1059,9 @@ class TCopyNew {
 public:
     template <class T>
     static inline T* Copy(T* t) {
-        if (t)
+        if (t) {
             return new T(*t);
+        }
         return nullptr;
     }
 };
@@ -1075,8 +1130,9 @@ class TCopyPtr: public TPointerBase<TCopyPtr<T, C, D>, T> {
 #endif
 private:
     inline void DoDestroy() noexcept {
-        if (T_)
+        if (T_) {
             D::Destroy(T_);
+        }
     }
 
 private:
@@ -1105,6 +1161,13 @@ class TCowPtr: public TPointerBase<TCowPtr<TPtr, TCopy>, const typename TPtr::TV
         return Const();
     }
 
+    /*
+     * for compatibility with std:: smart pointers.
+     */
+    inline const T* get() const noexcept {
+        return Const();
+    }
+
     inline const T* Const() const noexcept {
         return T_.Get();
     }
diff --git a/util/generic/ptr.pxd b/util/generic/ptr.pxd
index 16e8d191443..e4078295190 100644
--- a/util/generic/ptr.pxd
+++ b/util/generic/ptr.pxd
@@ -36,7 +36,8 @@ cdef extern from "<util/generic/ptr.h>" nogil:
         TAtomicSharedPtr(T*)
         T& operator*()
         T* Get()
-        void Reset(T*)
+        void Reset(T*)  # this is a fake signature as a workaround for Cython's inability to support implicit conversion T* -> TAtomicSharedPtr[T]
+        void Reset(TAtomicSharedPtr) noexcept
 
 
     cdef TAtomicSharedPtr[T] MakeAtomicShared[T](...)
diff --git a/util/generic/ptr_ut.cpp b/util/generic/ptr_ut.cpp
index 1e84e4fadb9..e6a4a7837c0 100644
--- a/util/generic/ptr_ut.cpp
+++ b/util/generic/ptr_ut.cpp
@@ -35,6 +35,8 @@ class TPointerTest: public TTestBase {
     UNIT_TEST(TestSimpleIntrusivePtrCtorTsan);
     UNIT_TEST(TestRefCountedPtrsInHashSet);
     UNIT_TEST(TestSharedPtrDowncast);
+    UNIT_TEST(TestStdCompatibility);
+    UNIT_TEST(TestGetRef);
     UNIT_TEST_SUITE_END();
 
 private:
@@ -89,6 +91,8 @@ class TPointerTest: public TTestBase {
     void TestRefCountedPtrsInHashSetImpl();
     void TestRefCountedPtrsInHashSet();
     void TestSharedPtrDowncast();
+    void TestStdCompatibility();
+    void TestGetRef();
 };
 
 UNIT_TEST_SUITE_REGISTRATION(TPointerTest);
@@ -385,7 +389,7 @@ namespace NTestIntrusiveConvertion {
 
     void Func(TIntrusiveConstPtr<TB>) {
     }
-}
+} // namespace NTestIntrusiveConvertion
 
 void TPointerTest::TestIntrusiveConvertion() {
     using namespace NTestIntrusiveConvertion;
@@ -559,7 +563,7 @@ namespace {
         }
     };
 
-}
+} // namespace
 
 void TPointerTest::TestOperatorBool() {
     using TVec = TVector<ui32>;
@@ -934,3 +938,56 @@ void TPointerTest::TestSharedPtrDowncast() {
         UNIT_ASSERT_VALUES_EQUAL(probeState.Destructors, 1);
     }
 }
+
+void TPointerTest::TestStdCompatibility() {
+    {
+        TSimpleSharedPtr<int> ptr = MakeSimpleShared<int>(5);
+        UNIT_ASSERT_TYPES_EQUAL(decltype(ptr)::element_type, int);
+        UNIT_ASSERT_VALUES_EQUAL(ptr.get(), ptr.Get());
+    }
+
+    {
+        TAtomicSharedPtr<int> ptr = MakeAtomicShared<int>(5);
+        UNIT_ASSERT_TYPES_EQUAL(decltype(ptr)::element_type, int);
+        UNIT_ASSERT_VALUES_EQUAL(ptr.get(), ptr.Get());
+    }
+
+    {
+        TAutoPtr<int> ptr = MakeHolder<int>(5);
+        UNIT_ASSERT_TYPES_EQUAL(decltype(ptr)::element_type, int);
+        UNIT_ASSERT_VALUES_EQUAL(ptr.get(), ptr.Get());
+    }
+
+    {
+        TIntrusivePtr<TOp> ptr;
+        UNIT_ASSERT_TYPES_EQUAL(decltype(ptr)::element_type, TOp);
+        UNIT_ASSERT_VALUES_EQUAL(ptr.get(), ptr.Get());
+    }
+}
+
+void TPointerTest::TestGetRef() {
+    {
+        TSimpleSharedPtr<int> ptr = MakeSimpleShared<int>(5);
+        UNIT_ASSERT_TYPES_EQUAL(decltype(ptr.GetRef()), int&);
+        UNIT_ASSERT_VALUES_EQUAL(ptr.GetRef(), 5);
+        ptr.GetRef() += 5;
+        UNIT_ASSERT_VALUES_EQUAL(ptr.GetRef(), 10);
+    }
+    {
+        THolder<const int> ptr = MakeHolder<int>(5);
+        UNIT_ASSERT_TYPES_EQUAL(decltype(ptr.GetRef()), const int&);
+        UNIT_ASSERT_VALUES_EQUAL(ptr.GetRef(), 5);
+    }
+    {
+        THolder<const int> ptr;
+        UNIT_ASSERT_EXCEPTION(ptr.GetRef(), yexception);
+    }
+
+    {
+        THolder<void, TNoAction> ptr((void*)10);
+        UNIT_ASSERT_TYPES_EQUAL(decltype(ptr.GetRef()), void);
+        ptr.GetRef();
+        ptr = {};
+        UNIT_ASSERT_EXCEPTION(ptr.GetRef(), yexception);
+    }
+}
diff --git a/util/generic/queue.h b/util/generic/queue.h
index f5959f68f28..f1d358daf25 100644
--- a/util/generic/queue.h
+++ b/util/generic/queue.h
@@ -24,11 +24,11 @@ class TQueue: public std::queue<T, S> {
         this->c.clear();
     }
 
-    inline S& Container() {
+    inline S& Container() Y_LIFETIME_BOUND {
         return this->c;
     }
 
-    inline const S& Container() const {
+    inline const S& Container() const Y_LIFETIME_BOUND {
         return this->c;
     }
 };
@@ -48,11 +48,20 @@ class TPriorityQueue: public std::priority_queue<T, S, C> {
         this->c.clear();
     }
 
-    inline S& Container() {
+    inline T PopValue() {
+        Y_ASSERT(!this->empty());
+        auto& container = this->c;
+        std::pop_heap(container.begin(), container.end(), this->comp);
+        T value = std::move(container.back());
+        container.pop_back();
+        return value;
+    }
+
+    inline S& Container() Y_LIFETIME_BOUND {
         return this->c;
     }
 
-    inline const S& Container() const {
+    inline const S& Container() const Y_LIFETIME_BOUND {
         return this->c;
     }
 };
diff --git a/util/generic/queue_ut.cpp b/util/generic/queue_ut.cpp
index a33399e1048..bc901ba8aa0 100644
--- a/util/generic/queue_ut.cpp
+++ b/util/generic/queue_ut.cpp
@@ -1,6 +1,7 @@
 #include "queue.h"
+#include "deque.h"
 #include "list.h"
-#include "vector.h"
+#include "ptr.h"
 
 #include <library/cpp/testing/unittest/registar.h>
 
@@ -152,6 +153,41 @@ Y_UNIT_TEST_SUITE(TYQueueTest) {
         UNIT_ASSERT(q.empty());
     }
 
+    struct THolderWithPriority {
+        THolderWithPriority(const TString& value, int priority)
+            : Value(MakeHolder<TString>(value))
+            , Priority(priority)
+        {
+        }
+
+        THolder<TString> Value; // THolder to test move-ctor
+        int Priority;
+
+        std::weak_ordering operator<=>(const THolderWithPriority& other) const noexcept {
+            return Priority <=> other.Priority;
+        }
+    };
+
+    Y_UNIT_TEST(pqueue5) {
+        // Test move-and-pop
+        TPriorityQueue<THolderWithPriority> q;
+
+        UNIT_ASSERT(q.empty());
+        q.emplace("min", 1);
+        q.emplace("max", 3);
+        q.emplace("middle", 2);
+
+        auto value = q.PopValue().Value;
+        UNIT_ASSERT(*value == "max");
+
+        value = q.PopValue().Value;
+        UNIT_ASSERT(*value == "middle");
+
+        value = q.PopValue().Value;
+        UNIT_ASSERT(*value == "min");
+        UNIT_ASSERT(q.empty());
+    }
+
     Y_UNIT_TEST(queue1) {
         TQueue<int, TList<int>> q;
 
@@ -207,4 +243,4 @@ Y_UNIT_TEST_SUITE(TYQueueTest) {
 
         UNIT_ASSERT(q.empty());
     }
-}
+} // Y_UNIT_TEST_SUITE(TYQueueTest)
diff --git a/util/generic/reserve.h b/util/generic/reserve.h
index 81ceed19dc4..8ee2d318225 100644
--- a/util/generic/reserve.h
+++ b/util/generic/reserve.h
@@ -1,10 +1,10 @@
 #pragma once
 
 namespace NDetail {
-    struct TReserveTag {
+    struct [[nodiscard]] TReserveTag {
         size_t Capacity;
     };
-}
+} // namespace NDetail
 
 constexpr ::NDetail::TReserveTag Reserve(size_t capacity) {
     return ::NDetail::TReserveTag{capacity};
diff --git a/util/generic/scope.h b/util/generic/scope.h
index b2c33af61e7..2ae3feb7178 100644
--- a/util/generic/scope.h
+++ b/util/generic/scope.h
@@ -29,24 +29,17 @@ namespace NPrivate {
     private:
         F Function_;
     };
-
-    struct TMakeGuardHelper {
-        template <class F>
-        TScopeGuard<F> operator|(F&& function) const {
-            return std::forward<F>(function);
-        }
-    };
-}
+} // namespace NPrivate
 
 // \brief `Y_SCOPE_EXIT(captures) { body };`
 //
-// General implementaion of RAII idiom (resource acquisition is initialization). Executes
-// function upon return from the current scope.
+// General implementaion of RAII idiom (resource acquisition is initialization). Executes code in the `body` block
+// upon return from the current scope.
 //
 // @note expects `body` to provide no-throw guarantee, otherwise whenever an exception
 // is thrown and leaves the outermost block of `body`, the function `std::terminate` is called.
 // @see http://drdobbs.com/184403758 for detailed motivation.
-#define Y_SCOPE_EXIT(...) const auto Y_GENERATE_UNIQUE_ID(scopeGuard) Y_DECLARE_UNUSED = ::NPrivate::TMakeGuardHelper{} | [__VA_ARGS__]() mutable -> void
+#define Y_SCOPE_EXIT(...) const ::NPrivate::TScopeGuard Y_GENERATE_UNIQUE_ID(scopeGuard) Y_DECLARE_UNUSED = [__VA_ARGS__]() mutable -> void
 
 // \brief `Y_DEFER { body };`
 //
diff --git a/util/generic/scope_ut.cpp b/util/generic/scope_ut.cpp
index bdb434d4875..2df66fda576 100644
--- a/util/generic/scope_ut.cpp
+++ b/util/generic/scope_ut.cpp
@@ -44,4 +44,4 @@ Y_UNIT_TEST_SUITE(ScopeToolsTest) {
 
         UNIT_ASSERT_VALUES_EQUAL(i, 20);
     }
-}
+} // Y_UNIT_TEST_SUITE(ScopeToolsTest)
diff --git a/util/generic/serialized_enum.h b/util/generic/serialized_enum.h
index 8188c43eede..352cd04dc84 100644
--- a/util/generic/serialized_enum.h
+++ b/util/generic/serialized_enum.h
@@ -41,7 +41,7 @@ namespace NEnumSerializationRuntime {
 
         template <typename TEnumType, typename TRepresentationType, typename TValueType, class TStorage = TMap<TRepresentationType, TValueType>>
         class TMappedDictView;
-    }
+    } // namespace NDetail
 
     /// Class with behaviour similar to TMap<EnumT, TValueType>
     template <typename EnumT, typename TValueType>
@@ -89,7 +89,7 @@ namespace NEnumSerializationRuntime {
      */
     template <typename EnumT>
     TStringBuf ToStringBuf(EnumT e);
-}
+} // namespace NEnumSerializationRuntime
 
 /**
  * Returns names for items in enum or enum class
@@ -403,5 +403,5 @@ namespace NEnumSerializationRuntime {
         private:
             const TStorage& Ref;
         };
-    }
-}
+    } // namespace NDetail
+} // namespace NEnumSerializationRuntime
diff --git a/util/generic/serialized_enum_ut.cpp b/util/generic/serialized_enum_ut.cpp
index 3a94e1d4716..92ddff98b00 100644
--- a/util/generic/serialized_enum_ut.cpp
+++ b/util/generic/serialized_enum_ut.cpp
@@ -117,4 +117,4 @@ Y_UNIT_TEST_SUITE(TestSerializedEnum) {
         UNIT_ASSERT_VALUES_EQUAL(materialized.size(), map.size());
         UNIT_ASSERT_VALUES_EQUAL(materialized.at(ETestEnum::Four), 16);
     }
-}
+} // Y_UNIT_TEST_SUITE(TestSerializedEnum)
diff --git a/util/generic/set_ut.cpp b/util/generic/set_ut.cpp
index d2769d327f7..bbaeb6a5b48 100644
--- a/util/generic/set_ut.cpp
+++ b/util/generic/set_ut.cpp
@@ -99,7 +99,7 @@ Y_UNIT_TEST_SUITE(YSetTest) {
         std::pair<TSet<int>::iterator, TSet<int>::iterator> pit;
         std::pair<TSet<int>::const_iterator, TSet<int>::const_iterator> pcit;
 
-        //Check iterator on mutable set
+        // Check iterator on mutable set
         sit = s.lower_bound(2);
         UNIT_ASSERT(sit != s.end());
         UNIT_ASSERT(*sit == 3);
@@ -122,7 +122,7 @@ Y_UNIT_TEST_SUITE(YSetTest) {
         UNIT_ASSERT(pit.second != s.end());
         UNIT_ASSERT(*pit.second == 6);
 
-        //Check const_iterator on mutable set
+        // Check const_iterator on mutable set
         scit = s.lower_bound(2);
         UNIT_ASSERT(scit != s.end());
         UNIT_ASSERT(*scit == 3);
@@ -138,7 +138,7 @@ Y_UNIT_TEST_SUITE(YSetTest) {
         UNIT_ASSERT(pcit.second != s.end());
         UNIT_ASSERT(*pcit.second == 7);
 
-        //Check const_iterator on const set
+        // Check const_iterator on const set
         scit = crs.lower_bound(2);
         UNIT_ASSERT(scit != crs.end());
         UNIT_ASSERT(*scit == 3);
@@ -405,4 +405,4 @@ Y_UNIT_TEST_SUITE(YSetTest) {
             UNIT_ASSERT(ckeySet.equal_range(2) != std::make_pair(ckeySet.begin(), ckeySet.end()));
         }
     }
-}
+} // Y_UNIT_TEST_SUITE(YSetTest)
diff --git a/util/generic/singleton.cpp b/util/generic/singleton.cpp
index df89d0a5791..43d626e7f01 100644
--- a/util/generic/singleton.cpp
+++ b/util/generic/singleton.cpp
@@ -23,10 +23,10 @@ namespace {
             return ret;
         }
 
-        //clash almost impossible, ONLY if we have threads with ids 0 and 1!
+        // clash almost impossible, ONLY if we have threads with ids 0 and 1!
         return 1;
     }
-}
+} // namespace
 
 void NPrivate::FillWithTrash(void* ptr, size_t len) {
 #if defined(NDEBUG)
diff --git a/util/generic/singleton.h b/util/generic/singleton.h
index ed01efb213e..5a7167107ea 100644
--- a/util/generic/singleton.h
+++ b/util/generic/singleton.h
@@ -103,7 +103,7 @@ namespace NPrivate {
 
         T* D;
     };
-}
+} // namespace NPrivate
 
 #define Y_DECLARE_SINGLETON_FRIEND()                \
     template <class T, size_t P, class... TArgs>    \
diff --git a/util/generic/singleton_ut.cpp b/util/generic/singleton_ut.cpp
index 35ba90cd760..062dc6c2bd3 100644
--- a/util/generic/singleton_ut.cpp
+++ b/util/generic/singleton_ut.cpp
@@ -43,4 +43,4 @@ Y_UNIT_TEST_SUITE(TestSingleton) {
         }
         UNIT_ASSERT_VALUES_EQUAL(Default<TWithParams>().Data1, 0);
     }
-}
+} // Y_UNIT_TEST_SUITE(TestSingleton)
diff --git a/util/generic/size_literals.h b/util/generic/size_literals.h
index 273fffcce5a..acf43cb0766 100644
--- a/util/generic/size_literals.h
+++ b/util/generic/size_literals.h
@@ -6,31 +6,31 @@
 
 // Unsigned literals
 
-constexpr ui64 operator"" _B(unsigned long long value) noexcept {
+constexpr ui64 operator""_B(unsigned long long value) noexcept {
     return value;
 }
 
-constexpr ui64 operator"" _KB(unsigned long long value) noexcept {
+constexpr ui64 operator""_KB(unsigned long long value) noexcept {
     return value * 1024;
 }
 
-constexpr ui64 operator"" _MB(unsigned long long value) noexcept {
+constexpr ui64 operator""_MB(unsigned long long value) noexcept {
     return value * 1024_KB;
 }
 
-constexpr ui64 operator"" _GB(unsigned long long value) noexcept {
+constexpr ui64 operator""_GB(unsigned long long value) noexcept {
     return value * 1024_MB;
 }
 
-constexpr ui64 operator"" _TB(unsigned long long value) noexcept {
+constexpr ui64 operator""_TB(unsigned long long value) noexcept {
     return value * 1024_GB;
 }
 
-constexpr ui64 operator"" _PB(unsigned long long value) noexcept {
+constexpr ui64 operator""_PB(unsigned long long value) noexcept {
     return value * 1024_TB;
 }
 
-constexpr ui64 operator"" _EB(unsigned long long value) noexcept {
+constexpr ui64 operator""_EB(unsigned long long value) noexcept {
     return value * 1024_PB;
 }
 
@@ -42,28 +42,28 @@ namespace NPrivate {
                    ? static_cast<i64>(value)
                    : ythrow yexception() << "The resulting value " << value << " does not fit into the i64 type";
     }
-}
+} // namespace NPrivate
 
-constexpr i64 operator"" _KBs(const unsigned long long value) noexcept {
+constexpr i64 operator""_KBs(const unsigned long long value) noexcept {
     return ::NPrivate::SignedCast(value * 1024);
 }
 
-constexpr i64 operator"" _MBs(unsigned long long value) noexcept {
+constexpr i64 operator""_MBs(unsigned long long value) noexcept {
     return ::NPrivate::SignedCast(value * 1024_KB);
 }
 
-constexpr i64 operator"" _GBs(unsigned long long value) noexcept {
+constexpr i64 operator""_GBs(unsigned long long value) noexcept {
     return ::NPrivate::SignedCast(value * 1024_MB);
 }
 
-constexpr i64 operator"" _TBs(unsigned long long value) noexcept {
+constexpr i64 operator""_TBs(unsigned long long value) noexcept {
     return ::NPrivate::SignedCast(value * 1024_GB);
 }
 
-constexpr i64 operator"" _PBs(unsigned long long value) noexcept {
+constexpr i64 operator""_PBs(unsigned long long value) noexcept {
     return ::NPrivate::SignedCast(value * 1024_TB);
 }
 
-constexpr i64 operator"" _EBs(unsigned long long value) noexcept {
+constexpr i64 operator""_EBs(unsigned long long value) noexcept {
     return ::NPrivate::SignedCast(value * 1024_PB);
 }
diff --git a/util/generic/size_literals_ut.cpp b/util/generic/size_literals_ut.cpp
index 410e22c39d0..ac53601c667 100644
--- a/util/generic/size_literals_ut.cpp
+++ b/util/generic/size_literals_ut.cpp
@@ -64,5 +64,5 @@ void CompileTestSigned() {
     static_assert(8388607_TBs == 8388607_GBs * 1024, "Wrong 8388607TBs value"); // 2**23 - 1 TB
 
     // Should cause compilation error if uncommented
-    //static_assert(8388608_TBs == 8388608_GBs * 1024, "Wrong 8388608TBs value");
+    // static_assert(8388608_TBs == 8388608_GBs * 1024, "Wrong 8388608TBs value");
 }
diff --git a/util/generic/stack_ut.cpp b/util/generic/stack_ut.cpp
index 248127d3260..637fa65040d 100644
--- a/util/generic/stack_ut.cpp
+++ b/util/generic/stack_ut.cpp
@@ -13,4 +13,4 @@ Y_UNIT_TEST_SUITE(TYStackTest) {
         UNIT_ASSERT(s);
         UNIT_ASSERT(!s.empty());
     }
-}
+} // Y_UNIT_TEST_SUITE(TYStackTest)
diff --git a/util/generic/store_policy.h b/util/generic/store_policy.h
index 497b13f6c41..93608571af2 100644
--- a/util/generic/store_policy.h
+++ b/util/generic/store_policy.h
@@ -10,7 +10,7 @@ struct TWithRefCount: public TBase, public TRefCounted<TWithRefCount<TBase, TCou
 
 template <class T>
 struct TPtrPolicy {
-    inline TPtrPolicy(T* t)
+    inline TPtrPolicy(T* t Y_LIFETIME_BOUND)
         : T_(t)
     {
     }
@@ -93,7 +93,7 @@ template <class T, bool IsReference = std::is_reference<T>::value>
 struct TAutoEmbedOrPtrPolicy: TPtrPolicy<std::remove_reference_t<T>> {
     using TBase = TPtrPolicy<std::remove_reference_t<T>>;
 
-    TAutoEmbedOrPtrPolicy(T& reference)
+    TAutoEmbedOrPtrPolicy(T& reference Y_LIFETIME_BOUND)
         : TBase(&reference)
     {
     }
diff --git a/util/generic/store_policy_ut.cpp b/util/generic/store_policy_ut.cpp
index d361338dfa7..3df74517440 100644
--- a/util/generic/store_policy_ut.cpp
+++ b/util/generic/store_policy_ut.cpp
@@ -114,4 +114,4 @@ Y_UNIT_TEST_SUITE(StorePolicy) {
         TestWrapperConstructors<TNoDefaultConstructible>();
         TestWrapperConstructors<TVector<short>>();
     }
-}
+} // Y_UNIT_TEST_SUITE(StorePolicy)
diff --git a/util/generic/strbase.h b/util/generic/strbase.h
index 86e5c0f2f25..fad89e5c124 100644
--- a/util/generic/strbase.h
+++ b/util/generic/strbase.h
@@ -32,7 +32,7 @@ namespace NStringPrivate {
         Y_ASSERT(s);
         return strnlen(s, maxlen);
     }
-}
+} // namespace NStringPrivate
 
 template <typename TDerived, typename TCharType, typename TTraitsType = std::char_traits<TCharType>>
 class TStringBase {
@@ -71,7 +71,7 @@ class TStringBase {
     }
 
     /**
-     * @param                           Pointer to character inside the string, or nullptr.
+     * @param ret                       Pointer to character inside the string, or nullptr.
      * @return                          Offset from string beginning (in chars), or npos on nullptr.
      */
     inline size_t off(const TCharType* ret) const noexcept {
@@ -552,3 +552,21 @@ class TStringBase {
         return toCopy;
     }
 };
+template <typename TDerived, typename TCharType, typename TTraitsType>
+class TStdStringCompatibilityBase {
+    using TStringView = std::basic_string_view<TCharType>;
+
+public:
+    inline bool contains(const TStringView s) const noexcept {
+        return This()->Contains(s);
+    }
+
+    inline bool contains(TChar c) const noexcept {
+        return This()->Contains(c);
+    }
+
+private:
+    constexpr inline const TDerived* This() const noexcept {
+        return static_cast<const TDerived*>(this);
+    }
+};
diff --git a/util/generic/strbuf.h b/util/generic/strbuf.h
index 77644a2f6ca..c4da8f52cc9 100644
--- a/util/generic/strbuf.h
+++ b/util/generic/strbuf.h
@@ -1,6 +1,7 @@
 #pragma once
 
 #include "fwd.h"
+#include "iterator.h"
 #include "strbase.h"
 #include "utility.h"
 #include "typetraits.h"
@@ -21,8 +22,8 @@ class TBasicStringBuf: public std::basic_string_view<TCharType>,
     using char_type = TCharType; // TODO: DROP
     using traits_type = TTraits;
 
-    //Resolving some ambiguity between TStringBase and std::basic_string_view
-    //for typenames
+    // Resolving some ambiguity between TStringBase and std::basic_string_view
+    // for typenames
     using typename TStringView::const_iterator;
     using typename TStringView::const_reference;
     using typename TStringView::const_reverse_iterator;
@@ -32,10 +33,10 @@ class TBasicStringBuf: public std::basic_string_view<TCharType>,
     using typename TStringView::size_type;
     using typename TStringView::value_type;
 
-    //for constants
+    // for constants
     using TStringView::npos;
 
-    //for methods and operators
+    // for methods and operators
     using TStringView::begin;
     using TStringView::cbegin;
     using TStringView::cend;
@@ -96,6 +97,8 @@ class TBasicStringBuf: public std::basic_string_view<TCharType>,
      *  to generate compilation error instead.
      */
     constexpr inline TBasicStringBuf(std::nullptr_t begin, size_t size) = delete;
+    // TODO: Uncomment.
+    // constexpr TBasicStringBuf(std::nullptr_t) = delete;
 
     constexpr inline TBasicStringBuf(const TCharType* data, size_t size) noexcept
         : TStringView(data, size)
@@ -111,8 +114,12 @@ class TBasicStringBuf: public std::basic_string_view<TCharType>,
     {
     }
 
-    constexpr inline TBasicStringBuf(const TCharType* beg, const TCharType* end) noexcept
-        : TStringView(beg, end - beg)
+    constexpr inline TBasicStringBuf(const TCharType* beg Y_LIFETIME_BOUND, const TCharType* end Y_LIFETIME_BOUND) noexcept
+#if __cplusplus >= 202002L && __cpp_lib_string_view >= 201803L && !defined(_LIBCPP_HAS_NO_CONCEPTS)
+        : TStringView(beg, end)
+#else
+        : TStringView(beg, NonNegativeDistance(beg, end))
+#endif
     {
     }
 
@@ -122,6 +129,12 @@ class TBasicStringBuf: public std::basic_string_view<TCharType>,
     {
     }
 
+    template <typename T>
+    inline TBasicStringBuf(const TBasicString<TCharType, T>& str Y_LIFETIME_BOUND) noexcept
+        : TStringView(str.data(), str.size())
+    {
+    }
+
     template <typename T, typename A>
     inline TBasicStringBuf(const std::basic_string<TCharType, T, A>& str) noexcept
         : TStringView(str)
@@ -129,13 +142,13 @@ class TBasicStringBuf: public std::basic_string_view<TCharType>,
     }
 
     template <typename TCharTraits>
-    constexpr TBasicStringBuf(std::basic_string_view<TCharType, TCharTraits> view) noexcept
+    constexpr TBasicStringBuf(std::basic_string_view<TCharType, TCharTraits> view Y_LIFETIME_BOUND) noexcept
         : TStringView(view)
     {
     }
 
     template <typename TCharTraits>
-    constexpr TBasicStringBuf(TBasicStringBuf<TCharType, TCharTraits> sb) noexcept
+    constexpr TBasicStringBuf(TBasicStringBuf<TCharType, TCharTraits> sb Y_LIFETIME_BOUND) noexcept
         : TStringView(sb)
     {
     }
@@ -151,13 +164,13 @@ class TBasicStringBuf: public std::basic_string_view<TCharType>,
          */
     }
 
-    inline TBasicStringBuf(const TBasicStringBuf& src, size_t pos, size_t n) noexcept
+    inline TBasicStringBuf(const TBasicStringBuf src Y_LIFETIME_BOUND, size_t pos, size_t n) noexcept
         : TBasicStringBuf(src)
     {
         Skip(pos).Trunc(n);
     }
 
-    inline TBasicStringBuf(const TBasicStringBuf& src, size_t pos) noexcept
+    inline TBasicStringBuf(const TBasicStringBuf src Y_LIFETIME_BOUND, size_t pos) noexcept
         : TBasicStringBuf(src, pos, TBase::npos)
     {
     }
@@ -274,8 +287,9 @@ class TBasicStringBuf: public std::basic_string_view<TCharType>,
     // s.TrySplitOn(s.find('z'), ...) is false, but s.TrySplitOn(100500, ...) is true.
 
     bool TrySplitOn(size_t pos, TdSelf& l, TdSelf& r, size_t len = 1) const noexcept {
-        if (TBase::npos == pos)
+        if (TBase::npos == pos) {
             return false;
+        }
 
         DoSplitOn(pos, l, r, len);
         return true;
@@ -455,7 +469,7 @@ class TBasicStringBuf: public std::basic_string_view<TCharType>,
     /// Sets the start pointer to a position relative to the end
     inline TdSelf& RSeek(size_t tailSize) noexcept {
         if (size() > tailSize) {
-            //WARN: removing TStringView:: will lead to an infinite recursion
+            // WARN: removing TStringView:: will lead to an infinite recursion
             *this = TStringView::substr(size() - tailSize, tailSize);
         }
 
@@ -468,7 +482,7 @@ class TBasicStringBuf: public std::basic_string_view<TCharType>,
         // exn_spec_violation: An exception of type "std::out_of_range" is thrown but the exception specification "noexcept" doesn't allow it to be thrown. This will result in a call to terminate().
         // fun_call_w_exception: Called function TStringView::substr throws an exception of type "std::out_of_range".
         // Suppress this issue because we pass argument pos=0 and string_view can't throw std::out_of_range.
-        *this = TStringView::substr(0, targetSize); //WARN: removing TStringView:: will lead to an infinite recursion
+        *this = TStringView::substr(0, targetSize); // WARN: removing TStringView:: will lead to an infinite recursion
         return *this;
     }
 
@@ -547,3 +561,9 @@ std::ostream& operator<<(std::ostream& os, TStringBuf buf);
 constexpr TStringBuf operator""_sb(const char* str, size_t len) {
     return TStringBuf{str, len};
 }
+
+#ifdef __cpp_lib_format
+template <typename TCharType, typename TTraits>
+struct std::formatter<TBasicStringBuf<TCharType, TTraits>, TCharType>
+    : std::formatter<std::basic_string_view<TCharType>, TCharType> {};
+#endif
diff --git a/util/generic/strbuf_ut.cpp b/util/generic/strbuf_ut.cpp
index 245b93bc98d..3e76036e858 100644
--- a/util/generic/strbuf_ut.cpp
+++ b/util/generic/strbuf_ut.cpp
@@ -100,7 +100,7 @@ Y_UNIT_TEST_SUITE(TStrBufTest) {
         UNIT_ASSERT(str.AfterPrefix("cat_", r));
         UNIT_ASSERT_EQUAL(r, "dog");
 
-        //example:
+        // example:
         str = "http://ya.ru";
         if (str.AfterPrefix("http://", r)) {
             UNIT_ASSERT_EQUAL(r, "ya.ru");
@@ -127,7 +127,7 @@ Y_UNIT_TEST_SUITE(TStrBufTest) {
         UNIT_ASSERT(str.BeforeSuffix("_dog", r));
         UNIT_ASSERT_EQUAL(r, "cat");
 
-        //example:
+        // example:
         str = "maps.yandex.com.ua";
         if (str.BeforeSuffix(".ru", r)) {
             UNIT_ASSERT_EQUAL(r, "maps.yandex");
@@ -362,7 +362,23 @@ Y_UNIT_TEST_SUITE(TStrBufTest) {
         static_assert(std::is_same_v<decltype(s), TStringBuf>);
         UNIT_ASSERT_VALUES_EQUAL(s, TStringBuf("123"));
     }
-}
+
+    // Test TStringBuf::contains only if std::string_view::contains exists.
+    // TStringBuf must be template parameter otherwise compilation of assertions fails.
+    template <typename TStringBuf = TStringBuf, typename T = std::string_view, decltype(T().contains(T())) = false>
+    void TestContainsImpl(int) {
+        UNIT_ASSERT(TStringBuf("123").contains("12"));
+        UNIT_ASSERT(!TStringBuf("123").contains("21"));
+    }
+
+    void TestContainsImpl(...) {
+        // Do nothing.
+    }
+
+    Y_UNIT_TEST(TestContains) {
+        TestContainsImpl(0);
+    }
+} // Y_UNIT_TEST_SUITE(TStrBufTest)
 
 Y_UNIT_TEST_SUITE(TWtrBufTest) {
     Y_UNIT_TEST(TestConstExpr) {
@@ -388,4 +404,27 @@ Y_UNIT_TEST_SUITE(TWtrBufTest) {
 
         static_assert(str1 == str2);
     }
-}
+} // Y_UNIT_TEST_SUITE(TWtrBufTest)
+
+#ifdef __cpp_lib_format
+
+    #include <format>
+
+Y_UNIT_TEST_SUITE(TStrBufStdFormatTest) {
+    Y_UNIT_TEST(TestFormatTStringBuf) {
+        TStringBuf buf("hello");
+        UNIT_ASSERT_VALUES_EQUAL(std::format("{}", buf), "hello");
+    }
+
+    Y_UNIT_TEST(TestFormatTStringBufWithWidth) {
+        TStringBuf buf("hi");
+        UNIT_ASSERT_VALUES_EQUAL(std::format("{:>5}", buf), "   hi");
+    }
+
+    Y_UNIT_TEST(TestFormatEmptyTStringBuf) {
+        TStringBuf buf;
+        UNIT_ASSERT_VALUES_EQUAL(std::format("{}", buf), "");
+    }
+} // Y_UNIT_TEST_SUITE(TStrBufStdFormatTest)
+
+#endif
diff --git a/util/generic/string.h b/util/generic/string.h
index 4aeb62d3925..e3554b91cb2 100644
--- a/util/generic/string.h
+++ b/util/generic/string.h
@@ -1,6 +1,7 @@
 #pragma once
 
 #include <algorithm>
+#include <cstdlib>
 #include <cstddef>
 #include <cstring>
 #include <ydb-cpp-sdk/stlfwd.h>
@@ -12,20 +13,27 @@
 #include <util/system/compiler.h>
 #include <util/system/yassert.h>
 
+#include "iterator.h"
 #include "ptr.h"
 #include "utility.h"
-#include "bitops.h"
 #include "explicit_type.h"
 #include "reserve.h"
-#include "singleton.h"
+#ifndef _LIBCPP_VERSION
+    #include "singleton.h"
+#endif
 #include "strbase.h"
 #include "strbuf.h"
 #include "string_hash.h"
+#include "ylimits.h"
 
 #if defined(address_sanitizer_enabled) || defined(thread_sanitizer_enabled)
     #include "hide_ptr.h"
 #endif
 
+extern "C" {
+    extern const int TStringUseCow;
+}
+
 template <class TCharType, class TCharTraits, class TAllocator>
 void ResizeUninitialized(std::basic_string<TCharType, TCharTraits, TAllocator>& s, size_t len) {
 #if defined(_YNDX_LIBCXX_ENABLE_STRING_RESIZE_UNINITIALIZED)
@@ -35,9 +43,44 @@ void ResizeUninitialized(std::basic_string<TCharType, TCharTraits, TAllocator>&
 #endif
 }
 
+template <typename TCharType, typename TTraits>
+struct TStringJoinHelper {
+    // Used to convert args like const char* into TStringBuf only once
+    template <typename T>
+    using TJoinParam = std::conditional_t<std::is_same_v<T, TCharType>, TCharType, TBasicStringBuf<TCharType, TTraits>>;
+
+    template <typename... R>
+    static size_t SumLength(const TBasicStringBuf<TCharType, TTraits> s1, const R&... r) noexcept {
+        return s1.size() + SumLength(r...);
+    }
+
+    template <typename... R>
+    static size_t SumLength(const TCharType /*s1*/, const R&... r) noexcept {
+        return 1 + SumLength(r...);
+    }
+
+    static constexpr size_t SumLength() noexcept {
+        return 0;
+    }
+
+    template <typename... R>
+    static void CopyAll(TCharType* p, const TBasicStringBuf<TCharType, TTraits> s, const R&... r) {
+        TTraits::copy(p, s.data(), s.size());
+        CopyAll(p + s.size(), r...);
+    }
+
+    template <typename... R, class TNextCharType, typename = std::enable_if_t<std::is_same<TCharType, TNextCharType>::value>>
+    static void CopyAll(TCharType* p, const TNextCharType s, const R&... r) {
+        p[0] = s;
+        CopyAll(p + 1, r...);
+    }
+
+    static void CopyAll(TCharType*) noexcept {
+    }
+};
+
 #define Y_NOEXCEPT
 
-#ifndef TSTRING_IS_STD_STRING
 template <class T>
 class TStringPtrOps {
 public:
@@ -81,11 +124,11 @@ struct TStdString: public TRefCountHolder, public B {
     }
 
     static TStdString* NullStr() noexcept {
-    #ifdef _LIBCPP_VERSION
+#ifdef _LIBCPP_VERSION
         return (TStdString*)NULL_STRING_REPR;
-    #else
+#else
         return Singleton<TStdString>();
-    #endif
+#endif
     }
 
 private:
@@ -155,10 +198,10 @@ class TBasicCharRef {
     TStringType& S_;
     size_t Pos_;
 };
-#endif
 
 template <typename TCharType, typename TTraits>
-class TBasicString: public TStringBase<TBasicString<TCharType, TTraits>, TCharType, TTraits> {
+class Y_EMPTY_BASES TBasicString: public TStringBase<TBasicString<TCharType, TTraits>, TCharType, TTraits>,
+                                  public TStdStringCompatibilityBase<TBasicString<TCharType, TTraits>, TCharType, TTraits> {
 public:
     // TODO: Move to private section
     using TBase = TStringBase<TBasicString, TCharType, TTraits>;
@@ -190,7 +233,7 @@ class TBasicString: public TStringBase<TBasicString<TCharType, TTraits>, TCharTy
         size_t Size;
     };
 
-    static size_t max_size() noexcept {
+    size_t max_size() noexcept {
         static size_t res = TStringType().max_size();
 
         return res;
@@ -325,14 +368,36 @@ class TBasicString: public TStringBase<TBasicString<TCharType, TTraits>, TCharTy
         return reverse_iterator(begin());
     }
 
-    using TBase::begin;   //!< const_iterator TStringBase::begin() const
-    using TBase::cbegin;  //!< const_iterator TStringBase::cbegin() const
-    using TBase::cend;    //!< const_iterator TStringBase::cend() const
-    using TBase::crbegin; //!< const_reverse_iterator TStringBase::crbegin() const
-    using TBase::crend;   //!< const_reverse_iterator TStringBase::crend() const
-    using TBase::end;     //!< const_iterator TStringBase::end() const
-    using TBase::rbegin;  //!< const_reverse_iterator TStringBase::rbegin() const
-    using TBase::rend;    //!< const_reverse_iterator TStringBase::rend() const
+    const_iterator begin() const noexcept Y_LIFETIME_BOUND {
+        return TBase::begin();
+    }
+    const_iterator cbegin() const noexcept Y_LIFETIME_BOUND {
+        return TBase::cbegin();
+    }
+
+    const_iterator cend() const noexcept Y_LIFETIME_BOUND {
+        return TBase::cend();
+    }
+
+    const_reverse_iterator crbegin() const noexcept Y_LIFETIME_BOUND {
+        return TBase::crbegin();
+    }
+
+    const_reverse_iterator crend() const noexcept Y_LIFETIME_BOUND {
+        return TBase::crend();
+    }
+
+    const_iterator end() const noexcept Y_LIFETIME_BOUND {
+        return TBase::end();
+    }
+
+    const_reverse_iterator rbegin() const noexcept Y_LIFETIME_BOUND {
+        return TBase::rbegin();
+    }
+
+    const_reverse_iterator rend() const noexcept Y_LIFETIME_BOUND {
+        return TBase::rend();
+    }
 
     inline size_t capacity() const noexcept {
 #ifdef TSTRING_IS_STD_STRING
@@ -346,7 +411,7 @@ class TBasicString: public TStringBase<TBasicString<TCharType, TTraits>, TCharTy
 #endif
     }
 
-    TCharType* Detach() {
+    TCharType* Detach() Y_LIFETIME_BOUND {
 #ifdef TSTRING_IS_STD_STRING
         return Storage_.data();
 #else
@@ -367,7 +432,7 @@ class TBasicString: public TStringBase<TBasicString<TCharType, TTraits>, TCharTy
     }
 
     // ~~~ Size and capacity ~~~
-    TBasicString& resize(size_t n, TCharType c = ' ') { // remove or append
+    TBasicString& resize(size_t n, TCharType c = ' ') Y_LIFETIME_BOUND { // remove or append
         MutRef().resize(n, c);
 
         return *this;
@@ -389,6 +454,16 @@ class TBasicString: public TStringBase<TBasicString<TCharType, TTraits>, TCharTy
         reserve(rt.Capacity);
     }
 
+#if 0
+    inline ~TBasicString() {
+        if (!TStringUseCow) {
+            if (S_.RefCount() > 1) {
+                abort();
+            }
+        }
+    }
+#endif
+
     inline TBasicString(const TBasicString& s)
 #ifdef TSTRING_IS_STD_STRING
         : Storage_(s.Storage_)
@@ -396,6 +471,11 @@ class TBasicString: public TStringBase<TBasicString<TCharType, TTraits>, TCharTy
         : S_(s.S_)
 #endif
     {
+#ifndef TSTRING_IS_STD_STRING
+        if (!TStringUseCow) {
+            Detach();
+        }
+#endif
     }
 
     inline TBasicString(TBasicString&& s) noexcept
@@ -440,8 +520,7 @@ class TBasicString: public TStringBase<TBasicString<TCharType, TTraits>, TCharTy
         : TBasicString(pc, TBase::StrLen(pc))
     {
     }
-    // TODO thegeorg@: uncomment and fix clients
-    // TBasicString(std::nullptr_t) = delete;
+    TBasicString(std::nullptr_t) = delete;
 
     TBasicString(const TCharType* pc, size_t n)
 #ifdef TSTRING_IS_STD_STRING
@@ -497,7 +576,7 @@ class TBasicString: public TStringBase<TBasicString<TCharType, TTraits>, TCharTy
     }
 
     TBasicString(const TCharType* b, const TCharType* e)
-        : TBasicString(b, e - b)
+        : TBasicString(b, NonNegativeDistance(b, e))
     {
     }
 
@@ -534,44 +613,12 @@ class TBasicString: public TStringBase<TBasicString<TCharType, TTraits>, TCharTy
     }
 
 private:
-    template <typename T>
-    using TJoinParam = std::conditional_t<std::is_same_v<T, TCharType>, TCharType, TBasicStringBuf<TCharType, TTraits>>;
-
-    template <typename... R>
-    static size_t SumLength(const TBasicStringBuf<TCharType, TTraits> s1, const R&... r) noexcept {
-        return s1.size() + SumLength(r...);
-    }
-
-    template <typename... R>
-    static size_t SumLength(const TCharType /*s1*/, const R&... r) noexcept {
-        return 1 + SumLength(r...);
-    }
-
-    static constexpr size_t SumLength() noexcept {
-        return 0;
-    }
-
-    template <typename... R>
-    static void CopyAll(TCharType* p, const TBasicStringBuf<TCharType, TTraits> s, const R&... r) {
-        TTraits::copy(p, s.data(), s.size());
-        CopyAll(p + s.size(), r...);
-    }
-
-    template <typename... R, class TNextCharType, typename = std::enable_if_t<std::is_same<TCharType, TNextCharType>::value>>
-    static void CopyAll(TCharType* p, const TNextCharType s, const R&... r) {
-        p[0] = s;
-        CopyAll(p + 1, r...);
-    }
-
-    static void CopyAll(TCharType*) noexcept {
-    }
+    using TJoinHelper = TStringJoinHelper<TCharType, TTraits>;
 
     template <typename... R>
     static inline TBasicString JoinImpl(const R&... r) {
-        TBasicString s{TUninitialized{SumLength(r...)}};
-
-        TBasicString::CopyAll((TCharType*)s.data(), r...);
-
+        TBasicString s{TUninitialized{TJoinHelper::SumLength(r...)}};
+        TJoinHelper::CopyAll((TCharType*)s.data(), r...);
         return s;
     }
 
@@ -592,35 +639,35 @@ class TBasicString: public TStringBase<TBasicString<TCharType, TTraits>, TCharTy
 
     template <typename... R>
     static inline TBasicString Join(const R&... r) {
-        return JoinImpl(TJoinParam<R>(r)...);
+        return JoinImpl(typename TJoinHelper::template TJoinParam<R>(r)...);
     }
 
     // ~~~ Assignment ~~~ : FAMILY0(TBasicString&, assign);
-    TBasicString& assign(size_t size, TCharType ch) {
+    TBasicString& assign(size_t size, TCharType ch) Y_LIFETIME_BOUND {
         ReserveAndResize(size);
         std::fill(begin(), vend(), ch);
         return *this;
     }
 
-    TBasicString& assign(const TBasicString& s) {
+    TBasicString& assign(const TBasicString& s) Y_LIFETIME_BOUND {
         TBasicString(s).swap(*this);
 
         return *this;
     }
 
-    TBasicString& assign(const TBasicString& s, size_t pos, size_t n) {
+    TBasicString& assign(const TBasicString& s, size_t pos, size_t n) Y_LIFETIME_BOUND {
         return assign(TBasicString(s, pos, n));
     }
 
-    TBasicString& assign(const TCharType* pc) {
+    TBasicString& assign(const TCharType* pc) Y_LIFETIME_BOUND {
         return assign(pc, TBase::StrLen(pc));
     }
 
-    TBasicString& assign(TCharType ch) {
+    TBasicString& assign(TCharType ch) Y_LIFETIME_BOUND {
         return assign(&ch, 1);
     }
 
-    TBasicString& assign(const TCharType* pc, size_t len) {
+    TBasicString& assign(const TCharType* pc, size_t len) Y_LIFETIME_BOUND {
 #if defined(address_sanitizer_enabled) || defined(thread_sanitizer_enabled)
         pc = (const TCharType*)HidePointerOrigin((void*)pc);
 #endif
@@ -633,35 +680,35 @@ class TBasicString: public TStringBase<TBasicString<TCharType, TTraits>, TCharTy
         return *this;
     }
 
-    TBasicString& assign(const TCharType* first, const TCharType* last) {
-        return assign(first, last - first);
+    TBasicString& assign(const TCharType* first, const TCharType* last) Y_LIFETIME_BOUND {
+        return assign(first, NonNegativeDistance(first, last));
     }
 
-    TBasicString& assign(const TCharType* pc, size_t pos, size_t n) {
+    TBasicString& assign(const TCharType* pc, size_t pos, size_t n) Y_LIFETIME_BOUND {
         return assign(pc + pos, n);
     }
 
-    TBasicString& assign(const TBasicStringBuf<TCharType, TTraits> s) {
+    TBasicString& assign(const TBasicStringBuf<TCharType, TTraits> s) Y_LIFETIME_BOUND {
         return assign(s.data(), s.size());
     }
 
-    TBasicString& assign(const TBasicStringBuf<TCharType, TTraits> s, size_t spos, size_t sn = TBase::npos) {
+    TBasicString& assign(const TBasicStringBuf<TCharType, TTraits> s, size_t spos, size_t sn = TBase::npos) Y_LIFETIME_BOUND {
         return assign(s.SubString(spos, sn));
     }
 
-    inline TBasicString& AssignNoAlias(const TCharType* pc, size_t len) {
+    inline TBasicString& AssignNoAlias(const TCharType* pc, size_t len) Y_LIFETIME_BOUND {
         return assign(pc, len);
     }
 
-    inline TBasicString& AssignNoAlias(const TCharType* b, const TCharType* e) {
+    inline TBasicString& AssignNoAlias(const TCharType* b, const TCharType* e) Y_LIFETIME_BOUND {
         return AssignNoAlias(b, e - b);
     }
 
-    TBasicString& AssignNoAlias(const TBasicStringBuf<TCharType, TTraits> s) {
+    TBasicString& AssignNoAlias(const TBasicStringBuf<TCharType, TTraits> s) Y_LIFETIME_BOUND {
         return AssignNoAlias(s.data(), s.size());
     }
 
-    TBasicString& AssignNoAlias(const TBasicStringBuf<TCharType, TTraits> s, size_t spos, size_t sn = TBase::npos) {
+    TBasicString& AssignNoAlias(const TBasicStringBuf<TCharType, TTraits> s, size_t spos, size_t sn = TBase::npos) Y_LIFETIME_BOUND {
         return AssignNoAlias(s.SubString(spos, sn));
     }
 
@@ -685,36 +732,36 @@ class TBasicString: public TStringBase<TBasicString<TCharType, TTraits>, TCharTy
         return AppendUtf16(s);
     }
 
-    TBasicString& operator=(const TBasicString& s) {
+    TBasicString& operator=(const TBasicString& s) Y_LIFETIME_BOUND {
         return assign(s);
     }
 
-    TBasicString& operator=(TBasicString&& s) noexcept {
+    TBasicString& operator=(TBasicString&& s) noexcept Y_LIFETIME_BOUND {
         swap(s);
         return *this;
     }
 
     template <typename T, typename A>
-    TBasicString& operator=(std::basic_string<TCharType, T, A>&& s) noexcept {
+    TBasicString& operator=(std::basic_string<TCharType, T, A>&& s) noexcept Y_LIFETIME_BOUND {
         TBasicString(std::move(s)).swap(*this);
 
         return *this;
     }
 
-    TBasicString& operator=(const TBasicStringBuf<TCharType, TTraits> s) {
+    TBasicString& operator=(const TBasicStringBuf<TCharType, TTraits> s) Y_LIFETIME_BOUND {
         return assign(s);
     }
 
-    TBasicString& operator=(std::initializer_list<TCharType> il) {
+    TBasicString& operator=(std::initializer_list<TCharType> il) Y_LIFETIME_BOUND {
         return assign(il.begin(), il.end());
     }
 
-    TBasicString& operator=(const TCharType* s) {
+    TBasicString& operator=(const TCharType* s) Y_LIFETIME_BOUND {
         return assign(s);
     }
-    TBasicString& operator=(std::nullptr_t) = delete;
+    TBasicString& operator=(std::nullptr_t) Y_LIFETIME_BOUND = delete;
 
-    TBasicString& operator=(TExplicitType<TCharType> ch) {
+    TBasicString& operator=(TExplicitType<TCharType> ch) Y_LIFETIME_BOUND {
         return assign(ch);
     }
 
@@ -723,43 +770,43 @@ class TBasicString: public TStringBase<TBasicString<TCharType, TTraits>, TCharTy
     }
 
     // ~~~ Appending ~~~ : FAMILY0(TBasicString&, append);
-    inline TBasicString& append(size_t count, TCharType ch) {
+    inline TBasicString& append(size_t count, TCharType ch) Y_LIFETIME_BOUND {
         MutRef().append(count, ch);
 
         return *this;
     }
 
-    inline TBasicString& append(const TBasicString& s) {
+    inline TBasicString& append(const TBasicString& s) Y_LIFETIME_BOUND {
         MutRef().append(s.ConstRef());
 
         return *this;
     }
 
-    inline TBasicString& append(const TBasicString& s, size_t pos, size_t n) {
+    inline TBasicString& append(const TBasicString& s, size_t pos, size_t n) Y_LIFETIME_BOUND {
         MutRef().append(s.ConstRef(), pos, n);
 
         return *this;
     }
 
-    inline TBasicString& append(const TCharType* pc) Y_NOEXCEPT {
+    inline TBasicString& append(const TCharType* pc) Y_NOEXCEPT Y_LIFETIME_BOUND {
         MutRef().append(pc);
 
         return *this;
     }
 
-    inline TBasicString& append(TCharType c) {
+    inline TBasicString& append(TCharType c) Y_LIFETIME_BOUND {
         MutRef().push_back(c);
 
         return *this;
     }
 
-    inline TBasicString& append(const TCharType* first, const TCharType* last) {
+    inline TBasicString& append(const TCharType* first, const TCharType* last) Y_LIFETIME_BOUND {
         MutRef().append(first, last);
 
         return *this;
     }
 
-    inline TBasicString& append(const TCharType* pc, size_t len) {
+    inline TBasicString& append(const TCharType* pc, size_t len) Y_LIFETIME_BOUND {
         MutRef().append(pc, len);
 
         return *this;
@@ -769,7 +816,7 @@ class TBasicString: public TStringBase<TBasicString<TCharType, TTraits>, TCharTy
         ::ResizeUninitialized(MutRef(), len);
     }
 
-    TBasicString& AppendNoAlias(const TCharType* pc, size_t len) {
+    TBasicString& AppendNoAlias(const TCharType* pc, size_t len) Y_LIFETIME_BOUND {
         if (len) {
             auto s = this->size();
 
@@ -780,23 +827,23 @@ class TBasicString: public TStringBase<TBasicString<TCharType, TTraits>, TCharTy
         return *this;
     }
 
-    TBasicString& AppendNoAlias(const TBasicStringBuf<TCharType, TTraits> s) {
+    TBasicString& AppendNoAlias(const TBasicStringBuf<TCharType, TTraits> s) Y_LIFETIME_BOUND {
         return AppendNoAlias(s.data(), s.size());
     }
 
-    TBasicString& AppendNoAlias(const TBasicStringBuf<TCharType, TTraits> s, size_t spos, size_t sn = TBase::npos) {
+    TBasicString& AppendNoAlias(const TBasicStringBuf<TCharType, TTraits> s, size_t spos, size_t sn = TBase::npos) Y_LIFETIME_BOUND {
         return AppendNoAlias(s.SubString(spos, sn));
     }
 
-    TBasicString& append(const TBasicStringBuf<TCharType, TTraits> s) {
+    TBasicString& append(const TBasicStringBuf<TCharType, TTraits> s) Y_LIFETIME_BOUND {
         return append(s.data(), s.size());
     }
 
-    TBasicString& append(const TBasicStringBuf<TCharType, TTraits> s, size_t spos, size_t sn = TBase::npos) {
+    TBasicString& append(const TBasicStringBuf<TCharType, TTraits> s, size_t spos, size_t sn = TBase::npos) Y_LIFETIME_BOUND {
         return append(s.SubString(spos, sn));
     }
 
-    TBasicString& append(const TCharType* pc, size_t pos, size_t n, size_t pc_len = TBase::npos) {
+    TBasicString& append(const TCharType* pc, size_t pos, size_t n, size_t pc_len = TBase::npos) Y_LIFETIME_BOUND {
         return append(pc + pos, Min(n, pc_len - pos));
     }
 
@@ -805,11 +852,11 @@ class TBasicString: public TStringBase<TBasicString<TCharType, TTraits>, TCharTy
      *    Certain invocations of this method will result in link-time error.
      *    You are free to implement corresponding methods in string.cpp if you need them.
      */
-    TBasicString& AppendAscii(const ::TStringBuf& s);
+    TBasicString& AppendAscii(const ::TStringBuf& s) Y_LIFETIME_BOUND;
 
-    TBasicString& AppendUtf8(const ::TStringBuf& s);
+    TBasicString& AppendUtf8(const ::TStringBuf& s) Y_LIFETIME_BOUND;
 
-    TBasicString& AppendUtf16(const ::TWtringBuf& s);
+    TBasicString& AppendUtf16(const ::TWtringBuf& s) Y_LIFETIME_BOUND;
 
     inline void push_back(TCharType c) {
         // TODO
@@ -817,7 +864,7 @@ class TBasicString: public TStringBase<TBasicString<TCharType, TTraits>, TCharTy
     }
 
     template <class T>
-    TBasicString& operator+=(const T& s) {
+    TBasicString& operator+=(const T& s) Y_LIFETIME_BOUND {
         return append(s);
     }
 
@@ -839,7 +886,7 @@ class TBasicString: public TStringBase<TBasicString<TCharType, TTraits>, TCharTy
     }
 
     template <class T>
-    TBasicString& operator*=(T count) {
+    TBasicString& operator*=(T count) Y_LIFETIME_BOUND {
         static_assert(std::is_integral<T>::value, "Integral type required.");
 
         TBasicString temp;
@@ -857,13 +904,16 @@ class TBasicString: public TStringBase<TBasicString<TCharType, TTraits>, TCharTy
         return *this;
     }
 
-    operator const TStringType&() const noexcept {
+    operator const TStringType&() const noexcept Y_LIFETIME_BOUND {
         return this->ConstRef();
     }
 
-    operator TStringType&() {
-        return this->MutRef();
-    }
+    /*
+     * We have operator casting TString to `const std::string&` but we explicitly don't support
+     * casting TString to `std::string&` since such casting requires detaching TString and therefore
+     * modifies TString object. Sometimes compiler might call `operator std::string&`
+     * implicitly and it might lead to problems. Check IGNIETFERRO-2155 for details.
+     */
 
     /*
      * Following overloads of "operator+" aim to choose the cheapest implementation depending on
@@ -974,66 +1024,66 @@ class TBasicString: public TStringBase<TBasicString<TCharType, TTraits>, TCharTy
     }
 
     // ~~~ Prepending ~~~ : FAMILY0(TBasicString&, prepend);
-    TBasicString& prepend(const TBasicString& s) {
+    TBasicString& prepend(const TBasicString& s) Y_LIFETIME_BOUND {
         MutRef().insert(0, s.ConstRef());
 
         return *this;
     }
 
-    TBasicString& prepend(const TBasicString& s, size_t pos, size_t n) {
+    TBasicString& prepend(const TBasicString& s, size_t pos, size_t n) Y_LIFETIME_BOUND {
         MutRef().insert(0, s.ConstRef(), pos, n);
 
         return *this;
     }
 
-    TBasicString& prepend(const TCharType* pc) {
+    TBasicString& prepend(const TCharType* pc) Y_LIFETIME_BOUND {
         MutRef().insert(0, pc);
 
         return *this;
     }
 
-    TBasicString& prepend(size_t n, TCharType c) {
+    TBasicString& prepend(size_t n, TCharType c) Y_LIFETIME_BOUND {
         MutRef().insert(size_t(0), n, c);
 
         return *this;
     }
 
-    TBasicString& prepend(TCharType c) {
+    TBasicString& prepend(TCharType c) Y_LIFETIME_BOUND {
         MutRef().insert(size_t(0), 1, c);
 
         return *this;
     }
 
-    TBasicString& prepend(const TBasicStringBuf<TCharType, TTraits> s, size_t spos = 0, size_t sn = TBase::npos) {
+    TBasicString& prepend(const TBasicStringBuf<TCharType, TTraits> s, size_t spos = 0, size_t sn = TBase::npos) Y_LIFETIME_BOUND {
         return insert(0, s, spos, sn);
     }
 
     // ~~~ Insertion ~~~ : FAMILY1(TBasicString&, insert, size_t pos);
-    TBasicString& insert(size_t pos, const TBasicString& s) {
+    TBasicString& insert(size_t pos, const TBasicString& s) Y_LIFETIME_BOUND {
         MutRef().insert(pos, s.ConstRef());
 
         return *this;
     }
 
-    TBasicString& insert(size_t pos, const TBasicString& s, size_t pos1, size_t n1) {
+    TBasicString& insert(size_t pos, const TBasicString& s, size_t pos1, size_t n1) Y_LIFETIME_BOUND {
         MutRef().insert(pos, s.ConstRef(), pos1, n1);
 
         return *this;
     }
 
-    TBasicString& insert(size_t pos, const TCharType* pc) {
+    TBasicString& insert(size_t pos, const TCharType* pc) Y_LIFETIME_BOUND {
         MutRef().insert(pos, pc);
 
         return *this;
     }
 
-    TBasicString& insert(size_t pos, const TCharType* pc, size_t len) {
+    TBasicString& insert(size_t pos, const TCharType* pc, size_t len) Y_LIFETIME_BOUND {
         MutRef().insert(pos, pc, len);
 
         return *this;
     }
 
-    TBasicString& insert(const_iterator pos, const_iterator b, const_iterator e) {
+    TBasicString& insert(const_iterator pos, const_iterator b, const_iterator e) Y_LIFETIME_BOUND {
 #ifdef TSTRING_IS_STD_STRING
         Storage_.insert(Storage_.begin() + this->off(pos), b, e);
 
@@ -1043,28 +1093,28 @@ class TBasicString: public TStringBase<TBasicString<TCharType, TTraits>, TCharTy
 #endif
     }
 
-    TBasicString& insert(size_t pos, size_t n, TCharType c) {
+    TBasicString& insert(size_t pos, size_t n, TCharType c) Y_LIFETIME_BOUND {
         MutRef().insert(pos, n, c);
 
         return *this;
     }
 
-    TBasicString& insert(const_iterator pos, size_t len, TCharType ch) {
+    TBasicString& insert(const_iterator pos, size_t len, TCharType ch) Y_LIFETIME_BOUND {
         return this->insert(this->off(pos), len, ch);
     }
 
-    TBasicString& insert(const_iterator pos, TCharType ch) {
+    TBasicString& insert(const_iterator pos, TCharType ch) Y_LIFETIME_BOUND {
         return this->insert(pos, 1, ch);
     }
 
-    TBasicString& insert(size_t pos, const TBasicStringBuf<TCharType, TTraits> s, size_t spos = 0, size_t sn = TBase::npos) {
+    TBasicString& insert(size_t pos, const TBasicStringBuf<TCharType, TTraits> s, size_t spos = 0, size_t sn = TBase::npos) Y_LIFETIME_BOUND {
         MutRef().insert(pos, s, spos, sn);
 
         return *this;
     }
 
     // ~~~ Removing ~~~
-    TBasicString& remove(size_t pos, size_t n) Y_NOEXCEPT {
+    TBasicString& remove(size_t pos, size_t n) Y_NOEXCEPT Y_LIFETIME_BOUND {
         if (pos < length()) {
             MutRef().erase(pos, n);
         }
@@ -1072,7 +1122,7 @@ class TBasicString: public TStringBase<TBasicString<TCharType, TTraits>, TCharTy
         return *this;
     }
 
-    TBasicString& remove(size_t pos = 0) Y_NOEXCEPT {
+    TBasicString& remove(size_t pos = 0) Y_NOEXCEPT Y_LIFETIME_BOUND {
         if (pos < length()) {
             MutRef().erase(pos);
         }
@@ -1080,21 +1130,21 @@ class TBasicString: public TStringBase<TBasicString<TCharType, TTraits>, TCharTy
         return *this;
     }
 
-    TBasicString& erase(size_t pos = 0, size_t n = TBase::npos) Y_NOEXCEPT {
+    TBasicString& erase(size_t pos = 0, size_t n = TBase::npos) Y_NOEXCEPT Y_LIFETIME_BOUND {
         MutRef().erase(pos, n);
 
         return *this;
     }
 
-    TBasicString& erase(const_iterator b, const_iterator e) Y_NOEXCEPT {
+    TBasicString& erase(const_iterator b, const_iterator e) Y_NOEXCEPT Y_LIFETIME_BOUND {
         return erase(this->off(b), e - b);
     }
 
-    TBasicString& erase(const_iterator i) Y_NOEXCEPT {
+    TBasicString& erase(const_iterator i) Y_NOEXCEPT Y_LIFETIME_BOUND {
         return erase(i, i + 1);
     }
 
-    TBasicString& pop_back() Y_NOEXCEPT {
+    TBasicString& pop_back() Y_NOEXCEPT Y_LIFETIME_BOUND {
         Y_ASSERT(!this->empty());
 
         MutRef().pop_back();
@@ -1103,43 +1153,43 @@ class TBasicString: public TStringBase<TBasicString<TCharType, TTraits>, TCharTy
     }
 
     // ~~~ replacement ~~~ : FAMILY2(TBasicString&, replace, size_t pos, size_t n);
-    TBasicString& replace(size_t pos, size_t n, const TBasicString& s) Y_NOEXCEPT {
+    TBasicString& replace(size_t pos, size_t n, const TBasicString& s) Y_NOEXCEPT Y_LIFETIME_BOUND {
         MutRef().replace(pos, n, s.ConstRef());
 
         return *this;
     }
 
-    TBasicString& replace(size_t pos, size_t n, const TBasicString& s, size_t pos1, size_t n1) Y_NOEXCEPT {
+    TBasicString& replace(size_t pos, size_t n, const TBasicString& s, size_t pos1, size_t n1) Y_NOEXCEPT Y_LIFETIME_BOUND {
         MutRef().replace(pos, n, s.ConstRef(), pos1, n1);
 
         return *this;
     }
 
-    TBasicString& replace(size_t pos, size_t n, const TCharType* pc) Y_NOEXCEPT {
+    TBasicString& replace(size_t pos, size_t n, const TCharType* pc) Y_NOEXCEPT Y_LIFETIME_BOUND {
         MutRef().replace(pos, n, pc);
 
         return *this;
     }
 
-    TBasicString& replace(size_t pos, size_t n, const TCharType* s, size_t len) Y_NOEXCEPT {
+    TBasicString& replace(size_t pos, size_t n, const TCharType* s, size_t len) Y_NOEXCEPT Y_LIFETIME_BOUND {
         MutRef().replace(pos, n, s, len);
 
         return *this;
     }
 
-    TBasicString& replace(size_t pos, size_t n, const TCharType* s, size_t spos, size_t sn) Y_NOEXCEPT {
+    TBasicString& replace(size_t pos, size_t n, const TCharType* s, size_t spos, size_t sn) Y_NOEXCEPT Y_LIFETIME_BOUND {
         MutRef().replace(pos, n, s + spos, sn - spos);
 
         return *this;
     }
 
-    TBasicString& replace(size_t pos, size_t n1, size_t n2, TCharType c) Y_NOEXCEPT {
+    TBasicString& replace(size_t pos, size_t n1, size_t n2, TCharType c) Y_NOEXCEPT Y_LIFETIME_BOUND {
         MutRef().replace(pos, n1, n2, c);
 
         return *this;
     }
 
-    TBasicString& replace(size_t pos, size_t n, const TBasicStringBuf<TCharType, TTraits> s, size_t spos = 0, size_t sn = TBase::npos) Y_NOEXCEPT {
+    TBasicString& replace(size_t pos, size_t n, const TBasicStringBuf<TCharType, TTraits> s, size_t spos = 0, size_t sn = TBase::npos) Y_NOEXCEPT Y_LIFETIME_BOUND {
         MutRef().replace(pos, n, s, spos, sn);
 
         return *this;
@@ -1173,6 +1223,10 @@ class TBasicString: public TStringBase<TBasicString<TCharType, TTraits>, TCharTy
     bool to_upper(size_t pos = 0, size_t n = TBase::npos);
     bool to_title(size_t pos = 0, size_t n = TBase::npos);
 
+    constexpr const TCharType* Data() const noexcept = delete;
+    constexpr size_t Size() noexcept = delete;
+    Y_PURE_FUNCTION constexpr bool Empty() const noexcept = delete;
+
 public:
     /**
      * Modifies the substring of length `n` starting from `pos`, applying `f` to each position and symbol.
@@ -1252,7 +1306,7 @@ namespace std {
             return NHashPrivate::ComputeStringHash(s.data(), s.size());
         }
     };
-}
+} // namespace std
 
 #undef Y_NOEXCEPT
 
@@ -1313,3 +1367,9 @@ template <class TCharType, class TTraits>
 void ResizeUninitialized(TBasicString<TCharType, TTraits>& s, size_t len) {
     s.ReserveAndResize(len);
 }
+
+#ifdef __cpp_lib_format
+template <typename TCharType, typename TTraits>
+struct std::formatter<TBasicString<TCharType, TTraits>, TCharType>
+    : std::formatter<std::basic_string_view<TCharType>, TCharType> {};
+#endif
diff --git a/util/generic/string.pxd b/util/generic/string.pxd
index c25f7392a1d..d9d5e014e17 100644
--- a/util/generic/string.pxd
+++ b/util/generic/string.pxd
@@ -29,8 +29,6 @@ cdef extern from "<util/generic/string.h>" nogil:
         TString(size_t, char) except +
         TString(char*, char*) except +
         TString(TStringBuf&) except +
-        TString(TStringBuf&, TStringBuf&) except +
-        TString(TStringBuf&, TStringBuf&, TStringBuf&) except +
 
         const char* c_str()
         size_t max_size()
diff --git a/util/generic/string_hash.h b/util/generic/string_hash.h
index 54eaaf942ae..c467d864d5b 100644
--- a/util/generic/string_hash.h
+++ b/util/generic/string_hash.h
@@ -19,4 +19,4 @@ namespace NHashPrivate {
         return MurmurHash<size_t>(ptr, size * sizeof(C));
 #endif
     }
-}
+} // namespace NHashPrivate
diff --git a/util/generic/string_transparent_hash_ut.cpp b/util/generic/string_transparent_hash_ut.cpp
index a03fc7e6d7d..e94f550a7c1 100644
--- a/util/generic/string_transparent_hash_ut.cpp
+++ b/util/generic/string_transparent_hash_ut.cpp
@@ -28,4 +28,4 @@ Y_UNIT_TEST_SUITE(StringHashFunctorTests) {
         UNIT_ASSERT_UNEQUAL(s.find(TStringBuf("foo")), s.end());
         UNIT_ASSERT_EQUAL(s.find(TStringBuf("bar")), s.end());
     }
-}
+} // Y_UNIT_TEST_SUITE(StringHashFunctorTests)
diff --git a/util/generic/string_ut.cpp b/util/generic/string_ut.cpp
index b49e5ddb6bb..11bddf16e4f 100644
--- a/util/generic/string_ut.cpp
+++ b/util/generic/string_ut.cpp
@@ -179,7 +179,7 @@ class TStringStdTestImpl {
         }
 
         {
-            //This is to test move constructor
+            // This is to test move constructor
             TVector<TStringType> str_vect;
 
             str_vect.push_back(short_str1);
@@ -279,7 +279,7 @@ class TStringStdTestImpl {
     void null_char_of_empty() {
         const TStringType s;
 
-        //NOTE: https://a.yandex-team.ru/arcadia/junk/grechnik/test_string?rev=r12602052
+        // NOTE: https://a.yandex-team.ru/arcadia/junk/grechnik/test_string?rev=r12602052
         i64 i = s[s.size()];
         UNIT_ASSERT_VALUES_EQUAL(i, 0);
     }
@@ -350,7 +350,7 @@ class TStringStdTestImpl {
         str.reserve(100);
         str = strorg;
 
-        //test self insertion:
+        // test self insertion:
         str.insert(10, str.c_str() + 5, 15);
         UNIT_ASSERT(str == Data_.This_is_teis_test_string_st_string_for_string_calls());
 
@@ -687,12 +687,10 @@ class TStringStdTestImpl {
         str.replace(5, 5, str.c_str(), 10);
         UNIT_ASSERT(str == Data.This_This_is_test_StringT_for_StringT_calls());
 
-    #if !defined(STLPORT) || defined(_STLP_MEMBER_TEMPLATES)
         deque<TChar> cdeque;
         cdeque.push_back(*Data.I());
         str.replace(str.begin(), str.begin() + 11, cdeque.begin(), cdeque.end());
         UNIT_ASSERT(str == Data.Is_test_StringT_for_StringT_calls());
-    #endif
     }
 #endif
 }; // TStringStdTestImpl
@@ -727,7 +725,7 @@ class TStringTest: public TTestBase, private TStringTestImpl<TString, TTestData<
     UNIT_TEST(TestAppendUtf16)
     UNIT_TEST(TestFillingAssign)
     UNIT_TEST(TestStdStreamApi)
-    //UNIT_TEST(TestOperatorsCI); must fail
+    // UNIT_TEST(TestOperatorsCI); must fail
     UNIT_TEST_SUITE_END();
 
     void TestAppendUtf16() {
@@ -1165,7 +1163,7 @@ Y_UNIT_TEST_SUITE(TStringConversionTest) {
         std::string_view stdAbra = abra;
         UNIT_ASSERT_VALUES_EQUAL(stdAbra, "cadabra");
     }
-}
+} // Y_UNIT_TEST_SUITE(TStringConversionTest)
 
 Y_UNIT_TEST_SUITE(HashFunctorTests) {
     Y_UNIT_TEST(TestTransparency) {
@@ -1178,7 +1176,7 @@ Y_UNIT_TEST_SUITE(HashFunctorTests) {
         UNIT_ASSERT_VALUES_EQUAL(h(ptr), h(str));
         UNIT_ASSERT_VALUES_EQUAL(h(ptr), h(stdStr));
     }
-}
+} // Y_UNIT_TEST_SUITE(HashFunctorTests)
 
 #if !defined(TSTRING_IS_STD_STRING)
 Y_UNIT_TEST_SUITE(StdNonConformant) {
@@ -1208,7 +1206,7 @@ Y_UNIT_TEST_SUITE(StdNonConformant) {
         UNIT_ASSERT_VALUES_EQUAL(s, "xabc");
         UNIT_ASSERT_VALUES_EQUAL(TString(s.c_str()), "xabc");
     }
-}
+} // Y_UNIT_TEST_SUITE(StdNonConformant)
 #endif
 
 Y_UNIT_TEST_SUITE(Interop) {
@@ -1243,4 +1241,38 @@ Y_UNIT_TEST_SUITE(Interop) {
     Y_UNIT_TEST(TestTemp) {
         UNIT_ASSERT_VALUES_EQUAL("x" + ConstRef(TString("y")), "xy");
     }
-}
+
+    static void ComparePointers(const std::string& s, const void* expected, TStringBuf descr) {
+        UNIT_ASSERT_VALUES_EQUAL_C(static_cast<const void*>(s.c_str()), expected, descr);
+    }
+
+    Y_UNIT_TEST(TestConstShared) {
+        TString s(600, 'a');
+        const void* stringStart = s.c_str();
+        ComparePointers(s, stringStart, "unique");
+        TString shared{s};
+        ComparePointers(s, stringStart, "shared"); // converting a TString to a `const std::string&` should not cause data cloning
+    }
+} // Y_UNIT_TEST_SUITE(Interop)
+
+#ifdef __cpp_lib_format
+
+    #include <format>
+Y_UNIT_TEST_SUITE(TStringStdFormatTest) {
+    Y_UNIT_TEST(TestFormatTString) {
+        TString s("hello");
+        UNIT_ASSERT_VALUES_EQUAL(std::format("{}", s), "hello");
+    }
+
+    Y_UNIT_TEST(TestFormatTStringWithWidth) {
+        TString s("hi");
+        UNIT_ASSERT_VALUES_EQUAL(std::format("{:>5}", s), "   hi");
+    }
+
+    Y_UNIT_TEST(TestFormatEmptyTString) {
+        TString s;
+        UNIT_ASSERT_VALUES_EQUAL(std::format("{}", s), "");
+    }
+} // Y_UNIT_TEST_SUITE(TStringStdFormatTest)
+
+#endif
diff --git a/util/generic/string_ut.h b/util/generic/string_ut.h
index 3a91f61dd18..32c179a47e3 100644
--- a/util/generic/string_ut.h
+++ b/util/generic/string_ut.h
@@ -525,18 +525,14 @@ class TStringTestImpl {
     }
 
     void TestConstructors() {
-        TStringType s0(nullptr);
+        TStringType s0;
         UNIT_ASSERT(s0.size() == 0);
-        UNIT_ASSERT_EQUAL(s0, TStringType());
 
         TStringType s;
         TStringType s1(*Data._0());
         TStringType s2(Data._0());
         UNIT_ASSERT(s1 == s2);
 
-        TStringType fromZero(0);
-        UNIT_ASSERT_VALUES_EQUAL(fromZero.size(), 0u);
-
         TStringType fromChar(char_type('a'));
         UNIT_ASSERT_VALUES_EQUAL(fromChar.size(), 1u);
         UNIT_ASSERT_VALUES_EQUAL(fromChar[0], char_type('a'));
@@ -674,7 +670,7 @@ class TStringTestImpl {
     }
 #endif
 
-    //  Find family
+    // Find family
 
     void TestFind() {
         const TStringType s(Data._0123456_12345());
@@ -732,6 +728,13 @@ class TStringTestImpl {
         UNIT_ASSERT(s.Contains('1'));
         UNIT_ASSERT(!s.Contains('*'));
 
+        // std-compatible "contains".
+        UNIT_ASSERT(s.contains(Data._345()));
+        UNIT_ASSERT(!s2.contains(Data._345()));
+
+        UNIT_ASSERT(s.contains('1'));
+        UNIT_ASSERT(!s.contains('*'));
+
         TStringType empty;
         UNIT_ASSERT(s.Contains(empty));
         UNIT_ASSERT(!empty.Contains(s));
@@ -897,7 +900,7 @@ class TStringTestImpl {
         ComputeHash(sS); /*size_t hash_val = sS.hash();
 
         try {
-            //UNIT_ASSERT(hash_val == Data.HashOf_0123456());
+            // UNIT_ASSERT(hash_val == Data.HashOf_0123456());
         } catch (...) {
             Cerr << hash_val << Endl;
             throw;
diff --git a/util/generic/typelist.h b/util/generic/typelist.h
index 5ce26ab97c7..41039aa4c72 100644
--- a/util/generic/typelist.h
+++ b/util/generic/typelist.h
@@ -19,7 +19,7 @@ namespace NTL {
     struct TGetImpl<0u, TL> {
         using type = typename TL::THead;
     };
-}
+} // namespace NTL
 
 template <>
 struct TTypeList<> {
@@ -55,7 +55,7 @@ struct TTypeList<H, R...> {
     };
 };
 
-//FIXME: temporary to check overall build
+// FIXME: temporary to check overall build
 template <class T>
 struct TTypeList<T, TNone>: public TTypeList<T> {
 };
@@ -67,7 +67,7 @@ using TFixedWidthUnsignedInts = TTypeList<ui8, ui16, ui32, ui64>;
 using TFloats = TTypeList<float, double, long double>;
 
 namespace NTL {
-    template <class T1, class T2>
+    template <class T1, class T2, class... TL>
     struct TConcat;
 
     template <class... R1, class... R2>
@@ -75,6 +75,34 @@ namespace NTL {
         using type = TTypeList<R1..., R2...>;
     };
 
+    template <class... R1, class... R2, class... TL>
+    struct TConcat<TTypeList<R1...>, TTypeList<R2...>, TL...> {
+        using type = typename TConcat<TTypeList<R1..., R2...>, TL...>::type;
+    };
+
+    template <class TResult, class T, class... Ts>
+    struct TUniqueImpl;
+
+    template <class TResult, class T>
+    struct TUniqueImpl<TResult, T> {
+        using type = std::conditional_t<TResult::template THave<T>::value, TResult, typename NTL::TConcat<TResult, TTypeList<T>>::type>;
+    };
+
+    template <class TResult, class T, class... Ts>
+    struct TUniqueImpl {
+        using type = std::conditional_t<TResult::template THave<T>::value,
+                                        typename TUniqueImpl<TResult, Ts...>::type,
+                                        typename TUniqueImpl<typename NTL::TConcat<TResult, TTypeList<T>>::type, Ts...>::type>;
+    };
+
+    template <class... Ts>
+    struct TUnique;
+
+    template <class... Ts>
+    struct TUnique<TTypeList<Ts...>> {
+        using type = typename TUniqueImpl<TTypeList<>, Ts...>::type;
+    };
+
     template <bool isSigned, class T, class TS, class TU>
     struct TTypeSelectorBase {
         using TSignedInts = typename TConcat<TTypeList<T>, TS>::type;
@@ -93,7 +121,10 @@ namespace NTL {
 
     using T1 = TTypeSelector<char, TCommonSignedInts, TCommonUnsignedInts>;
     using T2 = TTypeSelector<wchar_t, T1::TSignedInts, T1::TUnsignedInts>;
-}
+} // namespace NTL
+
+template <class... Ts>
+using TUniqueTypeList = typename NTL::TUniqueImpl<TTypeList<>, Ts...>::type;
 
 using TSignedInts = NTL::T2::TSignedInts;
 using TUnsignedInts = NTL::T2::TUnsignedInts;
diff --git a/util/generic/typelist_ut.cpp b/util/generic/typelist_ut.cpp
index 955ebb1f1bf..683be34dcdc 100644
--- a/util/generic/typelist_ut.cpp
+++ b/util/generic/typelist_ut.cpp
@@ -4,6 +4,12 @@
 #include "typelist.h"
 #include "vector.h"
 
+template <class A, class B>
+void UnitAssertTypesEqual()
+{
+    UNIT_ASSERT_TYPES_EQUAL(A, B);
+}
+
 class TTypeListTest: public TTestBase {
     UNIT_TEST_SUITE(TTypeListTest);
     UNIT_TEST(TestSimple);
@@ -11,6 +17,9 @@ class TTypeListTest: public TTestBase {
     UNIT_TEST(TestGet);
     UNIT_TEST(TestFloatList);
     UNIT_TEST(TestSelectBy);
+    UNIT_TEST(TestUnique);
+    UNIT_TEST(TestUniqueTypeList);
+    UNIT_TEST(TestConcat);
     UNIT_TEST_SUITE_END();
 
 public:
@@ -79,6 +88,36 @@ class TTypeListTest: public TTestBase {
         UNIT_ASSERT_TYPES_EQUAL(TFixedWidthFloat<ui64>, double);
         UNIT_ASSERT_TYPES_EQUAL(TFixedWidthFloat<i64>, double);
     }
+
+    void TestUnique() {
+        UnitAssertTypesEqual<NTL::TUnique<TSignedInts>::type, TSignedInts>();
+        UnitAssertTypesEqual<typename NTL::TUnique<typename NTL::TConcat<TSignedInts, TSignedInts>::type>::type, TSignedInts>();
+    }
+
+    void TestUniqueTypeList() {
+        UnitAssertTypesEqual<TUniqueTypeList<int>, TTypeList<int>>();
+        UnitAssertTypesEqual<TUniqueTypeList<int, int, int, int, int, int, int, int, int>, TTypeList<int>>();
+        UnitAssertTypesEqual<TUniqueTypeList<TSignedInts>, TTypeList<TSignedInts>>();
+        UnitAssertTypesEqual<TUniqueTypeList<TSignedInts, TSignedInts, TSignedInts, TSignedInts, TSignedInts, TSignedInts, TSignedInts, TSignedInts, TSignedInts>, TTypeList<TSignedInts>>();
+        UnitAssertTypesEqual<TUniqueTypeList<TSignedInts, TSignedInts, TSignedInts, TSignedInts, TSignedInts, TSignedInts, TSignedInts, TSignedInts, TSignedInts>, TUniqueTypeList<TSignedInts, TSignedInts, TSignedInts>>();
+    }
+
+    void TestConcat() {
+        using TFirstListType = TTypeList<TA, TB*>;
+        using TSecondListType = TTypeList<const TC&>;
+        using TThirdListType = TTypeList<int, double, TA>;
+        using TListType = NTL::TConcat<TFirstListType, TSecondListType, TThirdListType>::type;
+
+        UNIT_ASSERT(TListType::THave<TA>::value);
+        UNIT_ASSERT(TListType::THave<TB*>::value);
+        UNIT_ASSERT(TListType::THave<int>::value);
+        UNIT_ASSERT(TListType::THave<double>::value);
+        UNIT_ASSERT(!TListType::THave<std::string>::value);
+        UNIT_ASSERT(!TListType::THave<TB>::value);
+        UNIT_ASSERT(TListType::THave<const TC&>::value);
+        UNIT_ASSERT(!TListType::THave<TC&>::value);
+        UNIT_ASSERT_VALUES_EQUAL(TListType::Length, TFirstListType::Length + TSecondListType::Length + TThirdListType::Length);
+    }
 };
 
 UNIT_TEST_SUITE_REGISTRATION(TTypeListTest);
diff --git a/util/generic/typetraits.h b/util/generic/typetraits.h
index 0233945010d..ccca8b2fb91 100644
--- a/util/generic/typetraits.h
+++ b/util/generic/typetraits.h
@@ -46,7 +46,7 @@ namespace NPrivate {
         }
         return false;
     }
-}
+} // namespace NPrivate
 
 #if _LIBCPP_STD_VER >= 17 && !defined(_MSC_VER)
 // Disable std::conjunction for MSVC by analogy with std::disjunction.
@@ -93,7 +93,7 @@ class TTypeTraitsBase {
 namespace NPrivate {
     template <class T>
     struct TIsSmall: std::integral_constant<bool, (sizeof(T) <= sizeof(void*))> {};
-}
+} // namespace NPrivate
 
 template <class T>
 class TTypeTraits: public TTypeTraitsBase<T> {
@@ -133,19 +133,19 @@ class TTypeTraits<void>: public TTypeTraitsBase<void> {};
         struct TBase {                                                                    \
             void method();                                                                \
         };                                                                                \
-        class THelper: public T, public TBase {                                           \
+        class THelper: public std::remove_const_t<T>, public TBase {                      \
         public:                                                                           \
             template <class T1>                                                           \
-            inline THelper(const T1& = T1()) {                                            \
+            inline explicit THelper(const T1& = T1()) {                                   \
             }                                                                             \
         };                                                                                \
         template <class T1, T1 val>                                                       \
         class TChecker {};                                                                \
         struct TNo {                                                                      \
-            char ch;                                                                      \
+            char Ch;                                                                      \
         };                                                                                \
         struct TYes {                                                                     \
-            char arr[2];                                                                  \
+            char Arr[2]; /* NOLINT(modernize-avoid-c-arrays) */                           \
         };                                                                                \
         template <class T1>                                                               \
         static TNo CheckMember(T1*, TChecker<void (TBase::*)(), &T1::method>* = nullptr); \
@@ -273,7 +273,7 @@ namespace NPrivate {
 
         using TType = decltype(Check(std::declval<TDerived*>()));
     };
-}
+} // namespace NPrivate
 
 template <template <class...> class T, class U>
 struct TIsSpecializationOf: std::false_type {};
@@ -328,7 +328,7 @@ namespace NPrivate {
 
     template <typename T>
     std::false_type IsIterableImpl(...);
-}
+} // namespace NPrivate
 
 template <typename T>
 using TIsIterable = decltype(NPrivate::IsIterableImpl<T>(0));
diff --git a/util/generic/typetraits_ut.cpp b/util/generic/typetraits_ut.cpp
index 174efdbda3d..69a34dd7e4f 100644
--- a/util/generic/typetraits_ut.cpp
+++ b/util/generic/typetraits_ut.cpp
@@ -70,7 +70,7 @@ namespace {
     public:
         TEmptyClass Base;
     };
-}
+} // namespace
 
 #define ASSERT_SAME_TYPE(x, y)                     \
     {                                              \
@@ -257,7 +257,7 @@ Y_UNIT_TEST_SUITE(TTypeTraitsTest) {
         UNIT_ASSERT(!std::is_trivially_copyable<TNonTriviallyCopyConstructible>::value);
         UNIT_ASSERT(!std::is_trivially_copyable<TNonTriviallyDestructible>::value);
     }
-}
+} // Y_UNIT_TEST_SUITE(TTypeTraitsTest)
 
 namespace {
     template <typename T>
@@ -377,14 +377,14 @@ namespace {
         enum { IsArithmetic = false };
         enum { IsArray = true };
     };
-}
+} // namespace
 
 #define UNIT_ASSERT_EQUAL_ENUM(expected, actual) UNIT_ASSERT_VALUES_EQUAL((bool)(expected), (bool)(actual))
 
 Y_UNIT_TEST_SUITE(TTypeTraitsTestNg) {
     template <typename T>
     void TestImpl() {
-        //UNIT_ASSERT_EQUAL_ENUM(TTypeTraitsExpected<T>::IsPod, TTypeTraits<T>::IsPod);
+        // UNIT_ASSERT_EQUAL_ENUM(TTypeTraitsExpected<T>::IsPod, TTypeTraits<T>::IsPod);
         UNIT_ASSERT_EQUAL_ENUM(TTypeTraitsExpected<T>::IsVoid, std::is_void<T>::value);
         UNIT_ASSERT_EQUAL_ENUM(TTypeTraitsExpected<T>::IsEnum, std::is_enum<T>::value);
         UNIT_ASSERT_EQUAL_ENUM(TTypeTraitsExpected<T>::IsIntegral, std::is_integral<T>::value);
@@ -420,7 +420,7 @@ Y_UNIT_TEST_SUITE(TTypeTraitsTestNg) {
     TYPE_TEST(NonPodClass, TNonPodClass)
     TYPE_TEST(NonPodClassReference, TNonPodClass&)
     TYPE_TEST(NonPodClassConstReference, const TNonPodClass&)
-}
+} // Y_UNIT_TEST_SUITE(TTypeTraitsTestNg)
 
 enum E4 {
     X
diff --git a/util/generic/utility.h b/util/generic/utility.h
index 5362fd4e42c..9f4938d0076 100644
--- a/util/generic/utility.h
+++ b/util/generic/utility.h
@@ -52,15 +52,15 @@ static inline void Zero(T& t) noexcept {
 /**
  * Securely zero memory (compiler does not optimize this out)
  *
- * @param pointer   void pointer to start of memory block to be zeroed
- * @param count     size of memory block to be zeroed (in bytes)
+ * @param[out] pointer  void pointer to start of memory block to be zeroed
+ * @param count         size of memory block to be zeroed (in bytes)
  */
 void SecureZero(void* pointer, size_t count) noexcept;
 
 /**
  * Securely zero memory of given object (compiler does not optimize this out)
  *
- * @param t     reference to object, which must be zeroed
+ * @param[out] t        reference to object, which must be zeroed
  */
 template <class T>
 static inline void SecureZero(T& t) noexcept {
@@ -73,8 +73,8 @@ namespace NSwapCheck {
 
     template <class T, class = void>
     struct TSwapSelector {
-        static inline void Swap(T& l, T& r) noexcept(std::is_nothrow_move_constructible<T>::value&&
-                                                         std::is_nothrow_move_assignable<T>::value) {
+        static inline void Swap(T& l, T& r) noexcept(std::is_nothrow_move_constructible<T>::value &&
+                                                     std::is_nothrow_move_assignable<T>::value) {
             T tmp(std::move(l));
             l = std::move(r);
             r = std::move(tmp);
@@ -94,7 +94,7 @@ namespace NSwapCheck {
             l.swap(r);
         }
     };
-}
+} // namespace NSwapCheck
 
 /*
  * DoSwap better than ::Swap in member functions...
diff --git a/util/generic/va_args_ut.cpp b/util/generic/va_args_ut.cpp
index e3691d4c4a3..3fa020504ca 100644
--- a/util/generic/va_args_ut.cpp
+++ b/util/generic/va_args_ut.cpp
@@ -40,7 +40,7 @@ Y_UNIT_TEST_SUITE(TMacroVarargMapTest) {
 #undef ADD_ARG
 #undef ID_ARG
     }
-}
+} // Y_UNIT_TEST_SUITE(TMacroVarargMapTest)
 
 Y_UNIT_TEST_SUITE(TestVaArgs) {
     Y_UNIT_TEST(Count) {
@@ -103,4 +103,4 @@ Y_UNIT_TEST_SUITE(TestVaArgs) {
 #undef I2
 #undef I1
     }
-}
+} // Y_UNIT_TEST_SUITE(TestVaArgs)
diff --git a/util/generic/vector.h b/util/generic/vector.h
index 580fcec7c58..29791bff9d8 100644
--- a/util/generic/vector.h
+++ b/util/generic/vector.h
@@ -110,6 +110,7 @@ class TVector: public std::vector<T, TReboundAllocator<A, T>> {
         return TBase::empty();
     }
 
+    // DEPRECATED. DO NOT USE.
     inline yssize_t ysize() const noexcept {
         return static_cast<yssize_t>(TBase::size());
     }
diff --git a/util/generic/vector_ut.cpp b/util/generic/vector_ut.cpp
index 63b10edab59..21c5853fd7b 100644
--- a/util/generic/vector_ut.cpp
+++ b/util/generic/vector_ut.cpp
@@ -25,7 +25,7 @@ class TYVectorTest: public TTestBase {
     UNIT_TEST(TestAutoRef)
     UNIT_TEST(TestIterators)
     UNIT_TEST(TestShrink)
-    //UNIT_TEST(TestEbo)
+    // UNIT_TEST(TestEbo)
     UNIT_TEST(TestFillInConstructor)
     UNIT_TEST(TestYResize)
     UNIT_TEST(TestCrop)
@@ -283,7 +283,7 @@ class TYVectorTest: public TTestBase {
         v.clear();
         UNIT_ASSERT(v.empty());
 
-        //check that clear save reserved data
+        // check that clear save reserved data
         UNIT_ASSERT_EQUAL(curCapacity, v.capacity());
 
         v.insert(v.begin(), 5, 10);
@@ -318,7 +318,7 @@ class TYVectorTest: public TTestBase {
         }
 
         {
-            //Test that used to generate an assertion when using __debug_alloc.
+            // Test that used to generate an assertion when using __debug_alloc.
             TVector<TestStruct> va;
             va.reserve(1);
             va.reserve(2);
@@ -397,14 +397,14 @@ class TYVectorTest: public TTestBase {
 
         UNIT_ASSERT(vint.rbegin() == vint.rbegin());
         // Not Standard:
-        //UNIT_ASSERT(vint.rbegin() == crvint.rbegin());
-        //UNIT_ASSERT(crvint.rbegin() == vint.rbegin());
+        // UNIT_ASSERT(vint.rbegin() == crvint.rbegin());
+        // UNIT_ASSERT(crvint.rbegin() == vint.rbegin());
         UNIT_ASSERT(crvint.rbegin() == crvint.rbegin());
 
         UNIT_ASSERT(vint.rbegin() != vint.rend());
         // Not Standard:
-        //UNIT_ASSERT(vint.rbegin() != crvint.rend());
-        //UNIT_ASSERT(crvint.rbegin() != vint.rend());
+        // UNIT_ASSERT(vint.rbegin() != crvint.rend());
+        // UNIT_ASSERT(crvint.rbegin() != vint.rend());
         UNIT_ASSERT(crvint.rbegin() != crvint.rend());
     }
 
diff --git a/util/generic/xrange.h b/util/generic/xrange.h
index 5fc8c829121..c28aa8aff27 100644
--- a/util/generic/xrange.h
+++ b/util/generic/xrange.h
@@ -243,7 +243,7 @@ namespace NPrivate {
         const T Finish_;
     };
 
-}
+} // namespace NPrivate
 
 /**
  * generate arithmetic progression that starts at start with certain step and stop at finish (not including)
diff --git a/util/generic/xrange_ut.cpp b/util/generic/xrange_ut.cpp
index 8106da03e7f..bebbf25020c 100644
--- a/util/generic/xrange_ut.cpp
+++ b/util/generic/xrange_ut.cpp
@@ -214,4 +214,4 @@ Y_UNIT_TEST_SUITE(XRange) {
             UNIT_ASSERT_VALUES_EQUAL(5, *it);
         }
     }
-}
+} // Y_UNIT_TEST_SUITE(XRange)
diff --git a/util/generic/yexception.cpp b/util/generic/yexception.cpp
index 6b067e90bbc..2e5df6a9ff2 100644
--- a/util/generic/yexception.cpp
+++ b/util/generic/yexception.cpp
@@ -1,6 +1,6 @@
-#include "bt_exception.h"
 #include "yexception.h"
 
+#include <util/stream/str.h>
 #include <util/system/backtrace.h>
 #include <util/system/type_name.h>
 
@@ -103,8 +103,8 @@ std::string CurrentExceptionTypeName() {
         return TypeName(*currentExceptionTypePtr);
     }
 #endif
-    //There is no abi::__cxa_current_exception_type() on Windows.
-    //Emulated it with rethrow - catch construction.
+    // There is no abi::__cxa_current_exception_type() on Windows.
+    // Emulated it with rethrow - catch construction.
     std::exception_ptr currentException = std::current_exception();
     Y_ASSERT(currentException != nullptr);
     try {
diff --git a/util/generic/yexception.h b/util/generic/yexception.h
index 526023f5420..99688f19f52 100644
--- a/util/generic/yexception.h
+++ b/util/generic/yexception.h
@@ -1,13 +1,12 @@
 #pragma once
 
-#include "bt_exception.h"
 #include "strbuf.h"
 #include "string.h"
 #include "utility.h"
 #include "va_args.h"
-#include <utility>
 
 #include <util/stream/tempbuf.h>
+#include <util/system/backtrace.h>
 #include <util/system/compat.h>
 #include <util/system/compiler.h>
 #include <util/system/defaults.h>
@@ -16,11 +15,9 @@
 #include <util/system/platform.h>
 
 #include <exception>
-
+#include <utility>
 #include <cstdio>
 
-class TBackTrace;
-
 namespace NPrivateException {
     class TTempBufCuttingWrapperOutput: public IOutputStream {
     public:
@@ -56,7 +53,7 @@ namespace NPrivateException {
             ZeroTerminate();
         }
 
-        TStringBuf AsStrBuf() const;
+        TStringBuf AsStrBuf() const Y_LIFETIME_BOUND;
 
     private:
         void ZeroTerminate() noexcept;
@@ -67,17 +64,17 @@ namespace NPrivateException {
 
     template <class E, class T>
     static inline std::enable_if_t<std::is_base_of<yexception, std::decay_t<E>>::value, E&&>
-    operator<<(E&& e, const T& t) {
+    operator<<(E&& e Y_LIFETIME_BOUND, const T& t) {
         e.Append(t);
 
         return std::forward<E>(e);
     }
 
     template <class T>
-    static inline T&& operator+(const TSourceLocation& sl, T&& t) {
+    static inline T&& operator+(const TSourceLocation& sl, T&& t Y_LIFETIME_BOUND) {
         return std::forward<T>(t << sl << TStringBuf(": "));
     }
-}
+} // namespace NPrivateException
 
 class yexception: public NPrivateException::yexception {
 };
@@ -138,11 +135,29 @@ struct TBadArgumentException: public virtual yexception {
 struct TBadCastException: public virtual TBadArgumentException {
 };
 
+template <class T>
+class TWithBackTrace: public T {
+public:
+    template <typename... Args>
+    inline TWithBackTrace(Args&&... args)
+        : T(std::forward<Args>(args)...)
+    {
+        BT_.Capture();
+    }
+
+    const TBackTrace* BackTrace() const noexcept override {
+        return &BT_;
+    }
+
+private:
+    TBackTrace BT_;
+};
+
 #define ythrow throw __LOCATION__ +
 
 namespace NPrivate {
-    /// Encapsulates data for one of the most common case in which
-    /// exception message consists of single constant string
+    /// Encapsulates data for the most common case when
+    /// an exception message consists of a single constant string
     struct TSimpleExceptionMessage {
         TSourceLocation Location;
         TStringBuf Message;
@@ -150,7 +165,7 @@ namespace NPrivate {
 
     [[noreturn]] void ThrowYException(const TSimpleExceptionMessage& sm);
     [[noreturn]] void ThrowYExceptionWithBacktrace(const TSimpleExceptionMessage& sm);
-}
+} // namespace NPrivate
 
 void fputs(const std::exception& e, FILE* f = stderr);
 
@@ -198,13 +213,13 @@ TString FormatExc(const std::exception& exception);
 /// @def Y_ENSURE_SIMPLE
 /// This macro works like the Y_ENSURE, but requires the second argument to be a constant string view.
 /// Should not be used directly.
-#define Y_ENSURE_SIMPLE(CONDITION, MESSAGE, THROW_FUNCTION)                                                                 \
-    do {                                                                                                                    \
-        if (Y_UNLIKELY(!(CONDITION))) {                                                                                     \
-            /* use variable to guarantee evaluation at compile time */                                                      \
-            static constexpr const ::NPrivate::TSimpleExceptionMessage __SIMPLE_EXCEPTION_MESSAGE{__LOCATION__, (MESSAGE)}; \
-            THROW_FUNCTION(__SIMPLE_EXCEPTION_MESSAGE);                                                                     \
-        }                                                                                                                   \
+#define Y_ENSURE_SIMPLE(CONDITION, MESSAGE, THROW_FUNCTION)                                                             \
+    do {                                                                                                                \
+        if (Y_UNLIKELY(!(CONDITION))) {                                                                                 \
+            /* use variable to guarantee evaluation at compile time */                                                  \
+            static constexpr const ::NPrivate::TSimpleExceptionMessage SimpleExceptionMessage{__LOCATION__, (MESSAGE)}; \
+            THROW_FUNCTION(SimpleExceptionMessage);                                                                     \
+        }                                                                                                               \
     } while (false)
 
 #define Y_ENSURE_IMPL_1(CONDITION) Y_ENSURE_SIMPLE(CONDITION, ::TStringBuf("Condition violated: `" Y_STRINGIZE(CONDITION) "'"), ::NPrivate::ThrowYException)
diff --git a/util/generic/yexception_ut.cpp b/util/generic/yexception_ut.cpp
index 3c89a487db0..3228d2f2646 100644
--- a/util/generic/yexception_ut.cpp
+++ b/util/generic/yexception_ut.cpp
@@ -11,6 +11,7 @@ static inline void Throw2DontMove() {
 #include <library/cpp/testing/unittest/registar.h>
 
 #include <util/generic/algorithm.h>
+#include <util/generic/scope.h>
 #include <util/memory/tempbuf.h>
 #include <util/random/mersenne.h>
 #include <util/stream/output.h>
@@ -18,7 +19,6 @@ static inline void Throw2DontMove() {
 #include <util/string/split.h>
 
 #include "yexception_ut.h"
-#include "bt_exception.h"
 
 #if defined(_MSC_VER)
     #pragma warning(disable : 4702) /*unreachable code*/
@@ -34,7 +34,7 @@ namespace NOuter::NInner {
     void Compare10And20() {
         Y_ENSURE(10 > 20);
     }
-}
+} // namespace NOuter::NInner
 
 class TExceptionTest: public TTestBase {
     UNIT_TEST_SUITE(TExceptionTest);
@@ -160,7 +160,10 @@ class TExceptionTest: public TTestBase {
         auto invalidFormatter = [](IOutputStream*, void* const*, size_t) {
             Throw2DontMove();
         };
-        SetFormatBackTraceFn(invalidFormatter);
+        TFormatBackTraceFn prevFn = SetFormatBackTraceFn(invalidFormatter);
+        Y_DEFER {
+            SetFormatBackTraceFn(prevFn);
+        };
 
         try {
             Throw1DontMove();
@@ -377,23 +380,24 @@ class TExceptionTest: public TTestBase {
         UNIT_ASSERT(errMoveAssign.AsStrBuf().Contains(testStr));
     }
     inline void TestCurrentExceptionTypeNameMethod() {
-        //Basic test of getting the correct exception type name.
+        // Basic test of getting the correct exception type name.
         try {
             throw std::runtime_error("Test Runtime Error Exception");
         } catch (...) {
             UNIT_ASSERT_STRING_CONTAINS(CurrentExceptionTypeName(), "std::runtime_error");
         }
-        //Test when exception has an unusual type. Under Linux it should return "int" and under other OSs "unknown type".
+        // Test when exception has an unusual type. Under Linux it should return "int" and under other OSs "unknown type".
         try {
             throw int(1);
         } catch (...) {
-#if defined(LIBCXX_BUILDING_LIBCXXRT) || defined(LIBCXX_BUILDING_LIBGCC)
+#if defined(_linux_) || defined(_darwin_)
+            // On Linux and macOS we use libcxxrt which handles throw integers properly
             UNIT_ASSERT_VALUES_EQUAL(CurrentExceptionTypeName(), "int");
 #else
             UNIT_ASSERT_VALUES_EQUAL(CurrentExceptionTypeName(), "unknown type");
 #endif
         }
-        //Test when the caught exception is rethrown with std::rethrow_exception.
+        // Test when the caught exception is rethrown with std::rethrow_exception.
         try {
             throw std::logic_error("Test Logic Error Exception");
         } catch (...) {
@@ -403,8 +407,8 @@ class TExceptionTest: public TTestBase {
                 UNIT_ASSERT_STRING_CONTAINS(CurrentExceptionTypeName(), "std::logic_error");
             }
         }
-        //Test when the caught exception is rethrown with throw; .
-        //This test is different from the previous one because of the interaction with cxxabi specifics.
+        // Test when the caught exception is rethrown with throw; .
+        // This test is different from the previous one because of the interaction with cxxabi specifics.
         try {
             throw std::bad_alloc();
         } catch (...) {
@@ -422,21 +426,21 @@ class TExceptionTest: public TTestBase {
             try {
                 std::rethrow_exception(std::current_exception());
             } catch (...) {
-#if defined(LIBCXX_BUILDING_LIBGCC)
+#ifdef __GLIBCXX__
                 UNIT_ASSERT_VALUES_EQUAL(CurrentExceptionTypeName(), "int");
 #else
                 UNIT_ASSERT_VALUES_EQUAL(CurrentExceptionTypeName(), "unknown type");
 #endif
             }
         }
-        //Test when int is rethrown with throw; .
+        // Test when int is rethrown with throw; .
         try {
             throw int(1);
         } catch (...) {
             try {
                 throw;
             } catch (...) {
-#if defined(LIBCXX_BUILDING_LIBCXXRT) || defined(LIBCXX_BUILDING_LIBGCC)
+#if defined(_linux_) || defined(_darwin_)
                 UNIT_ASSERT_VALUES_EQUAL(CurrentExceptionTypeName(), "int");
 #else
                 UNIT_ASSERT_VALUES_EQUAL(CurrentExceptionTypeName(), "unknown type");
diff --git a/util/generic/ylimits.h b/util/generic/ylimits.h
index fe42b4dfc0e..26956d7d569 100644
--- a/util/generic/ylimits.h
+++ b/util/generic/ylimits.h
@@ -30,7 +30,7 @@ namespace NPrivate {
             return Min<T>();
         }
     };
-}
+} // namespace NPrivate
 
 static constexpr ::NPrivate::TMax Max() noexcept {
     return {};
@@ -65,7 +65,7 @@ namespace NPrivate {
     constexpr double MaxCeilValue<0xFFFF'FFFF'FFFF'FFFFull>() {
         return 18446744073709551616.0; // 0x10000000000000000p0
     }
-}
+} // namespace NPrivate
 
 // MaxFloor<T> is the greatest double within the range of T.
 //
diff --git a/util/generic/ymath.cpp b/util/generic/ymath.cpp
index 31270728f46..a28a71b0e03 100644
--- a/util/generic/ymath.cpp
+++ b/util/generic/ymath.cpp
@@ -13,15 +13,17 @@ float Exp2f(float x) {
 double Erf(double x) {
     static constexpr double _M_2_SQRTPI = 1.12837916709551257390;
     static constexpr double eps = 1.0e-7;
-    if (fabs(x) >= 3.75)
+    if (fabs(x) >= 3.75) {
         return x > 0 ? 1.0 : -1.0;
+    }
     double r = _M_2_SQRTPI * x;
     double f = r;
     for (int i = 1;; ++i) {
         r *= -x * x / i;
         f += r / (2 * i + 1);
-        if (fabs(r) < eps * (2 * i + 1))
+        if (fabs(r) < eps * (2 * i + 1)) {
             break;
+        }
     }
     return f;
 }
diff --git a/util/generic/ymath.h b/util/generic/ymath.h
index 6736c73d34b..325fb9c4524 100644
--- a/util/generic/ymath.h
+++ b/util/generic/ymath.h
@@ -73,8 +73,6 @@ static inline bool IsFinite(double f) {
     return isfinite(f);
 #elif defined(__GNUC__)
     return __builtin_isfinite(f);
-#elif defined(_STLP_VENDOR_STD)
-    return _STLP_VENDOR_STD::isfinite(f);
 #else
     return std::isfinite(f);
 #endif
@@ -193,7 +191,7 @@ namespace NUtilMathPrivate {
             return (x % y) ? (quot + 1) : quot;
         }
     };
-}
+} // namespace NUtilMathPrivate
 
 /**
  * @returns Equivalent to ceil((double) x / (double) y) but using only integer arithmetic operations
diff --git a/util/linters.make.inc b/util/linters.make.inc
new file mode 100644
index 00000000000..55dc0c103ca
--- /dev/null
+++ b/util/linters.make.inc
@@ -0,0 +1,3 @@
+IF (NOT USE_SYSTEM_PYTHON)
+    STYLE_CPP()
+ENDIF()
diff --git a/util/memory/addstorage.h b/util/memory/addstorage.h
index 597c73a988e..bcec22e46eb 100644
--- a/util/memory/addstorage.h
+++ b/util/memory/addstorage.h
@@ -20,7 +20,7 @@ namespace NPrivate {
     private:
         size_t Length_;
     };
-}
+} // namespace NPrivate
 
 template <class T>
 class alignas(::NPrivate::TAdditionalStorageInfo) TAdditionalStorage {
diff --git a/util/memory/addstorage_ut.cpp b/util/memory/addstorage_ut.cpp
index 9b0c4989ab6..15530159223 100644
--- a/util/memory/addstorage_ut.cpp
+++ b/util/memory/addstorage_ut.cpp
@@ -16,7 +16,7 @@ class TAddStorageTest: public TTestBase {
 
         UNIT_ASSERT_EQUAL(c->AdditionalDataLength(), 100);
 
-        //test segfault
+        // test segfault
         memset(c->AdditionalData(), 0, c->AdditionalDataLength());
     }
 };
diff --git a/util/memory/blob.h b/util/memory/blob.h
index 20c02a68dfb..f9ecb6007fd 100644
--- a/util/memory/blob.h
+++ b/util/memory/blob.h
@@ -96,6 +96,12 @@ class TBlob {
         return *this;
     }
 
+    inline TBlob& operator=(TBlob&& r) noexcept {
+        TBlob(std::move(r)).Swap(*this);
+
+        return *this;
+    }
+
     /// Swaps content of two data arrays.
     inline void Swap(TBlob& r) noexcept {
         S_.Swap(r.S_);
@@ -198,7 +204,7 @@ class TBlob {
     static TBlob Copy(const void* data, size_t length);
 
     /// Creates a blob which doesn't own data. No refcounter, no memory allocation, no data copy.
-    static TBlob NoCopy(const void* data, size_t length);
+    static TBlob NoCopy(const void* data Y_LIFETIME_BOUND, size_t length);
 
     /// Creates a blob with a single-threaded (non atomic) refcounter. It maps the file on the path as data.
     static TBlob FromFileSingleThreaded(const TString& path, EMappingMode);
diff --git a/util/memory/blob_ut.cpp b/util/memory/blob_ut.cpp
index e048f8617a8..a3cd84f6cf0 100644
--- a/util/memory/blob_ut.cpp
+++ b/util/memory/blob_ut.cpp
@@ -76,4 +76,4 @@ Y_UNIT_TEST_SUITE(TBlobTest) {
         TFsPath(path).Touch();
         TBlob::LockedFromFile(path);
     }
-}
+} // Y_UNIT_TEST_SUITE(TBlobTest)
diff --git a/util/memory/mmapalloc.cpp b/util/memory/mmapalloc.cpp
index ec618cc8084..03529160b4f 100644
--- a/util/memory/mmapalloc.cpp
+++ b/util/memory/mmapalloc.cpp
@@ -26,7 +26,7 @@ namespace {
             real->~TMappedAllocation();
         }
     };
-}
+} // namespace
 
 IAllocator* MmapAllocator() {
     return SingletonWithPriority<TMmapAllocator, 0>();
diff --git a/util/memory/pool.h b/util/memory/pool.h
index a7f09cd37b0..c16c3b47fce 100644
--- a/util/memory/pool.h
+++ b/util/memory/pool.h
@@ -131,6 +131,29 @@ class TMemoryPool {
         }
     };
 
+    // When a bookmark is destroyed, the memory pool returns to the state when the bookmark was created.
+    class TBookmark {
+    public:
+        inline TBookmark(TMemoryPool& memoryPool)
+            : OwnerPoolRef_(memoryPool)
+            , BookmarkChunk_(memoryPool.Current_)
+            , BookmarkChunkDataSize_(memoryPool.Current_->DataSize())
+        {
+        }
+
+        inline ~TBookmark() {
+            OwnerPoolRef_.Current_->ResetChunk();
+            if (OwnerPoolRef_.Current_ == BookmarkChunk_) {
+                Y_UNUSED(BookmarkChunk_->Allocate(BookmarkChunkDataSize_));
+            }
+        }
+
+    private:
+        TMemoryPool& OwnerPoolRef_;
+        TMemoryPool::TChunk* BookmarkChunk_;
+        size_t BookmarkChunkDataSize_;
+    };
+
     inline TMemoryPool(size_t initial, IGrowPolicy* grow = TExpGrow::Instance(), IAllocator* alloc = TDefaultAllocator::Instance(), const TOptions& options = TOptions())
         : Current_(&Empty_)
         , BlockSize_(initial)
diff --git a/util/memory/pool_ut.cpp b/util/memory/pool_ut.cpp
index e7c055f36a2..98dbb082d5f 100644
--- a/util/memory/pool_ut.cpp
+++ b/util/memory/pool_ut.cpp
@@ -84,6 +84,7 @@ class TMemPoolTest: public TTestBase {
     UNIT_TEST(TestLargeStartingAlign)
     UNIT_TEST(TestMoveAlloc)
     UNIT_TEST(TestRoundUpToNextPowerOfTwoOption)
+    UNIT_TEST(TestMemoryPoolBookmark)
     UNIT_TEST_SUITE_END();
 
 private:
@@ -280,6 +281,43 @@ class TMemPoolTest: public TTestBase {
         pool.Allocate(1);
         UNIT_ASSERT_VALUES_EQUAL(2 * EXPECTED_ALLOCATION_SIZE, allocator.GetSize());
     }
+
+    void TestMemoryPoolBookmark() {
+        TCheckedAllocator alloc;
+
+        {
+            TMemoryPool pool(200U, TMemoryPool::TExpGrow::Instance(), &alloc);
+            ui64* someData = pool.Allocate<ui64>();
+            static const ui64 TESTING{0x123456789ABCDEF};
+            *someData = TESTING;
+
+            const auto ma = pool.MemoryAllocated();
+            const auto chunkOverhead = ma - sizeof(ui64);
+            const auto firstChunkTotal = pool.MemoryWaste() + ma;
+
+            // Allocate some memory in pool but not enough to need new chunks:
+            {
+                TMemoryPool::TBookmark bookmarkA(pool);
+                for (size_t i = 0U; i != 10; ++i) {
+                    UNIT_ASSERT(pool.Allocate<ui64>());
+                }
+            }
+            UNIT_ASSERT_VALUES_EQUAL(pool.MemoryAllocated(), ma);
+            UNIT_ASSERT_VALUES_EQUAL(*someData, TESTING);
+
+            // Allocate some memory in pool enough to need a new single chunk:
+            {
+                TMemoryPool::TBookmark bookmarkB(pool);
+                for (size_t i = 0U; i != 50; ++i) {
+                    UNIT_ASSERT(pool.Allocate<ui64>());
+                }
+            }
+            UNIT_ASSERT_VALUES_EQUAL(pool.MemoryAllocated(), firstChunkTotal + chunkOverhead); // The last (second) chunk is completely free
+            UNIT_ASSERT_VALUES_EQUAL(*someData, TESTING);
+        }
+
+        alloc.CheckAtEnd();
+    }
 };
 
 UNIT_TEST_SUITE_REGISTRATION(TMemPoolTest);
diff --git a/util/memory/segmented_string_pool.h b/util/memory/segmented_string_pool.h
index a40aa408f51..4adcbb023c0 100644
--- a/util/memory/segmented_string_pool.h
+++ b/util/memory/segmented_string_pool.h
@@ -47,13 +47,15 @@ class segmented_pool: TNonCopyable {
 protected:
     void check_capacity(size_t len) {
         if (Y_UNLIKELY(!last_free || len > last_free)) {
-            if (curseg != segs.end() && curseg->freepos > 0)
+            if (curseg != segs.end() && curseg->freepos > 0) {
                 ++curseg;
+            }
             last_free = (len > segment_size ? len : segment_size);
             if (curseg == segs.end() || curseg->_size < last_free) {
                 segs.push_back(seg_inf(seg_allocator.allocate(last_free), last_free));
-                if (Y_UNLIKELY(Name))
+                if (Y_UNLIKELY(Name)) {
                     printf("Pool \"%s\" was increased by %" PRISZT " bytes to %" PRISZT " Mb.\n", Name, last_free * sizeof(T), capacity() / 0x100000);
+                }
                 curseg = segs.end() - 1;
             }
             Y_ASSERT(curseg->freepos == 0);
@@ -78,8 +80,9 @@ class segmented_pool: TNonCopyable {
         check_capacity(len);
         ui8* rv = (ui8*)curseg->data + curseg->freepos;
         last_ins_size = sizeof(T) * len;
-        if (src)
+        if (src) {
             memcpy(rv, src, last_ins_size);
+        }
         curseg->freepos += last_ins_size, last_free -= len;
         return (T*)rv;
     }
@@ -99,32 +102,38 @@ class segmented_pool: TNonCopyable {
         return segment_size;
     }
     bool contains(const T* ptr) const {
-        for (seg_const_iterator i = segs.begin(), ie = segs.end(); i != ie; ++i)
-            if ((char*)ptr >= (char*)i->data && (char*)ptr < (char*)i->data + i->freepos)
+        for (seg_const_iterator i = segs.begin(), ie = segs.end(); i != ie; ++i) {
+            if ((char*)ptr >= (char*)i->data && (char*)ptr < (char*)i->data + i->freepos) {
                 return true;
+            }
+        }
         return false;
     }
     size_t size() const {
         size_t r = 0;
-        for (seg_const_iterator i = segs.begin(); i != segs.end(); ++i)
+        for (seg_const_iterator i = segs.begin(); i != segs.end(); ++i) {
             r += i->freepos;
+        }
         return r;
     }
     size_t capacity() const {
         return segs.size() * segment_size * sizeof(T);
     }
     void restart() {
-        if (curseg != segs.end())
+        if (curseg != segs.end()) {
             ++curseg;
-        for (seg_iterator i = segs.begin(); i != curseg; ++i)
+        }
+        for (seg_iterator i = segs.begin(); i != curseg; ++i) {
             i->freepos = 0;
+        }
         curseg = segs.begin();
         last_free = 0;
         last_ins_size = 0;
     }
     void clear() {
-        for (seg_iterator i = segs.begin(); i != segs.end(); ++i)
+        for (seg_iterator i = segs.begin(); i != segs.end(); ++i) {
             seg_allocator.deallocate(i->data, i->_size);
+        }
         segs.clear();
         curseg = segs.begin();
         last_free = 0;
@@ -166,8 +175,9 @@ class segmented_string_pool: public segmented_pool<char> {
     }
     char* append(const char* src, size_t len) {
         char* rv = _Base::append(nullptr, len + 1);
-        if (src)
+        if (src) {
             memcpy(rv, src, len);
+        }
         rv[len] = 0;
         return rv;
     }
diff --git a/util/memory/segpool_alloc.h b/util/memory/segpool_alloc.h
index 0a06a79abe9..455d266d418 100644
--- a/util/memory/segpool_alloc.h
+++ b/util/memory/segpool_alloc.h
@@ -82,10 +82,10 @@ struct segpool_alloc {
         }
     }
     ~segpool_alloc() {
-        //assert(pool_count == pool_free_count && malloc_count == malloc_free_count); <- uncomment when swap() problem is solved
-        //printf("in ~segpool_alloc: size = %u, pool_count = %" PRId64 ", malloc_count = %" PRId64 ", pool_free_count = %" PRId64 ", malloc_free_count = %" PRId64 "\n",
+        // assert(pool_count == pool_free_count && malloc_count == malloc_free_count); <- uncomment when swap() problem is solved
+        // printf("in ~segpool_alloc: size = %u, pool_count = %" PRId64 ", malloc_count = %" PRId64 ", pool_free_count = %" PRId64 ", malloc_free_count = %" PRId64 "\n",
         //        sizeof(_Tp), pool_count, malloc_count, pool_free_count, malloc_free_count);
-        //fflush(stdout);
+        // fflush(stdout);
     }
     template <class _Tp1>
     struct rebind {
diff --git a/util/memory/tempbuf.cpp b/util/memory/tempbuf.cpp
index 27b45dea482..6c21631f42b 100644
--- a/util/memory/tempbuf.cpp
+++ b/util/memory/tempbuf.cpp
@@ -147,7 +147,7 @@ namespace {
     private:
         TIntrusiveSList<TPerThreadedBuf> Unused_;
     };
-}
+} // namespace
 
 static inline TTempBufManager* TempBufManager() {
     return FastTlsSingletonWithPriority<TTempBufManager, 2>();
diff --git a/util/network/address.cpp b/util/network/address.cpp
index 47badf504f2..e20acddf77b 100644
--- a/util/network/address.cpp
+++ b/util/network/address.cpp
@@ -79,7 +79,7 @@ static inline void PrintAddr(IOutputStream& out, const IRemoteAddr& addr) {
                 out << "(raw " << (int)a->sa_family << " ";
 
                 while (b != e) {
-                    //just print raw bytes
+                    // just print raw bytes
                     out << (int)*b++;
                     if (b != e) {
                         out << " ";
diff --git a/util/network/address.h b/util/network/address.h
index fac61ce665a..53939bb02c7 100644
--- a/util/network/address.h
+++ b/util/network/address.h
@@ -31,7 +31,7 @@ namespace NAddr {
 
     socklen_t SockAddrLength(const sockaddr* addr);
 
-    //for accept, recvfrom - see LenPtr()
+    // for accept, recvfrom - see LenPtr()
     class TOpaqueAddr: public IRemoteAddr {
     public:
         inline TOpaqueAddr() noexcept
@@ -75,7 +75,7 @@ namespace NAddr {
         socklen_t L_;
     };
 
-    //for TNetworkAddress
+    // for TNetworkAddress
     class TAddrInfo: public IRemoteAddr {
     public:
         inline TAddrInfo(const addrinfo* ai) noexcept
@@ -95,7 +95,7 @@ namespace NAddr {
         const addrinfo* const AI_;
     };
 
-    //compat, for TIpAddress
+    // compat, for TIpAddress
     class TIPv4Addr: public IRemoteAddr {
     public:
         inline TIPv4Addr(const TIpAddress& addr) noexcept
@@ -115,7 +115,7 @@ namespace NAddr {
         const TIpAddress A_;
     };
 
-    //same, for ipv6 addresses
+    // same, for ipv6 addresses
     class TIPv6Addr: public IRemoteAddr {
     public:
         inline TIPv6Addr(const sockaddr_in6& a) noexcept
@@ -146,4 +146,4 @@ namespace NAddr {
     private:
         TSockAddrLocal SockAddr_;
     };
-}
+} // namespace NAddr
diff --git a/util/network/address_ut.cpp b/util/network/address_ut.cpp
index 28f45172ffe..b5c9f064568 100644
--- a/util/network/address_ut.cpp
+++ b/util/network/address_ut.cpp
@@ -36,4 +36,4 @@ Y_UNIT_TEST_SUITE(IRemoteAddr_ToString) {
         TNetworkAddress localAddress2("127.0.0.1", 22);
         UNIT_ASSERT_VALUES_EQUAL(NAddr::IsLoopback(TAddrInfo(&*localAddress2.Begin())), true);
     }
-}
+} // Y_UNIT_TEST_SUITE(IRemoteAddr_ToString)
diff --git a/util/network/endpoint.h b/util/network/endpoint.h
index a3e59b49250..728f5841d5a 100644
--- a/util/network/endpoint.h
+++ b/util/network/endpoint.h
@@ -4,7 +4,7 @@
 
 #include <util/str_stl.h>
 
-//some equivalent boost::asio::ip::endpoint (easy for using pair ip:port)
+// some equivalent boost::asio::ip::endpoint (easy for using pair ip:port)
 class TEndpoint {
 public:
     using TAddrRef = NAddr::IRemoteAddrRef;
diff --git a/util/network/endpoint_ut.cpp b/util/network/endpoint_ut.cpp
index d5e40dd6e1c..4a7808929cf 100644
--- a/util/network/endpoint_ut.cpp
+++ b/util/network/endpoint_ut.cpp
@@ -120,4 +120,4 @@ Y_UNIT_TEST_SUITE(TEndpointTest) {
         UNIT_ASSERT(!ep2.IsUnix());
         UNIT_ASSERT(ep2.SockAddr()->sa_family != AF_UNIX);
     }
-}
+} // Y_UNIT_TEST_SUITE(TEndpointTest)
diff --git a/util/network/hostip.cpp b/util/network/hostip.cpp
index cb8d43bf903..e13ccc2b82f 100644
--- a/util/network/hostip.cpp
+++ b/util/network/hostip.cpp
@@ -53,15 +53,18 @@ int NResolver::GetHostIP(const char* hostname, ui32* ip, size_t* slots) {
 #else
     hostent* hostent = gethostbyname(hostname);
 
-    if (!hostent)
+    if (!hostent) {
         return GetDnsError();
+    }
 
-    if (hostent->h_addrtype != AF_INET || (unsigned)hostent->h_length < sizeof(ui32))
+    if (hostent->h_addrtype != AF_INET || (unsigned)hostent->h_length < sizeof(ui32)) {
         return HOST_NOT_FOUND;
+    }
 
     char** cur = hostent->h_addr_list;
-    for (i = 0; i < *slots && *cur; i++, cur++, ipsFound++)
+    for (i = 0; i < *slots && *cur; i++, cur++, ipsFound++) {
         ip[i] = *(ui32*)*cur;
+    }
 #endif
     for (i = 0; i < ipsFound; i++) {
         ip[i] = InetToHost(ip[i]);
diff --git a/util/network/hostip.h b/util/network/hostip.h
index cf63e4846ad..45bddf56790 100644
--- a/util/network/hostip.h
+++ b/util/network/hostip.h
@@ -13,4 +13,4 @@ namespace NResolver {
 
         return GetHostIP(hostname, ip, &slots);
     }
-}
+} // namespace NResolver
diff --git a/util/network/init.cpp b/util/network/init.cpp
index 430b25c2fce..fa0f06c7389 100644
--- a/util/network/init.cpp
+++ b/util/network/init.cpp
@@ -22,7 +22,7 @@ namespace {
 #endif
         }
     };
-}
+} // namespace
 
 void InitNetworkSubSystem() {
     (void)Singleton<TNetworkInit>();
diff --git a/util/network/interface.cpp b/util/network/interface.cpp
index 03c3ccd98d1..bcc14199ffb 100644
--- a/util/network/interface.cpp
+++ b/util/network/interface.cpp
@@ -23,7 +23,7 @@ namespace NAddr {
         TVector<char> buf;
         buf.resize(1000000);
         PIP_ADAPTER_ADDRESSES adapterBuf = (PIP_ADAPTER_ADDRESSES)&buf[0];
-        ULONG bufSize = buf.ysize();
+        ULONG bufSize = buf.size();
 
         if (GetAdaptersAddresses(AF_UNSPEC, 0, nullptr, adapterBuf, &bufSize) == ERROR_SUCCESS) {
             for (PIP_ADAPTER_ADDRESSES ptr = adapterBuf; ptr != 0; ptr = ptr->Next) {
@@ -78,4 +78,4 @@ namespace NAddr {
 
         return result;
     }
-}
+} // namespace NAddr
diff --git a/util/network/interface.h b/util/network/interface.h
index dda45550215..d37ee4bd01a 100644
--- a/util/network/interface.h
+++ b/util/network/interface.h
@@ -14,4 +14,4 @@ namespace NAddr {
     using TNetworkInterfaceList = TVector<TNetworkInterface>;
 
     TNetworkInterfaceList GetNetworkInterfaces();
-}
+} // namespace NAddr
diff --git a/util/network/nonblock.cpp b/util/network/nonblock.cpp
index e515c27cc51..4bc94bdc98f 100644
--- a/util/network/nonblock.cpp
+++ b/util/network/nonblock.cpp
@@ -25,7 +25,7 @@ namespace {
                 Accept4 = reinterpret_cast<TAccept4>(dlsym(RTLD_DEFAULT, "accept4"));
 
     #if defined(_musl_)
-                //musl always statically linked
+                // musl always statically linked
                 if (!Accept4) {
                     Accept4 = accept4;
                 }
@@ -60,7 +60,7 @@ namespace {
             const SOCKET ret = accept(s, addr, addrlen);
 
 #if !defined(_freebsd_)
-            //freebsd inherit O_NONBLOCK flag
+            // freebsd inherit O_NONBLOCK flag
             if (ret != INVALID_SOCKET) {
                 SetNonBlock(ret);
             }
@@ -93,7 +93,7 @@ namespace {
         TAccept4 Accept4;
         bool HaveSockNonBlock;
     };
-}
+} // namespace
 
 SOCKET Accept4(SOCKET s, struct sockaddr* addr, socklen_t* addrlen) {
     return TFeatureCheck::Instance()->FastAccept(s, addr, addrlen);
diff --git a/util/network/nonblock.h b/util/network/nonblock.h
index 54e5e44ae36..5afed8352fc 100644
--- a/util/network/nonblock.h
+++ b/util/network/nonblock.h
@@ -2,7 +2,7 @@
 
 #include "socket.h"
 
-//assume s is non-blocking, return non-blocking socket
+// assume s is non-blocking, return non-blocking socket
 SOCKET Accept4(SOCKET s, struct sockaddr* addr, socklen_t* addrlen);
-//create non-blocking socket
+// create non-blocking socket
 SOCKET Socket4(int domain, int type, int protocol);
diff --git a/util/network/pair.cpp b/util/network/pair.cpp
index 9751ef5c966..de07d5f35c0 100644
--- a/util/network/pair.cpp
+++ b/util/network/pair.cpp
@@ -47,17 +47,21 @@ int SocketPair(SOCKET socks[2], bool overlapped, bool cloexec) {
     }
 
     do {
-        if (listen(listener, 1) == SOCKET_ERROR)
+        if (listen(listener, 1) == SOCKET_ERROR) {
             break;
+        }
 
-        if ((socks[0] = WSASocket(AF_INET, SOCK_STREAM, 0, nullptr, 0, flags)) == INVALID_SOCKET)
+        if ((socks[0] = WSASocket(AF_INET, SOCK_STREAM, 0, nullptr, 0, flags)) == INVALID_SOCKET) {
             break;
+        }
 
-        if (connect(socks[0], (const struct sockaddr*)&addr, sizeof(addr)) == SOCKET_ERROR)
+        if (connect(socks[0], (const struct sockaddr*)&addr, sizeof(addr)) == SOCKET_ERROR) {
             break;
+        }
 
-        if ((socks[1] = accept(listener, nullptr, nullptr)) == INVALID_SOCKET)
+        if ((socks[1] = accept(listener, nullptr, nullptr)) == INVALID_SOCKET) {
             break;
+        }
 
         closesocket(listener);
 
diff --git a/util/network/poller.cpp b/util/network/poller.cpp
index 7954d0e8b55..1e5860b4af2 100644
--- a/util/network/poller.cpp
+++ b/util/network/poller.cpp
@@ -7,7 +7,7 @@ namespace {
     struct TMutexLocking {
         using TMyMutex = TMutex;
     };
-}
+} // namespace
 
 class TSocketPoller::TImpl: public TPollerImpl<TMutexLocking> {
 public:
diff --git a/util/network/poller_ut.cpp b/util/network/poller_ut.cpp
index e5914b7df3a..117fcc98029 100644
--- a/util/network/poller_ut.cpp
+++ b/util/network/poller_ut.cpp
@@ -240,4 +240,4 @@ Y_UNIT_TEST_SUITE(TSocketPollerTest) {
         UNIT_ASSERT_EXCEPTION_CONTAINS(poller.Set(nullptr, Max<int>(), CONT_POLL_READ | CONT_POLL_MODIFY), TSystemError, "epoll modify failed");
     }
 #endif
-}
+} // Y_UNIT_TEST_SUITE(TSocketPollerTest)
diff --git a/util/network/pollerimpl.h b/util/network/pollerimpl.h
index f92a6fb4890..36b82da5be6 100644
--- a/util/network/pollerimpl.h
+++ b/util/network/pollerimpl.h
@@ -19,7 +19,7 @@
     #define HAVE_EPOLL_POLLER
 #endif
 
-//now we always have it
+// now we always have it
 #define HAVE_SELECT_POLLER
 
 #if defined(HAVE_KQUEUE_POLLER)
diff --git a/util/network/sock.h b/util/network/sock.h
index b9b73b2d377..65ccd5e0e96 100644
--- a/util/network/sock.h
+++ b/util/network/sock.h
@@ -106,13 +106,15 @@ struct TSockAddrLocal: public ISockAddr {
             int ret = 0;
             // 1. open file
             TFileHandle f(Path, OpenExisting | RdOnly);
-            if (!f.IsOpen())
+            if (!f.IsOpen()) {
                 return -errno;
+            }
 
             // 2. read the port from file
             ret = f.Read(&in.sin_port, sizeof(in.sin_port));
-            if (ret != sizeof(in.sin_port))
+            if (ret != sizeof(in.sin_port)) {
                 return -(errno ? errno : EFAULT);
+            }
         }
 
         return 0;
@@ -123,24 +125,28 @@ struct TSockAddrLocal: public ISockAddr {
         int ret = 0;
         // 1. open file
         TFileHandle f(Path, CreateAlways | WrOnly);
-        if (!f.IsOpen())
+        if (!f.IsOpen()) {
             return -errno;
+        }
 
         // 2. find port and bind to it
         in.sin_port = 0;
         ret = bind(s, SockAddr(), Len());
-        if (ret != 0)
+        if (ret != 0) {
             return -WSAGetLastError();
+        }
 
         int size = Size();
         ret = getsockname(s, (struct sockaddr*)(&in), &size);
-        if (ret != 0)
+        if (ret != 0) {
             return -WSAGetLastError();
+        }
 
         // 3. write port to file
         ret = f.Write(&(in.sin_port), sizeof(in.sin_port));
-        if (ret != sizeof(in.sin_port))
+        if (ret != sizeof(in.sin_port)) {
             return -errno;
+        }
 
         return 0;
     }
@@ -208,12 +214,14 @@ struct TSockAddrLocal: public sockaddr_un, public ISockAddr {
         (void)unlink(sun_path);
 
         int ret = bind(s, SockAddr(), Len());
-        if (ret < 0)
+        if (ret < 0) {
             return -errno;
+        }
 
         ret = Chmod(sun_path, mode);
-        if (ret < 0)
+        if (ret < 0) {
             return -errno;
+        }
         return 0;
     }
 };
@@ -266,12 +274,14 @@ struct TSockAddrInet: public sockaddr_in, public ISockAddr {
     int Bind(SOCKET s, ui16 mode) const override {
         Y_UNUSED(mode);
         int ret = bind(s, SockAddr(), Len());
-        if (ret < 0)
+        if (ret < 0) {
             return -errno;
+        }
 
         socklen_t len = Len();
-        if (getsockname(s, (struct sockaddr*)(SockAddr()), &len) < 0)
+        if (getsockname(s, (struct sockaddr*)(SockAddr()), &len) < 0) {
             return -WSAGetLastError();
+        }
 
         return 0;
     }
@@ -377,13 +387,15 @@ class TBaseSocket: public TSocketHolder {
     }
 
     void CheckSock() {
-        if ((SOCKET) * this == INVALID_SOCKET)
+        if ((SOCKET) * this == INVALID_SOCKET) {
             ythrow TSystemError() << "no socket";
+        }
     }
 
     static ssize_t Check(ssize_t ret, const char* op = "") {
-        if (ret < 0)
+        if (ret < 0) {
             ythrow TSystemError(-(int)ret) << "socket operation " << op;
+        }
         return ret;
     }
 };
@@ -436,36 +448,41 @@ class TStreamSocket: public TBaseSocket {
 
     ssize_t Send(const void* msg, size_t len, int flags = 0) {
         const ssize_t ret = send((SOCKET) * this, (const char*)msg, (int)len, flags);
-        if (ret < 0)
+        if (ret < 0) {
             return -errno;
+        }
 
         return ret;
     }
 
     ssize_t Recv(void* buf, size_t len, int flags = 0) {
         const ssize_t ret = recv((SOCKET) * this, (char*)buf, (int)len, flags);
-        if (ret < 0)
+        if (ret < 0) {
             return -errno;
+        }
 
         return ret;
     }
 
     int Connect(const ISockAddr* addr) {
         int ret = addr->ResolveAddr();
-        if (ret < 0)
+        if (ret < 0) {
             return -errno;
+        }
 
         ret = connect((SOCKET) * this, addr->SockAddr(), addr->Len());
-        if (ret < 0)
+        if (ret < 0) {
             return -errno;
+        }
 
         return ret;
     }
 
     int Listen(int backlog) {
         int ret = listen((SOCKET) * this, backlog);
-        if (ret < 0)
+        if (ret < 0) {
             return -errno;
+        }
 
         return ret;
     }
@@ -479,8 +496,9 @@ class TStreamSocket: public TBaseSocket {
             s = accept((SOCKET) * this, nullptr, nullptr);
         }
 
-        if (s == INVALID_SOCKET)
+        if (s == INVALID_SOCKET) {
             return -errno;
+        }
 
         TSocketHolder sock(s);
         acceptedSock->Swap(sock);
diff --git a/util/network/sock_ut.cpp b/util/network/sock_ut.cpp
index c702e1ba04d..e4ba47d7e51 100644
--- a/util/network/sock_ut.cpp
+++ b/util/network/sock_ut.cpp
@@ -176,4 +176,4 @@ Y_UNIT_TEST_SUITE(TSocketTest) {
         sal.Set(sockPath);
         UNIT_ASSERT_STRINGS_EQUAL(sal.ToString(), "/var/run/some.sock");
     }
-}
+} // Y_UNIT_TEST_SUITE(TSocketTest)
diff --git a/util/network/socket.cpp b/util/network/socket.cpp
index fb9dac7f09c..ba9c3f7d421 100644
--- a/util/network/socket.cpp
+++ b/util/network/socket.cpp
@@ -110,15 +110,18 @@ static int convert_events(int events, const evpair* evpairs, size_t nevpairs, bo
         if (events & event) {
             events ^= event;
             long winEvent = evpairs[i].winevent;
-            if (winEvent == -1)
+            if (winEvent == -1) {
                 return -1;
-            if (winEvent == 0)
+            }
+            if (winEvent == 0) {
                 continue;
+            }
             result |= winEvent;
         }
     }
-    if (events != 0 && !ignoreUnknown)
+    if (events != 0 && !ignoreUnknown) {
         return -1;
+    }
     return result;
 }
 
@@ -199,12 +202,13 @@ int poll(struct pollfd fds[], nfds_t nfds, int timeout) noexcept {
 
     HANDLE events[] = {event.Get()};
     DWORD wait_result = WSAWaitForMultipleEvents(1, events, TRUE, timeout, FALSE);
-    if (wait_result == WSA_WAIT_TIMEOUT)
+    if (wait_result == WSA_WAIT_TIMEOUT) {
         return 0;
-    else if (wait_result == WSA_WAIT_EVENT_0) {
+    } else if (wait_result == WSA_WAIT_EVENT_0) {
         for (pollfd* fd = fds; fd < fds + nfds; ++fd) {
-            if (fd->revents == POLLNVAL)
+            if (fd->revents == POLLNVAL) {
                 continue;
+            }
             WSANETWORKEVENTS network_events;
             if (WSAEnumNetworkEvents(fd->fd, event.Get(), &network_events)) {
                 errno = EIO;
@@ -217,8 +221,9 @@ int poll(struct pollfd fds[], nfds_t nfds, int timeout) noexcept {
                     break;
                 }
             }
-            if (fd->revents == POLLERR)
+            if (fd->revents == POLLERR) {
                 continue;
+            }
             if (network_events.lNetworkEvents) {
                 fd->revents = static_cast<short>(convert_events(network_events.lNetworkEvents, evpairs_to_unix, nevpairs_to_unix, true));
                 if (fd->revents & POLLHUP) {
@@ -227,9 +232,11 @@ int poll(struct pollfd fds[], nfds_t nfds, int timeout) noexcept {
             }
         }
         int chanded_sockets = 0;
-        for (pollfd* fd = fds; fd < fds + nfds; ++fd)
-            if (fd->revents != 0)
+        for (pollfd* fd = fds; fd < fds + nfds; ++fd) {
+            if (fd->revents != 0) {
                 ++chanded_sockets;
+            }
+        }
         return chanded_sockets;
     } else {
         errno = EIO;
@@ -477,7 +484,7 @@ namespace {
         bool HasFastOpen_;
     };
 #endif
-}
+} // namespace
 
 void SetTcpFastOpen(SOCKET s, int qlen) {
 #if defined(TCP_FASTOPEN)
@@ -943,7 +950,7 @@ void TSocketOutput::DoWriteV(const TPart* parts, size_t count) {
 }
 
 namespace {
-    //https://bugzilla.mozilla.org/attachment.cgi?id=503263&action=diff
+    // https://bugzilla.mozilla.org/attachment.cgi?id=503263&action=diff
 
     struct TLocalNames: public THashSet<TStringBuf> {
         inline TLocalNames() {
@@ -965,7 +972,7 @@ namespace {
             return contains(name);
         }
     };
-}
+} // namespace
 
 class TNetworkAddress::TImpl: public TAtomicRefCount<TImpl> {
 private:
diff --git a/util/network/socket.h b/util/network/socket.h
index 856e707d8a9..db9b72e7a55 100644
--- a/util/network/socket.h
+++ b/util/network/socket.h
@@ -94,7 +94,7 @@ static inline void FixIPv6ListenSocket(SOCKET s) {
 
 namespace NAddr {
     class IRemoteAddr;
-}
+} // namespace NAddr
 
 void SetSocketTimeout(SOCKET s, long timeout);
 void SetSocketTimeout(SOCKET s, long sec, long msec);
@@ -143,7 +143,7 @@ struct addrinfo;
 
 class TNetworkResolutionError: public yexception {
 public:
-    // @param error error code (EAI_XXX) returned by getaddrinfo or getnameinfo (not errno)
+    //! @param error error code (EAI_XXX) returned by getaddrinfo or getnameinfo (not errno)
     TNetworkResolutionError(int error);
 };
 
@@ -423,5 +423,5 @@ class TSocketOutput: public IOutputStream {
     TSocket S_;
 };
 
-//return -(error code) if error occured, or number of ready fds
+// return -(error code) if error occured, or number of ready fds
 ssize_t PollD(struct pollfd fds[], nfds_t nfds, const TInstant& deadLine) noexcept;
diff --git a/util/network/socket_ut.cpp b/util/network/socket_ut.cpp
index b49ca639cc2..f8b97c3992c 100644
--- a/util/network/socket_ut.cpp
+++ b/util/network/socket_ut.cpp
@@ -270,8 +270,9 @@ void TPollTest::TestPollInOut() {
 
         if (i % 5 == 0 || i % 5 == 2) {
             char buffer = 'c';
-            if (send(*clientSocket, &buffer, 1, 0) == -1)
+            if (send(*clientSocket, &buffer, 1, 0) == -1) {
                 ythrow yexception() << "Can not send (" << LastSystemErrorText() << ")";
+            }
         }
 
         TSimpleSharedPtr<TSocketHolder> connectedSocket(new TSocketHolder(AcceptConnection(serverSocket)));
@@ -287,8 +288,9 @@ void TPollTest::TestPollInOut() {
     for (size_t i = 0; i < connectedSockets.size(); ++i) {
         pollfd fd = {(i % 5 == 4) ? INVALID_SOCKET : static_cast<SOCKET>(*connectedSockets[i]), POLLIN | POLLOUT, 0};
         fds.push_back(fd);
-        if (i % 5 != 4)
+        if (i % 5 != 4) {
             ++expectedCount;
+        }
     }
 
     int polledCount = poll(&fds[0], fds.size(), INFTIM);
diff --git a/util/random/common_ops.h b/util/random/common_ops.h
index 209e8dbb48e..0bbb80f3d3e 100644
--- a/util/random/common_ops.h
+++ b/util/random/common_ops.h
@@ -58,7 +58,7 @@ namespace NPrivate {
 
         return rand % max;
     }
-}
+} // namespace NPrivate
 
 template <class TRandType, class T>
 struct TCommonRNG {
@@ -115,7 +115,7 @@ struct TCommonRNG {
         return ::NPrivate::ToRandReal4(Engine().GenRand64());
     }
 
-    //compatibility stuff
+    // compatibility stuff
     inline TResult operator()() noexcept {
         return Engine().GenRand();
     }
diff --git a/util/random/common_ops_ut.cpp b/util/random/common_ops_ut.cpp
index 905912bd1ed..b85c6de4454 100644
--- a/util/random/common_ops_ut.cpp
+++ b/util/random/common_ops_ut.cpp
@@ -66,4 +66,4 @@ Y_UNIT_TEST_SUITE(TestCommonRNG) {
             UNIT_ASSERT_DOUBLES_EQUAL(nd(r), -0.430375088, 0.01);
         }
     }
-}
+} // Y_UNIT_TEST_SUITE(TestCommonRNG)
diff --git a/util/random/easy.h b/util/random/easy.h
index fd5b826fbe8..72e1db7a6bb 100644
--- a/util/random/easy.h
+++ b/util/random/easy.h
@@ -40,7 +40,7 @@ namespace NPrivate {
             return RandomNumber<long double>();
         }
     };
-}
+} // namespace NPrivate
 
 static inline ::NPrivate::TRandom Random() noexcept {
     return {};
diff --git a/util/random/easy_ut.cpp b/util/random/easy_ut.cpp
index d1d024a91fe..b3966a8b5a2 100644
--- a/util/random/easy_ut.cpp
+++ b/util/random/easy_ut.cpp
@@ -32,4 +32,4 @@ Y_UNIT_TEST_SUITE(TEasyRndInterface) {
             UNIT_ASSERT(x != 0);
         }
     }
-}
+} // Y_UNIT_TEST_SUITE(TEasyRndInterface)
diff --git a/util/random/entropy.cpp b/util/random/entropy.cpp
index 3617edb83d7..549d7c6325b 100644
--- a/util/random/entropy.cpp
+++ b/util/random/entropy.cpp
@@ -53,7 +53,7 @@ namespace {
                 try {
                     Save(&out, GetExecPath());
                 } catch (...) {
-                    //workaround - sometimes fails on FreeBSD
+                    // workaround - sometimes fails on FreeBSD
                 }
 
                 Save(&out, (size_t)Data());
@@ -85,7 +85,11 @@ namespace {
                     out << TStringBuf(CpuBrand(store));
                 }
 
-                out << NFs::CurrentWorkingDirectory();
+                try {
+                    out << NFs::CurrentWorkingDirectory();
+                } catch (const TSystemError& e) {
+                    // the current working directory has been unliked or unavailable for similar reasons
+                }
 
                 out.Finish();
             }
@@ -93,7 +97,7 @@ namespace {
             {
                 TMemoryOutput out(Data(), Size());
 
-                //replace zlib header with hash
+                // replace zlib header with hash
                 Save(&out, CityHash64(Data(), Size()));
             }
 
@@ -101,7 +105,7 @@ namespace {
         }
     };
 
-    //not thread-safe
+    // not thread-safe
     class TMersenneInput: public IInputStream {
         using TKey = ui64;
         using TRnd = TMersenne<TKey>;
@@ -206,7 +210,7 @@ namespace {
     };
 
     using TRandomTraits = TDefaultTraits;
-}
+} // namespace
 
 IInputStream& EntropyPool() {
     return TRandomTraits::Instance().EntropyPool();
diff --git a/util/random/entropy_ut.cpp b/util/random/entropy_ut.cpp
index 1ff27203f04..072060b2ac2 100644
--- a/util/random/entropy_ut.cpp
+++ b/util/random/entropy_ut.cpp
@@ -1,6 +1,9 @@
 #include "entropy.h"
 
+#include <library/cpp/testing/common/env.h>
 #include <library/cpp/testing/unittest/registar.h>
+#include <util/folder/tempdir.h>
+#include <util/system/fs.h>
 
 Y_UNIT_TEST_SUITE(TestEntropy) {
     Y_UNIT_TEST(TestSeed) {
@@ -10,4 +13,16 @@ Y_UNIT_TEST_SUITE(TestEntropy) {
             Seed().LoadOrFail(buf, i);
         }
     }
-}
+
+    Y_UNIT_TEST(TestReset) {
+        UNIT_ASSERT_NO_EXCEPTION(ResetEntropyPool());
+    }
+
+#if !defined(_win_)
+    Y_UNIT_TEST(TestMissingWorkingDirectory) {
+        NFs::SetCurrentWorkingDirectory(TTempDir::NewTempDir(GetWorkPath()).Name());
+        UNIT_ASSERT_NO_EXCEPTION(ResetEntropyPool());
+    }
+#endif
+
+} // Y_UNIT_TEST_SUITE(TestEntropy)
diff --git a/util/random/fast.h b/util/random/fast.h
index ddc57116416..70359135a24 100644
--- a/util/random/fast.h
+++ b/util/random/fast.h
@@ -95,7 +95,7 @@ namespace NPrivate {
     struct TFastRngTraits<ui64> {
         using TResult = TFastRng64;
     };
-}
+} // namespace NPrivate
 
 template <typename T>
 using TFastRng = typename ::NPrivate::TFastRngTraits<T>::TResult;
diff --git a/util/random/fast_ut.cpp b/util/random/fast_ut.cpp
index 60994a98b06..9254d0bbe12 100644
--- a/util/random/fast_ut.cpp
+++ b/util/random/fast_ut.cpp
@@ -116,4 +116,4 @@ Y_UNIT_TEST_SUITE(TTestFastRng) {
 
         UNIT_ASSERT_VALUES_EQUAL(rng.GenRand(), ULL(6223876579076085114));
     }
-}
+} // Y_UNIT_TEST_SUITE(TTestFastRng)
diff --git a/util/random/init_atfork.cpp b/util/random/init_atfork.cpp
index 4c9a7778d2d..ad5ccab06ca 100644
--- a/util/random/init_atfork.cpp
+++ b/util/random/init_atfork.cpp
@@ -22,7 +22,7 @@ namespace {
             ResetRandomState();
         }
     };
-}
+} // namespace
 
 void RNGInitAtForkHandlers() {
     SingletonWithPriority<TInit, 0>();
diff --git a/util/random/lcg_engine.cpp b/util/random/lcg_engine.cpp
index e1469104fa4..64be218a3f3 100644
--- a/util/random/lcg_engine.cpp
+++ b/util/random/lcg_engine.cpp
@@ -27,4 +27,4 @@ namespace NPrivate {
 
     template ui32 LcgAdvance<ui32>(ui32, ui32, ui32, ui32) noexcept;
     template ui64 LcgAdvance<ui64>(ui64, ui64, ui64, ui64) noexcept;
-}
+} // namespace NPrivate
diff --git a/util/random/lcg_engine.h b/util/random/lcg_engine.h
index 4347b1a5ed8..88e79cabf66 100644
--- a/util/random/lcg_engine.h
+++ b/util/random/lcg_engine.h
@@ -9,7 +9,7 @@
 namespace NPrivate {
     template <typename T>
     T LcgAdvance(T seed, T lcgBase, T lcgAddend, T delta) noexcept;
-}
+} // namespace NPrivate
 
 template <typename T, T A, T C>
 struct TFastLcgIterator {
@@ -31,15 +31,15 @@ struct TLcgIterator {
     {
     }
 
-    inline T Iterate(T x) noexcept {
+    inline T Iterate(T x) const noexcept {
         return x * A + C;
     }
 
-    inline T IterateMultiple(T x, T delta) noexcept {
+    inline T IterateMultiple(T x, T delta) const noexcept {
         return ::NPrivate::LcgAdvance(x, A, C, delta);
     }
 
-    const T C;
+    T C;
 };
 
 template <class TIterator, class TMixer>
diff --git a/util/random/mersenne.h b/util/random/mersenne.h
index b2044604ac7..291b0e57028 100644
--- a/util/random/mersenne.h
+++ b/util/random/mersenne.h
@@ -17,7 +17,7 @@ namespace NPrivate {
     struct TMersenneTraits<ui32> {
         using TImpl = TMersenne32;
     };
-}
+} // namespace NPrivate
 
 class IInputStream;
 
diff --git a/util/random/mersenne32.h b/util/random/mersenne32.h
index 861f3a3d387..08def52783f 100644
--- a/util/random/mersenne32.h
+++ b/util/random/mersenne32.h
@@ -47,4 +47,4 @@ namespace NPrivate {
         ui32 mt[N];
         int mti;
     };
-}
+} // namespace NPrivate
diff --git a/util/random/mersenne64.h b/util/random/mersenne64.h
index 12ca43b6afc..8549e270f7e 100644
--- a/util/random/mersenne64.h
+++ b/util/random/mersenne64.h
@@ -47,4 +47,4 @@ namespace NPrivate {
         ui64 mt[NN];
         int mti;
     };
-}
+} // namespace NPrivate
diff --git a/util/random/mersenne_ut.cpp b/util/random/mersenne_ut.cpp
index a4b84efa3d1..0a113acdf1e 100644
--- a/util/random/mersenne_ut.cpp
+++ b/util/random/mersenne_ut.cpp
@@ -79,4 +79,4 @@ Y_UNIT_TEST_SUITE(TMersenneRndTest) {
 
         UNIT_ASSERT_VALUES_EQUAL(r1.GenRand(), r2.GenRand());
     }
-}
+} // Y_UNIT_TEST_SUITE(TMersenneRndTest)
diff --git a/util/random/normal.cpp b/util/random/normal.cpp
index 478b38fd250..4d8a878772b 100644
--- a/util/random/normal.cpp
+++ b/util/random/normal.cpp
@@ -9,7 +9,7 @@ namespace {
             return RandomNumber<T>();
         }
     };
-}
+} // namespace
 
 template <>
 float StdNormalRandom<float>() noexcept {
diff --git a/util/random/normal_ut.cpp b/util/random/normal_ut.cpp
index 42b6cc4ba2f..526cc2fe85f 100644
--- a/util/random/normal_ut.cpp
+++ b/util/random/normal_ut.cpp
@@ -78,4 +78,4 @@ Y_UNIT_TEST_SUITE(TestNormalDistribution) {
         TestMD<double>(GenFunc2<double>(30, 40), 30, 40);
         TestMD<long double>(GenFunc2<long double>(40, 50), 40, 50);
     }
-}
+} // Y_UNIT_TEST_SUITE(TestNormalDistribution)
diff --git a/util/random/random.cpp b/util/random/random.cpp
index 71f93238568..c2775ec3f02 100644
--- a/util/random/random.cpp
+++ b/util/random/random.cpp
@@ -66,7 +66,7 @@ namespace {
     struct TToRealType {
         using TResult = typename TToRealTypeBySize<sizeof(T)>::TResult;
     };
-}
+} // namespace
 
 #define DEF_RND(TY)                                               \
     template <>                                                   \
diff --git a/util/random/random_ut.cpp b/util/random/random_ut.cpp
index 30427676f36..e919ba5a5e8 100644
--- a/util/random/random_ut.cpp
+++ b/util/random/random_ut.cpp
@@ -152,4 +152,4 @@ Y_UNIT_TEST_SUITE(TRandomNumberTest) {
             UNIT_ASSERT_EQUAL(RandomNumber<ui32>(1 << 8), el);
         }
     }
-}
+} // Y_UNIT_TEST_SUITE(TRandomNumberTest)
diff --git a/util/random/shuffle_ut.cpp b/util/random/shuffle_ut.cpp
index 8cab95d8b25..79b210cd9fd 100644
--- a/util/random/shuffle_ut.cpp
+++ b/util/random/shuffle_ut.cpp
@@ -111,4 +111,4 @@ Y_UNIT_TEST_SUITE(TRandUtilsTest) {
         TestIter(prng);
         TestIterPartial(prng);
     }
-}
+} // Y_UNIT_TEST_SUITE(TRandUtilsTest)
diff --git a/util/str_stl.h b/util/str_stl.h
index 70f9d46b077..4bbcd928b4a 100644
--- a/util/str_stl.h
+++ b/util/str_stl.h
@@ -30,13 +30,15 @@ namespace std {
         }
         using is_transparent = void;
     };
-}
+} // namespace std
 
 #endif
 
 namespace NHashPrivate {
     template <class T, bool needNumericHashing>
     struct THashHelper {
+        using is_default_implementation = std::true_type;
+
         inline size_t operator()(const T& t) const noexcept {
             return (size_t)t; // If you have a compilation error here, look at explanation below:
             // Probably error is caused by undefined template specialization of THash<T>
@@ -59,7 +61,7 @@ namespace NHashPrivate {
             return NHashPrivate::ComputeStringHash(s.data(), s.size());
         }
     };
-}
+} // namespace NHashPrivate
 
 template <class T>
 struct hash: public NHashPrivate::THashHelper<T, std::is_scalar<T>::value && !std::is_integral<T>::value> {
@@ -144,7 +146,7 @@ namespace NHashPrivate {
         }
     };
 
-}
+} // namespace NHashPrivate
 
 template <typename... TArgs>
 struct THash<std::tuple<TArgs...>> {
@@ -158,7 +160,7 @@ struct THash: public ::hash<T> {
 };
 
 namespace NHashPrivate {
-    template <class TFirst, class TSecond, bool IsEmpty = std::is_empty<THash<TFirst>>::value&& std::is_empty<THash<TSecond>>::value>
+    template <class TFirst, class TSecond, bool IsEmpty = std::is_empty<THash<TFirst>>::value && std::is_empty<THash<TSecond>>::value>
     struct TPairHash {
     private:
         THash<TFirst> FirstHash;
@@ -186,7 +188,7 @@ namespace NHashPrivate {
             return CombineHashes(THash<TFirstClean>()(pair.first), THash<TSecondClean>()(pair.second));
         }
     };
-}
+} // namespace NHashPrivate
 
 template <class TFirst, class TSecond>
 struct hash<std::pair<TFirst, TSecond>>: public NHashPrivate::TPairHash<TFirst, TSecond> {
@@ -218,6 +220,11 @@ struct TEqualTo<const char*> {
     }
 };
 
+template <>
+struct TEqualTo<std::string>: public TEqualTo<TStringBuf> {
+    using is_transparent = void;
+};
+
 template <class TFirst, class TSecond>
 struct TEqualTo<std::pair<TFirst, TSecond>> {
     template <class TOther>
@@ -261,6 +268,11 @@ struct TLess<TString>: public TLess<TStringBuf> {
     using is_transparent = void;
 };
 
+template <>
+struct TLess<std::string>: public TLess<TStringBuf> {
+    using is_transparent = void;
+};
+
 template <>
 struct TLess<TUtf16String>: public TLess<TWtringBuf> {
     using is_transparent = void;
@@ -287,6 +299,11 @@ struct TGreater<TString>: public TGreater<TStringBuf> {
     using is_transparent = void;
 };
 
+template <>
+struct TGreater<std::string>: public TGreater<TStringBuf> {
+    using is_transparent = void;
+};
+
 template <>
 struct TGreater<TUtf16String>: public TGreater<TWtringBuf> {
     using is_transparent = void;
diff --git a/util/stream/aligned.h b/util/stream/aligned.h
index 70e7be05a99..36304538387 100644
--- a/util/stream/aligned.h
+++ b/util/stream/aligned.h
@@ -17,7 +17,7 @@
  */
 class TAlignedInput: public IInputStream {
 public:
-    TAlignedInput(IInputStream* s)
+    TAlignedInput(IInputStream* s Y_LIFETIME_BOUND)
         : Stream_(s)
         , Position_(0)
     {
@@ -58,7 +58,7 @@ class TAlignedInput: public IInputStream {
  */
 class TAlignedOutput: public IOutputStream {
 public:
-    TAlignedOutput(IOutputStream* s)
+    TAlignedOutput(IOutputStream* s Y_LIFETIME_BOUND)
         : Stream_(s)
         , Position_(0)
     {
diff --git a/util/stream/aligned_ut.cpp b/util/stream/aligned_ut.cpp
index e980d05cf71..da4ef1c276c 100644
--- a/util/stream/aligned_ut.cpp
+++ b/util/stream/aligned_ut.cpp
@@ -60,4 +60,4 @@ Y_UNIT_TEST_SUITE(TAlignedTest) {
         alignedInput.ReadChar(c);
         UNIT_ASSERT_VALUES_EQUAL(c, '\x80');
     }
-}
+} // Y_UNIT_TEST_SUITE(TAlignedTest)
diff --git a/util/stream/buffer.cpp b/util/stream/buffer.cpp
index ac4c85f2880..85aaa2811d6 100644
--- a/util/stream/buffer.cpp
+++ b/util/stream/buffer.cpp
@@ -53,7 +53,7 @@ namespace {
         {
         }
     };
-}
+} // namespace
 
 TBufferOutput::TBufferOutput(size_t buflen)
     : Impl_(new TOwnedImpl(buflen))
diff --git a/util/stream/buffer_ut.cpp b/util/stream/buffer_ut.cpp
index 34946961907..77723077087 100644
--- a/util/stream/buffer_ut.cpp
+++ b/util/stream/buffer_ut.cpp
@@ -82,4 +82,4 @@ Y_UNIT_TEST_SUITE(TBufferTest) {
 
         UNIT_ASSERT(0 == memcmp(buffer.data(), "1234567890", buffer.size()));
     }
-}
+} // Y_UNIT_TEST_SUITE(TBufferTest)
diff --git a/util/stream/buffered.cpp b/util/stream/buffered.cpp
index c7d6647ec1d..c7c677d06eb 100644
--- a/util/stream/buffered.cpp
+++ b/util/stream/buffered.cpp
@@ -207,7 +207,7 @@ class TBufferedOutputBase::TImpl {
 
             Slave_->Write(parts, end - parts);
 
-            //grow buffer only on full flushes
+            // grow buffer only on full flushes
             OnBufferExhausted();
             Reset();
 
@@ -344,7 +344,7 @@ namespace {
         TBuffer B_;
         ui64 N_;
     };
-}
+} // namespace
 
 TBufferedOutputBase::TBufferedOutputBase(IOutputStream* slave)
     : Impl_(new TAdaptiveImpl(slave))
diff --git a/util/stream/buffered.h b/util/stream/buffered.h
index 0847186141f..c7bd2c5a82d 100644
--- a/util/stream/buffered.h
+++ b/util/stream/buffered.h
@@ -164,7 +164,7 @@ namespace NPrivate {
     struct TBufferedStreamFor {
         using TResult = std::conditional_t<std::is_base_of<IInputStream, T>::value, TBufferedInput, TMyBufferedOutput>;
     };
-}
+} // namespace NPrivate
 
 /**
  * A mixin class that turns unbuffered stream into a buffered one.
diff --git a/util/stream/buffered_ut.cpp b/util/stream/buffered_ut.cpp
index 41d2fc30308..aff7fde74e4 100644
--- a/util/stream/buffered_ut.cpp
+++ b/util/stream/buffered_ut.cpp
@@ -111,21 +111,21 @@ Y_UNIT_TEST_SUITE(TestBufferedIO) {
         TString s("0123456789abcdefghijklmn");
         TBuffered<TStringInput> in(5, s);
         char c;
-        UNIT_ASSERT_VALUES_EQUAL(in.Read(&c, 1), 1); //1
+        UNIT_ASSERT_VALUES_EQUAL(in.Read(&c, 1), 1); // 1
         UNIT_ASSERT_VALUES_EQUAL(c, '0');
-        UNIT_ASSERT_VALUES_EQUAL(in.Skip(4), 4);     //5 end of buffer
-        UNIT_ASSERT_VALUES_EQUAL(in.Read(&c, 1), 1); //6
+        UNIT_ASSERT_VALUES_EQUAL(in.Skip(4), 4);     // 5 end of buffer
+        UNIT_ASSERT_VALUES_EQUAL(in.Read(&c, 1), 1); // 6
         UNIT_ASSERT_VALUES_EQUAL(c, '5');
-        UNIT_ASSERT_VALUES_EQUAL(in.Skip(3), 3);     //9
-        UNIT_ASSERT_VALUES_EQUAL(in.Read(&c, 1), 1); //10 end of buffer
+        UNIT_ASSERT_VALUES_EQUAL(in.Skip(3), 3);     // 9
+        UNIT_ASSERT_VALUES_EQUAL(in.Read(&c, 1), 1); // 10 end of buffer
         UNIT_ASSERT_VALUES_EQUAL(c, '9');
-        UNIT_ASSERT_VALUES_EQUAL(in.Skip(3), 3);     //13
-        UNIT_ASSERT_VALUES_EQUAL(in.Read(&c, 1), 1); //14 start new buffer
+        UNIT_ASSERT_VALUES_EQUAL(in.Skip(3), 3);     // 13
+        UNIT_ASSERT_VALUES_EQUAL(in.Read(&c, 1), 1); // 14 start new buffer
         UNIT_ASSERT_VALUES_EQUAL(c, 'd');
-        UNIT_ASSERT_VALUES_EQUAL(in.Skip(6), 6);     //20
-        UNIT_ASSERT_VALUES_EQUAL(in.Read(&c, 1), 1); //21 start new buffer
+        UNIT_ASSERT_VALUES_EQUAL(in.Skip(6), 6);     // 20
+        UNIT_ASSERT_VALUES_EQUAL(in.Read(&c, 1), 1); // 21 start new buffer
         UNIT_ASSERT_VALUES_EQUAL(c, 'k');
-        UNIT_ASSERT_VALUES_EQUAL(in.Skip(6), 3); //24 eof
+        UNIT_ASSERT_VALUES_EQUAL(in.Skip(6), 3); // 24 eof
     }
 
     Y_UNIT_TEST(TestReadTo) {
@@ -139,4 +139,4 @@ Y_UNIT_TEST_SUITE(TestBufferedIO) {
         UNIT_ASSERT_VALUES_EQUAL(in.ReadTo(t, 'z'), 4);
         UNIT_ASSERT_VALUES_EQUAL(t, "9abc");
     }
-}
+} // Y_UNIT_TEST_SUITE(TestBufferedIO)
diff --git a/util/stream/debug.cpp b/util/stream/debug.cpp
deleted file mode 100644
index afd5b3e1c73..00000000000
--- a/util/stream/debug.cpp
+++ /dev/null
@@ -1,50 +0,0 @@
-#include "null.h"
-#include "debug.h"
-
-#include <util/string/cast.h>
-#include <util/generic/singleton.h>
-#include <util/generic/yexception.h>
-
-#include <cstdio>
-#include <cstdlib>
-
-void TDebugOutput::DoWrite(const void* buf, size_t len) {
-    if (len != fwrite(buf, 1, len, stderr)) {
-        ythrow yexception() << "write failed(" << LastSystemErrorText() << ")";
-    }
-}
-
-namespace {
-    struct TDbgSelector {
-        inline TDbgSelector() {
-            char* dbg = getenv("DBGOUT");
-            if (dbg) {
-                Out = &Cerr;
-                try {
-                    Level = FromString(dbg);
-                } catch (const yexception&) {
-                    Level = 0;
-                }
-            } else {
-                Out = &Cnull;
-                Level = 0;
-            }
-        }
-
-        IOutputStream* Out;
-        int Level;
-    };
-}
-
-template <>
-struct TSingletonTraits<TDbgSelector> {
-    static constexpr size_t Priority = 8;
-};
-
-IOutputStream& StdDbgStream() noexcept {
-    return *(Singleton<TDbgSelector>()->Out);
-}
-
-int StdDbgLevel() noexcept {
-    return Singleton<TDbgSelector>()->Level;
-}
diff --git a/util/stream/debug.h b/util/stream/debug.h
deleted file mode 100644
index 92d6d4b42da..00000000000
--- a/util/stream/debug.h
+++ /dev/null
@@ -1,53 +0,0 @@
-#pragma once
-
-#include "output.h"
-
-/**
- * @addtogroup Streams
- * @{
- */
-
-/**
- * Debug output stream. Writes into `stderr`.
- */
-class TDebugOutput: public IOutputStream {
-public:
-    inline TDebugOutput() noexcept = default;
-    ~TDebugOutput() override = default;
-
-    TDebugOutput(TDebugOutput&&) noexcept = default;
-    TDebugOutput& operator=(TDebugOutput&&) noexcept = default;
-
-private:
-    void DoWrite(const void* buf, size_t len) override;
-};
-
-/**
- * @returns                             Standard debug stream.
- * @see Cdbg
- */
-IOutputStream& StdDbgStream() noexcept;
-
-/**
- * This function returns the current debug level as set via `DBGOUT` environment
- * variable.
- *
- * Note that the proper way to use this function is via `Y_DBGTRACE` macro.
- * There are very few cases when there is a need to use it directly.
- *
- * @returns                             Debug level.
- * @see ETraceLevel
- * @see DBGTRACE
- */
-int StdDbgLevel() noexcept;
-
-/**
- * Standard debug stream.
- *
- * Behavior of this stream is controlled via `DBGOUT` environment variable.
- * If this variable is set, then this stream is redirected into `stderr`,
- * otherwise whatever is written into it is simply ignored.
- */
-#define Cdbg (StdDbgStream())
-
-/** @} */
diff --git a/util/stream/direct_io.h b/util/stream/direct_io.h
index 2e1f2e07dd7..66793c67ed8 100644
--- a/util/stream/direct_io.h
+++ b/util/stream/direct_io.h
@@ -6,7 +6,7 @@
 
 class TRandomAccessFileInput: public IInputStream {
 public:
-    TRandomAccessFileInput(TDirectIOBufferedFile& file, ui64 position);
+    TRandomAccessFileInput(TDirectIOBufferedFile& file Y_LIFETIME_BOUND, ui64 position);
 
 protected:
     size_t DoRead(void* buf, size_t len) override;
@@ -19,7 +19,7 @@ class TRandomAccessFileInput: public IInputStream {
 
 class TRandomAccessFileOutput: public IOutputStream {
 public:
-    TRandomAccessFileOutput(TDirectIOBufferedFile& file);
+    TRandomAccessFileOutput(TDirectIOBufferedFile& file Y_LIFETIME_BOUND);
 
     TRandomAccessFileOutput(TRandomAccessFileOutput&&) noexcept = default;
     TRandomAccessFileOutput& operator=(TRandomAccessFileOutput&&) noexcept = default;
diff --git a/util/stream/direct_io_ut.cpp b/util/stream/direct_io_ut.cpp
index 1fada06ecb2..dd13ceefa92 100644
--- a/util/stream/direct_io_ut.cpp
+++ b/util/stream/direct_io_ut.cpp
@@ -67,4 +67,4 @@ Y_UNIT_TEST_SUITE(TDirectIOTests) {
     Y_UNIT_TEST(ReadWriteDirectSeqTest) {
         Test(Direct | Seq, 100 * 4);
     }
-}
+} // Y_UNIT_TEST_SUITE(TDirectIOTests)
diff --git a/util/stream/file_ut.cpp b/util/stream/file_ut.cpp
index ac0f09796ee..91142a7dcda 100644
--- a/util/stream/file_ut.cpp
+++ b/util/stream/file_ut.cpp
@@ -71,4 +71,4 @@ Y_UNIT_TEST_SUITE(TFileTest) {
         close(fds[1]);
     }
 #endif
-}
+} // Y_UNIT_TEST_SUITE(TFileTest)
diff --git a/util/stream/format.cpp b/util/stream/format.cpp
index 3996130df5d..fa03dfd4346 100644
--- a/util/stream/format.cpp
+++ b/util/stream/format.cpp
@@ -34,7 +34,7 @@ namespace NFormatPrivate {
 
         return os << Prec(d, mode, ndigits);
     }
-}
+} // namespace NFormatPrivate
 
 template <>
 void Out<NFormatPrivate::THumanReadableSize>(IOutputStream& stream, const NFormatPrivate::THumanReadableSize& value) {
diff --git a/util/stream/format.h b/util/stream/format.h
index dc46684b397..adf42fb9705 100644
--- a/util/stream/format.h
+++ b/util/stream/format.h
@@ -45,8 +45,9 @@ namespace NFormatPrivate {
 
     template <typename T>
     static inline void WriteChars(T& os, char c, size_t count) {
-        if (count == 0)
+        if (count == 0) {
             return;
+        }
         TTempBuf buf(count);
         memset(buf.Data(), c, count);
         StreamWrite(os, buf.Data(), count);
@@ -67,7 +68,7 @@ namespace NFormatPrivate {
     };
 
     template <typename T>
-    IOutputStream& operator<<(IOutputStream& o, const TLeftPad<T>& lp) {
+    IOutputStream& operator<<(IOutputStream& o Y_LIFETIME_BOUND, const TLeftPad<T>& lp) {
         TTempBuf buf;
         TMemoryOutput ss(buf.Data(), buf.Size());
         ss << lp.Value;
@@ -94,7 +95,7 @@ namespace NFormatPrivate {
     };
 
     template <typename T>
-    IOutputStream& operator<<(IOutputStream& o, const TRightPad<T>& lp) {
+    IOutputStream& operator<<(IOutputStream& o Y_LIFETIME_BOUND, const TRightPad<T>& lp) {
         TTempBuf buf;
         TMemoryOutput ss(buf.Data(), buf.Size());
         ss << lp.Value;
@@ -123,7 +124,7 @@ namespace NFormatPrivate {
     using TUnsignedBaseNumber = TBaseNumber<std::make_unsigned_t<std::remove_cv_t<T>>, Base>;
 
     template <typename TStream, typename T, size_t Base>
-    TStream& ToStreamImpl(TStream& stream, const TBaseNumber<T, Base>& value) {
+    TStream& ToStreamImpl(TStream& stream Y_LIFETIME_BOUND, const TBaseNumber<T, Base>& value) {
         char buf[8 * sizeof(T) + 1]; /* Add 1 for sign. */
         TStringBuf str(buf, IntToString<Base>(value.Value, buf, sizeof(buf)));
 
@@ -149,12 +150,12 @@ namespace NFormatPrivate {
     }
 
     template <typename T, size_t Base>
-    IOutputStream& operator<<(IOutputStream& stream, const TBaseNumber<T, Base>& value) {
+    IOutputStream& operator<<(IOutputStream& stream Y_LIFETIME_BOUND, const TBaseNumber<T, Base>& value) {
         return ToStreamImpl(stream, value);
     }
 
     template <typename T, size_t Base>
-    std::ostream& operator<<(std::ostream& stream, const TBaseNumber<T, Base>& value) {
+    std::ostream& operator<<(std::ostream& stream Y_LIFETIME_BOUND, const TBaseNumber<T, Base>& value) {
         return ToStreamImpl(stream, value);
     }
 
@@ -169,7 +170,7 @@ namespace NFormatPrivate {
     };
 
     template <typename Char, size_t Base>
-    IOutputStream& operator<<(IOutputStream& os, const TBaseText<Char, Base>& text) {
+    IOutputStream& operator<<(IOutputStream& os Y_LIFETIME_BOUND, const TBaseText<Char, Base>& text) {
         for (size_t i = 0; i < text.Text.size(); ++i) {
             if (i != 0) {
                 os << ' ';
@@ -190,7 +191,7 @@ namespace NFormatPrivate {
     };
 
     template <typename T>
-    IOutputStream& operator<<(IOutputStream& o, const TFloatPrecision<T>& prec) {
+    IOutputStream& operator<<(IOutputStream& o Y_LIFETIME_BOUND, const TFloatPrecision<T>& prec) {
         char buf[512];
         size_t count = FloatToString(prec.Value, buf, sizeof(buf), prec.Mode, prec.NDigits);
         o << TStringBuf(buf, count);
@@ -210,7 +211,7 @@ namespace NFormatPrivate {
         double Value;
         ESizeFormat Format;
     };
-}
+} // namespace NFormatPrivate
 
 /**
  * Output manipulator basically equivalent to `std::setw` and `std::setfill`
@@ -396,7 +397,7 @@ static inline ::NFormatPrivate::TBaseText<TChar, 2> BinText(const TBasicStringBu
  * stream << HumanReadable(TDuration::Seconds(3672));       // Will output "1h 1m 12s"
  * @endcode
  *
- * @param value                         Value to output.
+ * @param duration                      Value to output.
  */
 static constexpr ::NFormatPrivate::THumanReadableDuration HumanReadable(const TDuration duration) noexcept {
     return ::NFormatPrivate::THumanReadableDuration(duration);
@@ -419,7 +420,7 @@ static constexpr ::NFormatPrivate::THumanReadableDuration HumanReadable(const TD
  * stream << "average usage " << HumanReadableSize(100 / 3., SF_BYTES);     // Will output    "average usage "33.3B""
  * @endcode
  *
- * @param value                         Value to output.
+ * @param size                          Value to output.
  * @param format                        Format to use.
  */
 static constexpr ::NFormatPrivate::THumanReadableSize HumanReadableSize(const double size, ESizeFormat format) noexcept {
diff --git a/util/stream/format_std_ut.cpp b/util/stream/format_std_ut.cpp
index b9030003822..0cb943206b7 100644
--- a/util/stream/format_std_ut.cpp
+++ b/util/stream/format_std_ut.cpp
@@ -26,4 +26,4 @@ Y_UNIT_TEST_SUITE(StdOstreamFormattingTest) {
         UNIT_ASSERT_VALUES_EQUAL(ToStringViaOstream(Bin(static_cast<ui8>(16))), "0b00010000");
         UNIT_ASSERT_VALUES_EQUAL(ToStringViaOstream(Bin(static_cast<ui64>(1234587912357ull))), "0b0000000000000000000000010001111101110011001011001000100010100101");
     }
-}
+} // Y_UNIT_TEST_SUITE(StdOstreamFormattingTest)
diff --git a/util/stream/format_ut.cpp b/util/stream/format_ut.cpp
index 43245aeb48e..bcafd22a006 100644
--- a/util/stream/format_ut.cpp
+++ b/util/stream/format_ut.cpp
@@ -179,4 +179,4 @@ Y_UNIT_TEST_SUITE(TOutputStreamFormattingTest) {
         UNIT_ASSERT_VALUES_EQUAL(ToString(HumanReadable(TDuration::Seconds(3672))), "1h 1m 12s");
         UNIT_ASSERT_VALUES_EQUAL(ToString(HumanReadable(TDuration::Seconds(4220))), "1h 10m 20s");
     }
-}
+} // Y_UNIT_TEST_SUITE(TOutputStreamFormattingTest)
diff --git a/util/stream/fwd.h b/util/stream/fwd.h
index 307676c6a7f..6c13f6fbefb 100644
--- a/util/stream/fwd.h
+++ b/util/stream/fwd.h
@@ -55,7 +55,7 @@ struct TZLibDecompressorError;
 
 namespace ZLib {
     enum StreamType: ui8;
-}
+} // namespace ZLib
 
 class TZLibDecompress;
 class TZLibCompress;
diff --git a/util/stream/hex_ut.cpp b/util/stream/hex_ut.cpp
index 5074a0b6168..b2c8ea5eb19 100644
--- a/util/stream/hex_ut.cpp
+++ b/util/stream/hex_ut.cpp
@@ -26,4 +26,4 @@ Y_UNIT_TEST_SUITE(THexCodingTest) {
     Y_UNIT_TEST(TestEmpty) {
         TestImpl("");
     }
-}
+} // Y_UNIT_TEST_SUITE(THexCodingTest)
diff --git a/util/stream/holder.h b/util/stream/holder.h
index c60a4e510ca..32752bb9f0b 100644
--- a/util/stream/holder.h
+++ b/util/stream/holder.h
@@ -19,7 +19,7 @@ namespace NPrivate {
         using TType = IOutputStream;
     };
 
-}
+} // namespace NPrivate
 
 /**
  * An ownership-gaining wrapper for proxy streams.
diff --git a/util/stream/input.cpp b/util/stream/input.cpp
index 6e8170f2f9f..a8969c7d852 100644
--- a/util/stream/input.cpp
+++ b/util/stream/input.cpp
@@ -248,7 +248,7 @@ namespace {
     };
     #endif
 #endif
-}
+} // namespace
 
 IInputStream& NPrivate::StdInStream() noexcept {
     return *SingletonWithPriority<TGetLine, 4>();
diff --git a/util/stream/input.h b/util/stream/input.h
index f0d5807ed27..60c89bfc092 100644
--- a/util/stream/input.h
+++ b/util/stream/input.h
@@ -31,7 +31,7 @@ class IInputStream: public TNonCopyable {
      * data than what was requested. Use `Load` function if you want to read as
      * much data as possible.
      *
-     * @param buf                       Buffer to read into.
+     * @param[out] buf                  Buffer to read into.
      * @param len                       Number of bytes to read.
      * @returns                         Number of bytes that were actually read.
      *                                  A return value of zero signals end of stream.
@@ -63,7 +63,7 @@ class IInputStream: public TNonCopyable {
      *
      * @param[out] st                   String to read into.
      * @param ch                        Character to stop at.
-     * @returns                         Total number of characters read from the stream.
+     * @returns                         Total number of bytes read from the stream.
      *                                  A return value of zero signals end of stream.
      */
     inline size_t ReadTo(TString& st, char ch) {
@@ -75,7 +75,7 @@ class IInputStream: public TNonCopyable {
      * function stops only when the requested amount of data is read, or when
      * end of stream is reached.
      *
-     * @param buf                       Buffer to read into.
+     * @param[out] buf                  Buffer to read into.
      * @param len                       Number of bytes to read.
      * @returns                         Number of bytes that were actually read.
      *                                  A return value different from `len`
@@ -87,7 +87,7 @@ class IInputStream: public TNonCopyable {
      * Reads the requested amount of data from the stream, or fails with an
      * exception if unable to do so.
      *
-     * @param buf                       Buffer to read into.
+     * @param[out] buf                  Buffer to read into.
      * @param len                       Number of bytes to read.
      * @see Load
      */
@@ -104,8 +104,8 @@ class IInputStream: public TNonCopyable {
      * Reads all data from this stream and writes it into a provided output
      * stream.
      *
-     * @param out                       Output stream to use.
-     * @returns                         Total number of characters read from the stream.
+     * @param[inout] out                Output stream to use.
+     * @returns                         Total number of bytes read from the stream.
      */
     ui64 ReadAll(IOutputStream& out);
 
@@ -140,19 +140,19 @@ class IInputStream: public TNonCopyable {
      *
      * @param[out] st                   String to store read characters into,
      *                                  excluding the line terminator.
-     * @returns                         Total number of characters read from the stream.
+     * @returns                         Total number of bytes read from the stream.
      *                                  A return value of zero signals end of stream.
      */
     size_t ReadLine(TString& st);
 
     /**
-     * Reads UTF8 encoded characters from the stream the first occurrence of '\n',
+     * Reads UTF8 encoded characters from the stream until the first occurrence of '\n',
      * converts them into wide ones, and stores into provided string. Also handles
      * Windows line breaks correctly.
      *
      * @param[out] w                    Wide string to store read characters into,
      *                                  excluding the line terminator.
-     * @returns                         Total number of characters read from the stream.
+     * @returns                         Total number of bytes read from the stream.
      *                                  A return value of zero signals end of stream.
      */
     size_t ReadLine(TUtf16String& w);
@@ -172,7 +172,7 @@ class IInputStream: public TNonCopyable {
      * Reads some data from the stream. Might read less data than what was
      * requested.
      *
-     * @param buf                       Buffer to read into.
+     * @param[out] buf                  Buffer to read into.
      * @param len                       Number of bytes to read.
      * @returns                         Number of bytes that were actually read.
      *                                  A return value of zero signals end of stream.
@@ -200,7 +200,7 @@ class IInputStream: public TNonCopyable {
      *
      * @param[out] st                   String to read into.
      * @param ch                        Character to stop at.
-     * @returns                         Total number of characters read from the stream.
+     * @returns                         Total number of bytes read from the stream.
      *                                  A return value of zero signals end of stream.
      * @throws yexception               If IO error occurs.
      */
@@ -210,8 +210,8 @@ class IInputStream: public TNonCopyable {
      * Reads all data from this stream and writes it into a provided output
      * stream.
      *
-     * @param out                       Output stream to use.
-     * @returns                         Total number of characters read from
+     * @param[inout] out                Output stream to use.
+     * @returns                         Total number of bytes read from
      *                                  this stream.
      * @throws yexception               If IO error occurs.
      */
@@ -221,8 +221,8 @@ class IInputStream: public TNonCopyable {
 /**
  * Transfers all data from the given input stream into the given output stream.
  *
- * @param in                            Input stream.
- * @param out                           Output stream.
+ * @param[inout] in                     Input stream.
+ * @param[inout] out                    Output stream.
  */
 ui64 TransferData(IInputStream* in, IOutputStream* out);
 
@@ -238,7 +238,7 @@ ui64 TransferData(IInputStream* in, IOutputStream* out);
  * However, if the flexibility of overload resolution is needed, then one should
  * just overload `operator>>`.
  *
- * @param in                            Input stream to read from.
+ * @param[inout] in                     Input stream to read from.
  * @param[out] value                    Value to read.
  * @throws                              `yexception` on invalid input or end of stream.
  * @see Out(IOutputStream&, T&)
@@ -249,21 +249,21 @@ void In(IInputStream& in, T& value);
 /**
  * Reads a value from the stream.
  *
- * @param in                            Input stream to read from.
+ * @param[inout] in                     Input stream to read from.
  * @param[out] value                    Value to read.
  * @returns                             Input stream.
  * @throws                              `yexception` on invalid input or end of stream.
  * @see operator<<(IOutputStream&, T&)
  */
 template <typename T>
-inline IInputStream& operator>>(IInputStream& in, T& value) {
+inline IInputStream& operator>>(IInputStream& in Y_LIFETIME_BOUND, T& value) {
     In<T>(in, value);
     return in;
 }
 
 namespace NPrivate {
     IInputStream& StdInStream() noexcept;
-}
+} // namespace NPrivate
 
 /**
  * Standard input stream.
diff --git a/util/stream/input_ut.cpp b/util/stream/input_ut.cpp
index 4a93f5458e6..482ebc77d4e 100644
--- a/util/stream/input_ut.cpp
+++ b/util/stream/input_ut.cpp
@@ -154,4 +154,4 @@ Y_UNIT_TEST_SUITE(TInputTest) {
                            });
         }
     }
-}
+} // Y_UNIT_TEST_SUITE(TInputTest)
diff --git a/util/stream/ios_ut.cpp b/util/stream/ios_ut.cpp
index 81d6bdf9b35..b60acec9313 100644
--- a/util/stream/ios_ut.cpp
+++ b/util/stream/ios_ut.cpp
@@ -393,7 +393,7 @@ namespace {
         TStringListInput sli(lst);
         test(sli, "IWalkInput");
     }
-}
+} // namespace
 
 void TStreamsTest::TestReadTo() {
     TestStreamReadTo("111a222b333c444d555e666f", TestStreamReadTo1);
diff --git a/util/stream/labeled_ut.cpp b/util/stream/labeled_ut.cpp
index 12d0dc50040..f2993d90e69 100644
--- a/util/stream/labeled_ut.cpp
+++ b/util/stream/labeled_ut.cpp
@@ -9,4 +9,4 @@ Y_UNIT_TEST_SUITE(TLabeledOutputTest) {
         out << LabeledOutput(x, 1, 2, 3 + 4);
         UNIT_ASSERT_STRINGS_EQUAL(out.Str(), "x = 3, 1 = 1, 2 = 2, 3 + 4 = 7");
     }
-}
+} // Y_UNIT_TEST_SUITE(TLabeledOutputTest)
diff --git a/util/stream/length.h b/util/stream/length.h
index 4d508ae24d2..670659e2c87 100644
--- a/util/stream/length.h
+++ b/util/stream/length.h
@@ -14,7 +14,7 @@
  */
 class TLengthLimitedInput: public IInputStream {
 public:
-    inline TLengthLimitedInput(IInputStream* slave, ui64 length) noexcept
+    inline TLengthLimitedInput(IInputStream* slave Y_LIFETIME_BOUND, ui64 length) noexcept
         : Slave_(slave)
         , Length_(length)
     {
@@ -40,7 +40,7 @@ class TLengthLimitedInput: public IInputStream {
  */
 class TCountingInput: public IInputStream {
 public:
-    inline TCountingInput(IInputStream* slave) noexcept
+    inline TCountingInput(IInputStream* slave Y_LIFETIME_BOUND) noexcept
         : Slave_(slave)
         , Count_()
     {
@@ -72,7 +72,7 @@ class TCountingInput: public IInputStream {
  */
 class TCountingOutput: public IOutputStream {
 public:
-    inline TCountingOutput(IOutputStream* slave) noexcept
+    inline TCountingOutput(IOutputStream* slave Y_LIFETIME_BOUND) noexcept
         : Slave_(slave)
         , Count_()
     {
diff --git a/util/stream/length_ut.cpp b/util/stream/length_ut.cpp
index 89684489544..446c40095c2 100644
--- a/util/stream/length_ut.cpp
+++ b/util/stream/length_ut.cpp
@@ -49,4 +49,4 @@ Y_UNIT_TEST_SUITE(TestLengthIO) {
         l1.Write(parts, 3);
         UNIT_ASSERT_VALUES_EQUAL(l1.Counter(), 14);
     }
-}
+} // Y_UNIT_TEST_SUITE(TestLengthIO)
diff --git a/util/stream/mem.h b/util/stream/mem.h
index 53383740a97..2a964974954 100644
--- a/util/stream/mem.h
+++ b/util/stream/mem.h
@@ -27,7 +27,7 @@ class TMemoryInput: public IZeroCopyInputFastReadTo {
      */
     TMemoryInput(const void* buf Y_LIFETIME_BOUND, size_t len) noexcept;
     TMemoryInput(TString&&) = delete;
-    explicit TMemoryInput(const TStringBuf buf) noexcept;
+    explicit TMemoryInput(const TStringBuf buf Y_LIFETIME_BOUND) noexcept;
     explicit TMemoryInput(const char* zstr Y_LIFETIME_BOUND)
         : TMemoryInput(TStringBuf(zstr))
     {
@@ -93,7 +93,7 @@ class TMemoryInput: public IZeroCopyInputFastReadTo {
      * Initializes this stream with a next chunk extracted from the given zero
      * copy stream.
      *
-     * @param stream                    Zero copy stream to initialize from.
+     * @param[inout] stream             Zero copy stream to initialize from.
      */
     void Fill(IZeroCopyInput* stream) {
         Len_ = stream->Next(&Buf_);
diff --git a/util/stream/mem_ut.cpp b/util/stream/mem_ut.cpp
index f388ae66acf..88ec97fc72f 100644
--- a/util/stream/mem_ut.cpp
+++ b/util/stream/mem_ut.cpp
@@ -75,4 +75,4 @@ Y_UNIT_TEST_SUITE(TestMemIO) {
         const char* const result = "1234567890";
         UNIT_ASSERT(0 == memcmp(buffer, result, strlen(result)));
     }
-}
+} // Y_UNIT_TEST_SUITE(TestMemIO)
diff --git a/util/stream/multi.h b/util/stream/multi.h
index 8bfd462d99e..ef04ec239c1 100644
--- a/util/stream/multi.h
+++ b/util/stream/multi.h
@@ -12,7 +12,7 @@
  */
 class TMultiInput: public IInputStream {
 public:
-    TMultiInput(IInputStream* f, IInputStream* s) noexcept;
+    TMultiInput(IInputStream* f Y_LIFETIME_BOUND, IInputStream* s Y_LIFETIME_BOUND) noexcept;
     ~TMultiInput() override;
 
 private:
diff --git a/util/stream/multi_ut.cpp b/util/stream/multi_ut.cpp
index 61869cdf1cb..7f57c937ae4 100644
--- a/util/stream/multi_ut.cpp
+++ b/util/stream/multi_ut.cpp
@@ -47,4 +47,4 @@ Y_UNIT_TEST_SUITE(TestMultiInput) {
         case3.TestReadToResult('j', 5, "fghi");
         case3.TestReadToResult('k', 1, "", "TRASH");
     }
-}
+} // Y_UNIT_TEST_SUITE(TestMultiInput)
diff --git a/util/stream/null.h b/util/stream/null.h
index 8c335a9a789..6d95c043835 100644
--- a/util/stream/null.h
+++ b/util/stream/null.h
@@ -51,7 +51,7 @@ class TNullIO: public TNullInput, public TNullOutput {
 
 namespace NPrivate {
     TNullIO& StdNullStream() noexcept;
-}
+} // namespace NPrivate
 
 /**
  * Standard null stream.
diff --git a/util/stream/output.cpp b/util/stream/output.cpp
index 8b3f78527dc..e4056df503e 100644
--- a/util/stream/output.cpp
+++ b/util/stream/output.cpp
@@ -1,7 +1,8 @@
 #include "output.h"
 
 #include <util/string/cast.h>
-#include "format.h"
+#include <util/stream/format.h>
+#include <util/stream/null.h>
 #include <util/memory/tempbuf.h>
 #include <util/generic/singleton.h>
 #include <util/generic/yexception.h>
@@ -17,9 +18,11 @@
 
 #include <cerrno>
 #include <cstdio>
+#include <cstdlib>
 #include <filesystem>
 #include <string_view>
 #include <optional>
+#include <complex>
 
 #if defined(_win_)
     #include <io.h>
@@ -251,6 +254,24 @@ void Out<void*>(IOutputStream& o, void* t) {
     Out<const void*>(o, t);
 }
 
+namespace {
+    template <typename T>
+    void ComplexOutImpl(IOutputStream& o, const T& t) {
+        // similar to operator<<(std::basic_ostream<...>&, const std::complex<...>&)
+        o << "(" << t.real() << "," << t.imag() << ")";
+    }
+} // namespace
+
+template <>
+void Out<std::complex<float>>(IOutputStream& o, const std::complex<float>& t) {
+    ComplexOutImpl(o, t);
+}
+
+template <>
+void Out<std::complex<double>>(IOutputStream& o, const std::complex<double>& t) {
+    ComplexOutImpl(o, t);
+}
+
 using TNullPtr = decltype(nullptr);
 
 template <>
@@ -274,6 +295,9 @@ DEF_OPTIONAL(ui64);
 DEF_OPTIONAL(std::string);
 DEF_OPTIONAL(TString);
 DEF_OPTIONAL(TStringBuf);
+#if defined(_darwin_) and defined(_arm64_)
+DEF_OPTIONAL(std::int64_t);
+#endif
 
 #if defined(_android_)
 namespace {
@@ -367,7 +391,7 @@ namespace {
     };
 
     bool TAndroidStdIOStreams::Enabled = false;
-}
+} // namespace
 #endif // _android_
 
 namespace {
@@ -431,7 +455,7 @@ namespace {
             return *SingletonWithPriority<TStdIOStreams, 4>();
         }
     };
-}
+} // namespace
 
 IOutputStream& NPrivate::StdErrStream() noexcept {
 #if defined(_android_)
@@ -458,3 +482,43 @@ void RedirectStdioToAndroidLog(bool redirect) {
     Y_UNUSED(redirect);
 #endif
 }
+void TDebugOutput::DoWrite(const void* buf, size_t len) {
+    if (len != fwrite(buf, 1, len, stderr)) {
+        ythrow yexception() << "write failed(" << LastSystemErrorText() << ")";
+    }
+}
+
+namespace {
+    struct TDbgSelector {
+        inline TDbgSelector() {
+            char* dbg = getenv("DBGOUT");
+            if (dbg) {
+                Out = &Cerr;
+                try {
+                    Level = FromString(dbg);
+                } catch (const yexception&) {
+                    Level = 0;
+                }
+            } else {
+                Out = &Cnull;
+                Level = 0;
+            }
+        }
+
+        IOutputStream* Out;
+        int Level;
+    };
+} // namespace
+
+template <>
+struct TSingletonTraits<TDbgSelector> {
+    static constexpr size_t Priority = 8;
+};
+
+IOutputStream& NPrivate::StdDbgStream() noexcept {
+    return *(Singleton<TDbgSelector>()->Out);
+}
+
+int StdDbgLevel() noexcept {
+    return Singleton<TDbgSelector>()->Level;
+}
diff --git a/util/stream/output.h b/util/stream/output.h
index 08e67c3c6f0..897e8e833fc 100644
--- a/util/stream/output.h
+++ b/util/stream/output.h
@@ -7,6 +7,7 @@
 #include <util/generic/string.h>
 #include <util/generic/strbuf.h>
 #include <util/generic/typetraits.h>
+#include <util/system/compiler.h>
 
 #include <type_traits>
 
@@ -182,7 +183,7 @@ class IOutputStream: public TNonCopyable {
  * However, if the flexibility of overload resolution is needed, then one should
  * just overload `operator<<`.
  *
- * @param out                           Output stream to write into.
+ * @param[inout] out                    Output stream to write into.
  * @param value                         Value to write.
  */
 template <class T>
@@ -207,54 +208,54 @@ void Out<const wchar16*>(IOutputStream& o, const wchar16* w);
 template <>
 void Out<const wchar32*>(IOutputStream& o, const wchar32* w);
 
-static inline IOutputStream& operator<<(IOutputStream& o, TStreamManipulator m) {
+static inline IOutputStream& operator<<(IOutputStream& o Y_LIFETIME_BOUND, TStreamManipulator m) {
     m(o);
 
     return o;
 }
 
-static inline IOutputStream& operator<<(IOutputStream& o, const char* t) {
+static inline IOutputStream& operator<<(IOutputStream& o Y_LIFETIME_BOUND, const char* t) {
     Out<const char*>(o, t);
 
     return o;
 }
 
-static inline IOutputStream& operator<<(IOutputStream& o, char* t) {
+static inline IOutputStream& operator<<(IOutputStream& o Y_LIFETIME_BOUND, char* t) {
     Out<const char*>(o, t);
 
     return o;
 }
 
 template <class T>
-static inline std::enable_if_t<std::is_scalar<T>::value, IOutputStream&> operator<<(IOutputStream& o, T t) {
+static inline std::enable_if_t<std::is_scalar<T>::value, IOutputStream&> operator<<(IOutputStream& o Y_LIFETIME_BOUND, T t) {
     Out<T>(o, t);
 
     return o;
 }
 
 template <class T>
-static inline std::enable_if_t<!std::is_scalar<T>::value, IOutputStream&> operator<<(IOutputStream& o, const T& t) {
+static inline std::enable_if_t<!std::is_scalar<T>::value, IOutputStream&> operator<<(IOutputStream& o Y_LIFETIME_BOUND, const T& t) {
     Out<T>(o, t);
 
     return o;
 }
 
-static inline IOutputStream& operator<<(IOutputStream& o, const wchar16* t) {
+static inline IOutputStream& operator<<(IOutputStream& o Y_LIFETIME_BOUND, const wchar16* t) {
     Out<const wchar16*>(o, t);
     return o;
 }
 
-static inline IOutputStream& operator<<(IOutputStream& o, wchar16* t) {
+static inline IOutputStream& operator<<(IOutputStream& o Y_LIFETIME_BOUND, wchar16* t) {
     Out<const wchar16*>(o, t);
     return o;
 }
 
-static inline IOutputStream& operator<<(IOutputStream& o, const wchar32* t) {
+static inline IOutputStream& operator<<(IOutputStream& o Y_LIFETIME_BOUND, const wchar32* t) {
     Out<const wchar32*>(o, t);
     return o;
 }
 
-static inline IOutputStream& operator<<(IOutputStream& o, wchar32* t) {
+static inline IOutputStream& operator<<(IOutputStream& o Y_LIFETIME_BOUND, wchar32* t) {
     Out<const wchar32*>(o, t);
     return o;
 }
@@ -262,7 +263,8 @@ static inline IOutputStream& operator<<(IOutputStream& o, wchar32* t) {
 namespace NPrivate {
     IOutputStream& StdOutStream() noexcept;
     IOutputStream& StdErrStream() noexcept;
-}
+    IOutputStream& StdDbgStream() noexcept;
+} // namespace NPrivate
 
 /**
  * Standard output stream.
@@ -279,6 +281,15 @@ namespace NPrivate {
  */
 #define Clog Cerr
 
+/**
+ * Standard debug stream.
+ *
+ * Behavior of this stream is controlled via `DBGOUT` environment variable.
+ * If this variable is set, then this stream is redirected into `stderr`,
+ * otherwise whatever is written into it is simply ignored.
+ */
+#define Cdbg (::NPrivate::StdDbgStream())
+
 /**
  * End-of-line output manipulator, basically the same as `std::endl`.
  */
@@ -297,8 +308,32 @@ static inline void Flush(IOutputStream& o) {
  * Also see format.h for additional manipulators.
  */
 
-#include "debug.h"
-
 void RedirectStdioToAndroidLog(bool redirect);
 
-/** @} */
+/**
+ * Debug output stream. Writes into `stderr`.
+ */
+class TDebugOutput: public IOutputStream {
+public:
+    inline TDebugOutput() noexcept = default;
+    ~TDebugOutput() override = default;
+
+    TDebugOutput(TDebugOutput&&) noexcept = default;
+    TDebugOutput& operator=(TDebugOutput&&) noexcept = default;
+
+private:
+    void DoWrite(const void* buf, size_t len) override;
+};
+
+/**
+ * This function returns the current debug level as set via `DBGOUT` environment
+ * variable.
+ *
+ * Note that the proper way to use this function is via `Y_DBGTRACE` macro.
+ * There are very few cases when there is a need to use it directly.
+ *
+ * @returns                             Debug level.
+ * @see ETraceLevel
+ * @see DBGTRACE
+ */
+int StdDbgLevel() noexcept;
diff --git a/util/stream/output_ut.cpp b/util/stream/output_ut.cpp
new file mode 100644
index 00000000000..fbfc12b268f
--- /dev/null
+++ b/util/stream/output_ut.cpp
@@ -0,0 +1,34 @@
+#include "output.h"
+#include <library/cpp/testing/unittest/registar.h>
+#include <complex>
+#include <sstream>
+#include <util/string/builder.h>
+#include <util/generic/vector.h>
+
+Y_UNIT_TEST_SUITE(TestOutput) {
+    namespace {
+        template <typename T>
+        void CheckComplexOutHelperImpl(const std::complex<T>& value) {
+            // Check Out << works as std::ostream << works
+            std::stringstream os;
+            os << value;
+            std::string stdStr = os.str();
+            TString arcadiaStr = TStringBuilder() << value;
+            UNIT_ASSERT_VALUES_EQUAL(stdStr, arcadiaStr);
+        }
+
+        void CheckComplexOutHelper(float real, float imag) {
+            CheckComplexOutHelperImpl(std::complex<double>(real, imag));
+            CheckComplexOutHelperImpl(std::complex<float>(real, imag));
+        }
+    } // namespace
+
+    Y_UNIT_TEST(TestComplex) {
+        TVector<float> values({-1., -0.5, 0., 0.5, 1.});
+        for (float real : values) {
+            for (float imag : values) {
+                CheckComplexOutHelper(real, imag);
+            }
+        }
+    }
+} // Y_UNIT_TEST_SUITE(TestOutput)
diff --git a/util/stream/printf.h b/util/stream/printf.h
index 1c7ddc06646..4f0f17551da 100644
--- a/util/stream/printf.h
+++ b/util/stream/printf.h
@@ -8,7 +8,7 @@ class IOutputStream;
  * Stream-based `printf` function. Prints formatted data into the provided stream.
  * Works the same way as a standard C `printf`.
  *
- * @param out                           Stream to write into.
+ * @param[inout] out                    Stream to write into.
  * @param fmt                           Format string.
  * @param ...                           Additional arguments.
  */
@@ -18,7 +18,7 @@ size_t Y_PRINTF_FORMAT(2, 3) Printf(IOutputStream& out, const char* fmt, ...);
  * Stream-based `vprintf` function. Prints formatted data from variable argument
  * list into the provided stream. Works the same way as a standard C `vprintf`.
  *
- * @param out                           Stream to write into.
+ * @param[inout] out                    Stream to write into.
  * @param fmt                           Format string.
  * @param params                        Additional arguments as a variable argument list.
  */
diff --git a/util/stream/printf_ut.cpp b/util/stream/printf_ut.cpp
index 0eab1670625..be82bd0f273 100644
--- a/util/stream/printf_ut.cpp
+++ b/util/stream/printf_ut.cpp
@@ -30,4 +30,4 @@ Y_UNIT_TEST_SUITE(TStreamPrintfTest) {
 
         UNIT_ASSERT_EQUAL(ss.Str(), s);
     }
-}
+} // Y_UNIT_TEST_SUITE(TStreamPrintfTest)
diff --git a/util/stream/str.cpp b/util/stream/str.cpp
index a0c3b1c75c7..9111e61ed14 100644
--- a/util/stream/str.cpp
+++ b/util/stream/str.cpp
@@ -1,5 +1,7 @@
 #include "str.h"
 
+#include <util/generic/bitops.h>
+
 static constexpr size_t MIN_BUFFER_GROW_SIZE = 16;
 
 TStringInput::~TStringInput() = default;
diff --git a/util/stream/str.pxd b/util/stream/str.pxd
index 76dc16a8220..5d6399cde40 100644
--- a/util/stream/str.pxd
+++ b/util/stream/str.pxd
@@ -5,7 +5,6 @@ from util.stream.output cimport IOutputStream
 
 cdef extern from "<util/stream/str.h>" nogil:
     cdef cppclass TStringOutput(IOutputStream):
-        TStringOutput() except+
         TStringOutput(TString&) except+
         void Reserve(size_t) except+
 
diff --git a/util/stream/str_ut.cpp b/util/stream/str_ut.cpp
index c5ab9ca5e95..ab3947ad208 100644
--- a/util/stream/str_ut.cpp
+++ b/util/stream/str_ut.cpp
@@ -222,4 +222,4 @@ Y_UNIT_TEST_SUITE(TStringInputOutputTest) {
         UNIT_ASSERT_STRINGS_EQUAL(str, "Быть или не быть? Вот в чём вопрос");
         str.clear();
     }
-}
+} // Y_UNIT_TEST_SUITE(TStringInputOutputTest)
diff --git a/util/stream/str_ut.pyx b/util/stream/str_ut.pyx
index 2ae617303f9..203efd1797a 100644
--- a/util/stream/str_ut.pyx
+++ b/util/stream/str_ut.pyx
@@ -10,10 +10,7 @@ import unittest
 
 
 class TestStringOutput(unittest.TestCase):
-    def test_ctor1(self):
-        cdef TStringOutput output
-
-    def test_ctor2(self):
+    def test_ctor(self):
         cdef TString string
         cdef THolder[TStringOutput] string_output = THolder[TStringOutput](new TStringOutput(string))
 
diff --git a/util/stream/tee.h b/util/stream/tee.h
index c69e232fb9f..8445ffd9c40 100644
--- a/util/stream/tee.h
+++ b/util/stream/tee.h
@@ -12,7 +12,7 @@
  */
 class TTeeOutput: public IOutputStream {
 public:
-    TTeeOutput(IOutputStream* l, IOutputStream* r) noexcept;
+    TTeeOutput(IOutputStream* l Y_LIFETIME_BOUND, IOutputStream* r Y_LIFETIME_BOUND) noexcept;
     ~TTeeOutput() override;
 
 private:
diff --git a/util/stream/tempbuf.cpp b/util/stream/tempbuf.cpp
index 801a1fabb05..799e0b0a398 100644
--- a/util/stream/tempbuf.cpp
+++ b/util/stream/tempbuf.cpp
@@ -4,7 +4,7 @@ namespace {
     static inline size_t Next(size_t size) noexcept {
         return size * 2;
     }
-}
+} // namespace
 
 void TTempBufOutput::DoWrite(const void* data, size_t len) {
     if (Y_LIKELY(len <= Left())) {
diff --git a/util/stream/tokenizer_ut.cpp b/util/stream/tokenizer_ut.cpp
index afc566da86e..181f95c78d9 100644
--- a/util/stream/tokenizer_ut.cpp
+++ b/util/stream/tokenizer_ut.cpp
@@ -261,4 +261,4 @@ Y_UNIT_TEST_SUITE(TStreamTokenizerTests) {
         }
         UNIT_ASSERT_VALUES_EQUAL(tokensSize, tokensCount);
     }
-}
+} // Y_UNIT_TEST_SUITE(TStreamTokenizerTests)
diff --git a/util/stream/trace.h b/util/stream/trace.h
index af5dc103974..40a2fe2108a 100644
--- a/util/stream/trace.h
+++ b/util/stream/trace.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include "debug.h"
+#include <util/stream/output.h>
 #include <util/system/defaults.h>
 
 /**
@@ -38,11 +38,11 @@ enum ETraceLevel: ui8 {
  * @see ETraceLevel
  */
 #define Y_DBGTRACE(elevel, args) Y_DBGTRACE0(int(TRACE_##elevel), args)
-#define Y_DBGTRACE0(level, args)                \
-    do {                                        \
-        if constexpr (Y_IS_DEBUG_BUILD) {       \
-            if ((level) <= StdDbgLevel()) {     \
-                StdDbgStream() << args << Endl; \
-            }                                   \
-        }                                       \
+#define Y_DBGTRACE0(level, args)            \
+    do {                                    \
+        if constexpr (Y_IS_DEBUG_BUILD) {   \
+            if ((level) <= StdDbgLevel()) { \
+                Cdbg << args << Endl;       \
+            }                               \
+        }                                   \
     } while (false)
diff --git a/util/stream/walk_ut.cpp b/util/stream/walk_ut.cpp
index e0a783799f2..14a44873730 100644
--- a/util/stream/walk_ut.cpp
+++ b/util/stream/walk_ut.cpp
@@ -52,4 +52,4 @@ Y_UNIT_TEST_SUITE(TWalkTest) {
         TString tmp4 = input.ReadAll();
         UNIT_ASSERT_VALUES_EQUAL(tmp4, "66f");
     }
-}
+} // Y_UNIT_TEST_SUITE(TWalkTest)
diff --git a/util/stream/zerocopy_output_ut.cpp b/util/stream/zerocopy_output_ut.cpp
index e81f7fb056c..df58d540f79 100644
--- a/util/stream/zerocopy_output_ut.cpp
+++ b/util/stream/zerocopy_output_ut.cpp
@@ -45,4 +45,4 @@ Y_UNIT_TEST_SUITE(TestZerocopyOutput) {
         output.Write(result.begin(), result.size());
         UNIT_ASSERT_STRINGS_EQUAL(str, result);
     }
-}
+} // Y_UNIT_TEST_SUITE(TestZerocopyOutput)
diff --git a/util/stream/zlib.cpp b/util/stream/zlib.cpp
index 06f181ee53a..dc14eca2971 100644
--- a/util/stream/zlib.cpp
+++ b/util/stream/zlib.cpp
@@ -10,13 +10,13 @@
 
 namespace {
     static const int opts[] = {
-        //Auto
+        // Auto
         15 + 32,
-        //ZLib
+        // ZLib
         15 + 0,
-        //GZip
+        // GZip
         15 + 16,
-        //Raw
+        // Raw
         -15};
 
     class TZLibCommon {
@@ -75,7 +75,7 @@ namespace {
         const char* Buf;
         size_t Len;
     };
-}
+} // namespace
 
 class TZLibDecompress::TImpl: private TZLibCommon, public TChunkedZeroCopyInput {
 public:
@@ -184,7 +184,7 @@ namespace {
     };
 
     using TZeroCopyDecompress = TZLibDecompress::TImpl;
-}
+} // namespace
 
 class TZLibCompress::TImpl: public TAdditionalStorage<TImpl>, private TZLibCommon {
     static inline ZLib::StreamType Type(ZLib::StreamType type) {
diff --git a/util/stream/zlib.h b/util/stream/zlib.h
index e7de7c81b74..648a5b99455 100644
--- a/util/stream/zlib.h
+++ b/util/stream/zlib.h
@@ -35,7 +35,7 @@ namespace ZLib {
     enum {
         ZLIB_BUF_LEN = 8 * 1024
     };
-}
+} // namespace ZLib
 
 /**
  * Non-buffered ZLib decompressing stream.
diff --git a/util/stream/zlib_ut.cpp b/util/stream/zlib_ut.cpp
index 2fef18cf0b0..388b6d79ecd 100644
--- a/util/stream/zlib_ut.cpp
+++ b/util/stream/zlib_ut.cpp
@@ -226,4 +226,4 @@ Y_UNIT_TEST_SUITE(TZLibTest) {
             }
         }
     }
-}
+} // Y_UNIT_TEST_SUITE(TZLibTest)
diff --git a/util/string/ascii.cpp b/util/string/ascii.cpp
index c9779c9dfaf..c18997b4a2c 100644
--- a/util/string/ascii.cpp
+++ b/util/string/ascii.cpp
@@ -3,46 +3,6 @@
 #include <util/system/yassert.h>
 #include <util/system/compat.h>
 
-// clang-format off
-extern const unsigned char NPrivate::ASCII_CLASS[256] = {
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x01, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
-    0x68, 0x68, 0x68, 0x68, 0x68, 0x68, 0x68, 0x68, 0x68, 0x68, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
-    0x80, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32,
-    0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x80, 0x80, 0x80, 0x80, 0x80,
-    0x80, 0x74, 0x74, 0x74, 0x74, 0x74, 0x74, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34,
-    0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x80, 0x80, 0x80, 0x80, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
-};
-
-extern const unsigned char NPrivate::ASCII_LOWER[256] = {
-    0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
-    16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
-    32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
-    48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
-    64, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111,
-    112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 91, 92, 93, 94, 95,
-    96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111,
-    112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127,
-    128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143,
-    144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159,
-    160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175,
-    176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191,
-    192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207,
-    208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223,
-    224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239,
-    240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255,
-};
-// clang-format on
-
 int AsciiCompareIgnoreCase(const TStringBuf s1, const TStringBuf s2) noexcept {
     if (s1.size() <= s2.size()) {
         if (int cmp = ::strnicmp(s1.data(), s2.data(), s1.size())) {
diff --git a/util/string/ascii.h b/util/string/ascii.h
index af74ff4382b..3cda6b40f16 100644
--- a/util/string/ascii.h
+++ b/util/string/ascii.h
@@ -23,8 +23,45 @@ namespace NPrivate {
         CC_PUNCT = 128,
     };
 
-    extern const unsigned char ASCII_CLASS[256];
-    extern const unsigned char ASCII_LOWER[256];
+    // clang-format off
+    inline constexpr unsigned char ASCII_CLASS[256] = {
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x01, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
+        0x68, 0x68, 0x68, 0x68, 0x68, 0x68, 0x68, 0x68, 0x68, 0x68, 0x80, 0x80, 0x80, 0x80, 0x80, 0x80,
+        0x80, 0x72, 0x72, 0x72, 0x72, 0x72, 0x72, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32,
+        0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x32, 0x80, 0x80, 0x80, 0x80, 0x80,
+        0x80, 0x74, 0x74, 0x74, 0x74, 0x74, 0x74, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34,
+        0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x34, 0x80, 0x80, 0x80, 0x80, 0x00,
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+    };
+
+    inline constexpr unsigned char ASCII_LOWER[256] = {
+        0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
+        16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31,
+        32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47,
+        48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
+        64, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111,
+        112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 91, 92, 93, 94, 95,
+        96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111,
+        112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127,
+        128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143,
+        144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159,
+        160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175,
+        176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191,
+        192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207,
+        208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223,
+        224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239,
+        240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255,
+    };
+    // clang-format on
 
     template <class T>
     struct TDereference {
@@ -42,7 +79,7 @@ namespace NPrivate {
     using TDereferenced = typename TDereference<T>::type;
 
     template <class T>
-    bool RangeOk(T c) noexcept {
+    constexpr bool RangeOk(T c) noexcept {
         static_assert(std::is_integral<T>::value, "Integral type character expected");
 
         if (sizeof(T) == 1) {
@@ -58,102 +95,102 @@ namespace NPrivate {
         return RangeOk(static_cast<typename String::value_type>(c));
     }
 #endif
-}
+} // namespace NPrivate
 
 constexpr bool IsAscii(const int c) noexcept {
     return !(c & ~0x7f);
 }
 
-inline bool IsAsciiSpace(unsigned char c) {
+constexpr bool IsAsciiSpace(unsigned char c) {
     return ::NPrivate::ASCII_CLASS[c] & ::NPrivate::CC_SPACE;
 }
 
-inline bool IsAsciiUpper(unsigned char c) {
+constexpr bool IsAsciiUpper(unsigned char c) {
     return ::NPrivate::ASCII_CLASS[c] & ::NPrivate::CC_UPPER;
 }
 
-inline bool IsAsciiLower(unsigned char c) {
+constexpr bool IsAsciiLower(unsigned char c) {
     return ::NPrivate::ASCII_CLASS[c] & ::NPrivate::CC_LOWER;
 }
 
-inline bool IsAsciiDigit(unsigned char c) {
+constexpr bool IsAsciiDigit(unsigned char c) {
     return ::NPrivate::ASCII_CLASS[c] & ::NPrivate::CC_DIGIT;
 }
 
-inline bool IsAsciiAlpha(unsigned char c) {
+constexpr bool IsAsciiAlpha(unsigned char c) {
     return ::NPrivate::ASCII_CLASS[c] & ::NPrivate::CC_ALPHA;
 }
 
-inline bool IsAsciiAlnum(unsigned char c) {
+constexpr bool IsAsciiAlnum(unsigned char c) {
     return ::NPrivate::ASCII_CLASS[c] & ::NPrivate::CC_ALNUM;
 }
 
-inline bool IsAsciiHex(unsigned char c) {
+constexpr bool IsAsciiHex(unsigned char c) {
     return ::NPrivate::ASCII_CLASS[c] & ::NPrivate::CC_ISHEX;
 }
 
-inline bool IsAsciiPunct(unsigned char c) {
+constexpr bool IsAsciiPunct(unsigned char c) {
     return ::NPrivate::ASCII_CLASS[c] & ::NPrivate::CC_PUNCT;
 }
 
 // some overloads
 
 template <class T>
-inline bool IsAsciiSpace(T c) {
+constexpr bool IsAsciiSpace(T c) {
     return ::NPrivate::RangeOk(c) && IsAsciiSpace(static_cast<unsigned char>(c));
 }
 
 template <class T>
-inline bool IsAsciiUpper(T c) {
+constexpr bool IsAsciiUpper(T c) {
     return ::NPrivate::RangeOk(c) && IsAsciiUpper(static_cast<unsigned char>(c));
 }
 
 template <class T>
-inline bool IsAsciiLower(T c) {
+constexpr bool IsAsciiLower(T c) {
     return ::NPrivate::RangeOk(c) && IsAsciiLower(static_cast<unsigned char>(c));
 }
 
 template <class T>
-inline bool IsAsciiDigit(T c) {
+constexpr bool IsAsciiDigit(T c) {
     return ::NPrivate::RangeOk(c) && IsAsciiDigit(static_cast<unsigned char>(c));
 }
 
 template <class T>
-inline bool IsAsciiAlpha(T c) {
+constexpr bool IsAsciiAlpha(T c) {
     return ::NPrivate::RangeOk(c) && IsAsciiAlpha(static_cast<unsigned char>(c));
 }
 
 template <class T>
-inline bool IsAsciiAlnum(T c) {
+constexpr bool IsAsciiAlnum(T c) {
     return ::NPrivate::RangeOk(c) && IsAsciiAlnum(static_cast<unsigned char>(c));
 }
 
 template <class T>
-inline bool IsAsciiHex(T c) {
+constexpr bool IsAsciiHex(T c) {
     return ::NPrivate::RangeOk(c) && IsAsciiHex(static_cast<unsigned char>(c));
 }
 
 template <class T>
-inline bool IsAsciiPunct(T c) {
+constexpr bool IsAsciiPunct(T c) {
     return ::NPrivate::RangeOk(c) && IsAsciiPunct(static_cast<unsigned char>(c));
 }
 
 // some extra helpers
-inline ui8 AsciiToLower(ui8 c) noexcept {
+constexpr ui8 AsciiToLower(ui8 c) noexcept {
     return ::NPrivate::ASCII_LOWER[c];
 }
 
-inline char AsciiToLower(char c) noexcept {
+constexpr char AsciiToLower(char c) noexcept {
     return (char)AsciiToLower((ui8)c);
 }
 
 template <class T>
-inline ::NPrivate::TDereferenced<T> AsciiToLower(T c) noexcept {
+constexpr ::NPrivate::TDereferenced<T> AsciiToLower(T c) noexcept {
     return (c >= 0 && c <= 127) ? (::NPrivate::TDereferenced<T>)AsciiToLower((ui8)c) : c;
 }
 
 template <class T>
-inline ::NPrivate::TDereferenced<T> AsciiToUpper(T c) noexcept {
+constexpr ::NPrivate::TDereferenced<T> AsciiToUpper(T c) noexcept {
     return IsAsciiLower(c) ? (c + ('A' - 'a')) : c;
 }
 
diff --git a/util/string/ascii_ut.cpp b/util/string/ascii_ut.cpp
index 89069fee50a..b745faf87ad 100644
--- a/util/string/ascii_ut.cpp
+++ b/util/string/ascii_ut.cpp
@@ -95,4 +95,4 @@ Y_UNIT_TEST_SUITE(TAsciiTest) {
         UNIT_ASSERT_EQUAL(AsciiHasSuffixIgnoreCase("qweasd", "asD"), true);
         UNIT_ASSERT_EQUAL(AsciiHasSuffixIgnoreCase("qweasd", "ast"), false);
     }
-}
+} // Y_UNIT_TEST_SUITE(TAsciiTest)
diff --git a/util/string/builder.h b/util/string/builder.h
index 9620fc86067..9da64824640 100644
--- a/util/string/builder.h
+++ b/util/string/builder.h
@@ -34,6 +34,6 @@ namespace NPrivateStringBuilder {
 
         return std::move(builder);
     }
-}
+} // namespace NPrivateStringBuilder
 
 using TStringBuilder = NPrivateStringBuilder::TStringBuilder;
diff --git a/util/string/builder_ut.cpp b/util/string/builder_ut.cpp
index 22def683ec2..1a165a42681 100644
--- a/util/string/builder_ut.cpp
+++ b/util/string/builder_ut.cpp
@@ -60,4 +60,4 @@ Y_UNIT_TEST_SUITE(TStringBuilderTest) {
         UNIT_ASSERT(TRValueAcceptTester::IsRValue(TStringBuilder() << b2));
         UNIT_ASSERT_VALUES_EQUAL("a1a", TStringBuilder() << b2);
     }
-}
+} // Y_UNIT_TEST_SUITE(TStringBuilderTest)
diff --git a/util/string/cast.cpp b/util/string/cast.cpp
index 4c74a4b868c..9364e5b0e26 100644
--- a/util/string/cast.cpp
+++ b/util/string/cast.cpp
@@ -347,7 +347,7 @@ namespace {
     constexpr TBounds<ui64> lUBounds = {static_cast<ui64>(ULONG_MAX), 0};
     constexpr TBounds<ui64> llSBounds = {static_cast<ui64>(LLONG_MAX), static_cast<ui64>(ULLONG_MAX - LLONG_MAX)};
     constexpr TBounds<ui64> llUBounds = {static_cast<ui64>(ULLONG_MAX), 0};
-}
+} // namespace
 
 #define DEF_INT_SPEC_II(TYPE, ITYPE, BASE)                              \
     template <>                                                         \
@@ -729,7 +729,7 @@ namespace {
 
         return FixEnd(buf, FixZeros(buf, sb.SB->position()));
     }
-}
+} // namespace
 
 template <>
 size_t ToStringImpl<double>(double d, char* buf, size_t len) {
diff --git a/util/string/cast.h b/util/string/cast.h
index 564baa93d5c..0c616738832 100644
--- a/util/string/cast.h
+++ b/util/string/cast.h
@@ -76,7 +76,7 @@ namespace NPrivate {
             return s;
         }
     };
-}
+} // namespace NPrivate
 
 /*
  * some clever implementations...
@@ -199,7 +199,7 @@ namespace NPrivate {
             return FromString<T, TChar>(Data, Len);
         }
     };
-}
+} // namespace NPrivate
 
 template <typename TChar>
 inline ::NPrivate::TFromString<TChar> FromString(const TChar* data, size_t len) {
@@ -217,13 +217,14 @@ inline ::NPrivate::TFromString<typename T::TChar> FromString(const T& s) {
 }
 
 // Conversion exception free versions
+// But can throw other exceptions, e.g. std::bad_alloc when allocating memory for the new 'result' value.
 template <typename T, typename TChar>
 bool TryFromStringImpl(const TChar* data, size_t len, T& result);
 
 /**
  * @param data Source string buffer pointer
  * @param len Source string length, in characters
- * @param result Place to store conversion result value.
+ * @param[out] result Place to store conversion result value.
  * If conversion error occurs, no value stored in @c result
  * @return @c true in case of successful conversion, @c false otherwise
  **/
@@ -271,8 +272,8 @@ inline bool TryFromString(const TUtf16String& s, T& result) {
     return TryFromString<T>(s.data(), s.size(), result);
 }
 
-template <class T, class TChar>
-inline TMaybe<T> TryFromString(TBasicStringBuf<TChar> s) {
+template <class T, class TChar, class TTraits>
+inline TMaybe<T> TryFromString(std::basic_string_view<TChar, TTraits> s) {
     TMaybe<T> result{NMaybe::TInPlace{}};
     if (!TryFromString<T>(s, *result)) {
         result.Clear();
diff --git a/util/string/cast_ut.cpp b/util/string/cast_ut.cpp
index 443f8a79f8e..d474b61d921 100644
--- a/util/string/cast_ut.cpp
+++ b/util/string/cast_ut.cpp
@@ -410,6 +410,11 @@ Y_UNIT_TEST_SUITE(TCastTest) {
         UNIT_ASSERT_VALUES_EQUAL(FromStringWithDefault<size_t>("100q500"), size_t());
         UNIT_CHECK_GENERATED_EXCEPTION(FromString<size_t>(s2), TFromStringException);
 
+        UNIT_ASSERT_VALUES_EQUAL(TryFromStringWithDefault("100"sv, res, def1), true);
+        UNIT_ASSERT_VALUES_EQUAL(res, 100);
+        UNIT_ASSERT_VALUES_EQUAL(TryFromStringWithDefault("abc"sv, res, def1), false);
+        UNIT_ASSERT_VALUES_EQUAL(res, def1);
+
         int res2 = 0;
         const int def2 = -6;
 
@@ -461,6 +466,12 @@ Y_UNIT_TEST_SUITE(TCastTest) {
         std::string s5 = "100500";
         UNIT_CHECK_GENERATED_NO_EXCEPTION(res = TryFromString<int>(s5), yexception);
         UNIT_ASSERT_VALUES_EQUAL(res, 100500);
+
+        UNIT_CHECK_GENERATED_NO_EXCEPTION(res = TryFromString<int>("500"sv), yexception);
+        UNIT_ASSERT_VALUES_EQUAL(res, 500);
+
+        UNIT_CHECK_GENERATED_NO_EXCEPTION(res = TryFromString<int>("abc"sv), yexception);
+        UNIT_ASSERT(res.Empty());
     }
 
     Y_UNIT_TEST(TestBool) {
@@ -616,4 +627,4 @@ Y_UNIT_TEST_SUITE(TCastTest) {
         UNIT_ASSERT_VALUES_EQUAL(ok, "foo");
         UNIT_ASSERT_VALUES_EQUAL(ToString(ToString(ok)), "foo");
     }
-}
+} // Y_UNIT_TEST_SUITE(TCastTest)
diff --git a/util/string/escape.cpp b/util/string/escape.cpp
index cd09a7dbd02..1ed8dfe6f75 100644
--- a/util/string/escape.cpp
+++ b/util/string/escape.cpp
@@ -146,7 +146,7 @@ namespace {
             }
         }
     };
-}
+} // namespace
 
 template <class TChar>
 TBasicString<TChar>& EscapeCImpl(const TChar* str, size_t len, TBasicString<TChar>& r) {
@@ -224,7 +224,7 @@ namespace {
 
         return maxsz;
     }
-}
+} // namespace
 
 template <class TChar, class TStr>
 static TStr& DoUnescapeC(const TChar* p, size_t sz, TStr& res) {
diff --git a/util/string/escape_ut.cpp b/util/string/escape_ut.cpp
index cd38ecffd34..01a95dc7ab3 100644
--- a/util/string/escape_ut.cpp
+++ b/util/string/escape_ut.cpp
@@ -18,7 +18,7 @@ namespace {
         {
         }
     };
-}
+} // namespace
 
 static const TExample CommonTestData[] = {
     // Should be valid UTF-8.
@@ -145,4 +145,4 @@ Y_UNIT_TEST_SUITE(TEscapeCTest) {
         UNIT_ASSERT_VALUES_EQUAL(UnescapeC("\\U00000020"), " ");
         UNIT_ASSERT_VALUES_EQUAL(UnescapeC("\\Uxxx"), "Uxxx");
     }
-}
+} // Y_UNIT_TEST_SUITE(TEscapeCTest)
diff --git a/util/string/hex.cpp b/util/string/hex.cpp
index 667397987fc..7b1af2c6b74 100644
--- a/util/string/hex.cpp
+++ b/util/string/hex.cpp
@@ -3,10 +3,10 @@
 const char* const Char2DigitTable = ("\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"
                                      "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"
                                      "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"
-                                     "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\xff\xff\xff\xff\xff\xff" //0-9
-                                     "\xff\x0a\x0b\x0c\x0d\x0e\x0f\xff\xff\xff\xff\xff\xff\xff\xff\xff" //A-Z
+                                     "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\xff\xff\xff\xff\xff\xff" // 0-9
+                                     "\xff\x0a\x0b\x0c\x0d\x0e\x0f\xff\xff\xff\xff\xff\xff\xff\xff\xff" // A-Z
                                      "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"
-                                     "\xff\x0a\x0b\x0c\x0d\x0e\x0f\xff\xff\xff\xff\xff\xff\xff\xff\xff" //a-z
+                                     "\xff\x0a\x0b\x0c\x0d\x0e\x0f\xff\xff\xff\xff\xff\xff\xff\xff\xff" // a-z
                                      "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"
                                      "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"
                                      "\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff"
diff --git a/util/string/hex_ut.cpp b/util/string/hex_ut.cpp
index 39a83d5e62b..497632a1264 100644
--- a/util/string/hex_ut.cpp
+++ b/util/string/hex_ut.cpp
@@ -16,4 +16,4 @@ Y_UNIT_TEST_SUITE(THexCodingTest) {
         UNIT_ASSERT_EXCEPTION(HexDecode("Hello"), yexception); //< incorrect chars
         UNIT_ASSERT_EXCEPTION(HexDecode("123"), yexception);   //< odd length
     }
-}
+} // Y_UNIT_TEST_SUITE(THexCodingTest)
diff --git a/util/string/join.h b/util/string/join.h
index e3c08ef584a..8bb9b69a9a5 100644
--- a/util/string/join.h
+++ b/util/string/join.h
@@ -73,7 +73,16 @@ namespace NPrivate {
     size_t GetAppendLength(const TStringBuf delim, const TFirst& f, const TRest&... r) {
         return delim.length() + ::NPrivate::GetLength(f) + ::NPrivate::GetAppendLength(delim, r...);
     }
-}
+
+    template <typename TCharType, typename TTraits, typename... R>
+    inline std::basic_string<TCharType, TTraits> ConcatImpl(const R&... r) {
+        using THelper = TStringJoinHelper<TCharType, TTraits>;
+        std::basic_string<TCharType, TTraits> s;
+        ::ResizeUninitialized(s, THelper::SumLength(r...));
+        THelper::CopyAll((TCharType*)s.data(), r...);
+        return s;
+    }
+} // namespace NPrivate
 
 template <typename TCharType>
 inline void AppendJoinNoReserve(TBasicString<TCharType>&, TBasicStringBuf<TCharType>) {
@@ -203,12 +212,13 @@ JoinSeq(TCharType delim, const TContainer& data) {
  */
 template <class TIterB, class TIterE>
 struct TRangeJoiner {
-    friend constexpr IOutputStream& operator<<(IOutputStream& stream, const TRangeJoiner<TIterB, TIterE>& rangeJoiner) {
+    friend constexpr IOutputStream& operator<<(IOutputStream& stream Y_LIFETIME_BOUND, const TRangeJoiner<TIterB, TIterE>& rangeJoiner) {
         if (rangeJoiner.b != rangeJoiner.e) {
             stream << *rangeJoiner.b;
 
-            for (auto it = std::next(rangeJoiner.b); it != rangeJoiner.e; ++it)
+            for (auto it = std::next(rangeJoiner.b); it != rangeJoiner.e; ++it) {
                 stream << rangeJoiner.delim << *it;
+            }
         }
         return stream;
     }
@@ -263,3 +273,18 @@ JoinSeq(const TStringBuf delim, const std::initializer_list<T>& data) {
 inline TString JoinSeq(const TStringBuf delim, const std::initializer_list<TStringBuf>& data) {
     return JoinRange(delim, data.begin(), data.end());
 }
+
+template <typename TStringType, typename... R>
+#if __cplusplus >= 202002L
+    requires requires(TStringType s) {
+        typename TStringType::value_type;
+        typename TStringType::traits_type;
+        ::ResizeUninitialized(s, size_t());
+    }
+#endif
+TStringType Concat(const R&... r) {
+    using TCharType = typename TStringType::value_type;
+    using TTraits = typename TStringType::traits_type;
+    using THelper = TStringJoinHelper<TCharType, TTraits>;
+    return ::NPrivate::ConcatImpl<TCharType, TTraits>(typename THelper::template TJoinParam<R>(r)...);
+}
diff --git a/util/string/join_ut.cpp b/util/string/join_ut.cpp
index 3ed2b2459c4..27b3e793f53 100644
--- a/util/string/join_ut.cpp
+++ b/util/string/join_ut.cpp
@@ -2,8 +2,9 @@
 
 #include <library/cpp/testing/unittest/registar.h>
 #include <util/generic/vector.h>
+#include <util/string/cast.h>
 
-#include <util/stream/output.h>
+#include <util/stream/str.h>
 
 struct TCustomData {
     TVector<int> Ints;
@@ -160,4 +161,9 @@ Y_UNIT_TEST_SUITE(JoinStringTest) {
         UNIT_ASSERT_EQUAL(Join('a', 'a', 'a'), "97a97");
         UNIT_ASSERT_EQUAL(Join("a", "a", "a"), "aaa");
     }
-}
+
+    Y_UNIT_TEST(Concat) {
+        UNIT_ASSERT_EQUAL(Concat<std::string>("test", '_', TIntStringBuf(123)), "test_123");
+        UNIT_ASSERT_EQUAL(Concat<TString>("test", '_', TIntStringBuf(123)), "test_123");
+    }
+} // Y_UNIT_TEST_SUITE(JoinStringTest)
diff --git a/util/string/printf_ut.cpp b/util/string/printf_ut.cpp
index 2b2f980b70e..6f59ef08dc2 100644
--- a/util/string/printf_ut.cpp
+++ b/util/string/printf_ut.cpp
@@ -27,4 +27,4 @@ Y_UNIT_TEST_SUITE(TStringPrintf) {
     Y_UNIT_TEST(TestExplicitPositions) {
         UNIT_ASSERT_EQUAL("abc xyz abc", Sprintf("%1$s %2$s %1$s", "abc", "xyz"));
     }
-}
+} // Y_UNIT_TEST_SUITE(TStringPrintf)
diff --git a/util/string/split.cpp b/util/string/split.cpp
index 7d26857cc7a..f27be107c76 100644
--- a/util/string/split.cpp
+++ b/util/string/split.cpp
@@ -22,3 +22,5 @@ size_t Split(const char* ptr, const char* delim, TVector<TString>& values) {
 size_t Split(const TString& in, const TString& delim, TVector<TString>& res) {
     return Split(in.data(), delim.data(), res);
 }
+
+alignas(wchar32) const char NStringSplitPrivate::SPLITTER_EMPTY_SENTINEL{0};
diff --git a/util/string/split.h b/util/string/split.h
index 51f97994474..100160a417f 100644
--- a/util/string/split.h
+++ b/util/string/split.h
@@ -47,7 +47,7 @@ namespace NStringSplitPrivate {
         return nullptr;
     }
 
-}
+} // namespace NStringSplitPrivate
 
 template <class I, class TDelim, class TConsumer>
 std::enable_if_t<::NStringSplitPrivate::TIsConsumerV<TConsumer, I>>
@@ -84,11 +84,11 @@ static inline I1* FastStrChr(I1* str, I2 f) noexcept {
 
 template <class I>
 static inline I* FastStrStr(I* str, I* f, size_t l) noexcept {
-    std::basic_string_view<I> strView(str);
+    auto strView = std::basic_string_view(str);
     const auto ret = strView.find(*f);
 
     if (ret != std::string::npos) {
-        std::basic_string_view<I> fView(f, l);
+        auto fView = std::basic_string_view(f, l);
         strView = strView.substr(ret);
         for (; strView.size() >= l; strView = strView.substr(1)) {
             if (strView.substr(0, l) == fView) {
@@ -117,7 +117,7 @@ struct TStringDelimiter {
     }
 
     inline Char* Find(Char*& b, Char* e) const noexcept {
-        const auto ret = std::basic_string_view<Char>(b, e - b).find(Delim, 0, Len);
+        const auto ret = std::basic_string_view(b, e - b).find(Delim, 0, Len);
 
         if (ret != std::string::npos) {
             const auto result = b + ret;
@@ -148,7 +148,7 @@ struct TCharDelimiter {
     }
 
     inline Char* Find(Char*& b, Char* e) const noexcept {
-        const auto ret = std::basic_string_view<Char>(b, e - b).find(Ch);
+        const auto ret = std::basic_string_view(b, e - b).find(Ch);
 
         if (ret != std::string::npos) {
             const auto result = b + ret;
@@ -205,14 +205,15 @@ struct TFindFirstOf {
     inline Char* FindFirstOf(Char* b, Char* e) const noexcept {
         Char* ret = b;
         for (; ret != e; ++ret) {
-            if (NStringSplitPrivate::Find(Set, *ret))
+            if (NStringSplitPrivate::Find(Set, *ret)) {
                 break;
+            }
         }
         return ret;
     }
 
     inline Char* FindFirstOf(Char* b) const noexcept {
-        const std::basic_string_view<Char> bView(b);
+        const auto bView = std::basic_string_view(b);
         const auto ret = bView.find_first_of(Set);
         return ret != std::string::npos ? b + ret : b + bView.size();
     }
@@ -262,7 +263,7 @@ struct TSetDelimiter: private TFindFirstOf<const Char> {
 
 namespace NSplitTargetHasPushBack {
     Y_HAS_MEMBER(push_back, PushBack);
-}
+} // namespace NSplitTargetHasPushBack
 
 template <class T, class = void>
 struct TConsumerBackInserter;
@@ -398,8 +399,9 @@ struct TSimplePusher {
 template <class T>
 static inline void Split(char* buf, char ch, T* res) {
     res->resize(0);
-    if (*buf == 0)
+    if (*buf == 0) {
         return;
+    }
 
     TCharDelimiter<char> delim(ch);
     TSimplePusher<T> pusher = {res};
@@ -494,6 +496,19 @@ namespace NStringSplitPrivate {
     Y_HAS_MEMBER(insert, Insert);
     Y_HAS_MEMBER(data, Data);
 
+    template <bool UseSentinel>
+    struct TIteratorStateTokenCounter {
+        bool HaveToUseNextToken = true; // At least one token must be returned. Only the first token needs to be distinguished.
+    };
+
+    // reserve an address that never aliases with user-provided strings
+    alignas(wchar32) Y_HIDDEN extern const char SPLITTER_EMPTY_SENTINEL;
+
+    template <>
+    struct TIteratorStateTokenCounter<true> {
+        static constexpr bool HaveToUseNextToken = false; // The sentinel value guarantees that the first token is not skipped anyway.
+    };
+
     /**
      * This one is needed here so that `std::string_view -> std::string_view`
      * conversion works.
@@ -654,14 +669,23 @@ namespace NStringSplitPrivate {
     class TStringSplitter;
 
     template <class String>
-    struct TIterState: public TStringBufOf<String> {
+    struct TIterState: public TStringBufOf<String>, private TIteratorStateTokenCounter<THasData<String>::value> {
     public:
         using TStringBufType = TStringBufOf<String>;
         using TIterator = TIteratorOf<String>;
         friend class TStringSplitter<String>;
 
+        template <typename S = String, std::enable_if_t<THasData<S>::value, int> = 0>
         TIterState(const String& string) noexcept
-            : TStringBufType()
+            : TStringBufType(MakeEmptyState())
+            , DelimiterEnd_(string.data())
+            , OriginEnd_(string.data() + string.size())
+        {
+        }
+
+        template <typename S = String, std::enable_if_t<!THasData<S>::value, int> = 0>
+        TIterState(const String& string) noexcept
+            : TStringBufType(MakeEmptyState())
             , DelimiterEnd_(std::begin(string))
             , OriginEnd_(std::end(string))
         {
@@ -694,10 +718,28 @@ namespace NStringSplitPrivate {
     private:
         void UpdateParentBuf(TIterator tokenStart, TIterator tokenDelim) noexcept {
             *static_cast<TStringBufType*>(this) = MakeStringBuf<TStringBufType>(tokenStart, tokenDelim);
+            if constexpr (!THasData<String>::value) {
+                this->HaveToUseNextToken = false;
+            }
         }
 
         bool DelimiterIsEmpty() const noexcept {
-            return TokenDelim() == DelimiterEnd_;
+            return TokenDelim() == DelimiterEnd_ && !this->HaveToUseNextToken;
+        }
+
+        void MarkExhausted() noexcept {
+            UpdateParentBuf(OriginEnd_, OriginEnd_);
+            DelimiterEnd_ = OriginEnd_;
+        }
+
+        static TStringBufType MakeEmptyState() noexcept {
+            if constexpr (THasData<String>::value) {
+                using TElement = std::remove_reference_t<decltype(*std::declval<TStringBufType>().data())>;
+                const TElement* ptr = reinterpret_cast<const TElement*>(&::NStringSplitPrivate::SPLITTER_EMPTY_SENTINEL);
+                return TStringBufType(ptr, ptr);
+            } else {
+                return TStringBufType{};
+            }
         }
 
     private:
@@ -782,7 +824,7 @@ namespace NStringSplitPrivate {
             size_t successfullyFilled = 0;
             auto it = this->begin();
 
-            //FIXME: actually, some kind of TryApplyToMany is needed in order to stop iteration upon first failure
+            // FIXME: actually, some kind of TryApplyToMany is needed in order to stop iteration upon first failure
             ApplyToMany([&](auto&& arg) {
                 if (it != this->end()) {
                     if (TryDoFromString(it->Token(), arg)) {
@@ -845,6 +887,24 @@ namespace NStringSplitPrivate {
             {
             }
 
+            TSplitRangeBase(const TSplitRangeBase& other)
+                : String_(other.String_)
+                , State_(String_)
+                , Delimiter_(other.Delimiter_)
+            {
+            }
+
+            TSplitRangeBase(TSplitRangeBase&& other)
+                : String_(std::move(other.String_))
+                , State_(String_)
+                , Delimiter_(std::move(other.Delimiter_))
+            {
+                other.State_.MarkExhausted();
+            }
+
+            TSplitRangeBase& operator=(const TSplitRangeBase& other) = delete;
+            TSplitRangeBase& operator=(TSplitRangeBase&& other) = delete;
+
             inline TIteratorState* Next() {
                 if (State_.DelimiterIsEmpty()) {
                     return nullptr;
@@ -1007,7 +1067,7 @@ namespace NStringSplitPrivate {
         {
         }
 
-        //does not own TDelim
+        // does not own TDelim
         template <class TDelim>
         inline TIt<TPtrPolicy<const TDelim>> Split(const TDelim& d) const noexcept {
             return {String_, &d};
@@ -1038,7 +1098,7 @@ namespace NStringSplitPrivate {
     auto MakeStringSplitter(String&& s) {
         return TStringSplitter<std::remove_reference_t<String>>(std::forward<String>(s));
     }
-}
+} // namespace NStringSplitPrivate
 
 template <class Iterator>
 auto StringSplitter(Iterator begin, Iterator end) {
diff --git a/util/string/split_ut.cpp b/util/string/split_ut.cpp
index ce3054bce12..4af57d579e6 100644
--- a/util/string/split_ut.cpp
+++ b/util/string/split_ut.cpp
@@ -301,7 +301,7 @@ Y_UNIT_TEST_SUITE(SplitStringTest) {
         UNIT_ASSERT_NO_EXCEPTION(Split(data, ' ', s1, s2, m1, m2, m1, m1, m1, m1));
         UNIT_ASSERT_EXCEPTION(Split(data, ' ', s1, s2, m1, m2, m1, m1, m1, m1, s1), yexception);
     }
-}
+} // Y_UNIT_TEST_SUITE(SplitStringTest)
 
 template <typename I, typename C>
 void TestStringSplitterCount(I* str, C delim, size_t good) {
@@ -443,6 +443,13 @@ Y_UNIT_TEST_SUITE(StringSplitter) {
             sum += FromString<int>(it.Token());
         }
         UNIT_ASSERT_VALUES_EQUAL(sum, 6);
+
+        TString ssum;
+        for (const auto& it : StringSplitter("  1 2 3   " + std::string(100, ' ')).Split(' ').SkipEmpty()) {
+            ssum += FromString<TString>(it.Token());
+            ssum += ';';
+        }
+        UNIT_ASSERT_VALUES_EQUAL(ssum, "1;2;3;");
     }
 
     Y_UNIT_TEST(TestTake) {
@@ -472,6 +479,16 @@ Y_UNIT_TEST_SUITE(StringSplitter) {
     Y_UNIT_TEST(TestStringSplitterCountEmpty) {
         TCharDelimiter<const char> delim(' ');
         TestStringSplitterCount("", delim, 1);
+
+        UNIT_ASSERT_VALUES_EQUAL(StringSplitter(TString{}).Split(',').Count(), 1);
+        UNIT_ASSERT_VALUES_EQUAL(StringSplitter(TStringBuf{}).Split(',').Count(), 1);
+        UNIT_ASSERT_VALUES_EQUAL(StringSplitter(TUtf16String{}).Split(u',').Count(), 1);
+        UNIT_ASSERT_VALUES_EQUAL(StringSplitter(TWtringBuf{}).Split(u',').Count(), 1);
+
+        UNIT_ASSERT_VALUES_EQUAL(StringSplitter(TString{}).Split(',').SkipEmpty().Count(), 0);
+        UNIT_ASSERT_VALUES_EQUAL(StringSplitter(TStringBuf{}).Split(',').SkipEmpty().Count(), 0);
+        UNIT_ASSERT_VALUES_EQUAL(StringSplitter(TUtf16String{}).Split(u',').SkipEmpty().Count(), 0);
+        UNIT_ASSERT_VALUES_EQUAL(StringSplitter(TWtringBuf{}).Split(u',').SkipEmpty().Count(), 0);
     }
 
     Y_UNIT_TEST(TestStringSplitterCountOne) {
@@ -579,15 +596,15 @@ Y_UNIT_TEST_SUITE(StringSplitter) {
         UNIT_ASSERT_VALUES_EQUAL(b, 500);
         UNIT_ASSERT_VALUES_EQUAL(c, 3);
 
-        //not enough tokens
+        // not enough tokens
         parsingSucceeded = StringSplitter("3,14").Split(',').TryCollectInto(&a, &b, &c);
         UNIT_ASSERT(!parsingSucceeded);
 
-        //too many tokens
+        // too many tokens
         parsingSucceeded = StringSplitter("3,14,15,92,6").Split(',').TryCollectInto(&a, &b, &c);
         UNIT_ASSERT(!parsingSucceeded);
 
-        //where single TryFromString fails
+        // where single TryFromString fails
         parsingSucceeded = StringSplitter("ot topota kopyt pyl po polu letit").Split(' ').TryCollectInto(&a, &b, &c);
         UNIT_ASSERT(!parsingSucceeded);
     }
@@ -713,7 +730,7 @@ Y_UNIT_TEST_SUITE(StringSplitter) {
     Y_UNIT_TEST(TestStdSplitAfterSplit) {
         std::string_view input = "a*b+a*b";
         for (std::string_view summand : StringSplitter(input).Split('+')) {
-            //FIXME: std::string is used to workaround MSVC ICE
+            // FIXME: std::string is used to workaround MSVC ICE
             UNIT_ASSERT_VALUES_EQUAL(std::string(summand), "a*b");
             std::string_view multiplier1, multiplier2;
             bool splitResult = StringSplitter(summand).Split('*').TryCollectInto(&multiplier1, &multiplier2);
@@ -746,6 +763,25 @@ Y_UNIT_TEST_SUITE(StringSplitter) {
         UNIT_ASSERT_VALUES_EQUAL(expected1, actual3);
     }
 
+    Y_UNIT_TEST(TesIterationAfterMove) {
+        const TString src = TString::Join(
+            "aaa",
+            TString(250, 'c'),
+            "bbb",
+            "aaa",
+            TString(250, 'c'),
+            "bbb");
+        auto s1 = StringSplitter(std::string(src)).SplitByString("c").SkipEmpty();
+        {
+            auto s2 = std::move(s1);
+            const TVector<TString> expected2 = {"aaa", "bbbaaa", "bbb"};
+            const auto result2 = s2.ToList<TString>();
+            UNIT_ASSERT_VALUES_EQUAL(result2, expected2);
+        }
+        const auto result1 = s1.ToList<TString>();
+        Y_UNUSED(result1); // valid but unspecified value
+    }
+
     Y_UNIT_TEST(TestConstCString) {
         const char* b = "a;b";
         const char* e = b + 3;
@@ -831,4 +867,14 @@ Y_UNIT_TEST_SUITE(StringSplitter) {
         }
         UNIT_ASSERT_VALUES_EQUAL(i, expected.size());
     }
-}
+
+    Y_UNIT_TEST(TestInputIteratorEmpty) {
+        const char* a = "";
+        auto splitFn = [](int value) { return value == 0; };
+        UNIT_ASSERT_VALUES_EQUAL(StringSplitter(TDoubleIterator(a), TDoubleIterator(a)).SplitByFunc(splitFn).Count(), 1);
+        UNIT_ASSERT_VALUES_EQUAL(StringSplitter(TDoubleIterator(a), TDoubleIterator(a)).SplitByFunc(splitFn).SkipEmpty().Count(), 0);
+        UNIT_ASSERT_C(TDoubleIterator() == TDoubleIterator(nullptr), "prerequisite for the next test case:");
+        UNIT_ASSERT_VALUES_EQUAL(StringSplitter(TDoubleIterator(nullptr), TDoubleIterator(nullptr)).SplitByFunc(splitFn).Count(), 1);
+        UNIT_ASSERT_VALUES_EQUAL(StringSplitter(TDoubleIterator(nullptr), TDoubleIterator(nullptr)).SplitByFunc(splitFn).SkipEmpty().Count(), 0);
+    }
+} // Y_UNIT_TEST_SUITE(StringSplitter)
diff --git a/util/string/strip.h b/util/string/strip.h
index 809a047cd87..c50cb3023ea 100644
--- a/util/string/strip.h
+++ b/util/string/strip.h
@@ -9,25 +9,25 @@
 
 template <class It>
 struct TIsAsciiSpaceAdapter {
-    bool operator()(const It& it) const noexcept {
+    constexpr bool operator()(const It& it) const noexcept {
         return IsAsciiSpace(*it);
     }
 };
 
 template <class It>
-TIsAsciiSpaceAdapter<It> IsAsciiSpaceAdapter(It) {
+constexpr TIsAsciiSpaceAdapter<It> IsAsciiSpaceAdapter(It) {
     return {};
 }
 
 template <class TChar>
 struct TEqualsStripAdapter {
-    TEqualsStripAdapter(TChar ch)
+    constexpr TEqualsStripAdapter(TChar ch)
         : Ch(ch)
     {
     }
 
     template <class It>
-    bool operator()(const It& it) const noexcept {
+    constexpr bool operator()(const It& it) const noexcept {
         return *it == Ch;
     }
 
@@ -35,38 +35,38 @@ struct TEqualsStripAdapter {
 };
 
 template <class TChar>
-TEqualsStripAdapter<TChar> EqualsStripAdapter(TChar ch) {
+constexpr TEqualsStripAdapter<TChar> EqualsStripAdapter(TChar ch) {
     return {ch};
 }
 
 template <class It, class TStripCriterion>
-inline void StripRangeBegin(It& b, const It& e, TStripCriterion&& criterion) noexcept {
+constexpr void StripRangeBegin(It& b, const It& e, TStripCriterion&& criterion) noexcept {
     while (b < e && criterion(b)) {
         ++b;
     }
 }
 
 template <class It>
-inline void StripRangeBegin(It& b, const It& e) noexcept {
+constexpr void StripRangeBegin(It& b, const It& e) noexcept {
     StripRangeBegin(b, e, IsAsciiSpaceAdapter(b));
 }
 
 template <class It, class TStripCriterion>
-inline void StripRangeEnd(const It& b, It& e, TStripCriterion&& criterion) noexcept {
+constexpr void StripRangeEnd(const It& b, It& e, TStripCriterion&& criterion) noexcept {
     while (b < e && criterion(e - 1)) {
         --e;
     }
 }
 
 template <class It>
-inline void StripRangeEnd(const It& b, It& e) noexcept {
+constexpr void StripRangeEnd(const It& b, It& e) noexcept {
     StripRangeEnd(b, e, IsAsciiSpaceAdapter(b));
 }
 
 template <bool stripBeg, bool stripEnd>
 struct TStripImpl {
     template <class It, class TStripCriterion>
-    static inline bool StripRange(It& b, It& e, TStripCriterion&& criterion) noexcept {
+    static constexpr bool StripRange(It& b, It& e, TStripCriterion&& criterion) noexcept {
         const size_t oldLen = e - b;
 
         if (stripBeg) {
@@ -82,7 +82,7 @@ struct TStripImpl {
     }
 
     template <class T, class TStripCriterion>
-    static inline bool StripString(const T& from, T& to, TStripCriterion&& criterion) {
+    static constexpr bool StripString(const T& from, T& to, TStripCriterion&& criterion) {
         auto b = from.begin();
         auto e = from.end();
 
@@ -102,30 +102,30 @@ struct TStripImpl {
     }
 
     template <class T, class TStripCriterion>
-    [[nodiscard]] static inline T StripString(const T& from, TStripCriterion&& criterion) {
+    [[nodiscard]] static constexpr T StripString(const T& from, TStripCriterion&& criterion) {
         T ret;
         StripString(from, ret, criterion);
         return ret;
     }
 
     template <class T>
-    [[nodiscard]] static inline T StripString(const T& from) {
+    [[nodiscard]] static constexpr T StripString(const T& from) {
         return StripString(from, IsAsciiSpaceAdapter(from.begin()));
     }
 };
 
 template <class It, class TStripCriterion>
-inline bool StripRange(It& b, It& e, TStripCriterion&& criterion) noexcept {
+constexpr bool StripRange(It& b, It& e, TStripCriterion&& criterion) noexcept {
     return TStripImpl<true, true>::StripRange(b, e, criterion);
 }
 
 template <class It>
-inline bool StripRange(It& b, It& e) noexcept {
+constexpr bool StripRange(It& b, It& e) noexcept {
     return StripRange(b, e, IsAsciiSpaceAdapter(b));
 }
 
 template <class It, class TStripCriterion>
-inline bool Strip(It& b, size_t& len, TStripCriterion&& criterion) noexcept {
+constexpr bool Strip(It& b, size_t& len, TStripCriterion&& criterion) noexcept {
     It e = b + len;
 
     if (StripRange(b, e, criterion)) {
@@ -138,47 +138,107 @@ inline bool Strip(It& b, size_t& len, TStripCriterion&& criterion) noexcept {
 }
 
 template <class It>
-inline bool Strip(It& b, size_t& len) noexcept {
+constexpr bool Strip(It& b, size_t& len) noexcept {
     return Strip(b, len, IsAsciiSpaceAdapter(b));
 }
 
 template <class T, class TStripCriterion>
-static inline bool StripString(const T& from, T& to, TStripCriterion&& criterion) {
+static constexpr bool StripString(const T& from, T& to, TStripCriterion&& criterion) {
     return TStripImpl<true, true>::StripString(from, to, criterion);
 }
 
 template <class T>
-static inline bool StripString(const T& from, T& to) {
+static constexpr bool StripString(const T& from, T& to) {
     return StripString(from, to, IsAsciiSpaceAdapter(from.begin()));
 }
 
 template <class T, class TStripCriterion>
-[[nodiscard]] static inline T StripString(const T& from, TStripCriterion&& criterion) {
+[[nodiscard]] static constexpr T StripString(const T& from, TStripCriterion&& criterion) {
+    return TStripImpl<true, true>::StripString(from, criterion);
+}
+
+template <typename TChar, typename TTraits, class TStripCriterion>
+[[nodiscard]] static constexpr std::enable_if_t<std::is_invocable_v<TStripCriterion, typename TBasicStringBuf<TChar, TTraits>::iterator>, TBasicStringBuf<TChar, TTraits>> StripString(const TBasicStringBuf<TChar, TTraits> from Y_LIFETIME_BOUND, TStripCriterion&& criterion) {
+    return TStripImpl<true, true>::StripString(from, criterion);
+}
+
+template <typename TChar, typename TTraits, class TStripCriterion>
+[[nodiscard]] static constexpr std::enable_if_t<std::is_invocable_v<TStripCriterion, typename std::basic_string_view<TChar, TTraits>::iterator>, std::basic_string_view<TChar, TTraits>> StripString(const std::basic_string_view<TChar, TTraits> from Y_LIFETIME_BOUND, TStripCriterion&& criterion) {
     return TStripImpl<true, true>::StripString(from, criterion);
 }
 
 template <class T>
-[[nodiscard]] static inline T StripString(const T& from) {
+[[nodiscard]] static constexpr T StripString(const T& from) {
+    return TStripImpl<true, true>::StripString(from);
+}
+
+template <typename TChar, typename TTraits>
+[[nodiscard]] static constexpr TBasicStringBuf<TChar, TTraits> StripString(const TBasicStringBuf<TChar, TTraits> from Y_LIFETIME_BOUND) {
+    return TStripImpl<true, true>::StripString(from);
+}
+
+template <typename TChar, typename TTraits>
+[[nodiscard]] static constexpr std::basic_string_view<TChar, TTraits> StripString(const std::basic_string_view<TChar, TTraits> from Y_LIFETIME_BOUND) {
     return TStripImpl<true, true>::StripString(from);
 }
 
 template <class T>
-[[nodiscard]] static inline T StripStringLeft(const T& from) {
+[[nodiscard]] static constexpr T StripStringLeft(const T& from) {
+    return TStripImpl<true, false>::StripString(from);
+}
+
+template <typename TChar, typename TTraits>
+[[nodiscard]] static constexpr TBasicStringBuf<TChar, TTraits> StripStringLeft(const TBasicStringBuf<TChar, TTraits> from Y_LIFETIME_BOUND) {
+    return TStripImpl<true, false>::StripString(from);
+}
+
+template <typename TChar, typename TTraits>
+[[nodiscard]] static constexpr std::basic_string_view<TChar, TTraits> StripStringLeft(const std::basic_string_view<TChar, TTraits> from Y_LIFETIME_BOUND) {
     return TStripImpl<true, false>::StripString(from);
 }
 
 template <class T>
-[[nodiscard]] static inline T StripStringRight(const T& from) {
+[[nodiscard]] static constexpr T StripStringRight(const T& from) {
+    return TStripImpl<false, true>::StripString(from);
+}
+
+template <typename TChar, typename TTraits>
+[[nodiscard]] static constexpr TBasicStringBuf<TChar, TTraits> StripStringRight(const TBasicStringBuf<TChar, TTraits> from Y_LIFETIME_BOUND) {
+    return TStripImpl<false, true>::StripString(from);
+}
+
+template <typename TChar, typename TTraits>
+[[nodiscard]] static constexpr std::basic_string_view<TChar, TTraits> StripStringRight(const std::basic_string_view<TChar, TTraits> from Y_LIFETIME_BOUND) {
     return TStripImpl<false, true>::StripString(from);
 }
 
 template <class T, class TStripCriterion>
-[[nodiscard]] static inline T StripStringLeft(const T& from, TStripCriterion&& criterion) {
+[[nodiscard]] static constexpr T StripStringLeft(const T& from, TStripCriterion&& criterion) {
+    return TStripImpl<true, false>::StripString(from, criterion);
+}
+
+template <typename TChar, typename TTraits, class TStripCriterion>
+[[nodiscard]] static constexpr std::enable_if_t<std::is_invocable_v<TStripCriterion, typename TBasicStringBuf<TChar, TTraits>::iterator>, TBasicStringBuf<TChar, TTraits>> StripStringLeft(const TBasicStringBuf<TChar, TTraits> from Y_LIFETIME_BOUND, TStripCriterion&& criterion) {
+    return TStripImpl<true, false>::StripString(from, criterion);
+}
+
+template <typename TChar, typename TTraits, class TStripCriterion>
+[[nodiscard]] static constexpr std::enable_if_t<std::is_invocable_v<TStripCriterion, typename std::basic_string_view<TChar, TTraits>::iterator>, std::basic_string_view<TChar, TTraits>> StripStringLeft(const std::basic_string_view<TChar, TTraits> from Y_LIFETIME_BOUND, TStripCriterion&& criterion) {
     return TStripImpl<true, false>::StripString(from, criterion);
 }
 
 template <class T, class TStripCriterion>
-[[nodiscard]] static inline T StripStringRight(const T& from, TStripCriterion&& criterion) {
+[[nodiscard]] static constexpr T StripStringRight(const T& from, TStripCriterion&& criterion) {
+    return TStripImpl<false, true>::StripString(from, criterion);
+}
+
+template <typename TChar, typename TTraits, class TStripCriterion>
+[[nodiscard]] static constexpr std::enable_if_t<std::is_invocable_v<TStripCriterion, typename TBasicStringBuf<TChar, TTraits>::iterator>, TBasicStringBuf<TChar, TTraits>> StripStringRight(const TBasicStringBuf<TChar, TTraits> from Y_LIFETIME_BOUND, TStripCriterion&& criterion) {
+    return TStripImpl<false, true>::StripString(from, criterion);
+}
+
+template <typename TChar, typename TTraits, class TStripCriterion>
+[[nodiscard]] static constexpr std::enable_if_t<std::is_invocable_v<TStripCriterion, typename std::basic_string_view<TChar, TTraits>::iterator>, std::basic_string_view<TChar, TTraits>> StripStringRight(const std::basic_string_view<TChar, TTraits> from Y_LIFETIME_BOUND, TStripCriterion&& criterion) {
     return TStripImpl<false, true>::StripString(from, criterion);
 }
 
diff --git a/util/string/strip_ut.cpp b/util/string/strip_ut.cpp
index 283ab66fdfa..7236ca2ebf8 100644
--- a/util/string/strip_ut.cpp
+++ b/util/string/strip_ut.cpp
@@ -4,14 +4,50 @@
 
 #include <util/charset/wide.h>
 
+#include <string_view>
+
 Y_UNIT_TEST_SUITE(TStripStringTest) {
+    Y_UNIT_TEST(TestConstexprStrip) {
+        constexpr std::string_view stripped = StripString<std::string_view>("  \n\t abc def \r\n ");
+        static_assert(stripped == "abc def");
+
+        constexpr std::string_view strippedLeft = StripStringLeft(std::string_view("  \n abc \n "));
+        static_assert(strippedLeft == "abc \n ");
+
+        constexpr std::string_view strippedRight = StripStringRight(std::string_view("  \n abc \n "));
+        static_assert(strippedRight == "  \n abc");
+
+        constexpr std::string_view empty = StripString<std::string_view>(" \n\t\r ");
+        static_assert(empty.empty());
+
+        constexpr std::string_view unchanged = StripString<std::string_view>("abc");
+        static_assert(unchanged == "abc");
+
+        UNIT_ASSERT_VALUES_EQUAL(stripped, "abc def");
+        UNIT_ASSERT_VALUES_EQUAL(strippedLeft, "abc \n ");
+        UNIT_ASSERT_VALUES_EQUAL(strippedRight, "  \n abc");
+    }
+
+    Y_UNIT_TEST(TestConstexprCustomStrip) {
+        constexpr std::string_view stripped = StripString(std::string_view("//abc//"), EqualsStripAdapter('/'));
+        static_assert(stripped == "abc");
+
+        constexpr std::string_view strippedLeft = StripStringLeft(std::string_view("//abc//"), EqualsStripAdapter('/'));
+        static_assert(strippedLeft == "abc//");
+
+        constexpr std::string_view strippedRight = StripStringRight(std::string_view("//abc//"), EqualsStripAdapter('/'));
+        static_assert(strippedRight == "//abc");
+
+        UNIT_ASSERT_VALUES_EQUAL(stripped, "abc");
+    }
+
     struct TStripTest {
         TStringBuf Str;
         TStringBuf StripLeftRes;
         TStringBuf StripRightRes;
         TStringBuf StripRes;
     };
-    static constexpr TStripTest StripTests[] = {
+    constexpr TStripTest StripTests[] = {
         {"  012  ", "012  ", "  012", "012"},
         {"  012", "012", "  012", "012"},
         {"012\t\t", "012\t\t", "012", "012"},
@@ -22,8 +58,12 @@ Y_UNIT_TEST_SUITE(TStripStringTest) {
         {"\n \t\r", "", "", ""},
         {"", "", "", ""},
         {"abc", "abc", "abc", "abc"},
+        {"  abc  ", "abc  ", "  abc", "abc"},
         {"a c", "a c", "a c", "a c"},
         {"  long string to avoid SSO            \n", "long string to avoid SSO            \n", "  long string to avoid SSO", "long string to avoid SSO"},
+        {"  набор не-ascii букв  ", "набор не-ascii букв  ", "  набор не-ascii букв", "набор не-ascii букв"},
+        // Russian "х" ends with \x85, whis is a space character in some encodings.
+        {"последней буквой идет х ", "последней буквой идет х ", "последней буквой идет х", "последней буквой идет х"},
     };
 
     Y_UNIT_TEST(TestStrip) {
@@ -32,20 +72,23 @@ Y_UNIT_TEST_SUITE(TStripStringTest) {
 
             TString s;
             Strip(inputStr, s);
-            UNIT_ASSERT_EQUAL(s, test.StripRes);
+            UNIT_ASSERT_VALUES_EQUAL(s, test.StripRes);
 
-            UNIT_ASSERT_EQUAL(StripString(inputStr), test.StripRes);
-            UNIT_ASSERT_EQUAL(StripStringLeft(inputStr), test.StripLeftRes);
-            UNIT_ASSERT_EQUAL(StripStringRight(inputStr), test.StripRightRes);
+            UNIT_ASSERT_VALUES_EQUAL(StripString(inputStr), test.StripRes);
+            UNIT_ASSERT_VALUES_EQUAL(StripStringLeft(inputStr), test.StripLeftRes);
+            UNIT_ASSERT_VALUES_EQUAL(StripStringRight(inputStr), test.StripRightRes);
 
             TStringBuf inputStrBuf(test.Str);
-            UNIT_ASSERT_EQUAL(StripString(inputStrBuf), test.StripRes);
-            UNIT_ASSERT_EQUAL(StripStringLeft(inputStrBuf), test.StripLeftRes);
-            UNIT_ASSERT_EQUAL(StripStringRight(inputStrBuf), test.StripRightRes);
+            UNIT_ASSERT_VALUES_EQUAL(StripString(inputStrBuf), test.StripRes);
+            UNIT_ASSERT_VALUES_EQUAL(StripStringLeft(inputStrBuf), test.StripLeftRes);
+            UNIT_ASSERT_VALUES_EQUAL(StripStringRight(inputStrBuf), test.StripRightRes);
         };
     }
 
     Y_UNIT_TEST(TestStripInPlace) {
+        // On Darwin default locale is set to a value which interprets certain cyrillic utf-8 sequences as spaces.
+        // Which we do not use ::isspace and only strip ASCII spaces, we want to ensure that this will not change in the future.
+        std::setlocale(LC_ALL, "");
         for (const auto& test : StripTests) {
             TString str(test.Str);
             Y_ASSERT(str.IsDetached() || str.empty()); // prerequisite of the test; check that we don't try to modify shared COW-string in-place by accident
@@ -95,9 +138,21 @@ Y_UNIT_TEST_SUITE(TStripStringTest) {
             UNIT_ASSERT_EQUAL(
                 StripStringLeft(TString(test.Str), EqualsStripAdapter('/')),
                 test.ResultLeft);
+            UNIT_ASSERT_EQUAL(
+                StripStringLeft(TStringBuf(test.Str), EqualsStripAdapter('/')),
+                test.ResultLeft);
+            UNIT_ASSERT_EQUAL(
+                StripStringLeft(std::string_view(test.Str), EqualsStripAdapter('/')),
+                test.ResultLeft);
             UNIT_ASSERT_EQUAL(
                 StripStringRight(TString(test.Str), EqualsStripAdapter('/')),
                 test.ResultRight);
+            UNIT_ASSERT_EQUAL(
+                StripStringRight(TStringBuf(test.Str), EqualsStripAdapter('/')),
+                test.ResultRight);
+            UNIT_ASSERT_EQUAL(
+                StripStringRight(std::string_view(test.Str), EqualsStripAdapter('/')),
+                test.ResultRight);
         };
     }
 
@@ -122,6 +177,16 @@ Y_UNIT_TEST_SUITE(TStripStringTest) {
             u"abc");
     }
 
+    Y_UNIT_TEST(TestSelfRefStringStrip) {
+        TStringBuf sb = "  abc ";
+        StripString(sb, sb);
+        UNIT_ASSERT_EQUAL(sb, "abc");
+
+        TString str = "  abc ";
+        StripString(str, str);
+        UNIT_ASSERT_EQUAL(str, "abc");
+    }
+
     Y_UNIT_TEST(TestCollapseUtf32) {
         TUtf32String s;
         Collapse(UTF8ToUTF32<true>("  123    456  "), s, IsWhitespace);
@@ -184,4 +249,4 @@ Y_UNIT_TEST_SUITE(TStripStringTest) {
         UNIT_ASSERT_EQUAL(abs2 == "Very long description string written in unknown ...", true);
         UNIT_ASSERT_EQUAL(abs3 == "Very long description string written in ...", true);
     }
-}
+} // Y_UNIT_TEST_SUITE(TStripStringTest)
diff --git a/util/string/strspn_ut.cpp b/util/string/strspn_ut.cpp
index 975374cba4e..ac0afa92d8b 100644
--- a/util/string/strspn_ut.cpp
+++ b/util/string/strspn_ut.cpp
@@ -70,4 +70,4 @@ Y_UNIT_TEST_SUITE(TStrSpnTest) {
         TStringBuf empty;
         UNIT_ASSERT_EQUAL(TCompactStrSpn("abc").FindFirstNotOf(empty.rbegin(), empty.rend()), empty.rend());
     }
-}
+} // Y_UNIT_TEST_SUITE(TStrSpnTest)
diff --git a/util/string/subst.h b/util/string/subst.h
index 3d36af7e856..16ec573e32c 100644
--- a/util/string/subst.h
+++ b/util/string/subst.h
@@ -4,34 +4,52 @@
 
 #include <ydb-cpp-sdk/stlfwd.h>
 
-/* Replace all occurences of substring `what` with string `with` starting from position `from`.
+/**
+ * Replace all occurences of substring `what` with string `with` starting from position `from`.
  *
- * @param text      String to modify.
- * @param what      Substring to replace.
- * @param with      Substring to use as replacement.
- * @param from      Position at with to start replacement.
+ * @param[inout] text   String to modify.
+ * @param what          Substring to replace.
+ * @param with          Substring to use as replacement.
+ * @param from          Position at with to start replacement.
  *
  * @return          Number of replacements occured.
  */
 size_t SubstGlobal(TString& text, TStringBuf what, TStringBuf with, size_t from = 0);
+
+//! @copydoc SubstGlobal(TString&,TStringBuf,TStringBuf,size_t)
 size_t SubstGlobal(std::string& text, TStringBuf what, TStringBuf with, size_t from = 0);
+
+//! @copydoc SubstGlobal(TString&,TStringBuf,TStringBuf,size_t)
 size_t SubstGlobal(TUtf16String& text, TWtringBuf what, TWtringBuf with, size_t from = 0);
+
+//! @copydoc SubstGlobal(TString&,TStringBuf,TStringBuf,size_t)
 size_t SubstGlobal(std::u16string& text, TWtringBuf what, TWtringBuf with, size_t from = 0);
+
+//! @copydoc SubstGlobal(TString&,TStringBuf,TStringBuf,size_t)
 size_t SubstGlobal(TUtf32String& text, TUtf32StringBuf what, TUtf32StringBuf with, size_t from = 0);
 
-/* Replace all occurences of character `what` with character `with` starting from position `from`.
+/**
+ * Replace all occurences of character `what` with character `with` starting from position `from`.
  *
- * @param text      String to modify.
- * @param what      Character to replace.
- * @param with      Character to use as replacement.
- * @param from      Position at with to start replacement.
+ * @param[inout] text   String to modify.
+ * @param what          Character to replace.
+ * @param with          Character to use as replacement.
+ * @param from          Position at with to start replacement.
  *
  * @return          Number of replacements occured.
  */
 size_t SubstGlobal(TString& text, char what, char with, size_t from = 0);
+
+//! @copydoc SubstGlobal(TString&,char,char,size_t)
 size_t SubstGlobal(std::string& text, char what, char with, size_t from = 0);
+
+//! @copydoc SubstGlobal(TString&,char,char,size_t)
 size_t SubstGlobal(TUtf16String& text, wchar16 what, wchar16 with, size_t from = 0);
+
+//! @copydoc SubstGlobal(TString&,char,char,size_t)
 size_t SubstGlobal(std::u16string& text, wchar16 what, wchar16 with, size_t from = 0);
+
+//! @copydoc SubstGlobal(TString&,char,char,size_t)
 size_t SubstGlobal(TUtf32String& text, wchar32 what, wchar32 with, size_t from = 0);
 
 // TODO(yazevnul):
@@ -40,9 +58,10 @@ size_t SubstGlobal(TUtf32String& text, wchar32 what, wchar32 with, size_t from =
 // - add `RemoveAll(text, what, from)` as a shortcut for `SubstGlobal(text, what, "", from)`
 // - rename file to `replace.h`
 
-/* Replace all occurences of substring or character `what` with string or character `with` starting from position `from`, and return result string.
+/**
+ * Replace all occurences of substring or character `what` with string or character `with` starting from position `from`, and return result string.
  *
- * @param text      String to modify.
+ * @param result    String to modify.
  * @param what      Substring/character to replace.
  * @param with      Substring/character to use as replacement.
  * @param from      Position at with to start replacement.
diff --git a/util/string/subst_ut.cpp b/util/string/subst_ut.cpp
index 21eccef7795..d977543fa62 100644
--- a/util/string/subst_ut.cpp
+++ b/util/string/subst_ut.cpp
@@ -250,4 +250,4 @@ Y_UNIT_TEST_SUITE(TStringSubst) {
             UNIT_ASSERT_VALUES_EQUAL(st, ss);
         }
     }
-}
+} // Y_UNIT_TEST_SUITE(TStringSubst)
diff --git a/util/string/type.cpp b/util/string/type.cpp
index 49671c02c2c..a1a34f6db57 100644
--- a/util/string/type.cpp
+++ b/util/string/type.cpp
@@ -59,7 +59,7 @@ namespace {
         }
         return false;
     }
-} //anonymous namespace
+} // anonymous namespace
 
 bool IsTrue(const TStringBuf v) noexcept {
     static constexpr std::array<TStringBuf, 7> trueOptions{
diff --git a/util/string/type_ut.cpp b/util/string/type_ut.cpp
index 03e7af62bd0..74ba51b05ca 100644
--- a/util/string/type_ut.cpp
+++ b/util/string/type_ut.cpp
@@ -73,4 +73,4 @@ Y_UNIT_TEST_SUITE(TStringClassify) {
         UNIT_ASSERT(!IsHexNumber(u"foobar"));
         UNIT_ASSERT(!IsHexNumber(TUtf16String()));
     }
-}
+} // Y_UNIT_TEST_SUITE(TStringClassify)
diff --git a/util/string/util.h b/util/string/util.h
index 0d77a5042b8..3f3596bdddc 100644
--- a/util/string/util.h
+++ b/util/string/util.h
@@ -1,7 +1,5 @@
 #pragma once
 
-//THIS FILE A COMPAT STUB HEADER
-
 #include <cstring>
 #include <cstdarg>
 #include <algorithm>
@@ -18,8 +16,9 @@ int a2i(const TString& s);
 template <class T>
 inline void RemoveIfLast(T& s, int c) {
     const size_t length = s.length();
-    if (length && s[length - 1] == c)
+    if (length && s[length - 1] == c) {
         s.remove(length - 1);
+    }
 }
 
 /// Adds lastCh symbol to the the of the string if it is not already there.
@@ -36,7 +35,7 @@ inline void addIfNotLast(TString& s, int lastCh) {
 inline void addIfAbsent(TString& s, char lastCh1, char lastCh2) {
     size_t pos = s.find(lastCh2);
     if (pos == TString::npos) {
-        //s.append((char)lastCh1);
+        // s.append((char)lastCh1);
         addIfNotLast(s, lastCh1);
     } else if (pos < s.length() - 1) {
         addIfNotLast(s, lastCh2);
@@ -72,28 +71,32 @@ class str_spn: public ui8_256 {
     /// That is, skip all characters not in table
     /// [DIFFERENCE FOR NOT_FOUND CASE: Returns end of string, not NULL]
     const char* brk(const char* s) const {
-        while (c_chars_table[(ui8)*s])
+        while (c_chars_table[(ui8)*s]) {
             ++s;
+        }
         return s;
     }
 
     const char* brk(const char* s, const char* e) const {
-        while (s < e && c_chars_table[(ui8)*s])
+        while (s < e && c_chars_table[(ui8)*s]) {
             ++s;
+        }
         return s;
     }
 
     /// Return first character not in table, like strpbrk() for inverted table.
     /// That is, skip all characters in table
     const char* cbrk(const char* s) const {
-        while (chars_table[(ui8)*s])
+        while (chars_table[(ui8)*s]) {
             ++s;
+        }
         return s;
     }
 
     const char* cbrk(const char* s, const char* e) const {
-        while (s < e && chars_table[(ui8)*s])
+        while (s < e && chars_table[(ui8)*s]) {
             ++s;
+        }
         return s;
     }
 
@@ -131,8 +134,9 @@ class str_spn: public ui8_256 {
 
     /// strsep + remember character that was destroyed
     char* sep(char*& s, char& sep_char) const {
-        if (!s)
+        if (!s) {
             return nullptr;
+        }
         char* ret = s;
         char* next = brk(ret);
         if (*next) {
@@ -161,17 +165,20 @@ class Tr {
     }
 
     void Do(char* s) const {
-        for (; *s; s++)
+        for (; *s; s++) {
             *s = ConvertChar(*s);
+        }
     }
     void Do(const char* src, char* dst) const {
-        for (; *src; src++)
+        for (; *src; src++) {
             *dst++ = ConvertChar(*src);
+        }
         *dst = 0;
     }
     void Do(char* s, size_t l) const {
-        for (size_t i = 0; i < l && s[i]; i++)
+        for (size_t i = 0; i < l && s[i]; i++) {
             s[i] = ConvertChar(s[i]);
+        }
     }
     void Do(TString& str) const;
 
@@ -185,8 +192,9 @@ class Tr {
 template <typename TStringType>
 void RemoveAll(TStringType& str, typename TStringType::char_type ch) {
     size_t pos = str.find(ch); // 'find' to avoid cloning of string in 'TString.begin()'
-    if (pos == TStringType::npos)
+    if (pos == TStringType::npos) {
         return;
+    }
 
     typename TStringType::iterator begin = str.begin();
     typename TStringType::iterator end = begin + str.length();
diff --git a/util/string/vector.h b/util/string/vector.h
index e36c348bbef..b807b0fc196 100644
--- a/util/string/vector.h
+++ b/util/string/vector.h
@@ -39,7 +39,7 @@ namespace NPrivate {
     struct TStringDeducer<wchar16> {
         using type = TUtf16String;
     };
-}
+} // namespace NPrivate
 
 template <typename C>
 TVector<typename ::NPrivate::TStringDeducer<C>::type>
@@ -68,8 +68,9 @@ SplitString(const typename ::NPrivate::TStringDeducer<C>::type& str, const C* de
 
 template <class TIter>
 inline TString JoinStrings(TIter begin, TIter end, const TStringBuf delim) {
-    if (begin == end)
+    if (begin == end) {
         return TString();
+    }
 
     TString result = ToString(*begin);
 
@@ -83,8 +84,9 @@ inline TString JoinStrings(TIter begin, TIter end, const TStringBuf delim) {
 
 template <class TIter>
 inline TUtf16String JoinStrings(TIter begin, TIter end, const TWtringBuf delim) {
-    if (begin == end)
+    if (begin == end) {
         return TUtf16String();
+    }
 
     TUtf16String result = ToWtring(*begin);
 
@@ -125,7 +127,7 @@ template <typename T, typename TStringType>
 TVector<T> Scan(const TVector<TStringType>& input) {
     TVector<T> output;
     output.reserve(input.size());
-    for (int i = 0; i < input.ysize(); ++i) {
+    for (size_t i = 0; i < input.size(); ++i) {
         output.push_back(FromString<T>(input[i]));
     }
     return output;
diff --git a/util/string/vector_ut.cpp b/util/string/vector_ut.cpp
index 628f5e2eedc..f2b628923c9 100644
--- a/util/string/vector_ut.cpp
+++ b/util/string/vector_ut.cpp
@@ -34,4 +34,4 @@ Y_UNIT_TEST_SUITE(TStringJoinTest) {
 
         UNIT_ASSERT_EQUAL(JoinStrings(v, TUtf16String()), str);
     }
-}
+} // Y_UNIT_TEST_SUITE(TStringJoinTest)
diff --git a/util/system/atexit.cpp b/util/system/atexit.cpp
index 09fa7d8381a..9d81ce2373e 100644
--- a/util/system/atexit.cpp
+++ b/util/system/atexit.cpp
@@ -110,7 +110,7 @@ namespace {
             return atExit;
         }
     }
-}
+} // namespace
 
 void ManualRunAtExitFinalizers() {
     OnExit();
diff --git a/util/system/atexit_ut.cpp b/util/system/atexit_ut.cpp
index f093c2b86b4..2d340bd3645 100644
--- a/util/system/atexit_ut.cpp
+++ b/util/system/atexit_ut.cpp
@@ -88,7 +88,6 @@ UNIT_TEST_SUITE_REGISTRATION(TAtExitTest);
 Y_UNIT_TEST_SUITE(TestAtExit) {
 
     Y_UNIT_TEST(CreateUponDestruction) {
-
         struct T1 {
         };
 
@@ -99,6 +98,5 @@ Y_UNIT_TEST_SUITE(TestAtExit) {
         };
 
         Singleton<T2>();
-
     }
-}
+} // Y_UNIT_TEST_SUITE(TestAtExit)
diff --git a/util/system/backtrace.cpp b/util/system/backtrace.cpp
index f8d37e8443c..482c02b7b84 100644
--- a/util/system/backtrace.cpp
+++ b/util/system/backtrace.cpp
@@ -17,7 +17,7 @@
 #endif
 
 #if defined(_bionic_)
-//TODO
+// TODO
 #else
     #if !defined(HAVE_BACKTRACE) && defined(_cygwin_)
         #define CaptureStackBackTrace RtlCaptureStackBackTrace
@@ -32,7 +32,7 @@ extern "C" __stdcall unsigned short CaptureStackBackTrace(unsigned long FramesTo
         #define HAVE_BACKTRACE
     #endif
 
-    #if !defined(HAVE_BACKTRACE) && defined(__GNUC__)
+    #if !defined(HAVE_BACKTRACE) && defined(__GNUC__) && !defined(__EMSCRIPTEN__)
         #define USE_GCC_BACKTRACE
         #define HAVE_BACKTRACE
     #endif
@@ -95,8 +95,8 @@ namespace {
 
             return 0;
         }
-    }
-}
+    } // namespace NGCCBacktrace
+} // namespace
 
 size_t BackTrace(void** p, size_t len) {
     return NGCCBacktrace::BackTrace(p, len);
@@ -216,7 +216,7 @@ namespace {
         TSymFromAddrFunc SymFromAddrFunc;
         BOOL InitOk;
     };
-}
+} // namespace
 
 TResolvedSymbol ResolveSymbol(void* sym, char* buf, size_t len) {
     return Singleton<TWinSymbolResolverImpl>()->Resolve(sym, buf, len);
@@ -232,6 +232,16 @@ TResolvedSymbol ResolveSymbol(void* sym, char*, size_t) {
 }
 #endif
 
+TBackTraceFn BackTraceFn = BackTrace;
+
+void SetBackTraceFn(TBackTraceFn f) {
+    BackTraceFn = f;
+}
+
+TBackTraceFn GetBackTraceFn() {
+    return BackTraceFn;
+}
+
 void FormatBackTrace(IOutputStream* out, void* const* backtrace, size_t backtraceSize) {
     char tmpBuf[1024];
 
@@ -270,7 +280,9 @@ TBackTrace::TBackTrace()
 }
 
 void TBackTrace::Capture() {
-    Size = BackTrace(Data, CAPACITY);
+    if (BackTraceFn) {
+        Size = BackTraceFn(Data, CAPACITY);
+    }
 }
 
 void TBackTrace::PrintTo(IOutputStream& out) const {
diff --git a/util/system/backtrace.h b/util/system/backtrace.h
index 2fce7585c3a..4e5ab6a68e1 100644
--- a/util/system/backtrace.h
+++ b/util/system/backtrace.h
@@ -7,6 +7,11 @@ class IOutputStream;
 
 size_t BackTrace(void** p, size_t len);
 
+using TBackTraceFn = size_t (*)(void** p, size_t len);
+
+void SetBackTraceFn(TBackTraceFn f);
+TBackTraceFn GetBackTraceFn();
+
 struct TResolvedSymbol {
     const char* Name;
     void* NearestSymbol;
diff --git a/util/system/backtrace_ut.cpp b/util/system/backtrace_ut.cpp
index 9b5ead71bc1..b2de5e39574 100644
--- a/util/system/backtrace_ut.cpp
+++ b/util/system/backtrace_ut.cpp
@@ -56,7 +56,7 @@ class TBackTraceTest: public TTestBase {
     }
 
     void TestBackTrace() {
-        //PrintBackTrace();
+        // PrintBackTrace();
         void* buf1[100];
         size_t ret1;
 
diff --git a/util/system/byteorder.h b/util/system/byteorder.h
index 94b9fea5152..4f1b1051181 100644
--- a/util/system/byteorder.h
+++ b/util/system/byteorder.h
@@ -2,7 +2,7 @@
 
 #include "defaults.h"
 
-//#define USE_GENERIC_ENDIAN_CVT
+// #define USE_GENERIC_ENDIAN_CVT
 
 #if defined(_linux_) && !defined(USE_GENERIC_ENDIAN_CVT)
     #include <byteswap.h>
@@ -66,7 +66,7 @@ inline ui64 SwapBytes64(ui64 val) noexcept {
 }
 #endif
 
-//for convenience
+// for convenience
 static inline ui8 SwapBytes8(ui8 v) noexcept {
     return v;
 }
@@ -91,7 +91,7 @@ namespace NSwapBytes {
     DEF_SB(64)
 
 #undef DEF_SB
-}
+} // namespace NSwapBytes
 
 template <class T>
 inline T SwapBytes(T val) noexcept {
diff --git a/util/system/compat.h b/util/system/compat.h
index 437e287497c..119b3a2d5fe 100644
--- a/util/system/compat.h
+++ b/util/system/compat.h
@@ -24,8 +24,8 @@ extern "C" {
 
     #define SIGQUIT SIGBREAK // instead of 3
     #define SIGKILL SIGTERM  // instead of 9
-    #define SIGPIPE 13       //will not receive under win?
-    #define SIGALRM 14       //will not receive under win?
+    #define SIGPIPE 13       // will not receive under win?
+    #define SIGALRM 14       // will not receive under win?
 #endif
 
 #if defined(__FreeBSD__) || defined(_darwin_)
diff --git a/util/system/compat_ut.cpp b/util/system/compat_ut.cpp
index dbd9289c17c..55932e388ac 100644
--- a/util/system/compat_ut.cpp
+++ b/util/system/compat_ut.cpp
@@ -9,4 +9,4 @@ Y_UNIT_TEST_SUITE(TCompatTest) {
     Y_UNIT_TEST(TestGetprogname) {
         getprogname(); // just check it links
     }
-}
+} // Y_UNIT_TEST_SUITE(TCompatTest)
diff --git a/util/system/compiler.h b/util/system/compiler.h
index 2b4b05fc5fb..e716438b97c 100644
--- a/util/system/compiler.h
+++ b/util/system/compiler.h
@@ -16,12 +16,12 @@
     #include <intrin.h>
 #endif
 
-// useful cross-platfrom definitions for compilers
+// useful cross-platform definitions for compilers
 
 /**
  * @def Y_FUNC_SIGNATURE
  *
- * Use this macro to get pretty function name (see example).
+ * Use this macro to get a pretty signature of the current function (see an example).
  *
  * @code
  * void Hi() {
@@ -67,7 +67,7 @@
 /**
  * @def Y_DECLARE_UNUSED
  *
- * Macro is needed to silence compiler warning about unused entities (e.g. function or argument).
+ * Use this macro to silence compiler warnings about unused entities (e.g. a function or an argument).
  *
  * @code
  * Y_DECLARE_UNUSED int FunctionUsedSolelyForDebugPurposes();
@@ -75,7 +75,7 @@
  *
  * void Foo(const int argumentUsedOnlyForDebugPurposes Y_DECLARE_UNUSED) {
  *     assert(argumentUsedOnlyForDebugPurposes == 42);
- *     // however you may as well omit `Y_DECLARE_UNUSED` and use `UNUSED` macro instead
+ *     // however you may as well omit `Y_DECLARE_UNUSED` and use `Y_UNUSED` macro instead
  *     Y_UNUSED(argumentUsedOnlyForDebugPurposes);
  * }
  * @endcode
@@ -98,7 +98,7 @@
 /**
  * @def Y_FORCE_INLINE
  *
- * Macro to use in place of 'inline' in function declaration/definition to force
+ * Macro to use in place of 'inline' in a function declaration/definition to force
  * it to be inlined.
  */
 #if !defined(Y_FORCE_INLINE)
@@ -118,7 +118,7 @@
 /**
  * @def Y_NO_INLINE
  *
- * Macro to use in place of 'inline' in function declaration/definition to
+ * Macro to use in place of 'inline' in a function declaration/definition to
  * prevent it from being inlined.
  */
 #if !defined(Y_NO_INLINE)
@@ -132,7 +132,20 @@
     #endif
 #endif
 
-//to cheat compiler about strict aliasing or similar problems
+/**
+ * @def Y_EMPTY_BASES
+ *
+ * Macro to enable EBO (empty base optimization).
+ */
+#if !defined(Y_EMPTY_BASES)
+    #if defined(_MSC_VER)
+        #define Y_EMPTY_BASES __declspec(empty_bases)
+    #else
+        #define Y_EMPTY_BASES
+    #endif
+#endif
+
+// to cheat compiler about strict aliasing or similar problems
 #if defined(__GNUC__)
     #define Y_FAKE_READ(X)                  \
         do {                                \
@@ -209,6 +222,30 @@ constexpr Y_FORCE_INLINE int Y_UNUSED(Types&&...) {
 }
 #endif
 
+/**
+ * @def Y_INITIALIZED
+ *
+ * This function can be used to silence erroneous bugprone-use-after-move warnings from clang-tidy.
+ * (see https://clang.llvm.org/extra/clang-tidy/checks/bugprone/use-after-move.html#silencing-erroneous-warnings)
+ *
+ * @code
+ * void Foo(T value, int i) {
+ *     if (i == 1) {
+ *         DoSomethingWith(std::move(value));
+ *     }
+ *     if (i == 2) {
+ *         Y_INITIALIZED(value);
+ *         DoOtherThingWith(std::move(value));
+ *     }
+ * }
+ */
+#if defined(__cplusplus)
+template <class... Types>
+constexpr Y_FORCE_INLINE int Y_INITIALIZED(Types&...) {
+    return 0; // constexpr void functions are not supported in c++11
+}
+#endif
+
 /**
  * @def Y_ASSUME
  *
@@ -227,7 +264,7 @@ constexpr Y_FORCE_INLINE int Y_UNUSED(Types&&...) {
  * }
  *
  * // we know that xs and ys are non-negative from domain knowledge,
- * // but we can't change the types of xs and ys because of API constrains
+ * // but we can't change the types of xs and ys because of API constraints
  * int Foo(const TVector<int>& xs, const TVector<int>& ys) {
  *     TVector<int> avgs;
  *     avgs.resize(xs.size());
@@ -351,7 +388,7 @@ _YandexAbort();
 /**
  * @def Y_PRAGMA
  *
- * Macro for use in other macros to define compiler pragma
+ * Macro to use in other macros to define compiler pragma
  * See below for other usage examples
  *
  * @code
@@ -431,7 +468,7 @@ _YandexAbort();
  * Y_PRAGMA_DIAGNOSTIC_PUSH
  * Y_PRAGMA_NO_WSHADOW
  *
- * // some code which use variable shadowing, e.g.:
+ * // some code that uses variable shadowing, e.g.:
  *
  * for (int i = 0; i < 100; ++i) {
  *   Use(i);
@@ -468,7 +505,7 @@ _YandexAbort();
  * Y_PRAGMA_DIAGNOSTIC_PUSH
  * Y_PRAGMA_NO_UNUSED_FUNCTION
  *
- * // some code which introduces a function which later will not be used, e.g.:
+ * // some code that introduces a function that later will not be used, e.g.:
  *
  * void Foo() {
  * }
@@ -501,7 +538,7 @@ _YandexAbort();
  * Y_PRAGMA_DIAGNOSTIC_PUSH
  * Y_PRAGMA_NO_UNUSED_PARAMETER
  *
- * // some code which introduces a function with unused parameter, e.g.:
+ * // some code that introduces a function with an unused parameter, e.g.:
  *
  * void foo(int a) {
  *     // a is not referenced
@@ -565,13 +602,13 @@ _YandexAbort();
 #if (defined(__clang__) || defined(__GNUC__)) && !defined(_msan_enabled_)
     /**
  * @def Y_CONST_FUNCTION
-   methods and functions, marked with this method are promised to:
+   Methods and functions marked with this attribute promise to:
      1. do not have side effects
-     2. this method do not read global memory
-   NOTE: this attribute can't be set for methods that depend on data, pointed by this
-   this allow compilers to do hard optimization of that functions
-   NOTE: in common case this attribute can't be set if method have pointer-arguments
-   NOTE: as result there no any reason to discard result of such method
+     2. do not read global memory
+   It allows compilers to do hard optimization in code that uses these functions/methods.
+   NOTE: this attribute can't be set for methods that use class members.
+   NOTE: this attribute can't be set for functions/methods that have pointer arguments.
+   NOTE: as a consequence there are no reasons to discard the result of such a method or a function.
 */
     #define Y_CONST_FUNCTION [[gnu::const]]
 #endif
@@ -583,11 +620,11 @@ _YandexAbort();
 #if defined(__clang__) || defined(__GNUC__)
     /**
  * @def Y_PURE_FUNCTION
-   methods and functions, marked with this method are promised to:
+   Methods and functions marked with this attribute promise to:
      1. do not have side effects
-     2. result will be the same if no global memory changed
-   this allow compilers to do hard optimization of that functions
-   NOTE: as result there no any reason to discard result of such method
+     2. return the same result if no global memory is changed
+   It allows compilers to do hard optimization in code that uses these functions/methods.
+   NOTE: as a consequence there are no reasons to discard the result of such a method or a function.
 */
     #define Y_PURE_FUNCTION [[gnu::pure]]
 #endif
@@ -619,8 +656,8 @@ _YandexAbort();
     #define Y_REINITIALIZES_OBJECT
 #endif
 
-// Use at the end of macros declaration. It allows macros usage only with semicolon at the end.
-// It prevents from warnings for extra semicolons when building with flag `-Wextra-semi`.
+// Use at the end of macros declarations. It allows macros usage only with a semicolon at the end.
+// It disables warnings about extra semicolons when building with a flag `-Wextra-semi`.
 #define Y_SEMICOLON_GUARD static_assert(true, "")
 
 #ifdef __cplusplus
@@ -643,7 +680,7 @@ Y_FORCE_INLINE void DoNotOptimizeAway(T&& datum) {
 
 /**
  * The usage for `const T&` is prohibited.
- * The compiler assume that a constant reference, even though escaped via asm volatile, is unchanged.
+ * The compiler assumes that a constant reference, even though escaped via asm volatile, is unchanged.
  * The const-ref interface is deleted to discourage new uses of it, as subtle compiler optimizations (invariant hoisting, etc.) can occur.
  * For more details see https://github.com/google/benchmark/pull/1493.
  */
@@ -658,42 +695,81 @@ Y_FORCE_INLINE void DoNotOptimizeAway(const T&) = delete;
 #endif
 
 /**
- * @def Y_LIFETIME_BOUND
+ * @def Y_HAS_ATTRIBUTE
  *
- * The attribute on a function parameter can be used to tell the compiler
- * that function return value may refer that parameter.
- * The compiler may produce compile-time warning if it is able to detect that
- * an object or reference refers to another object with a shorter lifetime.
+ * A function-like feature checking macro that is a wrapper around
+ * `__has_attribute` that is defined by GCC 5+ and Clang and evaluates to a
+ * nonzero constant integer if the attribute is supported or 0 if not.
+ *
+ * It evaluates to zero if `__has_attribute` is not defined by the compiler.
+ *
+ * @see
+ *     GCC: https://gcc.gnu.org/gcc-5/changes.html
+ *     Clang: https://clang.llvm.org/docs/LanguageExtensions.html
  */
-#if defined(__clang__) && defined(__cplusplus) && defined(__has_cpp_attribute)
-    #if defined(__CUDACC__) && !Y_CUDA_AT_LEAST(11, 0)
-        #define Y_LIFETIME_BOUND
-    #elif __has_cpp_attribute(clang::lifetimebound)
-        #define Y_LIFETIME_BOUND [[clang::lifetimebound]]
-    #else
-        #define Y_LIFETIME_BOUND
-    #endif
+#ifdef __has_attribute
+    #define Y_HAS_ATTRIBUTE(x) __has_attribute(x)
 #else
-    #define Y_LIFETIME_BOUND
+    #define Y_HAS_ATTRIBUTE(x) 0
 #endif
 
 /**
- * @def Y_HAVE_ATTRIBUTE
+ * @def Y_HAS_CPP_ATTRIBUTE
  *
  * A function-like feature checking macro that is a wrapper around
- * `__has_attribute`, which is defined by GCC 5+ and Clang and evaluates to a
- * nonzero constant integer if the attribute is supported or 0 if not.
+ * `__has_cpp_attribute` evaluates to a  nonzero constant integer
+ * if the attribute is supported or 0 if not.
  *
- * It evaluates to zero if `__has_attribute` is not defined by the compiler.
+ * It evaluates to zero if `__has_cpp_attribute` is not defined by the compiler.
  *
  * @see
  *     GCC: https://gcc.gnu.org/gcc-5/changes.html
  *     Clang: https://clang.llvm.org/docs/LanguageExtensions.html
  */
-#ifdef __has_attribute
-    #define Y_HAVE_ATTRIBUTE(x) __has_attribute(x)
+#if defined(__cplusplus) && defined(__has_cpp_attribute)
+    #define Y_HAS_CPP_ATTRIBUTE(x) __has_cpp_attribute(x)
+#else
+    #define Y_HAS_CPP_ATTRIBUTE(x) 0
+#endif
+
+/**
+ * @def Y_LIFETIME_BOUND
+ *
+ * This attribute on a function parameter can be used to tell the compiler
+ * that the function return value may refer that parameter.
+ * When applied to a parameter of a constructor it means that the constructed object
+ * may refer that parameter.
+ * This attribute can also be used to annotate non-static member functions meaning that the
+ * return value of this function may refer to the object on which the member function is invoked.
+ *
+ * The compiler may produce a compile-time warning if it is able to detect that
+ * an object or a reference refers to another object with a shorter lifetime.
+ *
+ * @see
+ *    Clang: https://clang.llvm.org/docs/AttributeReference.html#lifetimebound
+ */
+#if defined(__CUDACC__) && (!Y_CUDA_AT_LEAST(11, 0) || (__clang_major__ < 13))
+    #define Y_LIFETIME_BOUND
+#elif Y_HAS_CPP_ATTRIBUTE(clang::lifetimebound)
+    #define Y_LIFETIME_BOUND [[clang::lifetimebound]]
+#elif Y_HAS_CPP_ATTRIBUTE(msvc::lifetimebound)
+    #define Y_LIFETIME_BOUND [[msvc::lifetimebound]]
+#else
+    #define Y_LIFETIME_BOUND
+#endif
+
+/**
+ * @def Y_LIFETIME_CAPTURE_BY(X)
+ *
+ * The attribute on a function parameter or implicit object parameter indicates
+ * that the capturing entity X may refer to the object referred by that parameter.
+ */
+#if defined(__CUDACC__) && (!Y_CUDA_AT_LEAST(11, 0) || (__clang_major__ < 13))
+    #define Y_LIFETIME_CAPTURE_BY(X)
+#elif Y_HAS_CPP_ATTRIBUTE(clang::lifetime_capture_by)
+    #define Y_LIFETIME_CAPTURE_BY(X) [[clang::lifetime_capture_by(X)]]
 #else
-    #define Y_HAVE_ATTRIBUTE(x) 0
+    #define Y_LIFETIME_CAPTURE_BY(X)
 #endif
 
 /**
@@ -711,8 +787,112 @@ Y_FORCE_INLINE void DoNotOptimizeAway(const T&) = delete;
  * Y_RETURNS_NONNULL extern void* mymalloc(size_t len);
  * @endcode
  */
-#if Y_HAVE_ATTRIBUTE(returns_nonnull)
+#if Y_HAS_ATTRIBUTE(returns_nonnull)
     #define Y_RETURNS_NONNULL __attribute__((returns_nonnull))
 #else
     #define Y_RETURNS_NONNULL
 #endif
+
+/**
+ * @def Y_NONNULL
+ *
+ * The nonnull attribute indicates that a function parameter must not be null.
+ *
+ * @see
+ *    GCC: https://gcc.gnu.org/onlinedocs/gcc/Common-Function-Attributes.html#index-nonnull-function-attribute
+ *    Clang: https://clang.llvm.org/docs/AttributeReference.html#id15
+ *
+ * @code
+ * void func(char* Y_NONNULL arr, size_t len);
+ * @endcode
+ */
+#if Y_HAS_ATTRIBUTE(nonnull)
+    #define Y_NONNULL __attribute__((nonnull))
+#else
+    #define Y_NONNULL
+#endif
+
+/**
+ * @def Y_NO_UNIQUE_ADDRESS
+ *
+ * A macro that applies the [[no_unique_address]] attribute to a class/struct member,
+ * allowing it to potentially occupy no additional memory if it is empty.
+ * https://en.cppreference.com/w/cpp/language/attributes/no_unique_address
+ *
+ * @code
+ *
+ * struct TEmpty { ... };
+ *
+ * struct TFoo {
+ *     ...
+ *     Y_NO_UNIQUE_ADDRESS TEmpty Empty;
+ * };
+ *
+ * @endcode
+ */
+#if Y_HAS_CPP_ATTRIBUTE(no_unique_address)
+    #define Y_NO_UNIQUE_ADDRESS [[no_unique_address]]
+#elif Y_HAS_CPP_ATTRIBUTE(msvc::no_unique_address)
+    #define Y_NO_UNIQUE_ADDRESS [[msvc::no_unique_address]]
+#else
+    #define Y_NO_UNIQUE_ADDRESS
+#endif
+
+/**
+ * @def Y_TRIVIAL_ABI
+ *
+ * Indicates that a class or structure can be considered trivial for the purpose of calls.
+ *
+ * @see https://clang.llvm.org/docs/AttributeReference.html#trivial-abi
+ */
+#if Y_HAS_CPP_ATTRIBUTE(clang::trivial_abi)
+    #define Y_TRIVIAL_ABI [[clang::trivial_abi]]
+#else
+    #define Y_TRIVIAL_ABI
+#endif
+
+/**
+ * @def Y_CORO_AWAIT_ELIDABLE
+ *
+ * A class attribute which can be applied to a coroutine return type.
+ *
+ * Allows the compiler to apply heap allocation elision when the coroutine with such return type
+ * is immediately awaited or passed as an argument to a Y_CORO_AWAIT_ELIDABLE_ARGUMENT parameter.
+ *
+ * See https://clang.llvm.org/docs/AttributeReference.html#coro-await-elidable
+ */
+#if defined(__clang__) && Y_HAS_CPP_ATTRIBUTE(clang::coro_await_elidable)
+    #define Y_CORO_AWAIT_ELIDABLE [[clang::coro_await_elidable]]
+#else
+    #define Y_CORO_AWAIT_ELIDABLE
+#endif
+
+/**
+ * @def Y_CORO_AWAIT_ELIDABLE_ARGUMENT
+ *
+ * A function parameter attribute which allows the compiler to apply heap allocation elision for
+ * a coroutine with Y_CORO_AWAIT_ELIDABLE return type passed as argument to the annotated parameter.
+ *
+ * See https://clang.llvm.org/docs/AttributeReference.html#coro-await-elidable-argument
+ */
+#if defined(__clang__) && Y_HAS_CPP_ATTRIBUTE(clang::coro_await_elidable_argument)
+    #define Y_CORO_AWAIT_ELIDABLE_ARGUMENT [[clang::coro_await_elidable_argument]]
+#else
+    #define Y_CORO_AWAIT_ELIDABLE_ARGUMENT
+#endif
+
+/**
+ * @def Y_CORO_ONLY_DESTROY_WHEN_COMPLETE
+ *
+ * A class attribute which can be applied to a coroutine return type.
+ *
+ * Allows the compiler to skip generation of destructors for intermediate suspension points
+ * and reduce code size.
+ *
+ * See https://clang.llvm.org/docs/AttributeReference.html#coro-only-destroy-when-complete
+ */
+#if defined(__clang__) && Y_HAS_CPP_ATTRIBUTE(clang::coro_only_destroy_when_complete)
+    #define Y_CORO_ONLY_DESTROY_WHEN_COMPLETE [[clang::coro_only_destroy_when_complete]]
+#else
+    #define Y_CORO_ONLY_DESTROY_WHEN_COMPLETE
+#endif
diff --git a/util/system/compiler_ut.c b/util/system/compiler_ut.c
new file mode 100644
index 00000000000..7ca9b86ba5a
--- /dev/null
+++ b/util/system/compiler_ut.c
@@ -0,0 +1,2 @@
+// test for C-compiler compileability
+#include "compiler.h"
diff --git a/util/system/compiler_ut.cpp b/util/system/compiler_ut.cpp
index f93b1c08507..7e28e4adf86 100644
--- a/util/system/compiler_ut.cpp
+++ b/util/system/compiler_ut.cpp
@@ -2,6 +2,8 @@
 
 #include <library/cpp/testing/unittest/registar.h>
 
+#include <string>
+
 Y_UNIT_TEST_SUITE(TCompilerTest) {
     Y_UNIT_TEST(TestPragmaNoWshadow) {
         Y_PRAGMA_DIAGNOSTIC_PUSH
@@ -69,4 +71,13 @@ Y_UNIT_TEST_SUITE(TCompilerTest) {
 
         Y_PRAGMA_DIAGNOSTIC_POP
     }
-}
+
+    Y_UNIT_TEST(TestYInitialized) {
+        std::string s;
+        if (false) {
+            auto _ = std::move(s);
+        }
+        Y_INITIALIZED(s);   // not moved
+        Y_UNUSED(s.size()); // no bugprone-use-after-move warning
+    }
+} // Y_UNIT_TEST_SUITE(TCompilerTest)
diff --git a/util/system/condvar.cpp b/util/system/condvar.cpp
index b4d748e4e96..67df8a585b9 100644
--- a/util/system/condvar.cpp
+++ b/util/system/condvar.cpp
@@ -39,7 +39,7 @@ namespace {
 
         inline void BroadCast() noexcept {
             with_lock (Lock_) {
-                //TODO
+                // TODO
                 while (!Events_.Empty()) {
                     Events_.PopFront()->Signal();
                 }
@@ -70,7 +70,7 @@ namespace {
         TWaitEvents Events_;
         TLock Lock_;
     };
-}
+} // namespace
 
 #if defined(_win_)
 class TCondVar::TImpl: public TCondVarImpl {
diff --git a/util/system/condvar.h b/util/system/condvar.h
index 569162717cb..a0305283531 100644
--- a/util/system/condvar.h
+++ b/util/system/condvar.h
@@ -55,7 +55,7 @@ class TCondVar {
         WaitD(m, TInstant::Max(), std::move(pred));
     }
 
-    //deprecated
+    // deprecated
     inline void Wait(TMutex& m) noexcept {
         WaitI(m);
     }
diff --git a/util/system/context.cpp b/util/system/context.cpp
index 3a67593813e..9211c564aff 100644
--- a/util/system/context.cpp
+++ b/util/system/context.cpp
@@ -20,7 +20,7 @@ namespace __cxxabiv1 {
     };
 
     extern "C" __cxa_eh_globals* __cxa_get_globals();
-}
+} // namespace __cxxabiv1
     #endif
 #endif
 
@@ -117,22 +117,22 @@ namespace {
     #if defined(_x86_64_)
     // not sure if Y_NO_SANITIZE is needed
     Y_NO_SANITIZE("address")
-    Y_NO_SANITIZE("memory") extern "C" void ContextTrampoLine(void*, void*, void*, void*, void*, void*, // register arguments, no defined value
-                                                              /* first argument passed through the stack */ void* t1,
-                                                              /* second argument passed through the stack */ void* t2) {
+    Y_NO_SANITIZE("memory") extern "C" void
+    ContextTrampoLine(void*, void*, void*, void*, void*, void*, // register arguments, no defined value
+                      /* first argument passed through the stack */ void* t1,
+                      /* second argument passed through the stack */ void* t2) {
         Y_ASSERT(t1 == t2);
         Run(t1);
     }
     #else
     Y_NO_SANITIZE("address")
-    Y_NO_SANITIZE("memory") static void ContextTrampoLine() {
+    Y_NO_SANITIZE("memory") static void
+    ContextTrampoLine() {
         void** argPtr = (void**)((char*)AlignUp(&argPtr + EXTRA_PUSH_ARGS, STACK_ALIGN) + STACK_ALIGN);
-        Y_ASSERT(*(argPtr - 1) == *(argPtr - 2));
-
         Run(*(argPtr - 1));
     }
     #endif
-}
+} // namespace
 
     #if defined(USE_SANITIZER_CONTEXT)
 
diff --git a/util/system/context_ut.cpp b/util/system/context_ut.cpp
index 45cb0249f74..461bef2ccac 100644
--- a/util/system/context_ut.cpp
+++ b/util/system/context_ut.cpp
@@ -68,4 +68,4 @@ Y_UNIT_TEST_SUITE(TestContext) {
         UNIT_ASSERT(throwed);
         UNIT_ASSERT(!hasUncaught);
     }
-}
+} // Y_UNIT_TEST_SUITE(TestContext)
diff --git a/util/system/cpu_id.cpp b/util/system/cpu_id.cpp
index 48027650226..96b29e6ac28 100644
--- a/util/system/cpu_id.cpp
+++ b/util/system/cpu_id.cpp
@@ -83,7 +83,7 @@ namespace {
     };
 
     static_assert(sizeof(TX86CpuInfo) == 16, "please, fix me");
-}
+} // namespace
 
 // https://en.wikipedia.org/wiki/CPUID
 bool NX86::HaveRDTSCP() noexcept {
@@ -169,11 +169,11 @@ bool NX86::HaveBMI2() noexcept {
 bool NX86::HaveAVX512F() noexcept {
 #if defined(_x86_)
     // https://software.intel.com/en-us/articles/how-to-detect-knl-instruction-support
-    return HaveOSXSAVE()                           // implies HaveXSAVE()
-           && (_xgetbv(0) & 6u) == 6u              // XMM state and YMM state are enabled by OS
-           && ((_xgetbv(0) >> 5) & 7u) == 7u       // ZMM state is enabled by OS
-           && TX86CpuInfo(0x0).EAX >= 0x7          // leaf 7 is present
-           && ((TX86CpuInfo(0x7, 0x0).EBX >> 16) & 1u); // AVX512F bit
+    return HaveOSXSAVE()                              // implies HaveXSAVE()
+           && (_xgetbv(0) & 6u) == 6u                 // XMM state and YMM state are enabled by OS
+           && ((_xgetbv(0) >> 5) & 7u) == 7u          // ZMM state is enabled by OS
+           && TX86CpuInfo(0x0).EAX >= 0x7             // leaf 7 is present
+           && ((TX86CpuInfo(0x7, 0).EBX >> 16) & 1u); // AVX512F bit
 #else
     return false;
 #endif
@@ -231,6 +231,10 @@ bool NX86::HaveAVX512VL() noexcept {
     return HaveAVX512F() && ((TX86CpuInfo(0x7, 0).EBX >> 31) & 1u);
 }
 
+bool NX86::HaveAVX512VNNI() noexcept {
+    return HaveAVX512F() && ((TX86CpuInfo(0x7, 0).ECX >> 11) & 1u);
+}
+
 bool NX86::HavePREFETCHWT1() noexcept {
     return TX86CpuInfo(0x0).EAX >= 0x7 && ((TX86CpuInfo(0x7, 0).ECX >> 0) & 1u);
 }
diff --git a/util/system/cpu_id.h b/util/system/cpu_id.h
index 3c49e728a7d..32d74697298 100644
--- a/util/system/cpu_id.h
+++ b/util/system/cpu_id.h
@@ -28,6 +28,7 @@
     F(AVX512CD)               \
     F(AVX512BW)               \
     F(AVX512VL)               \
+    F(AVX512VNNI)             \
     F(AVX512VBMI)             \
     F(PREFETCHWT1)            \
     F(SHA)                    \
@@ -58,6 +59,7 @@
     F(AVX512CD)                                      \
     F(AVX512BW)                                      \
     F(AVX512VL)                                      \
+    F(AVX512VNNI)                                    \
     F(AVX512VBMI)                                    \
     F(PREFETCHWT1)                                   \
     F(SHA)                                           \
@@ -152,6 +154,6 @@ namespace NX86 {
 
 #undef Y_LOOKUP_CPU_ID_IMPL
 
-}
+} // namespace NX86
 
 const char* CpuBrand(ui32 store[12]) noexcept;
diff --git a/util/system/cpu_id_ut.cpp b/util/system/cpu_id_ut.cpp
index 68f1f8aac7f..baa9b613bd4 100644
--- a/util/system/cpu_id_ut.cpp
+++ b/util/system/cpu_id_ut.cpp
@@ -36,6 +36,7 @@ static void ExecuteAVX512ERInstruction();
 static void ExecuteAVX512CDInstruction();
 static void ExecuteAVX512BWInstruction();
 static void ExecuteAVX512VLInstruction();
+static void ExecuteAVX512VNNIInstruction();
 static void ExecuteAVX512VBMIInstruction();
 static void ExecutePREFETCHWT1Instruction();
 static void ExecuteSHAInstruction();
@@ -78,7 +79,7 @@ Y_UNIT_TEST_SUITE(TestCpuId) {
     Y_UNIT_TEST(TestCpuBrand) {
         ui32 store[12];
 
-        //Cout << CpuBrand(store) << Endl;;
+        // Cout << CpuBrand(store) << Endl;;
 
         UNIT_ASSERT(strlen(CpuBrand(store)) > 0);
     }
@@ -88,7 +89,7 @@ Y_UNIT_TEST_SUITE(TestCpuId) {
         Y_CPU_ID_ENUMERATE(Y_DEF_NAME)
 #undef Y_DEF_NAME
     }
-}
+} // Y_UNIT_TEST_SUITE(TestCpuId)
 
 #if defined(_x86_64_)
     #if defined(__GNUC__)
@@ -214,6 +215,9 @@ void ExecuteAVX512BWInstruction() {
 void ExecuteAVX512VLInstruction() {
 }
 
+void ExecuteAVX512VNNIInstruction() {
+}
+
 void ExecuteAVX512VBMIInstruction() {
 }
 
@@ -324,6 +328,9 @@ void ExecuteAVX512BWInstruction() {
 void ExecuteAVX512VLInstruction() {
 }
 
+void ExecuteAVX512VNNIInstruction() {
+}
+
 void ExecuteAVX512VBMIInstruction() {
 }
 
@@ -421,6 +428,9 @@ void ExecuteAVX512BWInstruction() {
 void ExecuteAVX512VLInstruction() {
 }
 
+void ExecuteAVX512VNNIInstruction() {
+}
+
 void ExecuteAVX512VBMIInstruction() {
 }
 
diff --git a/util/system/daemon.h b/util/system/daemon.h
index b00793b9c97..19c52e5433c 100644
--- a/util/system/daemon.h
+++ b/util/system/daemon.h
@@ -24,4 +24,4 @@ namespace NDaemonMaker {
 
     bool MakeMeDaemon(ECloseDescriptors cd = closeAll, EStdIoDescriptors iod = openDevNull, EChDir chd = chdirRoot, EParent parent = callExitFromParent);
     void CloseFrom(int fd);
-}
+} // namespace NDaemonMaker
diff --git a/util/system/daemon_ut.cpp b/util/system/daemon_ut.cpp
index f93b9a96458..862d8f55b4b 100644
--- a/util/system/daemon_ut.cpp
+++ b/util/system/daemon_ut.cpp
@@ -91,4 +91,4 @@ Y_UNIT_TEST_SUITE(TDaemonTest) {
         delete[] pages;
     }
 #endif
-}
+} // Y_UNIT_TEST_SUITE(TDaemonTest)
diff --git a/util/system/datetime.cpp b/util/system/datetime.cpp
index 449d850bafe..10cf0a5a843 100644
--- a/util/system/datetime.cpp
+++ b/util/system/datetime.cpp
@@ -99,7 +99,7 @@ namespace NPrivate {
     bool HaveRdtscpImpl() {
         return NX86::HaveRDTSCP();
     }
-}
+} // namespace NPrivate
 #endif
 
 #ifdef Y_HAS_CLOCK_GETTIME
diff --git a/util/system/datetime.h b/util/system/datetime.h
index f2c2c9f8c88..35c77570b6f 100644
--- a/util/system/datetime.h
+++ b/util/system/datetime.h
@@ -27,7 +27,7 @@ inline ui64 millisec() {
 }
 /// Current time in seconds since epoch
 ui32 Seconds() noexcept;
-///Current thread time in microseconds
+/// Current thread time in microseconds
 ui64 ThreadCPUUserTime() noexcept;
 ui64 ThreadCPUSystemTime() noexcept;
 ui64 ThreadCPUTime() noexcept;
@@ -37,7 +37,7 @@ void NanoSleep(ui64 ns) noexcept;
 #if defined(_x86_)
 namespace NPrivate {
     bool HaveRdtscpImpl();
-}
+} // namespace NPrivate
 #endif
 
 // GetCycleCount guarantees to return synchronous values on different cores
diff --git a/util/system/defaults.c b/util/system/defaults.c
deleted file mode 100644
index 75710009ac2..00000000000
--- a/util/system/defaults.c
+++ /dev/null
@@ -1,2 +0,0 @@
-//test for C-compiler compileability
-#include "defaults.h"
diff --git a/util/system/defaults.h b/util/system/defaults.h
index dcd7abea38e..c90e40ce226 100644
--- a/util/system/defaults.h
+++ b/util/system/defaults.h
@@ -152,4 +152,4 @@ constexpr bool Y_IS_DEBUG_BUILD = true;
     #define Y_GENERATE_UNIQUE_ID(N) Y_CAT(N, __LINE__)
 #endif
 
-#define NPOS ((size_t)-1)
+#define NPOS ((size_t) - 1)
diff --git a/util/system/defaults_ut.c b/util/system/defaults_ut.c
new file mode 100644
index 00000000000..90a367c7817
--- /dev/null
+++ b/util/system/defaults_ut.c
@@ -0,0 +1,2 @@
+// test for C-compiler compileability
+#include "defaults.h"
diff --git a/util/system/demangle_impl.h b/util/system/demangle_impl.h
index 081004f976b..9184e1f5603 100644
--- a/util/system/demangle_impl.h
+++ b/util/system/demangle_impl.h
@@ -18,4 +18,4 @@ namespace NPrivate {
         THolder<char, TFree> TmpBuf_;
     };
 
-} //namespace NPrivate
+} // namespace NPrivate
diff --git a/util/system/direct_io.cpp b/util/system/direct_io.cpp
index 1b6c39f42ca..e3b825193fe 100644
--- a/util/system/direct_io.cpp
+++ b/util/system/direct_io.cpp
@@ -44,7 +44,7 @@ namespace {
 
         size_t Alignment;
     };
-}
+} // namespace
 
 TDirectIOBufferedFile::TDirectIOBufferedFile(const TString& path, EOpenMode oMode, size_t buflen /*= 1 << 17*/)
     : File(path, oMode)
diff --git a/util/system/direct_io_ut.cpp b/util/system/direct_io_ut.cpp
index 839c3de7ca4..31b840cd586 100644
--- a/util/system/direct_io_ut.cpp
+++ b/util/system/direct_io_ut.cpp
@@ -18,7 +18,7 @@ Y_UNIT_TEST_SUITE(TDirectIoTestSuite) {
             i = RandomNumber<ui64>();
         }
         for (size_t writePos = 0; writePos < data.size();) {
-            size_t writeCount = Min<size_t>(1 + RandomNumber<size_t>(1 << 10), data.ysize() - writePos);
+            size_t writeCount = Min<size_t>(1 + RandomNumber<size_t>(1 << 10), data.size() - writePos);
             file.Write(&data[writePos], sizeof(ui64) * writeCount);
             writePos += writeCount;
             size_t readPos = RandomNumber(writePos);
@@ -86,7 +86,7 @@ Y_UNIT_TEST_SUITE(TDirectIoTestSuite) {
             TestHugeFile(5 * 1024 * 1024 * 1024ULL + 1111);
         }
     }
-}
+} // Y_UNIT_TEST_SUITE(TDirectIoTestSuite)
 
 Y_UNIT_TEST_SUITE(TDirectIoErrorHandling) {
     Y_UNIT_TEST(Constructor) {
@@ -112,4 +112,4 @@ Y_UNIT_TEST_SUITE(TDirectIoErrorHandling) {
         UNIT_ASSERT_EXCEPTION(file.Finish(), TFileError);
         NFs::Remove(FileName_);
     }
-}
+} // Y_UNIT_TEST_SUITE(TDirectIoErrorHandling)
diff --git a/util/system/dynlib.cpp b/util/system/dynlib.cpp
index 9d2541c25f1..55348288c86 100644
--- a/util/system/dynlib.cpp
+++ b/util/system/dynlib.cpp
@@ -34,10 +34,12 @@ inline TString DLLERR() {
     char* msg = 0;
     DWORD cnt = FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
                               nullptr, GetLastError(), MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (char*)&msg, 0, nullptr);
-    if (!msg)
+    if (!msg) {
         return "DLLERR() unknown error";
-    while (cnt && isspace(msg[cnt - 1]))
+    }
+    while (cnt && isspace(msg[cnt - 1])) {
         --cnt;
+    }
     TString err(msg, 0, cnt);
     LocalFree(msg);
     return err;
diff --git a/util/system/dynlib.h b/util/system/dynlib.h
index 66eaf4a5c1c..03e4b3dff89 100644
--- a/util/system/dynlib.h
+++ b/util/system/dynlib.h
@@ -55,18 +55,20 @@ class TExternalSymbol {
     TExternalSymbol(const TExternalSymbol& es) {
         PLib = nullptr;
         DLib = nullptr;
-        if (es.IsDynamic())
+        if (es.IsDynamic()) {
             Open(es.LibName().data(), es.VtblName().data());
-        else if (es.IsStatic())
+        } else if (es.IsStatic()) {
             SetSym(es.Symbol());
+        }
     }
     TExternalSymbol& operator=(const TExternalSymbol& es) {
         if (this != &es) {
             Close();
-            if (es.IsDynamic())
+            if (es.IsDynamic()) {
                 Open(es.LibName().data(), es.VtblName().data());
-            else if (es.IsStatic())
+            } else if (es.IsStatic()) {
                 SetSym(es.Symbol());
+            }
         }
         return *this;
     }
@@ -75,8 +77,9 @@ class TExternalSymbol {
     }
     // set the symbol from dynamic source
     void Open(const char* lib_name, const char* vtbl_name) {
-        if (DLib != nullptr || PLib != nullptr)
+        if (DLib != nullptr || PLib != nullptr) {
             return;
+        }
         try {
             DLib = new TDynamicLibrary();
             DLib->Open(lib_name);
@@ -91,8 +94,9 @@ class TExternalSymbol {
     }
     // set the symbol from static source
     void SetSym(TLib* pl) noexcept {
-        if (DLib == nullptr && PLib == nullptr)
+        if (DLib == nullptr && PLib == nullptr) {
             PLib = pl;
+        }
     }
     void Close() noexcept {
         delete DLib;
diff --git a/util/system/env.cpp b/util/system/env.cpp
index ea81c3a1d08..24bd7707025 100644
--- a/util/system/env.cpp
+++ b/util/system/env.cpp
@@ -5,15 +5,23 @@
 #include <util/generic/yexception.h>
 
 #ifdef _win_
+    #include <util/generic/scope.h>
     #include <util/generic/vector.h>
+    #include <util/system/yassert.h>
     #include "winint.h"
 #else
+    #ifndef _linux_
+        #include <util/generic/vector.h> // ClearEnv impl
+    #endif
+
     #include <cerrno>
     #include <cstdlib>
+
+extern char** environ;
 #endif
 
 /**
- * On Windows there may be many copies of enviroment variables, there at least two known, one is
+ * On Windows there may be many copies of environment variables, there at least two known, one is
  * manipulated by Win32 API, another by C runtime, so we must be consistent in the choice of
  * functions used to manipulate them.
  *
@@ -63,19 +71,12 @@ TString GetEnv(const TString& key, const TString& def) {
 
 void SetEnv(const TString& key, const TString& value) {
     bool isOk = false;
-    int errorCode = 0;
 #ifdef _win_
     isOk = SetEnvironmentVariable(key.data(), value.data());
-    if (!isOk) {
-        errorCode = GetLastError();
-    }
 #else
     isOk = (0 == setenv(key.data(), value.data(), true /*replace*/));
-    if (!isOk) {
-        errorCode = errno;
-    }
 #endif
-    Y_ENSURE_EX(isOk, TSystemError() << "failed to SetEnv with error-code " << errorCode);
+    Y_ENSURE_EX(isOk, TSystemError() << "failed to SetEnv");
 }
 
 void UnsetEnv(const TString& key) {
@@ -91,3 +92,73 @@ void UnsetEnv(const TString& key) {
 #endif
     Y_ENSURE_EX(ok || notFound, TSystemError() << "failed to unset environment variable " << key.Quote());
 }
+
+void IterateEnv(const std::function<void(TStringBuf, TStringBuf)>& f, bool ignoreMalformedStrings) {
+#ifdef _win_
+    // Env block format:
+    // Var1=Value1\0
+    // Var2=Value2\0
+    // ...
+    // VarN=ValueN\0\0
+    // Or "\0" if empty
+
+    auto envBlock = GetEnvironmentStringsA();
+    if (!envBlock) {
+        ythrow TSystemError() << "failed to get environment variables";
+    }
+    Y_DEFER {
+        bool ok = FreeEnvironmentStringsA(envBlock);
+        Y_ABORT_UNLESS(ok, "failed to free env block"); // ¯\_(ツ)_/¯
+    };
+    const char* charEnv = envBlock;
+    while (*charEnv) {
+        TStringBuf varStr(charEnv);
+        TStringBuf name, value;
+        if (varStr.TrySplit('=', name, value)) { // Not optimal (we could scan for null byte and '=' in one pass), but less bugprone
+            f(name, value);
+        } else {
+            Y_ENSURE(ignoreMalformedStrings, "Environment contains a string without '=': \"" << varStr << '"');
+        }
+        charEnv = varStr.data() + varStr.size() + 1;
+    }
+#else
+    if (!environ) { // may be null after clearenv
+        return;
+    }
+    for (char** var = environ; *var; ++var) {
+        TStringBuf varStr(*var);
+        TStringBuf name, value;
+        if (varStr.TrySplit('=', name, value)) {
+            f(name, value);
+        } else {
+            Y_ENSURE(ignoreMalformedStrings, "Environment contains a string without '=': \"" << varStr << '"');
+        }
+    }
+#endif
+}
+
+void ClearEnv() {
+#if defined(_win_)
+    wchar_t emptyEnv[] = {L'\0'};
+    // At least on Wine, SetEnvironmentStringsA expects a multi-byte string that is internally converted to UTF-16.
+    // So it's easier to use SetEnvironmentStringsW directly.
+    bool ok = SetEnvironmentStringsW(emptyEnv);
+    Y_ENSURE_EX(ok, TSystemError() << "failed to clear environment");
+#elif defined(_linux_)
+    bool ok = !clearenv();
+    Y_ENSURE_EX(ok, TSystemError() << "failed to clear environment");
+#else
+    // Darwin or other unix platform that may not have clearenv
+    TVector<TString> keys;
+    IterateEnv(
+        [&keys](TStringBuf name, TStringBuf) {
+            keys.emplace_back(name);
+        },
+        true // Ignore malformed strings - they don't seem to be accessible anyway.
+             // IterateEnv won't expose these strings, and GetEnv/SetEnv/UnsetEnv ignore them (at least in glibc).
+    );
+    for (const auto& key : keys) {
+        UnsetEnv(key); // duplicate UnsetEnv is ok.
+    }
+#endif
+}
diff --git a/util/system/env.h b/util/system/env.h
index 55f43bd9b82..5aa4fbe400f 100644
--- a/util/system/env.h
+++ b/util/system/env.h
@@ -2,6 +2,12 @@
 
 #include <util/generic/fwd.h>
 #include <util/generic/string.h>
+#include <util/generic/strbuf.h>
+
+#include <functional>
+
+// NOTE: On Windows, functions from this header may have unexpected behavior when used with codepages that don't support all Unicode characters.
+//       For more info, see https://blog.orange.tw/posts/2025-01-worstfit-unveiling-hidden-transformers-in-windows-ansi/
 
 /**
  * Search the environment list provided by the host environment for associated variable.
@@ -9,12 +15,12 @@
  * @param key   String identifying the name of the environmental variable to look for
  * @param def   String that returns if environmental variable not found by key
  *
- * @return      String that is associated with the matched environment variable or empty string if
+ * @return      String that is associated with the matched environment variable or the value of `def` parameter if
  *              such variable is missing.
  *
  * @note        Use it only in pair with `SetEnv` as there may be inconsistency in their behaviour
  *              otherwise.
- * @note        Calls to `GetEnv` and `SetEnv` from different threads must be synchronized.
+ * @note        Calls to `GetEnv` and environment modifying functions (like `SetEnv`) from different threads must be synchronized.
  * @see         SetEnv
  */
 TString GetEnv(const TString& key, const TString& def = TString());
@@ -22,29 +28,28 @@ TString GetEnv(const TString& key, const TString& def = TString());
 /**
  * Search the environment list provided by the host environment for associated variable.
  *
- * @param key               String identifying the name of the environmental variable to look for
- *
- * @return                  String that is associated with the matched environment
- *                          variable or empty optional value if such variable is missing.
+ * @param key   String identifying the name of the environmental variable to look for
  *
- * @throws TSystemError     If name of the variable has invalid format
+ * @return      String that is associated with the matched environment
+ *              variable or empty optional value if such variable is missing.
  *
- * @note                    Use it only in pair with `SetEnv` as there may be inconsistency
- *                          in their behaviour otherwise.
- * @note                    Calls to `TryGetEnv` and `SetEnv` from different threads must be synchronized.
- * @see                     SetEnv
+ * @note        Use it only in pair with `SetEnv` as there may be inconsistency in their behaviour otherwise.
+ * @note        Calls to `TryGetEnv` and environment modifying functions (like `SetEnv`) from different threads must be synchronized.
+ * @see         SetEnv
  */
 TMaybe<TString> TryGetEnv(const TString& key);
 
 /**
  * Add or change environment variable provided by the host environment.
  *
- * @param key   String identifying the name of the environment variable to set or change
- * @param value Value to assign
-
+ * @param key               String identifying the name of the environment variable to set or change
+ * @param value             Value to assign
+ *
+ * @throws TSystemError     On error
+ *
  * @note        Use it only in pair with `GetEnv` as there may be inconsistency in their behaviour
  *              otherwise.
- * @note        Calls to `GetEnv` and `SetEnv` from different threads must be synchronized.
+ * @note        Calls to `SetEnv` and all other env-related functions from different threads must be synchronized.
  * @see         GetEnv
  */
 void SetEnv(const TString& key, const TString& value);
@@ -52,11 +57,40 @@ void SetEnv(const TString& key, const TString& value);
 /**
  * Remove environment variable from the host environment.
  *
- * @param key   String identifying the name of the environment variable to remove
+ * @param key               String identifying the name of the environment variable to remove
  *
- * @note        If key does not exist in the environment, then the environment is unchanged,
- *              and the function returns normally.
- * @note        Calls to `GetEnv` and `SetEnv` from different threads must be synchronized.
- * @see         GetEnv
+ * @throws TSystemError     On error
+ *
+ * @note                    If key does not exist in the environment, then the environment is unchanged,
+ *                          and the function returns normally.
+ * @note                    Calls to `UnsetEnv` and and all other env-related functions from different threads must be synchronized.
+ * @see                     GetEnv
  */
 void UnsetEnv(const TString& key);
+
+/**
+ * Clear the host environment.
+ *
+ * @throws TSystemError     On error
+ *
+ * @note                    Calls to `ClearEnv` and all other env-related functions from different threads must be synchronized.
+ */
+void ClearEnv();
+
+/**
+ * Call the provided function `f` with name and value as arguments for each environment variable.
+ *
+ * @param f                         The function to call
+ * @param ignoreMalformedStrings    If false, any malformed string in host environment (one that doesn't contain a '=') will cause an exception.
+ *                                  If true, such strings will be skipped.
+ *
+ * @throws TSystemError         On error
+ * @throws yexception           On encountering a malformed string (see `ignoreMalformedStrings`)
+ *
+ * @note                        The function `f` may be called with the same variable name multiple times.
+ *                              Lifetime for contents of `name` and `value` is not guaranteed to last beyond the scope of the invocation of `f`.
+ *
+ * @note                        Calls to `IterateEnv` and environment modifying functions (like `SetEnv`) from different threads must be synchronized.
+ *                              Also, `f` must not call any environment modifying functions.
+ */
+void IterateEnv(const std::function<void(TStringBuf /*name*/, TStringBuf /*value*/)>& f, bool ignoreMalformedStrings = false);
diff --git a/util/system/env_ut.cpp b/util/system/env_ut.cpp
index 6023ce2afdd..fff32b9abd6 100644
--- a/util/system/env_ut.cpp
+++ b/util/system/env_ut.cpp
@@ -56,4 +56,43 @@ Y_UNIT_TEST_SUITE(EnvTest) {
         UNIT_ASSERT_EXCEPTION(SetEnv("", "value"), yexception);
         UNIT_ASSERT_EXCEPTION(SetEnv("A=B", "C=D"), yexception);
     }
-}
+
+    Y_UNIT_TEST(ClearEnv) {
+        TString key1 = "util_GETENV_TestVar1";
+        TString key2 = "util_GETENV_TestVar2";
+        SetEnv(key1, "some value");
+        SetEnv(key2, "some other value");
+        ClearEnv();
+        UNIT_ASSERT(TryGetEnv(key1).Empty());
+        UNIT_ASSERT(TryGetEnv(key2).Empty());
+    }
+
+    Y_UNIT_TEST(IterateEnv) {
+        ClearEnv();
+        IterateEnv([](TStringBuf name, TStringBuf value) {
+            UNIT_FAIL(TString::Join("Got unexpected env variable ", name, " with value ", value));
+        });
+        TString key1 = "util_GETENV_TestVar1";
+        TString key2 = "util_GETENV_TestVar2";
+        TString value1 = "some value";
+        TString value2 = "some other value";
+        SetEnv(key1, value1);
+        SetEnv(key2, value2);
+
+        bool foundVar1 = false;
+        bool foundVar2 = false;
+        IterateEnv([&](TStringBuf name, TStringBuf value) {
+            if (name == key1) {
+                foundVar1 = true;
+                UNIT_ASSERT_EQUAL(value, value1);
+            } else if (name == key2) {
+                foundVar2 = true;
+                UNIT_ASSERT_EQUAL(value, value2);
+            } else {
+                UNIT_FAIL(TString::Join("Got unexpected env variable ", name, " with value ", value));
+            }
+        });
+        UNIT_ASSERT(foundVar1);
+        UNIT_ASSERT(foundVar2);
+    }
+} // Y_UNIT_TEST_SUITE(EnvTest)
diff --git a/util/system/err.cpp b/util/system/err.cpp
index e2e5d8c9fdb..b7fe13aa1c4 100644
--- a/util/system/err.cpp
+++ b/util/system/err.cpp
@@ -9,6 +9,8 @@
 #include <util/stream/printf.h>
 #include <util/stream/output.h>
 
+#include <cstdlib>
+
 void vwarnx(const char* fmt, va_list args) {
     Cerr << GetProgramName() << ": ";
 
diff --git a/util/system/error.cpp b/util/system/error.cpp
index c7f22acd32e..52b1bbb104a 100644
--- a/util/system/error.cpp
+++ b/util/system/error.cpp
@@ -24,13 +24,15 @@ int LastSystemError() {
 #if defined(_win_)
     int ret = GetLastError();
 
-    if (ret)
+    if (ret) {
         return ret;
+    }
 
     ret = WSAGetLastError();
 
-    if (ret)
+    if (ret) {
         return ret;
+    }
     // when descriptors number are over maximum, errno set in this variable
     ret = *(_errno());
     return ret;
@@ -49,7 +51,7 @@ namespace {
 
         char data[1024];
     };
-}
+} // namespace
 #endif
 
 const char* LastSystemErrorText(int code) {
@@ -68,8 +70,9 @@ static char* Strip(char* s) {
     size_t len = strlen(s);
     const char* ptr = s;
     Strip(ptr, len);
-    if (ptr != s)
+    if (ptr != s) {
         memmove(s, ptr, len);
+    }
     s[len] = 0;
     return s;
 }
diff --git a/util/system/event.cpp b/util/system/event.cpp
index 42311d48352..9bb27aed2c9 100644
--- a/util/system/event.cpp
+++ b/util/system/event.cpp
@@ -37,7 +37,7 @@ class TSystemEvent::TEvImpl: public TAtomicRefCount<TSystemEvent::TEvImpl> {
         const TInstant now = Now();
 
         if (now < deadLine) {
-            //TODO
+            // TODO
             return WaitForSingleObject(cond, (deadLine - now).MilliSeconds()) == WAIT_OBJECT_0;
         }
 
diff --git a/util/system/event.h b/util/system/event.h
index cab2fc478ab..e4dc6996729 100644
--- a/util/system/event.h
+++ b/util/system/event.h
@@ -46,7 +46,7 @@ class TSystemEvent: public TEventResetType {
         WaitD(TInstant::Max());
     }
 
-    //return true if signaled, false if timed out.
+    // return true if signaled, false if timed out.
     inline bool Wait(ui32 timer) noexcept {
         return WaitT(TDuration::MilliSeconds(timer));
     }
diff --git a/util/system/event_ut.cpp b/util/system/event_ut.cpp
index 448f1e1350a..4a4f33a1378 100644
--- a/util/system/event_ut.cpp
+++ b/util/system/event_ut.cpp
@@ -75,7 +75,7 @@ namespace {
         }
     };
 
-}
+} // namespace
 
 Y_UNIT_TEST_SUITE(EventTest) {
     Y_UNIT_TEST(WaitAndSignalTest) {
@@ -124,4 +124,4 @@ Y_UNIT_TEST_SUITE(EventTest) {
         }
         queue.Stop();
     }
-}
+} // Y_UNIT_TEST_SUITE(EventTest)
diff --git a/util/system/execpath.cpp b/util/system/execpath.cpp
index 9e1b5cec93c..b253ea3063e 100644
--- a/util/system/execpath.cpp
+++ b/util/system/execpath.cpp
@@ -14,6 +14,7 @@
     #include <sys/types.h> // for u_int not defined in sysctl.h
     #include <sys/sysctl.h>
     #include <unistd.h>
+    #include <util/folder/dirut.h>
 #endif
 
 #include <util/generic/singleton.h>
@@ -178,7 +179,7 @@ namespace {
         TString ExecPath;
         TString PersistentExecPath;
     };
-}
+} // namespace
 
 const TString& GetExecPath() {
     return TExecPathsHolder::Instance()->ExecPath;
diff --git a/util/system/execpath_ut.cpp b/util/system/execpath_ut.cpp
index f8ca86d9cf2..6c90cbfe1b0 100644
--- a/util/system/execpath_ut.cpp
+++ b/util/system/execpath_ut.cpp
@@ -18,4 +18,4 @@ Y_UNIT_TEST_SUITE(TExecPathTest) {
             throw;
         }
     }
-}
+} // Y_UNIT_TEST_SUITE(TExecPathTest)
diff --git a/util/system/fasttime.cpp b/util/system/fasttime.cpp
index 22b9e9f4665..9bb70be5f35 100644
--- a/util/system/fasttime.cpp
+++ b/util/system/fasttime.cpp
@@ -231,7 +231,7 @@ namespace {
         TLinePredictor<16, TTime, TTime> P_;
         TTime Next_;
     };
-}
+} // namespace
 
 ui64 InterpolatedMicroSeconds() {
     return FastTlsSingleton<TTimePredictor>()->Get();
diff --git a/util/system/file.cpp b/util/system/file.cpp
index 30bba71a038..1f029a71f99 100644
--- a/util/system/file.cpp
+++ b/util/system/file.cpp
@@ -297,7 +297,7 @@ TFileHandle::TFileHandle(const std::filesystem::path& path, EOpenMode oMode) noe
     }
     #endif
 
-    //temp file
+    // temp file
     if (Fd_ >= 0 && (oMode & Transient)) {
         std::filesystem::remove(path);
     }
@@ -670,7 +670,7 @@ bool TFileHandle::LinkTo(const TFileHandle& fh) const noexcept {
         return false;
     }
 
-    //not thread-safe
+    // not thread-safe
     nh.Swap(*const_cast<TFileHandle*>(this));
 
     return true;
@@ -1336,7 +1336,7 @@ void TFile::LinkTo(const TFile& f) const {
 }
 
 TFile TFile::Temporary(const TString& prefix) {
-    //TODO - handle impossible case of name collision
+    // TODO - handle impossible case of name collision
     return TFile(prefix + ToString(MicroSeconds()) + "-" + ToString(RandomNumber<ui64>()), CreateNew | RdWr | Seq | Temp | Transient);
 }
 
diff --git a/util/system/file.h b/util/system/file.h
index bf5791271df..ae73bb79c67 100644
--- a/util/system/file.h
+++ b/util/system/file.h
@@ -61,7 +61,7 @@ enum SeekDir {
     sEnd = 2,
 };
 
-class TFileHandle: public TNonCopyable {
+class TFileHandle: TMoveOnly {
 public:
     constexpr TFileHandle() = default;
 
@@ -85,6 +85,12 @@ class TFileHandle: public TNonCopyable {
         Close();
     }
 
+    TFileHandle& operator=(TFileHandle&& other) noexcept {
+        Close();
+        Fd_ = other.Release();
+        return *this;
+    }
+
     bool Close() noexcept;
 
     inline FHANDLE Release() noexcept {
@@ -114,7 +120,7 @@ class TFileHandle: public TNonCopyable {
     bool FallocateNoResize(i64 length) noexcept;
     bool ShrinkToFit() noexcept;
     bool Flush() noexcept;
-    //flush data only, without file metadata
+    // flush data only, without file metadata
     bool FlushData() noexcept;
     i32 Read(void* buffer, ui32 byteCount) noexcept;
     i32 Write(const void* buffer, ui32 byteCount) noexcept;
@@ -125,22 +131,22 @@ class TFileHandle: public TNonCopyable {
     FHANDLE Duplicate() const noexcept;
     int Duplicate2Posix(int dstHandle) const noexcept;
 
-    //dup2 - like semantics, return true on success
+    // dup2 - like semantics, return true on success
     bool LinkTo(const TFileHandle& fh) const noexcept;
 
-    //very low-level methods
+    // very low-level methods
     bool SetDirect();
     void ResetDirect();
 
     /* Manual file cache management, length = 0 means "as much as possible" */
 
-    //measure amount of cached data in bytes, returns -1 if failed
+    // measure amount of cached data in bytes, returns -1 if failed
     i64 CountCache(i64 offset = 0, i64 length = 0) const noexcept;
-    //read data into cache and optionally wait for completion
+    // read data into cache and optionally wait for completion
     void PrefetchCache(i64 offset = 0, i64 length = 0, bool wait = true) const noexcept;
-    //remove clean and unused data from cache
+    // remove clean and unused data from cache
     void EvictCache(i64 offset = 0, i64 length = 0) const noexcept;
-    //flush unwritten data in this range and optionally wait for completion
+    // flush unwritten data in this range and optionally wait for completion
     bool FlushCache(i64 offset = 0, i64 length = 0, bool wait = true) noexcept;
 
 private:
@@ -201,19 +207,19 @@ class TFile {
 
     void Flock(int op);
 
-    //do not use, their meaning very platform-dependant
+    // do not use, their meaning very platform-dependant
     void SetDirect();
     void ResetDirect();
 
     /* Manual file cache management, length = 0 means "as much as possible" */
 
-    //measure amount of cached data in bytes, returns -1 if failed
+    // measure amount of cached data in bytes, returns -1 if failed
     i64 CountCache(i64 offset = 0, i64 length = 0) const noexcept;
-    //read data into cache and optionally wait for completion
+    // read data into cache and optionally wait for completion
     void PrefetchCache(i64 offset = 0, i64 length = 0, bool wait = true) const noexcept;
-    //remove clean and unused data from cache, incomplete pages could stay
+    // remove clean and unused data from cache, incomplete pages could stay
     void EvictCache(i64 offset = 0, i64 length = 0) const noexcept;
-    //flush unwritten data in this range and optionally wait for completion
+    // flush unwritten data in this range and optionally wait for completion
     void FlushCache(i64 offset = 0, i64 length = 0, bool wait = true);
 
     static TFile Temporary(const TString& prefix);
diff --git a/util/system/file_lock.cpp b/util/system/file_lock.cpp
index 45d91282c5b..0d9b296453b 100644
--- a/util/system/file_lock.cpp
+++ b/util/system/file_lock.cpp
@@ -17,7 +17,7 @@ namespace {
         }
         Y_UNREACHABLE();
     }
-}
+} // namespace
 
 TFileLock::TFileLock(const TString& filename, const EFileLockType type)
     : TFile(filename, OpenAlways | RdOnly)
diff --git a/util/system/file_ut.cpp b/util/system/file_ut.cpp
index 941e6a50f3d..312a0e8f2c5 100644
--- a/util/system/file_ut.cpp
+++ b/util/system/file_ut.cpp
@@ -335,76 +335,101 @@ void TFileTest::TestPread() {
     #define TMPFS_MAGIC 0x01021994
 #endif
 
-void TFileTest::TestCache(){
+void TFileTest::TestCache() {
 #ifdef _linux_
-    {// create file in /tmp, current dir could be tmpfs which does not support fadvise
-     TFile file(MakeTempName("/tmp"), OpenAlways | Transient | RdWr | NoReadAhead);
+    { // create file in /tmp, current dir could be tmpfs which does not support fadvise
+        TFile file(MakeTempName("/tmp"), OpenAlways | Transient | RdWr | NoReadAhead);
 
-struct statfs fs;
-if (!fstatfs(file.GetHandle(), &fs) && fs.f_type == TMPFS_MAGIC) {
-    return;
-}
+        struct statfs fs;
+        if (!fstatfs(file.GetHandle(), &fs) && fs.f_type == TMPFS_MAGIC) {
+            return;
+        }
 
-UNIT_ASSERT_VALUES_EQUAL(file.CountCache(), 0);
-UNIT_ASSERT_VALUES_EQUAL(file.CountCache(0, 0), 0);
+        UNIT_ASSERT_VALUES_EQUAL(file.CountCache(), 0);
+        UNIT_ASSERT_VALUES_EQUAL(file.CountCache(0, 0), 0);
 
-file.Resize(7);
-file.PrefetchCache();
-UNIT_ASSERT_VALUES_EQUAL(file.CountCache(), 7);
-UNIT_ASSERT_VALUES_EQUAL(file.CountCache(3, 2), 2);
+        file.Resize(7);
+        file.PrefetchCache();
+        UNIT_ASSERT_VALUES_EQUAL(file.CountCache(), 7);
+        UNIT_ASSERT_VALUES_EQUAL(file.CountCache(3, 2), 2);
 
-file.FlushCache();
-UNIT_ASSERT_VALUES_EQUAL(file.CountCache(), 7);
+        file.FlushCache();
+        UNIT_ASSERT_VALUES_EQUAL(file.CountCache(), 7);
 
-file.EvictCache();
-UNIT_ASSERT_VALUES_EQUAL(file.CountCache(), 0);
+        file.EvictCache();
+        UNIT_ASSERT_VALUES_EQUAL(file.CountCache(), 0);
 
-file.PrefetchCache();
-UNIT_ASSERT_VALUES_EQUAL(file.CountCache(), 7);
+        file.PrefetchCache();
+        UNIT_ASSERT_VALUES_EQUAL(file.CountCache(), 7);
 
-file.Resize(12345);
-UNIT_ASSERT_VALUES_EQUAL(file.CountCache(), 4096);
-UNIT_ASSERT_VALUES_EQUAL(file.CountCache(4096, 0), 0);
+        file.Resize(12345);
+        UNIT_ASSERT_VALUES_EQUAL(file.CountCache(), 4096);
+        UNIT_ASSERT_VALUES_EQUAL(file.CountCache(4096, 0), 0);
 
-file.PrefetchCache();
-UNIT_ASSERT_VALUES_EQUAL(file.CountCache(), 12345);
+        file.PrefetchCache();
+        UNIT_ASSERT_VALUES_EQUAL(file.CountCache(), 12345);
 
-file.FlushCache();
-file.EvictCache();
-UNIT_ASSERT_LE(file.CountCache(), 0);
+        file.FlushCache();
+        file.EvictCache();
+        UNIT_ASSERT_LE(file.CountCache(), 0);
 
-file.Resize(33333333);
-file.PrefetchCache(11111111, 11111111);
-UNIT_ASSERT_GE(file.CountCache(), 11111111);
+        file.Resize(33333333);
+        file.PrefetchCache(11111111, 11111111);
+        UNIT_ASSERT_GE(file.CountCache(), 11111111);
 
-UNIT_ASSERT_LE(file.CountCache(0, 11111111), 1111111);
-UNIT_ASSERT_VALUES_EQUAL(file.CountCache(11111111, 11111111), 11111111);
-UNIT_ASSERT_LE(file.CountCache(22222222, 11111111), 1111111);
+        UNIT_ASSERT_LE(file.CountCache(0, 11111111), 1111111);
+        UNIT_ASSERT_VALUES_EQUAL(file.CountCache(11111111, 11111111), 11111111);
+        UNIT_ASSERT_LE(file.CountCache(22222222, 11111111), 1111111);
 
-file.FlushCache(11111111, 11111111);
-UNIT_ASSERT_GE(file.CountCache(), 11111111);
+        file.FlushCache(11111111, 11111111);
+        UNIT_ASSERT_GE(file.CountCache(), 11111111);
 
-// first and last incomplete pages could stay in cache
-file.EvictCache(11111111, 11111111);
-UNIT_ASSERT_LT(file.CountCache(11111111, 11111111), 4096 * 2);
+        // first and last incomplete pages could stay in cache
+        file.EvictCache(11111111, 11111111);
+        UNIT_ASSERT_LT(file.CountCache(11111111, 11111111), 4096 * 2);
 
-file.EvictCache();
-UNIT_ASSERT_VALUES_EQUAL(file.CountCache(), 0);
-}
+        file.EvictCache();
+        UNIT_ASSERT_VALUES_EQUAL(file.CountCache(), 0);
+    }
 #else
-    {TFile file(MakeTempName(), OpenAlways | Transient | RdWr);
+    {
+        TFile file(MakeTempName(), OpenAlways | Transient | RdWr);
 
-file.Resize(12345);
+        file.Resize(12345);
 
-UNIT_ASSERT_VALUES_EQUAL(file.CountCache(), -1);
-file.PrefetchCache();
-file.FlushCache();
-file.EvictCache();
-UNIT_ASSERT_VALUES_EQUAL(file.CountCache(0, 12345), -1);
-}
+        UNIT_ASSERT_VALUES_EQUAL(file.CountCache(), -1);
+        file.PrefetchCache();
+        file.FlushCache();
+        file.EvictCache();
+        UNIT_ASSERT_VALUES_EQUAL(file.CountCache(0, 12345), -1);
+    }
 #endif
 }
 
+Y_UNIT_TEST_SUITE(TTestFileHandle) {
+    Y_UNIT_TEST(MoveAssignment) {
+        TTempFile tmp("tmp");
+        {
+            TFileHandle file1(tmp.Name(), OpenAlways | WrOnly);
+            file1.Write("1", 1);
+
+            TFileHandle file2;
+            file2 = std::move(file1);
+            Y_ENSURE(!file1.IsOpen());
+            Y_ENSURE(file2.IsOpen());
+
+            file2.Write("2", 1);
+        }
+
+        {
+            TFileHandle file(tmp.Name(), OpenExisting | RdOnly);
+            char buf[2];
+            Y_ENSURE(file.Read(buf, 2) == 2);
+            Y_ENSURE(TStringBuf(buf, 2) == "12");
+        }
+    }
+} // Y_UNIT_TEST_SUITE(TTestFileHandle)
+
 Y_UNIT_TEST_SUITE(TTestDecodeOpenMode) {
     Y_UNIT_TEST(It) {
         UNIT_ASSERT_VALUES_EQUAL("0", DecodeOpenMode(0));
@@ -413,4 +438,4 @@ Y_UNIT_TEST_SUITE(TTestDecodeOpenMode) {
         UNIT_ASSERT_VALUES_EQUAL("WrOnly|ForAppend", DecodeOpenMode(WrOnly | ForAppend));
         UNIT_ASSERT_VALUES_EQUAL("RdWr|CreateAlways|CreateNew|ForAppend|Transient|CloseOnExec|Temp|Sync|Direct|DirectAligned|Seq|NoReuse|NoReadAhead|AX|AR|AW|AWOther|0xF8888000", DecodeOpenMode(0xFFFFFFFF));
     }
-}
+} // Y_UNIT_TEST_SUITE(TTestDecodeOpenMode)
diff --git a/util/system/filemap.cpp b/util/system/filemap.cpp
index 8e25d84928e..10706ca4e1d 100644
--- a/util/system/filemap.cpp
+++ b/util/system/filemap.cpp
@@ -37,7 +37,7 @@
 #undef GRANULARITY
 
 #ifdef _win_
-    #define MAP_FAILED ((void*)(LONG_PTR)-1)
+    #define MAP_FAILED ((void*)(LONG_PTR) - 1)
 #endif
 
 namespace {
@@ -65,7 +65,7 @@ namespace {
         const size_t GRANULARITY_;
         const size_t PAGE_SIZE_;
     };
-}
+} // namespace
 
 #define GRANULARITY (TSysInfo::Instance().GRANULARITY_)
 #define PAGE_SIZE (TSysInfo::Instance().PAGE_SIZE_)
@@ -246,7 +246,7 @@ class TMemoryMap::TImpl: public TAtomicRefCount<TImpl> {
     #endif
             result.Ptr = mmap((caddr_t) nullptr, size, ModeToMmapProt(Mode_), ModeToMmapFlags(Mode_), File_.GetHandle(), base);
 
-            if (result.Ptr == (char*)(-1)) {
+            if (result.Ptr == MAP_FAILED) {
                 result.Ptr = nullptr;
             }
     #if defined(_unix_)
@@ -300,7 +300,7 @@ class TMemoryMap::TImpl: public TAtomicRefCount<TImpl> {
 
     void Evict() {
 #if defined(_unix_)
-//        Evict(PtrStart_, Length_);
+// Evict(PtrStart_, Length_);
 #endif
     }
 
diff --git a/util/system/filemap.h b/util/system/filemap.h
index 933d169adb7..200774593b3 100644
--- a/util/system/filemap.h
+++ b/util/system/filemap.h
@@ -17,7 +17,7 @@
 namespace NPrivate {
     // NB: use TFileMap::Precharge() and TFileMappedArray::Prechage()
     void Precharge(const void* data, size_t dataSize, size_t offset, size_t size);
-}
+} // namespace NPrivate
 
 struct TMemoryMapCommon {
     struct TMapResult {
@@ -233,8 +233,9 @@ class TFileMappedArray {
         return Size_;
     }
     const T& GetAt(size_t pos) const {
-        if (pos < Size_)
+        if (pos < Size_) {
             return Ptr_[pos];
+        }
         return Dummy();
     }
     void SetDummy(const T& n_Dummy) {
@@ -334,8 +335,9 @@ class TMappedArray: private TMappedAllocation {
     TMappedArray(size_t siz = 0)
         : TMappedAllocation(0)
     {
-        if (siz)
+        if (siz) {
             Create(siz);
+        }
     }
     ~TMappedArray() {
         Destroy();
@@ -343,18 +345,21 @@ class TMappedArray: private TMappedAllocation {
     T* Create(size_t siz) {
         Y_ASSERT(MappedSize() == 0 && Ptr() == nullptr);
         T* arr = (T*)Alloc((sizeof(T) * siz));
-        if (!arr)
+        if (!arr) {
             return nullptr;
+        }
         Y_ASSERT(MappedSize() == sizeof(T) * siz);
-        for (size_t n = 0; n < siz; n++)
+        for (size_t n = 0; n < siz; n++) {
             new (&arr[n]) T();
+        }
         return arr;
     }
     void Destroy() {
         T* arr = (T*)Ptr();
         if (arr) {
-            for (size_t n = 0; n < size(); n++)
+            for (size_t n = 0; n < size(); n++) {
                 arr[n].~T();
+            }
             Dealloc();
         }
     }
diff --git a/util/system/filemap_ut.cpp b/util/system/filemap_ut.cpp
index 1305e34995b..58a37ecbf9f 100644
--- a/util/system/filemap_ut.cpp
+++ b/util/system/filemap_ut.cpp
@@ -127,9 +127,9 @@ Y_UNIT_TEST_SUITE(TFileMapTest) {
     }
 
 #if defined(_asan_enabled_) || defined(_msan_enabled_)
-//setrlimit incompatible with asan runtime
+// setrlimit incompatible with asan runtime
 #elif defined(_cygwin_)
-//cygwin is not real unix :(
+// cygwin is not real unix :(
 #else
     Y_UNIT_TEST(TestNotGreedy) {
         unsigned page[4096 / sizeof(unsigned)];
@@ -356,4 +356,4 @@ Y_UNIT_TEST_SUITE(TFileMapTest) {
         }
         NFs::Remove(FileName_);
     }
-}
+} // Y_UNIT_TEST_SUITE(TFileMapTest)
diff --git a/util/system/flock.h b/util/system/flock.h
index 797b1970a1f..a3695fde70c 100644
--- a/util/system/flock.h
+++ b/util/system/flock.h
@@ -2,7 +2,6 @@
 
 #include "error.h"
 #include "defaults.h"
-#include "file.h"
 
 #if defined(_unix_)
 
diff --git a/util/system/flock_ut.cpp b/util/system/flock_ut.cpp
index b5f6cb53287..21737e35bed 100644
--- a/util/system/flock_ut.cpp
+++ b/util/system/flock_ut.cpp
@@ -54,4 +54,4 @@ Y_UNIT_TEST_SUITE(TFileLockTest) {
             UNIT_ASSERT(guard3.WasAcquired());
         }
     }
-}
+} // Y_UNIT_TEST_SUITE(TFileLockTest)
diff --git a/util/system/fs.cpp b/util/system/fs.cpp
index 808bc0b7b6a..0e5ffe4e415 100644
--- a/util/system/fs.cpp
+++ b/util/system/fs.cpp
@@ -88,7 +88,7 @@ bool NFs::MakeDirectoryRecursive(const TString& path, EFilePermissions mode, boo
         }
         return true;
     } else {
-        //NOTE: recursion is finite due to existence of "." and "/"
+        // NOTE: recursion is finite due to existence of "." and "/"
         if (!NFs::MakeDirectoryRecursive(TFsPath(path).Parent(), mode, false)) {
             return false;
         }
diff --git a/util/system/fs.h b/util/system/fs.h
index f4ab746aa36..71078af78eb 100644
--- a/util/system/fs.h
+++ b/util/system/fs.h
@@ -159,6 +159,6 @@ namespace NFs {
         Y_ENSURE_EX(Exists(path), TFileError{} << "Path " << path << " does not exists (checked from cwd:" << NFs::CurrentWorkingDirectory() << ")");
         return path;
     }
-}
+} // namespace NFs
 
 Y_DECLARE_OPERATORS_FOR_FLAGS(NFs::EFilePermissions);
diff --git a/util/system/fs_ut.cpp b/util/system/fs_ut.cpp
index ddee6670a8a..2df9a3b2a42 100644
--- a/util/system/fs_ut.cpp
+++ b/util/system/fs_ut.cpp
@@ -6,7 +6,7 @@
 #include "fstat.h"
 #include <util/folder/path.h>
 
-//WARNING: on windows the test must be run with administative rules
+// WARNING: on windows the test must be run with administative rules
 
 class TFsTest: public TTestBase {
     UNIT_TEST_SUITE(TFsTest);
@@ -45,7 +45,7 @@ void TFsTest::TestCreateRemove() {
 
     UNIT_ASSERT(NFs::Exists(dir1));
     TFsPath subdir1 = dir1 / "a" / "b";
-    //TFsPath link = dir1 / "link";
+    // TFsPath link = dir1 / "link";
 
     UNIT_ASSERT(NFs::MakeDirectoryRecursive(subdir1, NFs::FP_COMMON_FILE, true));
     UNIT_ASSERT(NFs::Exists(subdir1));
@@ -59,7 +59,7 @@ void TFsTest::TestCreateRemove() {
     Touch(file1);
     Touch(file2);
     Touch(file3);
-    //UNIT_ASSERT(NFs::SymLink(file3.RealPath(), link));
+    // UNIT_ASSERT(NFs::SymLink(file3.RealPath(), link));
 
     UNIT_ASSERT(NFs::MakeDirectoryRecursive(dir1 / "subdir1" / "subdir2" / "subdir3" / "subdir4", NFs::FP_COMMON_FILE, false));
     UNIT_ASSERT(NFs::MakeDirectoryRecursive(dir1 / "subdir1" / "subdir2", NFs::FP_COMMON_FILE, false));
@@ -80,7 +80,7 @@ void TFsTest::TestCreateRemove() {
     UNIT_ASSERT(NFs::Exists(file1));
     UNIT_ASSERT(NFs::Exists(file2));
     UNIT_ASSERT(NFs::Exists(file3));
-    //UNIT_ASSERT(NFs::Exists(link));
+    // UNIT_ASSERT(NFs::Exists(link));
 
     UNIT_ASSERT(!NFs::Remove(dir1));
     NFs::RemoveRecursive(dir1);
@@ -88,7 +88,7 @@ void TFsTest::TestCreateRemove() {
     UNIT_ASSERT(!NFs::Exists(file1));
     UNIT_ASSERT(!NFs::Exists(file2));
     UNIT_ASSERT(!NFs::Exists(file3));
-    //UNIT_ASSERT(!NFs::Exists(link));
+    // UNIT_ASSERT(!NFs::Exists(link));
     UNIT_ASSERT(!NFs::Exists(subdir1));
     UNIT_ASSERT(!NFs::Exists(longfile));
     UNIT_ASSERT(!NFs::Exists(dir1));
@@ -186,7 +186,7 @@ static void RunHardlinkTest(const TFsPath& src, const TFsPath& dst) {
 
 void TFsTest::TestHardlink() {
     RunHardlinkTest("tempfile", "hardlinkfile");
-    RunHardlinkTest("tempfile_абвг", "hardlinkfile_абвг"); //utf-8 names
+    RunHardlinkTest("tempfile_абвг", "hardlinkfile_абвг"); // utf-8 names
 }
 
 static void RunSymLinkTest(TString fileLocalName, TString symLinkName) {
@@ -240,7 +240,7 @@ static void RunSymLinkTest(TString fileLocalName, TString symLinkName) {
     {
         TFileStat fs(linkD1, true);
         UNIT_ASSERT(!fs.IsFile());
-        //UNIT_ASSERT(fs.IsDir()); // failed on unix
+        // UNIT_ASSERT(fs.IsDir()); // failed on unix
         UNIT_ASSERT(fs.IsSymlink());
     }
     {
@@ -253,7 +253,7 @@ static void RunSymLinkTest(TString fileLocalName, TString symLinkName) {
 
     {
         TFileStat fs(symLinkName, true);
-        //UNIT_ASSERT(fs.IsFile()); // no evidence that symlink has to be a file as well
+        // UNIT_ASSERT(fs.IsFile()); // no evidence that symlink has to be a file as well
         UNIT_ASSERT(!fs.IsDir());
         UNIT_ASSERT(fs.IsSymlink());
     }
@@ -277,7 +277,7 @@ static void RunSymLinkTest(TString fileLocalName, TString symLinkName) {
 void TFsTest::TestSymlink() {
     // if previous running was failed
     RunSymLinkTest("f.txt", "fl.txt");
-    RunSymLinkTest("f_абвг.txt", "fl_абвг.txt"); //utf-8 names
+    RunSymLinkTest("f_абвг.txt", "fl_абвг.txt"); // utf-8 names
 }
 
 void TFsTest::TestCwdOpts() {
diff --git a/util/system/fs_win.cpp b/util/system/fs_win.cpp
index 16a87ff3853..65e695bee44 100644
--- a/util/system/fs_win.cpp
+++ b/util/system/fs_win.cpp
@@ -12,8 +12,9 @@ namespace NFsPrivate {
     static LPCWSTR UTF8ToWCHAR(const TStringBuf str, TUtf16String& wstr) {
         wstr.resize(str.size());
         size_t written = 0;
-        if (!UTF8ToWide(str.data(), str.size(), wstr.begin(), written))
+        if (!UTF8ToWide(str.data(), str.size(), wstr.begin(), written)) {
             return nullptr;
+        }
         wstr.erase(written);
         static_assert(sizeof(WCHAR) == sizeof(wchar16), "expect sizeof(WCHAR) == sizeof(wchar16)");
         return (const WCHAR*)wstr.data();
@@ -64,8 +65,9 @@ namespace NFsPrivate {
                 fad.dwFileAttributes = FILE_ATTRIBUTE_NORMAL;
                 ::SetFileAttributesW(wname, fad.dwFileAttributes);
             }
-            if (fad.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
+            if (fad.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
                 return ::RemoveDirectoryW(wname) != 0;
+            }
             return ::DeleteFileW(wname) != 0;
         }
 
@@ -76,8 +78,9 @@ namespace NFsPrivate {
         TString tName(targetName);
         {
             size_t pos;
-            while ((pos = tName.find('/')) != TString::npos)
+            while ((pos = tName.find('/')) != TString::npos) {
                 tName.replace(pos, 1, LOCSLASH_S);
+            }
         }
         TUtf16String tstr;
         LPCWSTR wname = UTF8ToWCHAR(tName, tstr);
@@ -127,8 +130,9 @@ namespace NFsPrivate {
         TTempBuf result;
         LPWSTR buf = reinterpret_cast<LPWSTR>(result.Data());
         int r = GetCurrentDirectoryW(result.Size() / sizeof(WCHAR), buf);
-        if (r == 0)
+        if (r == 0) {
             throw TIoSystemError() << "failed to GetCurrentDirectory";
+        }
         return WCHARToUTF8(buf, r);
     }
 
@@ -225,7 +229,7 @@ namespace NFsPrivate {
             size_t len = rdb->MountPointReparseBuffer.SubstituteNameLength / sizeof(wchar16);
             return WideToUTF8(str, len);
         }
-        //this reparse point is unsupported in arcadia
+        // this reparse point is unsupported in arcadia
         return TString();
     }
 
@@ -236,7 +240,7 @@ namespace NFsPrivate {
     }
 
     // we can't use this function to get an analog of unix inode due to a lot of NTFS folders do not have this GUID
-    //(it will be 'create' case really)
+    // (it will be 'create' case really)
     /*
 bool GetObjectId(const char* path, GUID* id) {
     TFileHandle h = CreateFileWithUtf8Name(path, 0, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
@@ -255,4 +259,4 @@ bool GetObjectId(const char* path, GUID* id) {
 }
 */
 
-}
+} // namespace NFsPrivate
diff --git a/util/system/fs_win.h b/util/system/fs_win.h
index b91f8691060..e46f7a2fda0 100644
--- a/util/system/fs_win.h
+++ b/util/system/fs_win.h
@@ -28,4 +28,4 @@ namespace NFsPrivate {
     bool WinSetCurrentWorkingDirectory(const TString& path);
 
     bool WinMakeDirectory(const TString& path);
-}
+} // namespace NFsPrivate
diff --git a/util/system/fs_win_ut.cpp b/util/system/fs_win_ut.cpp
index 46a8c5f2b0c..ce9c0d86e5f 100644
--- a/util/system/fs_win_ut.cpp
+++ b/util/system/fs_win_ut.cpp
@@ -20,8 +20,9 @@ static void Touch(const TFsPath& path) {
 static LPCWSTR UTF8ToWCHAR(const TStringBuf str, TUtf16String& wstr) {
     wstr.resize(str.size());
     size_t written = 0;
-    if (!UTF8ToWide(str.data(), str.size(), wstr.begin(), written))
+    if (!UTF8ToWide(str.data(), str.size(), wstr.begin(), written)) {
         return nullptr;
+    }
     wstr.erase(written);
     static_assert(sizeof(WCHAR) == sizeof(wchar16), "expect sizeof(WCHAR) == sizeof(wchar16)");
     return (const WCHAR*)wstr.data();
@@ -68,4 +69,4 @@ Y_UNIT_TEST_SUITE(TFsWinTest) {
         NFsPrivate::WinRemove(dir1);
         UNIT_ASSERT(!NFsPrivate::WinExists(dir1));
     }
-}
+} // Y_UNIT_TEST_SUITE(TFsWinTest)
diff --git a/util/system/fstat.cpp b/util/system/fstat.cpp
index cfc5bed3231..55d95463cf0 100644
--- a/util/system/fstat.cpp
+++ b/util/system/fstat.cpp
@@ -44,8 +44,9 @@ static ui32 GetWinFileType(DWORD fileAttributes, ULONG reparseTag) {
 
 static ui32 GetFileMode(DWORD fileAttributes, ULONG reparseTag) {
     ui32 mode = 0;
-    if (fileAttributes == 0xFFFFFFFF)
+    if (fileAttributes == 0xFFFFFFFF) {
         return mode;
+    }
 
     mode |= GetWinFileType(fileAttributes, reparseTag);
 
@@ -229,8 +230,9 @@ bool TFileStat::IsSymlink() const noexcept {
 i64 GetFileLength(FHANDLE fd) {
 #if defined(_win_)
     LARGE_INTEGER pos;
-    if (!::GetFileSizeEx(fd, &pos))
+    if (!::GetFileSizeEx(fd, &pos)) {
         return -1L;
+    }
     return pos.QuadPart;
 #elif defined(_unix_)
     struct stat statbuf;
@@ -252,8 +254,9 @@ i64 GetFileLength(const char* name) {
 #if defined(_win_)
     WIN32_FIND_DATA fData;
     HANDLE h = FindFirstFileA(name, &fData);
-    if (h == INVALID_HANDLE_VALUE)
+    if (h == INVALID_HANDLE_VALUE) {
         return -1;
+    }
     FindClose(h);
     return (((i64)fData.nFileSizeHigh) * (i64(MAXDWORD) + 1)) + (i64)fData.nFileSizeLow;
 #elif defined(_unix_)
diff --git a/util/system/fstat_ut.cpp b/util/system/fstat_ut.cpp
index 300f76d7e64..8cdd8d169a9 100644
--- a/util/system/fstat_ut.cpp
+++ b/util/system/fstat_ut.cpp
@@ -52,7 +52,7 @@ Y_UNIT_TEST_SUITE(TestFileStat) {
         UNIT_ASSERT(!fs.IsFile());
         UNIT_ASSERT(fs.IsDir());
         UNIT_ASSERT(!fs.IsSymlink());
-        //UNIT_ASSERT(fs.Size == 0); // it fails under unix
+        // UNIT_ASSERT(fs.Size == 0); // it fails under unix
         UNIT_ASSERT(NFs::Remove("tmpd"));
         fs = TFileStat("tmpd");
         UNIT_ASSERT(!fs.IsFile());
@@ -225,4 +225,4 @@ Y_UNIT_TEST_SUITE(TestFileStat) {
         UNIT_ASSERT(!stat.IsNull());
     }
 #endif
-}
+} // Y_UNIT_TEST_SUITE(TestFileStat)
diff --git a/util/system/guard.h b/util/system/guard.h
index b6ca45fff67..2b4192c01a8 100644
--- a/util/system/guard.h
+++ b/util/system/guard.h
@@ -21,7 +21,7 @@ struct TTryLockOps: public TCommonLockOps<T> {
     }
 };
 
-//must be used with great care
+// must be used with great care
 template <class TOps>
 struct TInverseLockOps: public TOps {
     template <class T>
diff --git a/util/system/hi_lo.h b/util/system/hi_lo.h
index f86870534fb..07bcd4c57bd 100644
--- a/util/system/hi_lo.h
+++ b/util/system/hi_lo.h
@@ -106,7 +106,7 @@ namespace NHiLoPrivate {
 
         return MakeIntRef<TRepr>(CharPtrOf(std::forward<T>(value)) + offset);
     }
-}
+} // namespace NHiLoPrivate
 
 /**
  * Return manipulator object that allows to get and set lower or higher bits of the value.
diff --git a/util/system/hi_lo_ut.cpp b/util/system/hi_lo_ut.cpp
index 850c12327db..d36b17e69a1 100644
--- a/util/system/hi_lo_ut.cpp
+++ b/util/system/hi_lo_ut.cpp
@@ -66,4 +66,4 @@ Y_UNIT_TEST_SUITE(HiLo) {
         UNIT_ASSERT_VALUES_EQUAL(Lo32(x).Get(), 0x55667788);
         UNIT_ASSERT_VALUES_EQUAL(Hi32(x).Get(), 0x11223344);
     }
-}
+} // Y_UNIT_TEST_SUITE(HiLo)
diff --git a/util/system/hostname.cpp b/util/system/hostname.cpp
index e377910d5cd..cf9343f3eb2 100644
--- a/util/system/hostname.cpp
+++ b/util/system/hostname.cpp
@@ -81,7 +81,7 @@ namespace {
 
         TString FQDNHostName;
     };
-}
+} // namespace
 
 const TString& HostName() {
     return (Singleton<THostNameHolder>())->HostName;
diff --git a/util/system/hostname_ut.cpp b/util/system/hostname_ut.cpp
index 7e0da106b6e..6f043e964f4 100644
--- a/util/system/hostname_ut.cpp
+++ b/util/system/hostname_ut.cpp
@@ -22,4 +22,4 @@ Y_UNIT_TEST_SUITE(THostNameTest) {
             throw;
         }
     }
-}
+} // Y_UNIT_TEST_SUITE(THostNameTest)
diff --git a/util/system/hp_timer.cpp b/util/system/hp_timer.cpp
index e4c3f21e6b4..e80eb13f35f 100644
--- a/util/system/hp_timer.cpp
+++ b/util/system/hp_timer.cpp
@@ -91,7 +91,7 @@ namespace {
         const double Rate;
         const ui64 CyclesPerSecond;
     };
-}
+} // namespace
 
 double NHPTimer::GetSeconds(const STime& a) noexcept {
     return TFreq::Instance().GetSeconds(a);
diff --git a/util/system/hp_timer.h b/util/system/hp_timer.h
index 0a4c252ec26..0a1aee48fbb 100644
--- a/util/system/hp_timer.h
+++ b/util/system/hp_timer.h
@@ -14,7 +14,7 @@ namespace NHPTimer {
     double GetClockRate() noexcept;
     // same as GetClockRate, but in integer
     ui64 GetCyclesPerSecond() noexcept;
-}
+} // namespace NHPTimer
 
 struct THPTimer {
     THPTimer() noexcept {
diff --git a/util/system/info.cpp b/util/system/info.cpp
index 59a8ab0e0b7..c6030c1cd88 100644
--- a/util/system/info.cpp
+++ b/util/system/info.cpp
@@ -3,6 +3,7 @@
 #include "error.h"
 #include "fs.h"
 
+#include <atomic>
 #include <cmath>
 #include <cstdlib>
 
@@ -19,7 +20,7 @@
 #endif
 
 #if defined(_bionic_)
-//TODO
+// TODO
 #elif defined(_cygwin_)
 static int getloadavg(double* loadavg, int nelem) {
     for (int i = 0; i < nelem; ++i) {
@@ -234,23 +235,27 @@ size_t NSystemInfo::LoadAverage(double* la, size_t len) {
     return (size_t)ret;
 }
 
-static size_t NCpus;
-static size_t NMillicores;
+static std::atomic<size_t> NCpus{0};
+static std::atomic<size_t> NMillicores{0};
 
 size_t NSystemInfo::CachedNumberOfCpus() {
-    if (!NCpus) {
-        NCpus = NumberOfCpus();
+    auto ncpus_snapshot = NCpus.load();
+    if (!ncpus_snapshot) {
+        ncpus_snapshot = NumberOfCpus();
+        NCpus = ncpus_snapshot;
     }
 
-    return NCpus;
+    return ncpus_snapshot;
 }
 
 size_t NSystemInfo::CachedNumberOfMillicores() {
-    if (!NMillicores) {
-        NMillicores = NumberOfMillicores();
+    auto nmillicores_snapshot = NMillicores.load();
+    if (!nmillicores_snapshot) {
+        nmillicores_snapshot = NumberOfMillicores();
+        NMillicores = nmillicores_snapshot;
     }
 
-    return NMillicores;
+    return nmillicores_snapshot;
 }
 
 size_t NSystemInfo::GetPageSize() noexcept {
diff --git a/util/system/info.h b/util/system/info.h
index 9e6fa2fb3da..f30d71a1881 100644
--- a/util/system/info.h
+++ b/util/system/info.h
@@ -11,4 +11,4 @@ namespace NSystemInfo {
     size_t GetPageSize() noexcept;
     size_t TotalMemorySize();
     size_t MaxOpenFiles();
-}
+} // namespace NSystemInfo
diff --git a/util/system/interrupt_signals_ut.cpp b/util/system/interrupt_signals_ut.cpp
index 2a7f0bddd7d..d5f0279413f 100644
--- a/util/system/interrupt_signals_ut.cpp
+++ b/util/system/interrupt_signals_ut.cpp
@@ -43,4 +43,4 @@ Y_UNIT_TEST_SUITE(TTestInterruptSignals) {
             UNIT_ASSERT_VALUES_EQUAL(HandledSigNum.load(), signum);
         }
     }
-}
+} // Y_UNIT_TEST_SUITE(TTestInterruptSignals)
diff --git a/util/system/madvise.cpp b/util/system/madvise.cpp
index ad24ac0f1de..3f045f24cfe 100644
--- a/util/system/madvise.cpp
+++ b/util/system/madvise.cpp
@@ -40,7 +40,7 @@ namespace {
         }
 #endif
     }
-}
+} // namespace
 
 void MadviseSequentialAccess(const void* begin, size_t size) {
 #if !defined(_win_)
diff --git a/util/system/mem_info.cpp b/util/system/mem_info.cpp
index 90ed353a59d..e910dd747f5 100644
--- a/util/system/mem_info.cpp
+++ b/util/system/mem_info.cpp
@@ -5,6 +5,7 @@
 #include <util/string/cast.h>
 #include <util/string/builder.h>
 #include "error.h"
+#include "getpid.h"
 #include "info.h"
 
 #if defined(_unix_)
@@ -119,10 +120,13 @@ namespace NMemInfo {
         result.RSS = FromString<ui64>(statsiter.NextTok(' ')) * pagesize;
 
         #if defined(_cygwin_)
-        //cygwin not very accurate
+        // cygwin not very accurate
         result.VMS = Max(result.VMS, result.RSS);
         #endif
     #elif defined(_freebsd_)
+        if (pid == 0) {
+            pid = GetPID();
+        }
         int mib[4] = {CTL_KERN, KERN_PROC, KERN_PROC_PID, pid};
         size_t size = sizeof(struct kinfo_proc);
 
@@ -212,4 +216,4 @@ namespace NMemInfo {
 #endif
         return result;
     }
-}
+} // namespace NMemInfo
diff --git a/util/system/mem_info.h b/util/system/mem_info.h
index f303d491970..c44b86e2083 100644
--- a/util/system/mem_info.h
+++ b/util/system/mem_info.h
@@ -15,4 +15,4 @@ namespace NMemInfo {
     };
 
     TMemInfo GetMemInfo(pid_t = 0);
-}
+} // namespace NMemInfo
diff --git a/util/system/mincore.h b/util/system/mincore.h
index 0f5d8b78c7d..a0db6b35ee6 100644
--- a/util/system/mincore.h
+++ b/util/system/mincore.h
@@ -25,7 +25,7 @@ void InCoreMemory(const void* addr, size_t len, unsigned char* vec, size_t vecLe
 /**
  * Takes as an argument an element of the vector previously filled by InCoreMemory.
  *
- * @param[in]           byte corresponding to the status of a single page
+ * @param[in] s         byte corresponding to the status of a single page
  *
  * @returns             true if this page was resident in memory at the time out the InCoreMemory execution
  */
diff --git a/util/system/mincore_ut.cpp b/util/system/mincore_ut.cpp
index ae4a10c517c..27c342d57fa 100644
--- a/util/system/mincore_ut.cpp
+++ b/util/system/mincore_ut.cpp
@@ -36,4 +36,4 @@ Y_UNIT_TEST_SUITE(MincoreSuite) {
         }
 #endif
     }
-}
+} // Y_UNIT_TEST_SUITE(MincoreSuite)
diff --git a/util/system/mktemp_ut.cpp b/util/system/mktemp_ut.cpp
index 19bcf708525..38eab941c74 100644
--- a/util/system/mktemp_ut.cpp
+++ b/util/system/mktemp_ut.cpp
@@ -38,4 +38,4 @@ Y_UNIT_TEST_SUITE(MakeTempFileSuite) {
             UNIT_ASSERT(TFsPath{tempFilePath}.Exists());
         }
     }
-}
+} // Y_UNIT_TEST_SUITE(MakeTempFileSuite)
diff --git a/util/system/mlock.cpp b/util/system/mlock.cpp
index 27895bbacc4..3205e188a8e 100644
--- a/util/system/mlock.cpp
+++ b/util/system/mlock.cpp
@@ -34,12 +34,15 @@ void LockMemory(const void* addr, size_t len) {
 #elif defined(_win_)
     HANDLE hndl = GetCurrentProcess();
     SIZE_T min, max;
-    if (!GetProcessWorkingSetSize(hndl, &min, &max))
+    if (!GetProcessWorkingSetSize(hndl, &min, &max)) {
         ythrow yexception() << LastSystemErrorText();
-    if (!SetProcessWorkingSetSize(hndl, min + len, max + len))
+    }
+    if (!SetProcessWorkingSetSize(hndl, min + len, max + len)) {
         ythrow yexception() << LastSystemErrorText();
-    if (!VirtualLock((LPVOID)addr, len))
+    }
+    if (!VirtualLock((LPVOID)addr, len)) {
         ythrow yexception() << LastSystemErrorText();
+    }
 #endif
 }
 
@@ -58,12 +61,15 @@ void UnlockMemory(const void* addr, size_t len) {
 #elif defined(_win_)
     HANDLE hndl = GetCurrentProcess();
     SIZE_T min, max;
-    if (!GetProcessWorkingSetSize(hndl, &min, &max))
+    if (!GetProcessWorkingSetSize(hndl, &min, &max)) {
         ythrow yexception() << LastSystemErrorText();
-    if (!SetProcessWorkingSetSize(hndl, min - len, max - len))
+    }
+    if (!SetProcessWorkingSetSize(hndl, min - len, max - len)) {
         ythrow yexception() << LastSystemErrorText();
-    if (!VirtualUnlock((LPVOID)addr, len))
+    }
+    if (!VirtualUnlock((LPVOID)addr, len)) {
         ythrow yexception() << LastSystemErrorText();
+    }
 #endif
 }
 
diff --git a/util/system/mlock.h b/util/system/mlock.h
index 41a9e4457e0..7fe36095f9a 100644
--- a/util/system/mlock.h
+++ b/util/system/mlock.h
@@ -4,11 +4,11 @@
 
 #include <util/generic/flags.h>
 
-//on some systems (not win, freebd, linux, but darwin (Mac OS X)
-//multiple mlock calls on the same address range
-//require the corresponding number of munlock calls to actually unlock the pages
+// on some systems (not win, freebd, linux, but darwin (Mac OS X)
+// multiple mlock calls on the same address range
+// require the corresponding number of munlock calls to actually unlock the pages
 
-//on some systems you must have privilege and resource limit
+// on some systems you must have privilege and resource limit
 
 void LockMemory(const void* addr, size_t len);
 void UnlockMemory(const void* addr, size_t len);
diff --git a/util/system/mutex.h b/util/system/mutex.h
index 2899ed9a50b..b7e4d0d9cc6 100644
--- a/util/system/mutex.h
+++ b/util/system/mutex.h
@@ -6,7 +6,7 @@
 #include <util/generic/ptr.h>
 #include <util/generic/noncopyable.h>
 
-class TFakeMutex: public TNonCopyable {
+class TFakeMutex: public TMoveOnly {
 public:
     inline void Acquire() noexcept {
     }
@@ -29,11 +29,9 @@ class TFakeMutex: public TNonCopyable {
     inline void unlock() noexcept {
         Release();
     }
-
-    ~TFakeMutex() = default;
 };
 
-class TMutex {
+class TMutex: public TMoveOnly {
 public:
     TMutex();
     TMutex(TMutex&&) noexcept;
@@ -55,7 +53,7 @@ class TMutex {
         Release();
     }
 
-    //return opaque pointer to real handler
+    // return opaque pointer to real handler
     void* Handle() const noexcept;
 
 private:
diff --git a/util/system/nice_ut.cpp b/util/system/nice_ut.cpp
index ae0051f285a..ae0d9c04aec 100644
--- a/util/system/nice_ut.cpp
+++ b/util/system/nice_ut.cpp
@@ -39,4 +39,4 @@ Y_UNIT_TEST_SUITE(NiceTest) {
         UNIT_ASSERT_VALUES_EQUAL(GetPriority(), prio + 3);
     }
 #endif
-}
+} // Y_UNIT_TEST_SUITE(NiceTest)
diff --git a/util/system/pipe.h b/util/system/pipe.h
index 75d03600492..1bf8f9082a9 100644
--- a/util/system/pipe.h
+++ b/util/system/pipe.h
@@ -2,7 +2,7 @@
 
 #ifdef __GNUC__
     #pragma GCC diagnostic push
-    #pragma GCC diagnostic ignored "-Warray-bounds" //need because of bug in gcc4.9.2
+    #pragma GCC diagnostic ignored "-Warray-bounds" // need because of bug in gcc4.9.2
 #endif
 
 #include "defaults.h"
diff --git a/util/system/pipe_ut.cpp b/util/system/pipe_ut.cpp
index 6d53432de8d..d6b61e10ced 100644
--- a/util/system/pipe_ut.cpp
+++ b/util/system/pipe_ut.cpp
@@ -12,4 +12,4 @@ Y_UNIT_TEST_SUITE(TPipeTest) {
         UNIT_ASSERT(1 == r.Read(&c, 1));
         UNIT_ASSERT_VALUES_EQUAL('a', c);
     }
-}
+} // Y_UNIT_TEST_SUITE(TPipeTest)
diff --git a/util/system/platform.h b/util/system/platform.h
index e99f3b78281..d2f1fec9b36 100644
--- a/util/system/platform.h
+++ b/util/system/platform.h
@@ -11,6 +11,12 @@
     #define _win32_
 #elif defined(__WIN32__) || defined(_WIN32) // _WIN32 is also defined by the 64-bit compiler for backward compatibility
     #define _win32_
+#elif defined(__FREERTOS__)
+    #define _freertos_
+    #define _rtos_
+#elif defined(__ZEPHYR__)
+    #define _zephyr_
+    #define _rtos_
 #else
     #define _unix_
 
@@ -115,7 +121,11 @@
     #define _wasm64_
 #endif
 
-#if !defined(sparc) && !defined(__sparc) && !defined(__hpux__) && !defined(__alpha__) && !defined(_ia64_) && !defined(_x86_64_) && !defined(_arm_) && !defined(_i386_) && !defined(_ppc_) && !defined(_ppc64_) && !defined(_wasm64_)
+#if defined(__wasm32__)
+    #define _wasm32_
+#endif
+
+#if !defined(sparc) && !defined(__sparc) && !defined(__hpux__) && !defined(__alpha__) && !defined(_ia64_) && !defined(_x86_64_) && !defined(_arm_) && !defined(_i386_) && !defined(_ppc_) && !defined(_ppc64_) && !defined(_wasm64_) && !defined(_wasm32_) && !defined(__riscv)
     #error "platform not defined, please, define one"
 #endif
 
@@ -138,51 +148,51 @@
     #define _console_
 #endif
 
-#if defined(__SSE__) || defined(SSE_ENABLED)
+#if defined(__SSE__)
     #define _sse_
 #endif
 
-#if defined(__SSE2__) || defined(SSE2_ENABLED)
+#if defined(__SSE2__)
     #define _sse2_
 #endif
 
-#if defined(__SSE3__) || defined(SSE3_ENABLED)
+#if defined(__SSE3__)
     #define _sse3_
 #endif
 
-#if defined(__SSSE3__) || defined(SSSE3_ENABLED)
+#if defined(__SSSE3__)
     #define _ssse3_
 #endif
 
-#if defined(__SSE4_1__) || defined(SSE41_ENABLED)
+#if defined(__SSE4_1__)
     #define _sse4_1_
 #endif
 
-#if defined(__SSE4_2__) || defined(SSE42_ENABLED)
+#if defined(__SSE4_2__)
     #define _sse4_2_
 #endif
 
-#if defined(__POPCNT__) || defined(POPCNT_ENABLED)
+#if defined(__POPCNT__)
     #define _popcnt_
 #endif
 
-#if defined(__PCLMUL__) || defined(PCLMUL_ENABLED)
+#if defined(__PCLMUL__)
     #define _pclmul_
 #endif
 
-#if defined(__AES__) || defined(AES_ENABLED)
+#if defined(__AES__)
     #define _aes_
 #endif
 
-#if defined(__AVX__) || defined(AVX_ENABLED)
+#if defined(__AVX__)
     #define _avx_
 #endif
 
-#if defined(__AVX2__) || defined(AVX2_ENABLED)
+#if defined(__AVX2__)
     #define _avx2_
 #endif
 
-#if defined(__FMA__) || defined(FMA_ENABLED)
+#if defined(__FMA__)
     #define _fma_
 #endif
 
@@ -190,13 +200,16 @@
     #define _dll_
 #endif
 
-// 16, 32 or 64
-#if defined(__sparc_v9__) || defined(_x86_64_) || defined(_ia64_) || defined(_arm64_) || defined(_ppc64_) || defined(_wasm64_)
+// 32 or 64
+#if defined(__sparc_v9__) || defined(_x86_64_) || defined(_ia64_) || defined(_arm64_) || defined(_ppc64_) || defined(_wasm64_) || __riscv_xlen == 64
     #define _64_
 #else
     #define _32_
 #endif
 
+
+// The following SIZEOF_* definitions are needed for use in preprocessor conditional directives (#if, #elif).
+
 /* All modern 64-bit Unix systems use scheme LP64 (long, pointers are 64-bit).
  * Microsoft uses a different scheme: LLP64 (long long, pointers are 64-bit).
  *
diff --git a/util/system/progname.cpp b/util/system/progname.cpp
index 2c291193203..a7eaa82b4b1 100644
--- a/util/system/progname.cpp
+++ b/util/system/progname.cpp
@@ -15,7 +15,7 @@ namespace {
 
         TString ProgName;
     };
-}
+} // namespace
 
 const TString& GetProgramName() {
     return Singleton<TProgramNameHolder>()->ProgName;
diff --git a/util/system/progname_ut.cpp b/util/system/progname_ut.cpp
index 11f3d9308b0..e6441081573 100644
--- a/util/system/progname_ut.cpp
+++ b/util/system/progname_ut.cpp
@@ -15,4 +15,4 @@ Y_UNIT_TEST_SUITE(TProgramNameTest) {
             throw;
         }
     }
-}
+} // Y_UNIT_TEST_SUITE(TProgramNameTest)
diff --git a/util/system/protect.cpp b/util/system/protect.cpp
index 6e435e648e3..271a275722f 100644
--- a/util/system/protect.cpp
+++ b/util/system/protect.cpp
@@ -88,7 +88,8 @@ void ProtectMemory(void* addr, const size_t length, const EProtectMemory mode) {
             break;
     }
     DWORD oldMode = 0;
-    if (!VirtualProtect(addr, length, mpMode, &oldMode))
+    if (!VirtualProtect(addr, length, mpMode, &oldMode)) {
         ythrow TSystemError() << "Memory protection failed for mode " << ModeToString(mode) << ". ";
+    }
 #endif
 }
diff --git a/util/system/rusage.cpp b/util/system/rusage.cpp
index 8bcaade7e39..2f9d861025c 100644
--- a/util/system/rusage.cpp
+++ b/util/system/rusage.cpp
@@ -49,8 +49,9 @@ size_t TRusage::GetCurrentRSS() {
     struct mach_task_basic_info info;
     mach_msg_type_number_t infoCount = MACH_TASK_BASIC_INFO_COUNT;
     if (task_info(mach_task_self(), MACH_TASK_BASIC_INFO,
-                  (task_info_t)&info, &infoCount) != KERN_SUCCESS)
+                  (task_info_t)&info, &infoCount) != KERN_SUCCESS) {
         return (size_t)0L; /* Can't access? */
+    }
     return (size_t)info.resident_size;
 #elif defined(__linux__) || defined(__linux) || defined(linux) || defined(__gnu_linux__)
     /* Linux ---------------------------------------------------- */
diff --git a/util/system/rusage_ut.cpp b/util/system/rusage_ut.cpp
index 0d4e0fe54b4..1dc4c5b6872 100644
--- a/util/system/rusage_ut.cpp
+++ b/util/system/rusage_ut.cpp
@@ -8,4 +8,4 @@ Y_UNIT_TEST_SUITE(TRusageTest) {
         // just check it returns something
         r.Fill();
     }
-}
+} // Y_UNIT_TEST_SUITE(TRusageTest)
diff --git a/util/system/rwlock.cpp b/util/system/rwlock.cpp
index d4664d72d6f..9faff9df5f5 100644
--- a/util/system/rwlock.cpp
+++ b/util/system/rwlock.cpp
@@ -11,7 +11,7 @@
     #include "mutex.h"
     #include "condvar.h"
 
-//darwin rwlocks not recursive
+// darwin rwlocks not recursive
 class TRWMutex::TImpl {
 public:
     TImpl();
diff --git a/util/system/sanitizers.cpp b/util/system/sanitizers.cpp
index 3e710b39c7b..5796c59151b 100644
--- a/util/system/sanitizers.cpp
+++ b/util/system/sanitizers.cpp
@@ -20,7 +20,7 @@ namespace {
     }
     void __tsan_set_fiber_name(void*, const char*) {
     }
-}
+} // namespace
     #endif
 #endif
 
diff --git a/util/system/sanitizers.h b/util/system/sanitizers.h
index 47d3e8627c8..e7f4450d387 100644
--- a/util/system/sanitizers.h
+++ b/util/system/sanitizers.h
@@ -196,4 +196,4 @@ namespace NSan {
         Y_UNUSED(a);
 #endif
     }
-}
+} // namespace NSan
diff --git a/util/system/sem.cpp b/util/system/sem.cpp
index 1825ac3093c..e2761489352 100644
--- a/util/system/sem.cpp
+++ b/util/system/sem.cpp
@@ -16,7 +16,7 @@
     #if defined(_bionic_) || defined(_darwin_) && defined(_arm_)
         #include <fcntl.h>
     #else
-        #define USE_SYSV_SEMAPHORES //unixoids declared the standard but not implemented it...
+        #define USE_SYSV_SEMAPHORES // unixoids declared the standard but not implemented it...
     #endif
 #endif
 
@@ -26,7 +26,7 @@
     #include <sys/ipc.h>
     #include <sys/sem.h>
 
-    #if defined(_linux_) || defined(_sun_) || defined(_cygwin_)
+    #if defined(_linux_) || defined(_sun_) || defined(_cygwin_) || defined(_freebsd_)
 union semun {
     int val;
     struct semid_ds* buf;
@@ -70,12 +70,14 @@ namespace {
                 size_t len = strlen(name);
                 key = (char*)alloca(len + 1);
                 strcpy(key, name);
-                if (len > MAX_PATH)
+                if (len > MAX_PATH) {
                     *(key + MAX_PATH) = 0;
+                }
                 char* p = key;
                 while (*p) {
-                    if (*p == '\\')
+                    if (*p == '\\') {
                         *p = '/';
+                    }
                     ++p;
                 }
             }
@@ -83,7 +85,7 @@ namespace {
             Handle = ::CreateSemaphore(0, max_free_count, max_free_count, key);
 #else
     #ifdef USE_SYSV_SEMAPHORES
-            key_t key = TPCGMixer::Mix(CityHash64(name, strlen(name))); //32 bit hash
+            key_t key = TPCGMixer::Mix(CityHash64(name, strlen(name))); // 32 bit hash
             Handle = semget(key, 0, 0);                                 // try to open exist semaphore
             if (Handle == -1) {                                         // create new semaphore
                 Handle = semget(key, 1, 0666 | IPC_CREAT);
@@ -110,8 +112,8 @@ namespace {
 #else
     #ifdef USE_SYSV_SEMAPHORES
     // we DO NOT want 'semctl(Handle, 0, IPC_RMID)' for multiprocess tasks;
-    //struct sembuf ops[] = {{0, 0, IPC_NOWAIT}};
-    //if (semop(Handle, ops, 1) != 0) // close only if semaphore's value is zero
+    // struct sembuf ops[] = {{0, 0, IPC_NOWAIT}};
+    // if (semop(Handle, ops, 1) != 0) // close only if semaphore's value is zero
     //    semctl(Handle, 0, IPC_RMID);
     #else
             sem_close(Handle); // we DO NOT want sem_unlink(...)
@@ -133,8 +135,8 @@ namespace {
 #endif
         }
 
-        //The UNIX semaphore object does not support a timed "wait", and
-        //hence to maintain consistancy, for win32 case we use INFINITE or 0 timeout.
+        // The UNIX semaphore object does not support a timed "wait", and
+        // hence to maintain consistancy, for win32 case we use INFINITE or 0 timeout.
         inline void Acquire() noexcept {
 #ifdef _win_
             Y_ABORT_UNLESS(::WaitForSingleObject(Handle, INFINITE) == WAIT_OBJECT_0, "can not acquire semaphore");
@@ -210,7 +212,7 @@ namespace {
     Y_PRAGMA_DIAGNOSTIC_POP
     #endif
 #endif
-}
+} // namespace
 
 class TSemaphore::TImpl: public TSemaphoreImpl {
 public:
diff --git a/util/system/sem.h b/util/system/sem.h
index 0c964ad6b60..e37799d1489 100644
--- a/util/system/sem.h
+++ b/util/system/sem.h
@@ -4,20 +4,20 @@
 
 #include <util/generic/ptr.h>
 
-//named sempahore
+// named sempahore
 class TSemaphore {
 public:
     TSemaphore(const char* name, ui32 maxFreeCount);
     ~TSemaphore();
 
-    //Increase the semaphore counter.
+    // Increase the semaphore counter.
     void Release() noexcept;
 
-    //Keep a thread held while the semaphore counter is equal 0.
+    // Keep a thread held while the semaphore counter is equal 0.
     void Acquire() noexcept;
 
-    //Try to enter the semaphore gate. A non-blocking variant of Acquire.
-    //Returns 'true' if the semaphore counter decreased
+    // Try to enter the semaphore gate. A non-blocking variant of Acquire.
+    // Returns 'true' if the semaphore counter decreased
     bool TryAcquire() noexcept;
 
 private:
@@ -25,7 +25,7 @@ class TSemaphore {
     THolder<TImpl> Impl_;
 };
 
-//unnamed semaphore, faster, than previous
+// unnamed semaphore, faster, than previous
 class TFastSemaphore {
 public:
     TFastSemaphore(ui32 maxFreeCount);
diff --git a/util/system/shellcommand.cpp b/util/system/shellcommand.cpp
index 6742f46c641..48c1717b7e6 100644
--- a/util/system/shellcommand.cpp
+++ b/util/system/shellcommand.cpp
@@ -89,22 +89,24 @@ namespace {
     constexpr static size_t MAX_COMMAND_LINE = 32 * 1024;
 
     std::wstring GetWString(const char* astring) {
-        if (!astring)
+        if (!astring) {
             return std::wstring();
+        }
 
         std::string str(astring);
         return std::wstring(str.begin(), str.end());
     }
 
     std::string GetAString(const wchar_t* wstring) {
-        if (!wstring)
+        if (!wstring) {
             return std::string();
+        }
 
         std::wstring str(wstring);
         return std::string(str.begin(), str.end());
     }
 #endif
-}
+} // namespace
 
 // temporary measure to avoid rewriting all poll calls on win TPipeHandle
 #if defined(_win_)
@@ -130,8 +132,9 @@ class TRealPipeHandle
 
     bool Close() noexcept {
         bool ok = true;
-        if (Fd_ != INVALID_REALPIPEHANDLE)
+        if (Fd_ != INVALID_REALPIPEHANDLE) {
             ok = CloseHandle(Fd_);
+        }
         Fd_ = INVALID_REALPIPEHANDLE;
         return ok;
     }
@@ -156,22 +159,25 @@ class TRealPipeHandle
 
     ssize_t Read(void* buffer, size_t byteCount) const noexcept {
         DWORD doneBytes;
-        if (!ReadFile(Fd_, buffer, byteCount, &doneBytes, nullptr))
+        if (!ReadFile(Fd_, buffer, byteCount, &doneBytes, nullptr)) {
             return -1;
+        }
         return doneBytes;
     }
     ssize_t Write(const void* buffer, size_t byteCount) const noexcept {
         DWORD doneBytes;
-        if (!WriteFile(Fd_, buffer, byteCount, &doneBytes, nullptr))
+        if (!WriteFile(Fd_, buffer, byteCount, &doneBytes, nullptr)) {
             return -1;
+        }
         return doneBytes;
     }
 
     static void Pipe(TRealPipeHandle& reader, TRealPipeHandle& writer, EOpenMode mode) {
         (void)mode;
         REALPIPEHANDLE fds[2];
-        if (!CreatePipe(&fds[0], &fds[1], nullptr /* handles are not inherited */, 0))
+        if (!CreatePipe(&fds[0], &fds[1], nullptr /* handles are not inherited */, 0)) {
             ythrow TFileError() << "failed to create a pipe";
+        }
         TRealPipeHandle(fds[0]).Swap(reader);
         TRealPipeHandle(fds[1]).Swap(writer);
     }
@@ -186,8 +192,7 @@ using REALPIPEHANDLE = PIPEHANDLE;
     #define INVALID_REALPIPEHANDLE INVALID_PIPEHANDLE
 #endif
 
-class TShellCommand::TImpl
-    : public TAtomicRefCount<TShellCommand::TImpl> {
+class TShellCommand::TImpl {
 private:
     TString Command;
     TList<TString> Arguments;
@@ -497,8 +502,9 @@ void TShellCommand::TImpl::StartProcess(TShellCommand::TImpl::TPipes& pipes) {
         }
     }
     if (InputMode != TShellCommandOptions::HANDLE_INHERIT) {
-        if (!SetHandleInformation(pipes.InputPipeFd[0], HANDLE_FLAG_INHERIT, HANDLE_FLAG_INHERIT))
+        if (!SetHandleInformation(pipes.InputPipeFd[0], HANDLE_FLAG_INHERIT, HANDLE_FLAG_INHERIT)) {
             ythrow TSystemError() << "cannot set handle info";
+        }
     }
 
     // A sockets do not work as std streams for some reason
@@ -774,11 +780,16 @@ void TShellCommand::TImpl::Run() {
     qargv.push_back(nullptr);
 
     TVector<TString> envHolder;
+    envHolder.reserve(Options_.Environment.size());
+    for (const auto& [name, value] : Options_.Environment) {
+        envHolder.emplace_back(name + '=' + value);
+    }
+
     TVector<char*> envp;
-    if (!Options_.Environment.empty()) {
-        for (auto& env : Options_.Environment) {
-            envHolder.emplace_back(env.first + '=' + env.second);
-            envp.push_back(const_cast<char*>(envHolder.back().data()));
+    if (!envHolder.empty()) {
+        envp.reserve(envHolder.size() + 1);
+        for (auto& env : envHolder) {
+            envp.push_back(const_cast<char*>(env.data()));
         }
         envp.push_back(nullptr);
     }
@@ -881,8 +892,9 @@ void TShellCommand::TImpl::Communicate(TProcessInfo* pi) {
             streamThreads.emplace_back(new TThread(&TImpl::WriteStream, &pumps[2]));
         }
 
-        for (auto& threadHolder : streamThreads)
+        for (auto& threadHolder : streamThreads) {
             threadHolder->Start();
+        }
 #else
         TBuffer buffer(DATA_BUFFER_SIZE);
         TBuffer inputBuffer(DATA_BUFFER_SIZE);
@@ -1042,8 +1054,9 @@ void TShellCommand::TImpl::Communicate(TProcessInfo* pi) {
             if (!GetExitCodeProcess(pi->Parent->Pid, &exitCode)) {
                 ythrow yexception() << "GetExitCodeProcess: " << LastSystemErrorText();
             }
-            if (exitCode == 0)
+            if (exitCode == 0) {
                 cleanExit = true;
+            }
             processExitCode = static_cast<int>(exitCode);
             DBG(Cerr << "exit code: " << exitCode << Endl);
         }
@@ -1056,11 +1069,13 @@ void TShellCommand::TImpl::Communicate(TProcessInfo* pi) {
         }
 
 #if defined(_win_)
-        for (auto& threadHolder : streamThreads)
+        for (auto& threadHolder : streamThreads) {
             threadHolder->Join();
+        }
         for (const auto pump : pumps) {
-            if (!pump.InternalError.empty())
+            if (!pump.InternalError.empty()) {
                 throw yexception() << pump.InternalError;
+            }
         }
 #else
         // Now let's read remaining stdout/stderr
diff --git a/util/system/shellcommand.h b/util/system/shellcommand.h
index 6c2b9e276c8..a9eb8c590b2 100644
--- a/util/system/shellcommand.h
+++ b/util/system/shellcommand.h
@@ -119,8 +119,9 @@ class TShellCommandOptions {
      */
     inline TShellCommandOptions& SetAsync(bool async) {
         AsyncMode = async;
-        if (AsyncMode)
+        if (AsyncMode) {
             PollDelayMs = 0;
+        }
         return *this;
     }
 
@@ -215,8 +216,9 @@ class TShellCommandOptions {
      */
     inline TShellCommandOptions& SetUseShell(bool useShell) {
         UseShell = useShell;
-        if (!useShell)
+        if (!useShell) {
             QuoteArguments = false;
+        }
         return *this;
     }
 
@@ -347,7 +349,7 @@ class TShellCommandOptions {
  * @brief Execute command in shell and provide its results
  * @attention Not thread-safe
  */
-class TShellCommand: public TNonCopyable {
+class TShellCommand: public TMoveOnly {
 private:
     TShellCommand();
 
@@ -489,7 +491,7 @@ class TShellCommand: public TNonCopyable {
 
 private:
     class TImpl;
-    using TImplRef = TSimpleIntrusivePtr<TImpl>;
+    using TImplRef = THolder<TImpl>;
     TImplRef Impl;
 };
 
diff --git a/util/system/shellcommand_ut.cpp b/util/system/shellcommand_ut.cpp
index 13a5fad75fa..416ae22c104 100644
--- a/util/system/shellcommand_ut.cpp
+++ b/util/system/shellcommand_ut.cpp
@@ -67,7 +67,7 @@ Y_UNIT_TEST_SUITE(TShellQuoteTest) {
         ShellQuoteArgSp(cmd, "-DVal=Blah");
         UNIT_ASSERT_STRINGS_EQUAL(cmd, "\"/pr f/krev/prev.exe\" \"-DVal=\\\"W Quotes\\\"\" \"-DVal=W Space\" \"-DVal=Blah\"");
     }
-}
+} // Y_UNIT_TEST_SUITE(TShellQuoteTest)
 
 Y_UNIT_TEST_SUITE(TShellCommandTest) {
     Y_UNIT_TEST(TestNoQuotes) {
@@ -489,4 +489,4 @@ Y_UNIT_TEST_SUITE(TShellCommandTest) {
 
         UNIT_ASSERT_VALUES_EQUAL(firstLine, text);
     }
-}
+} // Y_UNIT_TEST_SUITE(TShellCommandTest)
diff --git a/util/system/shmat.cpp b/util/system/shmat.cpp
index f10a1268e7c..3ae199d4292 100644
--- a/util/system/shmat.cpp
+++ b/util/system/shmat.cpp
@@ -86,7 +86,7 @@ namespace {
         return syscall(__NR_ipc, IPCOP_shmdt, 0, 0, 0, addr);
     }
     #endif
-}
+} // namespace
 #endif
 
 TSharedMemory::TSharedMemory()
@@ -102,7 +102,7 @@ static void FormatName(char* buf, const TGUID& id) {
 }
 
 bool TSharedMemory::Open(const TGUID& id, int size) {
-    //Y_ASSERT(Data == 0);
+    // Y_ASSERT(Data == 0);
     Id = id;
     Size = size;
 
@@ -117,7 +117,7 @@ bool TSharedMemory::Open(const TGUID& id, int size) {
     Data = MapViewOfFile(Handle, FILE_MAP_ALL_ACCESS, 0, 0, size);
 
     if (Data == 0) {
-        //Y_ASSERT(0);
+        // Y_ASSERT(0);
         CloseHandle(Handle);
         Handle = INVALID_OS_HANDLE;
 
@@ -128,7 +128,7 @@ bool TSharedMemory::Open(const TGUID& id, int size) {
 }
 
 bool TSharedMemory::Create(int size) {
-    //Y_ASSERT(Data == 0);
+    // Y_ASSERT(Data == 0);
     Size = size;
 
     CreateGuid(&Id);
@@ -138,14 +138,14 @@ bool TSharedMemory::Create(int size) {
     Handle = CreateFileMappingA(INVALID_OS_HANDLE, nullptr, PAGE_READWRITE, 0, size, name);
 
     if (Handle == 0) {
-        //Y_ASSERT(0);
+        // Y_ASSERT(0);
         return false;
     }
 
     Data = MapViewOfFile(Handle, FILE_MAP_ALL_ACCESS, 0, 0, size);
 
     if (Data == 0) {
-        //Y_ASSERT(0);
+        // Y_ASSERT(0);
         CloseHandle(Handle);
         Handle = INVALID_OS_HANDLE;
 
@@ -172,7 +172,7 @@ static key_t GetKey(const TGUID& id) {
 bool TSharedMemory::Open(const TGUID& id, int size) {
     Y_ABORT_UNLESS(id, "invalid shared memory guid: %s", GetGuidAsString(id).data());
 
-    //Y_ASSERT(Data == 0);
+    // Y_ASSERT(Data == 0);
     Size = size;
 
     key_t k = GetKey(id);
@@ -185,7 +185,7 @@ bool TSharedMemory::Open(const TGUID& id, int size) {
     Data = shmat(shmId, nullptr, 0);
 
     if (Data == nullptr) {
-        //Y_ASSERT(0);
+        // Y_ASSERT(0);
         return false;
     }
 
@@ -193,7 +193,7 @@ bool TSharedMemory::Open(const TGUID& id, int size) {
 }
 
 bool TSharedMemory::Create(int size) {
-    //Y_ASSERT(Data == 0);
+    // Y_ASSERT(Data == 0);
     Size = size;
 
     CreateGuid(&Id);
@@ -202,14 +202,14 @@ bool TSharedMemory::Create(int size) {
     Handle = shmget(k, Size, IPC_CREAT | IPC_EXCL | 0777);
 
     if (Handle < 0) {
-        //Y_ASSERT(0);
+        // Y_ASSERT(0);
         return false;
     }
 
     Data = shmat(Handle, nullptr, 0);
 
     if (Data == (void*)-1) {
-        //Y_ASSERT(0);
+        // Y_ASSERT(0);
         shmctl(Handle, IPC_RMID, nullptr);
         Handle = -1;
 
diff --git a/util/system/shmat_ut.cpp b/util/system/shmat_ut.cpp
index 9d92243ae7f..c38c2b8873b 100644
--- a/util/system/shmat_ut.cpp
+++ b/util/system/shmat_ut.cpp
@@ -14,4 +14,4 @@ Y_UNIT_TEST_SUITE(TTestSharedMemory) {
 
         UNIT_ASSERT_VALUES_EQUAL(*(ui32*)m2.GetPtr(), 123);
     }
-}
+} // Y_UNIT_TEST_SUITE(TTestSharedMemory)
diff --git a/util/system/spin_wait.cpp b/util/system/spin_wait.cpp
index ba125291110..bb13e3fd98c 100644
--- a/util/system/spin_wait.cpp
+++ b/util/system/spin_wait.cpp
@@ -16,10 +16,10 @@ namespace {
         return (t * 4 + (rndNum % t) * 2) / 5;
     }
 
-    //arbitrary values
+    // arbitrary values
     constexpr unsigned MIN_SLEEP_TIME = 500;
     constexpr unsigned MAX_SPIN_COUNT = 0x7FF;
-}
+} // namespace
 
 TSpinWait::TSpinWait() noexcept
     : T(MIN_SLEEP_TIME)
diff --git a/util/system/spinlock.h b/util/system/spinlock.h
index 9e7f603f491..e296d7a034e 100644
--- a/util/system/spinlock.h
+++ b/util/system/spinlock.h
@@ -32,10 +32,18 @@ class TSpinLockBase {
         return Val_.compare_exchange_strong(zero, 1);
     }
 
+    inline void Release() noexcept {
+        Val_.store(0, std::memory_order_release);
+    }
+
     inline bool try_lock() noexcept {
         return TryAcquire();
     }
 
+    inline void unlock() noexcept {
+        Release();
+    }
+
 protected:
     std::atomic<intptr_t> Val_{0};
 };
@@ -58,10 +66,6 @@ class TSpinLock: public TSpinLockBase {
 public:
     using TSpinLockBase::TSpinLockBase;
 
-    inline void Release() noexcept {
-        Val_.store(0, std::memory_order_release);
-    }
-
     inline void Acquire() noexcept {
         intptr_t zero = 0;
         if (Val_.compare_exchange_strong(zero, 1)) {
@@ -74,10 +78,6 @@ class TSpinLock: public TSpinLockBase {
                  !Val_.compare_exchange_strong(zero, 1));
     }
 
-    inline void unlock() noexcept {
-        Release();
-    }
-
     inline void lock() noexcept {
         Acquire();
     }
@@ -95,10 +95,6 @@ class TAdaptiveLock: public TSpinLockBase {
 public:
     using TSpinLockBase::TSpinLockBase;
 
-    void Release() noexcept {
-        Val_.store(0, std::memory_order_release);
-    }
-
     void Acquire() noexcept {
         intptr_t zero = 0;
         if (Val_.compare_exchange_strong(zero, 1)) {
@@ -117,10 +113,6 @@ class TAdaptiveLock: public TSpinLockBase {
         }
     }
 
-    inline void unlock() noexcept {
-        Release();
-    }
-
     inline void lock() noexcept {
         Acquire();
     }
diff --git a/util/system/spinlock_ut.cpp b/util/system/spinlock_ut.cpp
index e8639a6404c..5b482cbcf18 100644
--- a/util/system/spinlock_ut.cpp
+++ b/util/system/spinlock_ut.cpp
@@ -34,4 +34,4 @@ Y_UNIT_TEST_SUITE(TSpinLock) {
     Y_UNIT_TEST(TAdaptiveLock_IsLocked) {
         TestLock<TAdaptiveLock>();
     }
-}
+} // Y_UNIT_TEST_SUITE(TSpinLock)
diff --git a/util/system/src_location_ut.cpp b/util/system/src_location_ut.cpp
index 5b86cb86efc..955a6e15d2d 100644
--- a/util/system/src_location_ut.cpp
+++ b/util/system/src_location_ut.cpp
@@ -15,4 +15,4 @@ Y_UNIT_TEST_SUITE(TestLocation) {
         static constexpr TSourceLocation location = __LOCATION__;
         static_assert(location.Line >= 0, "__LOCATION__ can be used at compile time expressions");
     }
-}
+} // Y_UNIT_TEST_SUITE(TestLocation)
diff --git a/util/system/src_root.h b/util/system/src_root.h
index 4f2d9f5ee6c..15733d26dbb 100644
--- a/util/system/src_root.h
+++ b/util/system/src_root.h
@@ -63,6 +63,6 @@ namespace NPrivate {
     constexpr Y_FORCE_INLINE TStaticBuf StripRoot(const TStaticBuf& f) noexcept {
         return StripRoot(f, RootPrefixLength(f));
     }
-}
+} // namespace NPrivate
 
 #define __SOURCE_FILE_IMPL__ ::NPrivate::StripRoot(STATIC_BUF(__FILE__), std::integral_constant<unsigned, ::NPrivate::RootPrefixLength(STATIC_BUF(__FILE__))>::value)
diff --git a/util/system/src_root_ut.cpp b/util/system/src_root_ut.cpp
index e9a675eb9ab..3d4a33c350d 100644
--- a/util/system/src_root_ut.cpp
+++ b/util/system/src_root_ut.cpp
@@ -24,4 +24,4 @@ Y_UNIT_TEST_SUITE(TestSourceRoot) {
         static_assert(!::NPrivate::IsProperPrefix(STATIC_BUF(""), STATIC_BUF("")), R"(IsProperPrefix("", "") failed)");
         static_assert(::NPrivate::IsProperPrefix(STATIC_BUF("dir"), STATIC_BUF("dir/file")), R"(IsProperPrefix("dir", "dir/file") failed)");
     }
-}
+} // Y_UNIT_TEST_SUITE(TestSourceRoot)
diff --git a/util/system/sys_alloc.h b/util/system/sys_alloc.h
index 4221a28f8cc..1e214a09cd2 100644
--- a/util/system/sys_alloc.h
+++ b/util/system/sys_alloc.h
@@ -20,16 +20,13 @@ inline void y_deallocate(void* p) {
 }
 
 /**
- * Behavior of realloc from C++99 to C++11 changed (http://www.cplusplus.com/reference/cstdlib/realloc/).
+ * Behavior of 'realloc' changed from C++98 to C++11 (http://www.cplusplus.com/reference/cstdlib/realloc/).
  *
- * Our implementation work as C++99: if new_sz == 0 free will be called on 'p' and nullptr returned.
+ * Our implementation works as in C++98: if new_sz == 0 'free' will be called on 'p' and 'nullptr' returned.
  */
 inline void* y_reallocate(void* p, size_t new_sz) {
     if (!new_sz) {
-        if (p) {
-            free(p);
-        }
-
+        free(p);
         return nullptr;
     }
 
diff --git a/util/system/sysstat.cpp b/util/system/sysstat.cpp
index db3338b02e4..34868174841 100644
--- a/util/system/sysstat.cpp
+++ b/util/system/sysstat.cpp
@@ -11,8 +11,9 @@ int Chmod(const char* fname, int mode) {
         return -1;
     }
     ui32 fAttr = ::GetFileAttributesA(fname);
-    if (fAttr == 0xffffffff)
+    if (fAttr == 0xffffffff) {
         return -1;
+    }
     if (mode & _S_IWRITE) {
         fAttr &= ~FILE_ATTRIBUTE_READONLY;
     } else {
diff --git a/util/system/tempfile.cpp b/util/system/tempfile.cpp
index a2e9f49eb12..90e65d46a38 100644
--- a/util/system/tempfile.cpp
+++ b/util/system/tempfile.cpp
@@ -1,5 +1,18 @@
 #include "tempfile.h"
 
+#include "error.h"
+
+#include <util/generic/yexception.h>
+
+TTempFile& TTempFile::operator=(TTempFile&& rhs) {
+    if (Name_.Defined()) {
+        Y_ENSURE(NFs::Remove(*Name_), "Removing \"" << *Name_ << "\" failed: " << LastSystemErrorText());
+    }
+    Name_ = std::move(rhs.Name_);
+    rhs.Name_.Clear();
+    return *this;
+}
+
 TTempFileHandle::TTempFileHandle()
     : TTempFile(MakeTempName())
     , TFile(CreateFile())
diff --git a/util/system/tempfile.h b/util/system/tempfile.h
index ac8bc5c3226..070a17aeb29 100644
--- a/util/system/tempfile.h
+++ b/util/system/tempfile.h
@@ -4,25 +4,37 @@
 #include "file.h"
 
 #include <util/folder/path.h>
+#include <util/generic/maybe.h>
+#include <util/generic/noncopyable.h>
 #include <util/generic/string.h>
 
-class TTempFile {
+class TTempFile: TMoveOnly {
 public:
     inline TTempFile(const TString& fname)
         : Name_(fname)
     {
     }
 
+    inline TTempFile(TTempFile&& rhs) noexcept
+        : Name_(std::move(rhs.Name_))
+    {
+        rhs.Name_.Clear();
+    }
+
     inline ~TTempFile() {
-        NFs::Remove(Name());
+        if (Name_.Defined()) {
+            NFs::Remove(*Name_);
+        }
     }
 
-    inline const TString& Name() const noexcept {
-        return Name_;
+    TTempFile& operator=(TTempFile&& rhs);
+
+    inline const TString& Name() const {
+        return *Name_;
     }
 
 private:
-    const TString Name_;
+    TMaybe<TString> Name_;
 };
 
 class TTempFileHandle: public TTempFile, public TFile {
diff --git a/util/system/tempfile_ut.cpp b/util/system/tempfile_ut.cpp
index e4a0923d0bc..a749b05469b 100644
--- a/util/system/tempfile_ut.cpp
+++ b/util/system/tempfile_ut.cpp
@@ -115,7 +115,7 @@ Y_UNIT_TEST_SUITE(TTempFileHandle) {
     Y_UNIT_TEST(NonExistingDirectory) {
         UNIT_ASSERT_EXCEPTION(TTempFileHandle::InDir("nonexsistingdirname"), TSystemError);
     }
-}
+} // Y_UNIT_TEST_SUITE(TTempFileHandle)
 
 Y_UNIT_TEST_SUITE(MakeTempName) {
     Y_UNIT_TEST(Default) {
@@ -148,4 +148,4 @@ Y_UNIT_TEST_SUITE(MakeTempName) {
         }
         UNIT_ASSERT(!NFs::Exists(path));
     }
-}
+} // Y_UNIT_TEST_SUITE(MakeTempName)
diff --git a/util/system/thread.cpp b/util/system/thread.cpp
index 8b0d988d237..e1a8a7366e1 100644
--- a/util/system/thread.cpp
+++ b/util/system/thread.cpp
@@ -4,6 +4,7 @@
 #include "thread.h"
 #include "thread.i"
 
+#include <util/generic/bitops.h>
 #include <util/generic/ptr.h>
 #include <util/generic/ymath.h>
 #include <util/generic/ylimits.h>
@@ -50,7 +51,7 @@ bool SetLowestThreadPriority() {
     struct sched_param sch;
     memset(&sch, 0, sizeof(sch));
     sch.sched_priority = 0;
-    #ifdef _darwin_
+    #if defined(_darwin_) || defined(_freebsd_)
     return pthread_setschedparam(pthread_self(), SCHED_RR, &sch) == 0;
     #else
     return pthread_setschedparam(pthread_self(), SCHED_IDLE, &sch) == 0;
@@ -135,7 +136,7 @@ namespace {
             {
                 TParamsRef p((TMyParams*)(ptr));
 
-                //drop counter, gotten in Start()
+                // drop counter, gotten in Start()
                 p->UnRef();
 
                 SetThrName(*p);
@@ -146,7 +147,7 @@ namespace {
         }
 
         inline void Start() {
-            //do not do this, kids, at home
+            // do not do this, kids, at home
             P_->Ref();
     #if _WIN32_WINNT < 0x0502
             Handle = reinterpret_cast<HANDLE>(::_beginthreadex(nullptr, (unsigned)StackSize(*P_), Proxy, (void*)P_.Get(), 0, &ThreadId));
@@ -170,7 +171,7 @@ namespace {
 
     using TThreadBase = TWinThread;
 #else
-    //unix
+    // unix
 
     #define PCHECK(x, y)                                    \
         {                                                   \
@@ -268,7 +269,7 @@ namespace {
 
         return t.Get();
     }
-}
+} // namespace
 
 class TThread::TImpl: public TThreadBase {
 public:
@@ -352,6 +353,8 @@ TThread::TId TThread::CurrentThreadId() noexcept {
 TThread::TId TThread::CurrentThreadNumericId() noexcept {
 #if defined(_win_)
     return GetCurrentThreadId();
+#elif defined(_freebsd_)
+    return pthread_getthreadid_np();
 #elif defined(_darwin_)
     // There is no gettid() on MacOS and SYS_gettid returns completely unrelated numbers.
     // See: http://elliotth.blogspot.com/2012/04/gettid-on-mac-os.html
@@ -382,7 +385,7 @@ namespace {
     static void* ThreadProcWrapper(void* param) {
         return reinterpret_cast<T*>(param)->ThreadProc();
     }
-}
+} // namespace
 
 ISimpleThread::ISimpleThread(size_t stackSize)
     : TThread(TParams(ThreadProcWrapper<ISimpleThread>, reinterpret_cast<void*>(this), stackSize))
@@ -463,7 +466,7 @@ namespace {
         TSetThreadDescription SetThreadDescription;
         TGetThreadDescription GetThreadDescription;
     };
-}
+} // namespace
 #endif // _win_
 
 void TThread::SetCurrentThreadName(const char* name) {
@@ -535,11 +538,11 @@ TCurrentThreadLimits::TCurrentThreadLimits() noexcept
     : StackBegin(nullptr)
     , StackLength(0)
 {
-#if defined(_linux_) || defined(_cygwin_) || defined(_freebsd_)
+#if defined(_linux_) || defined(_cygwin_) || defined(_freebsd_) || defined(__EMSCRIPTEN__)
     pthread_attr_t attr;
     pthread_attr_init(&attr);
 
-    #if defined(_linux_) || defined(_cygwin_)
+    #if defined(_linux_) || defined(_cygwin_) || defined(__EMSCRIPTEN__)
     Y_ABORT_UNLESS(pthread_getattr_np(pthread_self(), &attr) == 0, "pthread_getattr failed");
     #else
     Y_ABORT_UNLESS(pthread_attr_get_np(pthread_self(), &attr) == 0, "pthread_attr_get_np failed");
diff --git a/util/system/thread_ut.cpp b/util/system/thread_ut.cpp
index 24eeee5016d..e1b88c1d735 100644
--- a/util/system/thread_ut.cpp
+++ b/util/system/thread_ut.cpp
@@ -226,4 +226,4 @@ Y_UNIT_TEST_SUITE(TSysThreadTest) {
         UNIT_ASSERT_VALUES_EQUAL(thread.Join(), nullptr);
         UNIT_ASSERT(flag);
     }
-}
+} // Y_UNIT_TEST_SUITE(TSysThreadTest)
diff --git a/util/system/tls.cpp b/util/system/tls.cpp
index 40d748274ec..74cd4b6fc73 100644
--- a/util/system/tls.cpp
+++ b/util/system/tls.cpp
@@ -115,7 +115,7 @@ namespace {
 
         virtual ~TGenericTlsBase() = default;
     };
-}
+} // namespace
 
 #if defined(_unix_)
 namespace {
@@ -126,7 +126,7 @@ namespace {
         }
 
         inline ~TMasterTls() override {
-            //explicitly call dtor for main thread
+            // explicitly call dtor for main thread
             Dtor(pthread_getspecific(Key_));
 
             Y_ABORT_UNLESS(!pthread_key_delete(Key_), "pthread_key_delete failed");
@@ -158,7 +158,7 @@ namespace {
     };
 
     using TKeyDescriptor = TMasterTls::TPerThreadStorage::TKey;
-}
+} // namespace
 
 class TKey::TImpl: public TKeyDescriptor {
 public:
@@ -211,7 +211,7 @@ namespace {
         TMutex Lock_;
         THashMap<TThread::TId, TPTSRef> Datas_;
     };
-}
+} // namespace
 
 class TKey::TImpl {
 public:
diff --git a/util/system/tls.h b/util/system/tls.h
index 3c4f56dbeb7..3a50777cfea 100644
--- a/util/system/tls.h
+++ b/util/system/tls.h
@@ -45,9 +45,9 @@
 
     Example:
         @code
-        //the field declaration in header
+        // the field declaration in header
         Y_THREAD(TBuffer) TmpBuffer;
-        //...later somewhere in cpp...
+        // ...later somewhere in cpp...
         TmpBuffer.Clear();
         for (size_t i = 0; i < sz && TrieCursor[i].second.IsFork(); ++i) {
             TmpBuffer.Append(TrieCursor[i].second.Char);
@@ -56,9 +56,9 @@
 
     Example:
         @code
-        //the field decalrataion in header
+        // the field decalrataion in header
         Y_THREAD(TMyWriter*) ThreadLocalWriter;
-        //...later somewhere in cpp...
+        // ...later somewhere in cpp...
         TMyWriter*& writerRef = ThreadLocalWriter.Get();
         if (writerRef == nullptr) {
             THolder<TMyWriter> threadLocalWriter( new TMyWriter(
@@ -74,18 +74,18 @@
 
     Example:
         @code
-        //in header
+        // in header
         namespace TMorph {
             Y_THREAD(ELanguage) ThreadLocalMainLanguage;
         }
-        //in cpp
+        // in cpp
         Y_THREAD(ELanguage) TMorph::ThreadLocalMainLanguage(LANG_RUS);
         @endcode
 
     Example:
         @code
         Y_THREAD(TScoreCalcer*) ScoreCalcerPtr;
-        static TScoreCalcer* GetScoreCalcer(yint maxElemCount) {
+        static TScoreCalcer* GetScoreCalcer(size_t maxElemCount) {
             if (ScoreCalcerPtr == 0) {
                 ScoreCalcerPtr = new TScoreCalcer();
                 ScoreCalcerPtr->Alloc(maxElemCount);
@@ -149,7 +149,7 @@
 
 namespace NPrivate {
     void FillWithTrash(void* ptr, size_t len);
-}
+} // namespace NPrivate
 
 namespace NTls {
     using TDtor = void (*)(void*);
@@ -192,7 +192,7 @@ namespace NTls {
             ~TDefaultConstructor() override = default;
 
             T* Construct(void* ptr) const override {
-                //memset(ptr, 0, sizeof(T));
+                // memset(ptr, 0, sizeof(T));
                 return ::new (ptr) T();
             }
         };
@@ -289,7 +289,7 @@ namespace NTls {
         THolder<TConstructor> Constructor_;
         TKey Key_;
     };
-}
+} // namespace NTls
 
 template <class T>
 static inline T& TlsRef(NTls::TValue<T>& v) noexcept {
diff --git a/util/system/tls_ut.cpp b/util/system/tls_ut.cpp
index e84d34b42a3..5022d5ef1a9 100644
--- a/util/system/tls_ut.cpp
+++ b/util/system/tls_ut.cpp
@@ -55,4 +55,4 @@ Y_UNIT_TEST_SUITE(TTestTLS) {
             UNIT_ASSERT_VALUES_EQUAL(x.Get()[i].Get(), 0);
         }
     }
-}
+} // Y_UNIT_TEST_SUITE(TTestTLS)
diff --git a/util/system/type_name.cpp b/util/system/type_name.cpp
index 52f47a1ddd6..69e0f2d9af9 100644
--- a/util/system/type_name.cpp
+++ b/util/system/type_name.cpp
@@ -38,22 +38,26 @@ const char* NPrivate::TCppDemangler::Demangle(const char* name) {
 #endif
 }
 
+static TString CppDemangleImpl(const char* name) {
+    return NPrivate::TCppDemangler().Demangle(name);
+}
+
 TString CppDemangle(const TString& name) {
-    return NPrivate::TCppDemangler().Demangle(name.data());
+    return CppDemangleImpl(name.c_str());
 }
 
-TString TypeName(const std::type_info& typeInfo) {
-    TString demangled = CppDemangle(typeInfo.name()); // NOLINT(arcadia-typeid-name-restriction)
+static TString TypeNameImpl(const char* name) {
+    TString demangled = CppDemangleImpl(name);
 #if defined(_linux_) || defined(_darwin_)
     SubstGlobal(demangled, STD_ABI_PREFIX, STD_PREFIX);
 #endif
     return demangled;
 }
 
+TString TypeName(const std::type_info& typeInfo) {
+    return TypeNameImpl(typeInfo.name()); // NOLINT(arcadia-typeid-name-restriction)
+}
+
 TString TypeName(const std::type_index& typeIndex) {
-    TString demangled = CppDemangle(typeIndex.name());
-#if defined(_linux_) || defined(_darwin_)
-    SubstGlobal(demangled, STD_ABI_PREFIX, STD_PREFIX);
-#endif
-    return demangled;
+    return TypeNameImpl(typeIndex.name());
 }
diff --git a/util/system/type_name_ut.cpp b/util/system/type_name_ut.cpp
index c9b2a1e7756..269668c5b77 100644
--- a/util/system/type_name_ut.cpp
+++ b/util/system/type_name_ut.cpp
@@ -15,7 +15,7 @@ Y_UNIT_TEST_SUITE(TDemangleTest) {
         CppDemangle("");
         CppDemangle("Sfsdf$dfsdfTTSFSDF23234::SDFS:FSDFSDF#$%");
     }
-}
+} // Y_UNIT_TEST_SUITE(TDemangleTest)
 
 namespace NUtil::NTypeNameTest {
 
@@ -51,7 +51,7 @@ namespace NUtil::NTypeNameTest {
             return TypeName(*this);
         }
     };
-}
+} // namespace NUtil::NTypeNameTest
 
 using namespace NUtil::NTypeNameTest;
 
@@ -181,4 +181,4 @@ Y_UNIT_TEST_SUITE(TypeName) {
         UNIT_ASSERT_VALUES_EQUAL(TypeName(cvPtr), "char const volatile*");
 #endif
     }
-}
+} // Y_UNIT_TEST_SUITE(TypeName)
diff --git a/util/system/types.cpp b/util/system/types.cpp
index 11cc72aee37..b16d22140d9 100644
--- a/util/system/types.cpp
+++ b/util/system/types.cpp
@@ -3,6 +3,10 @@
 #include <util/generic/typetraits.h>
 #include <util/generic/typelist.h>
 
+#include <limits.h>
+
+static_assert(CHAR_BIT == 8, "Non 8-bit bytes are not supported");
+
 static_assert(sizeof(ui8) == 1, "incorrect ui8 type");
 static_assert(sizeof(ui16) == 2, "incorrect ui16 type");
 static_assert(sizeof(ui32) == 4, "incorrect ui32 type");
diff --git a/util/system/types_ut.cpp b/util/system/types_ut.cpp
index 19e40cef460..f3289fc80d0 100644
--- a/util/system/types_ut.cpp
+++ b/util/system/types_ut.cpp
@@ -20,4 +20,4 @@ Y_UNIT_TEST_SUITE(TestTypes) {
         sscanf("159", "%" SCNx64, &val64);
         UNIT_ASSERT(val64 == 345);
     }
-}
+} // Y_UNIT_TEST_SUITE(TestTypes)
diff --git a/util/system/unaligned_mem_ut.cpp b/util/system/unaligned_mem_ut.cpp
index ac135752aaa..68a923d30e3 100644
--- a/util/system/unaligned_mem_ut.cpp
+++ b/util/system/unaligned_mem_ut.cpp
@@ -26,7 +26,7 @@ namespace {
 
         __uint128_t x;
     };
-}
+} // namespace
 #endif
 
 Y_UNIT_TEST_SUITE(UnalignedMem) {
@@ -93,4 +93,4 @@ Y_UNIT_TEST_SUITE(UnalignedMem) {
         UNIT_ASSERT(val == TUInt128::Max());
     }
 #endif
-}
+} // Y_UNIT_TEST_SUITE(UnalignedMem)
diff --git a/util/system/user.cpp b/util/system/user.cpp
index 05439f8939d..53767e8ff90 100644
--- a/util/system/user.cpp
+++ b/util/system/user.cpp
@@ -25,10 +25,11 @@ TString GetUsername() {
         DWORD len = (DWORD)Min(nameBuf.Size(), size_t(32767));
         if (!GetUserNameA(nameBuf.Data(), &len)) {
             DWORD err = GetLastError();
-            if ((err == ERROR_INSUFFICIENT_BUFFER) && (nameBuf.Size() <= 32767))
+            if ((err == ERROR_INSUFFICIENT_BUFFER) && (nameBuf.Size() <= 32767)) {
                 nameBuf = TTempBuf((size_t)len);
-            else
+            } else {
                 ythrow TSystemError(err) << " GetUserName failed";
+            }
         } else {
             return TString(nameBuf.Data(), (size_t)(len - 1));
         }
diff --git a/util/system/user_ut.cpp b/util/system/user_ut.cpp
index 4f8a5ce2efc..0a42167fe35 100644
--- a/util/system/user_ut.cpp
+++ b/util/system/user_ut.cpp
@@ -6,4 +6,4 @@ Y_UNIT_TEST_SUITE(TestUser) {
     Y_UNIT_TEST(TestNotEmpty) {
         UNIT_ASSERT(GetUsername());
     }
-}
+} // Y_UNIT_TEST_SUITE(TestUser)
diff --git a/util/system/ut/stdin_osfhandle/main.cpp b/util/system/ut/stdin_osfhandle/main.cpp
index fe2ea836a96..cf364c7a7e6 100644
--- a/util/system/ut/stdin_osfhandle/main.cpp
+++ b/util/system/ut/stdin_osfhandle/main.cpp
@@ -9,7 +9,8 @@ int main() {
     // https://docs.microsoft.com/en-us/cpp/c-runtime-library/reference/get-osfhandle
     // _get_osfhandle returns INVALID_HANDLE_VALUE - 1 without any sign of error if specified fd was closed.
     // Working with such handle will lead to future various errors.
-    if (handle + 1 == (unsigned long long)INVALID_HANDLE_VALUE)
+    if (handle + 1 == (unsigned long long)INVALID_HANDLE_VALUE) {
         return 1;
+    }
     return 0;
 }
diff --git a/util/system/valgrind.h b/util/system/valgrind.h
index 2ec4ed927ca..a8c87ef3803 100644
--- a/util/system/valgrind.h
+++ b/util/system/valgrind.h
@@ -45,4 +45,4 @@ namespace NValgrind {
         return plain;
 #endif
     }
-}
+} // namespace NValgrind
diff --git a/util/system/yassert.cpp b/util/system/yassert.cpp
index 0f586648b78..c2265533c4d 100644
--- a/util/system/yassert.cpp
+++ b/util/system/yassert.cpp
@@ -33,10 +33,10 @@ extern "C" {
 namespace {
     struct TPanicLockHolder: public TAdaptiveLock {
     };
-}
+} // namespace
 namespace NPrivate {
     [[noreturn]] Y_NO_INLINE void InternalPanicImpl(int line, const char* function, const char* expr, int, int, int, const TStringBuf file, const char* errorMessage, size_t errorMessageSize) noexcept;
-}
+} // namespace NPrivate
 
 void ::NPrivate::Panic(const TStaticBuf& file, int line, const char* function, const char* expr, const char* format, ...) noexcept {
     try {
@@ -78,10 +78,18 @@ namespace NPrivate {
         } else {
             o << "  " << function << "() failed" << Endl;
         }
-        Cerr << r << Flush;
+
+        TString backTrace;
 #ifndef WITH_VALGRIND
-        PrintBackTrace();
+        try {
+            TStringOutput backTraceOutput(backTrace);
+            FormatBackTrace(&backTraceOutput);
+        } catch (...) {
+            backTrace = "Failed to print backtrace due: " + CurrentExceptionMessage() + "\n";
+        }
 #endif
+        o << backTrace;
+        Cerr << r << Flush;
 #ifdef CLANG_COVERAGE
         if (__llvm_profile_write_file()) {
             Cerr << "Failed to dump clang coverage" << Endl;
@@ -91,4 +99,4 @@ namespace NPrivate {
     } catch (...) {
         abort();
     }
-}
+} // namespace NPrivate
diff --git a/util/system/yassert.h b/util/system/yassert.h
index 4e2e72e22f1..201f9605c20 100644
--- a/util/system/yassert.h
+++ b/util/system/yassert.h
@@ -74,7 +74,7 @@ inline void YaDebugBreak() {
 namespace NPrivate {
     /// method should not be used directly
     [[noreturn]] void Panic(const TStaticBuf& file, int line, const char* function, const char* expr, const char* format, ...) noexcept Y_PRINTF_FORMAT(5, 6);
-}
+} // namespace NPrivate
 
 /// Assert that does not depend on NDEBUG macro and outputs message like printf
 #define Y_ABORT_UNLESS(expr, ...)                                                                    \
@@ -90,7 +90,7 @@ namespace NPrivate {
 #define Y_ABORT(...) Y_ABORT_UNLESS(false, __VA_ARGS__)
 
 #ifndef NDEBUG
-    /// Assert that depend on NDEBUG macro and outputs message like printf
+  /// Assert that depend on NDEBUG macro and outputs message like printf
     #define Y_DEBUG_ABORT_UNLESS Y_ABORT_UNLESS
 #else
     #define Y_DEBUG_ABORT_UNLESS(expr, ...)           \
diff --git a/util/system/yassert_ut.cpp b/util/system/yassert_ut.cpp
index 701da9bf6c2..106eda691ba 100644
--- a/util/system/yassert_ut.cpp
+++ b/util/system/yassert_ut.cpp
@@ -38,4 +38,4 @@ Y_UNIT_TEST_SUITE(YassertTest) {
             []() { Y_ABORT_UNLESS([]() {throw yexception{} << "check"; return false; }(), "hi %s", "there"); }(),
             yexception);
     }
-}
+} // Y_UNIT_TEST_SUITE(YassertTest)
diff --git a/util/tests/ya_util_tests.inc b/util/tests/ya_util_tests.inc
index 57855aee6bd..eb060e18341 100644
--- a/util/tests/ya_util_tests.inc
+++ b/util/tests/ya_util_tests.inc
@@ -1,4 +1,9 @@
 IF (OS_DARWIN)
     SIZE(LARGE)
-    TAG(ya:fat ya:force_sandbox ya:exotic_platform)
+    TAG(
+        ya:fat
+        ya:force_sandbox
+        ya:exotic_platform
+        ya:large_tests_on_single_slots
+    )
 ENDIF()
diff --git a/util/thread/factory.cpp b/util/thread/factory.cpp
index b71d9972bb1..c7c42f59e37 100644
--- a/util/thread/factory.cpp
+++ b/util/thread/factory.cpp
@@ -64,7 +64,7 @@ namespace {
     private:
         std::function<void()> Func;
     };
-}
+} // namespace
 
 THolder<IThread> IThreadFactory::Run(const std::function<void()>& func) {
     THolder<IThread> ret(DoCreate());
diff --git a/util/thread/lfqueue.h b/util/thread/lfqueue.h
index bfe88013fc2..089f2347410 100644
--- a/util/thread/lfqueue.h
+++ b/util/thread/lfqueue.h
@@ -72,8 +72,9 @@ class TLockFreeQueue: public TNonCopyable {
     void TryToFreeAsyncMemory() {
         const auto keepCounter = FreeingTaskCounter.load();
         TRootNode* current = FreePtr.load(std::memory_order_acquire);
-        if (current == nullptr)
+        if (current == nullptr) {
             return;
+        }
         if (FreememCounter.load() == 1) {
             // we are the last thread, try to cleanup
             // check if another thread have cleaned up
@@ -103,8 +104,9 @@ class TLockFreeQueue: public TNonCopyable {
         toDelete->ToDelete.store(lst, std::memory_order_release);
         for (auto freePtr = FreePtr.load();;) {
             toDelete->NextFree.store(freePtr, std::memory_order_release);
-            if (FreePtr.compare_exchange_weak(freePtr, toDelete))
+            if (FreePtr.compare_exchange_weak(freePtr, toDelete)) {
                 break;
+            }
         }
     }
     void AsyncUnref(TRootNode* toDelete, TListNode* lst) {
@@ -148,15 +150,17 @@ class TLockFreeQueue: public TNonCopyable {
                     Tail->Next.store(newCopy, std::memory_order_release);
                     newCopy = Copy;
                     Copy = nullptr; // do not destroy prev try
-                    if (!newTail)
+                    if (!newTail) {
                         newTail = Tail; // tried to invert same list
+                    }
                     break;
                 }
                 TListNode* newElem = new TListNode(ptr->Data, newCopy);
                 newCopy = newElem;
                 ptr = ptr->Next.load(std::memory_order_acquire);
-                if (!newTail)
+                if (!newTail) {
                     newTail = newElem;
+                }
             }
             EraseList(Copy); // copy was useless
             Copy = newCopy;
@@ -176,8 +180,9 @@ class TLockFreeQueue: public TNonCopyable {
 
             for (TListNode* node = head;; node = node->Next.load(std::memory_order_acquire)) {
                 newRoot->IncCount(node->Data);
-                if (node == tail)
+                if (node == tail) {
                     break;
+                }
             }
 
             if (JobQueue.compare_exchange_weak(curRoot, newRoot)) {
@@ -251,8 +256,9 @@ class TLockFreeQueue: public TNonCopyable {
     }
     template <typename TIter>
     void EnqueueAll(TIter dataBegin, TIter dataEnd) {
-        if (dataBegin == dataEnd)
+        if (dataBegin == dataEnd) {
             return;
+        }
 
         TIter i = dataBegin;
         TListNode* node = new TListNode(*i);
@@ -272,8 +278,9 @@ class TLockFreeQueue: public TNonCopyable {
             TListNode* tail = curRoot->PopQueue.load(std::memory_order_acquire);
             if (tail) {
                 // has elems to pop
-                if (!newRoot)
+                if (!newRoot) {
                     newRoot = new TRootNode;
+                }
 
                 newRoot->PushQueue.store(curRoot->PushQueue.load(std::memory_order_acquire), std::memory_order_release);
                 newRoot->PopQueue.store(tail->Next.load(std::memory_order_acquire), std::memory_order_release);
@@ -294,8 +301,9 @@ class TLockFreeQueue: public TNonCopyable {
                 return false; // no elems to pop
             }
 
-            if (!newRoot)
+            if (!newRoot) {
                 newRoot = new TRootNode;
+            }
             newRoot->PushQueue.store(nullptr, std::memory_order_release);
             listInvertor.DoCopy(curRoot->PushQueue.load(std::memory_order_acquire));
             newRoot->PopQueue.store(listInvertor.Copy, std::memory_order_release);
diff --git a/util/thread/lfqueue_ut.cpp b/util/thread/lfqueue_ut.cpp
index 626f7d4091a..bb98d0d7473 100644
--- a/util/thread/lfqueue_ut.cpp
+++ b/util/thread/lfqueue_ut.cpp
@@ -328,4 +328,4 @@ Y_UNIT_TEST_SUITE(TLockFreeQueueTests) {
         queue.Dequeue(&o);
         o.Check(0, 0, 2, 1, 0);
     }
-}
+} // Y_UNIT_TEST_SUITE(TLockFreeQueueTests)
diff --git a/util/thread/lfstack.h b/util/thread/lfstack.h
index effde7c706d..b81c6403c9a 100644
--- a/util/thread/lfstack.h
+++ b/util/thread/lfstack.h
@@ -30,12 +30,14 @@ class TLockFreeStack: TNonCopyable {
 
     void TryToFreeMemory() {
         TNode* current = FreePtr.load(std::memory_order_acquire);
-        if (!current)
+        if (!current) {
             return;
+        }
         if (DequeueCount.load() == 1) {
             // node current is in free list, we are the last thread so try to cleanup
-            if (FreePtr.compare_exchange_strong(current, nullptr))
+            if (FreePtr.compare_exchange_strong(current, nullptr)) {
                 EraseList(current);
+            }
         }
     }
     void EraseList(TNode* p) {
@@ -54,8 +56,9 @@ class TLockFreeStack: TNonCopyable {
             // act as if *this != expected even if they are equal.
             // When a compare-and-exchange is in a loop, the weak version will yield better
             // performance on some platforms.
-            if (Head.compare_exchange_weak(headValue, head))
+            if (Head.compare_exchange_weak(headValue, head)) {
                 break;
+            }
         }
     }
     template <class U>
@@ -115,8 +118,9 @@ class TLockFreeStack: TNonCopyable {
                     // Dequeue()s in progress, put node to free list
                     for (TNode* freePtr = FreePtr.load(std::memory_order_acquire);;) {
                         current->Next.store(freePtr, std::memory_order_release);
-                        if (FreePtr.compare_exchange_weak(freePtr, current))
+                        if (FreePtr.compare_exchange_weak(freePtr, current)) {
                             break;
+                        }
                     }
                 }
                 return true;
@@ -151,8 +155,9 @@ class TLockFreeStack: TNonCopyable {
                     }
                     for (TNode* freePtr = FreePtr.load(std::memory_order_acquire);;) {
                         currentLast->Next.store(freePtr, std::memory_order_release);
-                        if (FreePtr.compare_exchange_weak(freePtr, current))
+                        if (FreePtr.compare_exchange_weak(freePtr, current)) {
                             break;
+                        }
                     }
                 }
                 return;
diff --git a/util/thread/lfstack_ut.cpp b/util/thread/lfstack_ut.cpp
index e0527aa5012..9202b21eff5 100644
--- a/util/thread/lfstack_ut.cpp
+++ b/util/thread/lfstack_ut.cpp
@@ -344,4 +344,4 @@ Y_UNIT_TEST_SUITE(TLockFreeStackTests) {
     Y_UNIT_TEST(TesMultiThreadMove) {
         TMultiThreadTester<TMoveTest>().Run();
     }
-}
+} // Y_UNIT_TEST_SUITE(TLockFreeStackTests)
diff --git a/util/thread/pool.cpp b/util/thread/pool.cpp
index a0d11e49fdb..798a9cf9484 100644
--- a/util/thread/pool.cpp
+++ b/util/thread/pool.cpp
@@ -1,6 +1,7 @@
 #include <atomic>
 
 #include <util/system/defaults.h>
+#include <util/system/spinlock.h>
 
 #if defined(_unix_)
     #include <pthread.h>
@@ -57,7 +58,7 @@ namespace {
         bool EnumerateThreads = false;
         std::atomic<ui64> Index{0};
     };
-}
+} // namespace
 
 TThreadFactoryHolder::TThreadFactoryHolder() noexcept
     : Pool_(SystemThreadFactory())
@@ -80,8 +81,11 @@ class TThreadPool::TImpl: public TIntrusiveListItem<TImpl>, public IThreadFactor
         , ThreadCountExpected(0)
         , ThreadCountReal(0)
         , Forked(false)
+        , IsForkAware_(params.IsForkAware_)
     {
-        TAtforkQueueRestarter::Get().RegisterObject(this);
+        if (IsForkAware_) {
+            TAtforkQueueRestarter::Get().RegisterObject(this);
+        }
         Start(thrnum, maxqueue);
     }
 
@@ -92,7 +96,9 @@ class TThreadPool::TImpl: public TIntrusiveListItem<TImpl>, public IThreadFactor
             // ¯\_(ツ)_/¯
         }
 
-        TAtforkQueueRestarter::Get().UnregisterObject(this);
+        if (IsForkAware_) {
+            TAtforkQueueRestarter::Get().UnregisterObject(this);
+        }
         Y_ASSERT(Tharr.empty());
     }
 
@@ -268,6 +274,7 @@ class TThreadPool::TImpl: public TIntrusiveListItem<TImpl>, public IThreadFactor
     size_t ThreadCountExpected;
     size_t ThreadCountReal;
     bool Forked;
+    bool IsForkAware_;
 
     class TAtforkQueueRestarter {
     public:
@@ -289,30 +296,36 @@ class TThreadPool::TImpl: public TIntrusiveListItem<TImpl>, public IThreadFactor
 
     private:
         void ChildAction() {
-            TTryGuard guard{ActionMutex};
-            // If you get an error here, it means you've used fork(2) in multi-threaded environment and probably created thread pools often.
-            // Don't use fork(2) in multi-threaded programs, don't create thread pools often.
-            // The mutex is locked after fork iff the fork(2) call was concurrent with RegisterObject / UnregisterObject in another thread.
-            Y_ABORT_UNLESS(guard.WasAcquired(), "Failed to acquire ActionMutex after fork");
+            Y_ABORT_UNLESS(ActionMutex.IsLocked(), "ActionMutex must be locked after fork");
 
             for (auto it = RegisteredObjects.Begin(); it != RegisteredObjects.End(); ++it) {
                 it->AtforkAction();
             }
+
+            ActionMutex.Release();
         }
 
         static void ProcessChildAction() {
             Get().ChildAction();
         }
 
+        static void ProcessParentBeforeFork() {
+            Get().ActionMutex.Acquire();
+        }
+
+        static void ProcessParentAfterFork() {
+            Get().ActionMutex.Release();
+        }
+
         TIntrusiveList<TImpl> RegisteredObjects;
-        TMutex ActionMutex;
+        TAdaptiveLock ActionMutex;
 
     public:
         inline TAtforkQueueRestarter() {
 #if defined(_bionic_)
-//no pthread_atfork on android libc
+// no pthread_atfork on android libc
 #elif defined(_unix_)
-            pthread_atfork(nullptr, nullptr, ProcessChildAction);
+            pthread_atfork(ProcessParentBeforeFork, ProcessParentAfterFork, ProcessChildAction);
 #endif
         }
     };
@@ -660,7 +673,7 @@ namespace {
             Owned->Process(data);
         }
     };
-}
+} // namespace
 
 void IThreadPool::SafeAdd(IObjectInQueue* obj) {
     Y_ENSURE_EX(Add(obj), TThreadPoolException() << TStringBuf("can not add object to queue"));
@@ -757,7 +770,7 @@ namespace {
         IThreadPool* Parent_;
         TThreadImplRef Impl_;
     };
-}
+} // namespace
 
 IThread* IThreadPool::DoCreate() {
     return new TPoolThread(this);
diff --git a/util/thread/pool.h b/util/thread/pool.h
index f7422645f96..d4f7b0cd85c 100644
--- a/util/thread/pool.h
+++ b/util/thread/pool.h
@@ -86,6 +86,7 @@ struct TThreadPoolParams {
     IThreadFactory* Factory_ = SystemThreadFactory();
     TString ThreadName_;
     bool EnumerateThreads_ = false;
+    bool IsForkAware_ = true;
 
     using TSelf = TThreadPoolParams;
 
@@ -131,6 +132,11 @@ struct TThreadPoolParams {
         EnumerateThreads_ = true;
         return *this;
     }
+
+    TSelf& SetForkAware(bool val) {
+        IsForkAware_ = val;
+        return *this;
+    }
 };
 
 /**
@@ -313,7 +319,7 @@ class TAdaptiveThreadPool: public TThreadPoolBase {
     THolder<TImpl> Impl_;
 };
 
-/** Behave like TThreadPool or TAdaptiveThreadPool, choosen by thrnum parameter of Start()  */
+/** Behave like TThreadPool or TAdaptiveThreadPool, chosen by thrnum parameter of Start()  */
 class TSimpleThreadPool: public TThreadPoolBase {
 public:
     TSimpleThreadPool(const TParams& params = {});
@@ -321,7 +327,7 @@ class TSimpleThreadPool: public TThreadPoolBase {
 
     bool Add(IObjectInQueue* obj) override Y_WARN_UNUSED_RESULT;
     /**
-     * @parameter thrnum. If thrnum is 0, use TAdaptiveThreadPool with small
+     * @param thrnum If thrnum is 0, use TAdaptiveThreadPool with small
      * SetMaxIdleTime interval parameter. if thrnum is not 0, use non-blocking TThreadPool
      */
     void Start(size_t thrnum, size_t maxque = 0) override;
diff --git a/util/thread/pool_ut.cpp b/util/thread/pool_ut.cpp
index 85cbcdf6c97..e3512458128 100644
--- a/util/thread/pool_ut.cpp
+++ b/util/thread/pool_ut.cpp
@@ -253,4 +253,4 @@ Y_UNIT_TEST_SUITE(TThreadPoolTest) {
             TestEnumeratedThreadName(pool, expectedNames);
         }
     }
-}
+} // Y_UNIT_TEST_SUITE(TThreadPoolTest)
diff --git a/util/thread/singleton.h b/util/thread/singleton.h
index dc9ee5a4eb7..fac938d2c59 100644
--- a/util/thread/singleton.h
+++ b/util/thread/singleton.h
@@ -25,7 +25,7 @@ namespace NPrivate {
 #endif
         }
     };
-}
+} // namespace NPrivate
 
 template <class T, size_t Priority>
 Y_RETURNS_NONNULL static inline T* FastTlsSingletonWithPriority() {
diff --git a/util/thread/singleton_ut.cpp b/util/thread/singleton_ut.cpp
index 164b1cc184d..1f5c96f0fd1 100644
--- a/util/thread/singleton_ut.cpp
+++ b/util/thread/singleton_ut.cpp
@@ -10,7 +10,7 @@ namespace {
         {
         }
     };
-}
+} // namespace
 
 Y_UNIT_TEST_SUITE(Tls) {
     Y_UNIT_TEST(FastThread) {
@@ -18,4 +18,4 @@ Y_UNIT_TEST_SUITE(Tls) {
         FastTlsSingleton<TFoo>()->i += 3;
         UNIT_ASSERT_VALUES_EQUAL(3, FastTlsSingleton<TFoo>()->i);
     }
-}
+} // Y_UNIT_TEST_SUITE(Tls)
diff --git a/util/ysafeptr.cpp b/util/ysafeptr.cpp
index 96f25140673..db2ff21ec0c 100644
--- a/util/ysafeptr.cpp
+++ b/util/ysafeptr.cpp
@@ -1,5 +1,7 @@
 #include "ysafeptr.h"
 
+#include <util/system/sanitizers.h>
+
 #ifdef CHECK_YPTR2
 Y_POD_THREAD(bool)
 IObjectBase::DisableThreadCheck;
@@ -24,6 +26,11 @@ void IObjectBase::ReleaseObjComplete(int nMask) {
     }
 }
 ////////////////////////////////////////////////////////////////////////////////////////////////////
+void IObjectBase::UnpoisonCounters() noexcept {
+    NSan::Unpoison(&ObjData, sizeof(ObjData));
+    NSan::Unpoison(&RefData, sizeof(RefData));
+}
+////////////////////////////////////////////////////////////////////////////////////////////////////
 void IObjectBase::ReleaseRefComplete() {
     assert(RefData == 0);
     if ((ObjData & 0x3fffffff) == 0) {
diff --git a/util/ysafeptr.h b/util/ysafeptr.h
index c33f66db842..807ed63b67e 100644
--- a/util/ysafeptr.h
+++ b/util/ysafeptr.h
@@ -7,18 +7,18 @@
 #include <util/system/tls.h>
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
-//   There are different templates of pointers:
-//     1. Simple pointers.
-//     2. TPtr with refereces.
-//     3. TObj/TMObj with ownership. After destruction of a TObj the object it referenced to is
-//        cleaned up and marked as non valid. Similarly does TMobj organizing the parallel ownership
-//        of an object.
+// There are different templates of pointers:
+//   1. Simple pointers.
+//   2. TPtr with refereces.
+//   3. TObj/TMObj with ownership. After destruction of a TObj the object it referenced to is
+//      cleaned up and marked as non valid. Similarly does TMobj organizing the parallel ownership
+//      of an object.
 //
-//   Limitations:
-//     1. It may be necessary to use BASIC_REGISTER_CLASS() in .cpp files to be able to use a
-//        pointer to a forward declared class.
-//     2. It's prohibited to override the 'new' operator, since the standard 'delete' will be used
-//        for destruction of objects (because of 'delete this').
+// Limitations:
+//   1. It may be necessary to use BASIC_REGISTER_CLASS() in .cpp files to be able to use a
+//      pointer to a forward declared class.
+//   2. It's prohibited to override the 'new' operator, since the standard 'delete' will be used
+//      for destruction of objects (because of 'delete this').
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
 #if defined(_MSC_VER) && defined(_DEBUG)
@@ -33,10 +33,11 @@ class IObjectBase {
 #ifdef CHECK_YPTR2
     static Y_POD_THREAD(bool) DisableThreadCheck;
     void CheckThreadId() {
-        if (dwThreadId == 0)
+        if (dwThreadId == 0) {
             dwThreadId = GetCurrentThreadId();
-        else
+        } else {
             Y_ASSERT(dwThreadId == GetCurrentThreadId() || DisableThreadCheck);
+        }
     }
     void AddRef() {
         CheckThreadId();
@@ -69,14 +70,16 @@ class IObjectBase {
     void ReleaseRef() {
         CheckThreadId();
         --RefData;
-        if (RefData == 0)
+        if (RefData == 0) {
             ReleaseRefComplete();
+        }
     }
     void ReleaseObj(int nRef, int nMask) {
         CheckThreadId();
         ObjData -= nRef;
-        if ((ObjData & nMask) == 0)
+        if ((ObjData & nMask) == 0) {
             ReleaseObjComplete(nMask);
+        }
     }
 
 protected:
@@ -88,6 +91,8 @@ class IObjectBase {
     // function should clear contents of object, easy to implement via consequent calls to
     // destructor and constructor, this function should not be called directly, use Clear()
     virtual void DestroyContents() = 0;
+    // Unpoison ObjData/RefData to mute deliberate use-after-dtor
+    void UnpoisonCounters() noexcept;
     virtual ~IObjectBase() = default;
     inline void CopyValidFlag(const IObjectBase& a) {
         ObjData &= 0x7fffffff;
@@ -204,6 +209,7 @@ public:                                                           \
 protected:                                                        \
     virtual void DestroyContents() override {                     \
         this->~classname();                                       \
+        this->UnpoisonCounters();                                 \
         int nHoldRefs = this->RefData, nHoldObjs = this->ObjData; \
         new (this) classname();                                   \
         this->RefData += nHoldRefs;                               \
@@ -262,18 +268,21 @@ class TPtrBase {
 
     void AddRef(TUserObj* _ptr) {
         TRef p;
-        if (_ptr)
+        if (_ptr) {
             p.AddRef(CastToObjectBase(_ptr));
+        }
     }
     void DecRef(TUserObj* _ptr) {
         TRef p;
-        if (_ptr)
+        if (_ptr) {
             p.DecRef(CastToObjectBase(_ptr));
+        }
     }
     void Release(TUserObj* _ptr) {
         TRef p;
-        if (_ptr)
+        if (_ptr) {
             p.Release(CastToObjectBase(_ptr));
+        }
     }
 
 protected:
diff --git a/util/ysafeptr_ut.cpp b/util/ysafeptr_ut.cpp
new file mode 100644
index 00000000000..a57732ac66e
--- /dev/null
+++ b/util/ysafeptr_ut.cpp
@@ -0,0 +1,128 @@
+#include <util/ysafeptr.h>
+
+#include <library/cpp/testing/unittest/registar.h>
+
+#include <util/generic/vector.h>
+#include <util/digest/numeric.h>
+
+namespace {
+
+    class TTestObject: public IObjectBase {
+        OBJECT_METHODS(TTestObject);
+
+    public:
+        TTestObject(int value = 20)
+            : Value(value)
+        {
+        }
+
+        int Value;
+    };
+
+    class TDerivedTestObject: public TTestObject {
+    public:
+        TDerivedTestObject(int value = 50)
+            : TTestObject(value)
+        {
+        }
+    };
+
+    class TRecursive: public IObjectBase {
+        OBJECT_METHODS(TRecursive);
+
+    public:
+        TRecursive(TVector<TObj<TRecursive>> own, TVector<TPtr<TRecursive>> ref)
+            : Own(std::move(own))
+            , Ref(std::move(ref))
+        {
+        }
+
+        TRecursive(TObj<TRecursive> own, TVector<TPtr<TRecursive>> ref)
+            : TRecursive(TVector<TObj<TRecursive>>{std::move(own)}, std::move(ref))
+        {
+        }
+
+        TRecursive() = default;
+
+        TVector<TObj<TRecursive>> Own;
+        TVector<TPtr<TRecursive>> Ref;
+    };
+
+    std::pair<TVector<TObj<TRecursive>>, TVector<TPtr<TRecursive>>> MakeCycle(size_t length) {
+        TVector<TObj<TRecursive>> objects;
+        TVector<TPtr<TRecursive>> references;
+        for (size_t i = 0; i < length; ++i) {
+            TObj<TRecursive> p{new TRecursive{
+                objects.empty() ? nullptr : objects.back(),
+                references}};
+            objects.push_back(p.Get());
+            references.push_back(p.Get());
+        }
+        references.front()->Ref.push_back(objects.back().Get());
+        return {std::move(objects), std::move(references)};
+    }
+
+    std::pair<TVector<TObj<TRecursive>>, TVector<TPtr<TRecursive>>> MakeGraph(size_t size) {
+        TVector<TObj<TRecursive>> objects;
+        TVector<TPtr<TRecursive>> references;
+        for (size_t i = 0; i < size; ++i) {
+            TObj<TRecursive> p{new TRecursive{}};
+            if (i > 0) {
+                for (size_t refsN = 0; refsN < 5; ++refsN) {
+                    size_t random = IntHash(i) % references.size();
+                    p->Ref.push_back(references[random]);
+                }
+                size_t parent = (i - 1) >> 1;
+                objects[parent]->Own.push_back(p.Get());
+                size_t random = IntHash(i) % objects.size();
+                objects[random]->Own.push_back(p.Get());
+            }
+            objects.push_back(p.Get());
+            references.push_back(p.Get());
+        }
+        return {std::move(objects), std::move(references)};
+    }
+} // namespace
+
+Y_UNIT_TEST_SUITE(SafePtr) {
+    Y_UNIT_TEST(Basic) {
+        TObj<TTestObject> a = new TTestObject();
+    }
+
+    Y_UNIT_TEST(Clear) {
+        TObj<TTestObject> a = new TTestObject(30);
+        UNIT_ASSERT_VALUES_EQUAL(a->Value, 30);
+        a->Clear();
+        UNIT_ASSERT_VALUES_EQUAL(a->Value, 20);
+    }
+
+    Y_UNIT_TEST(ClearDynamicType) {
+        TObj<TTestObject> a = new TDerivedTestObject(30);
+        UNIT_ASSERT_VALUES_EQUAL(a->Value, 30);
+        a->Clear();
+        UNIT_ASSERT_VALUES_EQUAL(a->Value, 20);
+    }
+
+    Y_UNIT_TEST(RefCycle) {
+        auto [objects, references] = MakeCycle(50);
+        for (const auto& ref : references) {
+            UNIT_ASSERT(IsValid(ref));
+            UNIT_ASSERT_GE(ref->Ref.size(), 0);
+        }
+        objects.clear();
+        for (const auto& ref : references) {
+            UNIT_ASSERT(!IsValid(ref));
+        }
+    }
+
+    Y_UNIT_TEST(RefGraph) {
+        auto [objects, references] = MakeGraph(500);
+        for (const auto& ref : references) {
+            UNIT_ASSERT(IsValid(ref));
+        }
+        objects.clear();
+        for (const auto& ref : references) {
+            UNIT_ASSERT(!IsValid(ref));
+        }
+    }
+}; // Y_UNIT_TEST_SUITE(SafePtr)
diff --git a/util/ysaveload.h b/util/ysaveload.h
index 155720bdf5d..510f970d74f 100644
--- a/util/ysaveload.h
+++ b/util/ysaveload.h
@@ -10,6 +10,9 @@
 #include <util/stream/input.h>
 #include <util/system/compiler.h>
 
+#include <unordered_map>
+#include <unordered_set>
+
 #ifndef __NVCC__
     // cuda is compiled in C++14 mode at the time
     #include <optional>
@@ -59,7 +62,7 @@ static inline void SavePodType(IOutputStream* rh, const T& t) {
 namespace NPrivate {
     [[noreturn]] void ThrowLoadEOFException(size_t typeSize, size_t realSize, TStringBuf structName);
     [[noreturn]] void ThrowUnexpectedVariantTagException(ui8 tagIndex);
-}
+} // namespace NPrivate
 
 template <class T>
 static inline void LoadPodType(IInputStream* rh, T& t) {
@@ -132,7 +135,7 @@ struct TSerializerTakingIntoAccountThePodType {
 
 namespace NHasSaveLoad {
     Y_HAS_MEMBER(SaveLoad);
-}
+} // namespace NHasSaveLoad
 
 template <class T, class = void>
 struct TSerializerMethodSelector;
@@ -140,7 +143,7 @@ struct TSerializerMethodSelector;
 template <class T>
 struct TSerializerMethodSelector<T, std::enable_if_t<NHasSaveLoad::THasSaveLoad<T>::value>> {
     static inline void Save(IOutputStream* out, const T& t) {
-        //assume Save clause do not change t
+        // assume Save clause do not change t
         (const_cast<T&>(t)).SaveLoad(out);
     }
 
@@ -493,15 +496,11 @@ class TSetSerializerInserter<TSetType, TValue, true>: public TSetSerializerInser
         : TBase(s)
     {
         Y_UNUSED(cnt);
-        P_ = this->S_.begin();
     }
 
     inline void Insert(const TValue& v) {
-        P_ = this->S_.insert(P_, v);
+        this->S_.insert(this->S_.end(), v);
     }
-
-private:
-    typename TSetType::iterator P_;
 };
 
 template <class T1, class T2, class T3, class T4, class T5, class TValue>
@@ -603,6 +602,10 @@ template <class T1, class T2, class T3, class T4, class T5>
 class TSerializer<THashMap<T1, T2, T3, T4, T5>>: public TMapSerializer<THashMap<T1, T2, T3, T4, T5>, false> {
 };
 
+template <class K, class T, class C, class A>
+class TSerializer<std::unordered_map<K, T, C, A>>: public TMapSerializer<std::unordered_map<K, T, C, A>, false> {
+};
+
 template <class T1, class T2, class T3, class T4, class T5>
 class TSerializer<THashMultiMap<T1, T2, T3, T4, T5>>: public TMapSerializer<THashMultiMap<T1, T2, T3, T4, T5>, false> {
 };
@@ -619,6 +622,10 @@ template <class T1, class T2, class T3, class T4>
 class TSerializer<THashSet<T1, T2, T3, T4>>: public TSetSerializer<THashSet<T1, T2, T3, T4>, false> {
 };
 
+template <class K, class C, class A>
+class TSerializer<std::unordered_set<K, C, A>>: public TSetSerializer<std::unordered_set<K, C, A>, false> {
+};
+
 template <class T1, class T2>
 class TSerializer<TQueue<T1, T2>> {
 public:
@@ -671,7 +678,7 @@ namespace NPrivate {
         ::Load(is, loaded);
         v.template emplace<I>(std::move(loaded));
     }
-}
+} // namespace NPrivate
 
 template <typename... Args>
 struct TSerializer<std::variant<Args...>> {
diff --git a/util/ysaveload_ut.cpp b/util/ysaveload_ut.cpp
index 38f1e3bde5d..fe6b0eec8f1 100644
--- a/util/ysaveload_ut.cpp
+++ b/util/ysaveload_ut.cpp
@@ -114,7 +114,7 @@ class TSaveLoadTest: public TTestBase {
     inline void TestSaveLoad() {
         TBufferStream S_;
 
-        //save part
+        // save part
         {
             Save(&S_, (ui8)1);
             Save(&S_, (ui16)2);
@@ -142,6 +142,16 @@ class TSaveLoadTest: public TTestBase {
             Save(&S_, map);
         }
 
+        {
+            std::map<ui16, ui32> map;
+
+            map[(ui16)1] = 2;
+            map[(ui16)2] = 3;
+            map[(ui16)3] = 4;
+
+            Save(&S_, map);
+        }
+
         {
             TMultiMap<ui16, ui32> multimap;
 
@@ -154,6 +164,88 @@ class TSaveLoadTest: public TTestBase {
             Save(&S_, multimap);
         }
 
+        {
+            std::multimap<ui16, ui32> multimap;
+
+            multimap.emplace((ui16)1, 2);
+            multimap.emplace((ui16)2, 3);
+            multimap.emplace((ui16)2, 4);
+            multimap.emplace((ui16)2, 5);
+            multimap.emplace((ui16)3, 6);
+
+            Save(&S_, multimap);
+        }
+
+        {
+            THashMap<ui16, ui32> hmap;
+
+            hmap[(ui16)1] = 2;
+            hmap[(ui16)2] = 3;
+            hmap[(ui16)3] = 4;
+
+            Save(&S_, hmap);
+        }
+
+        {
+            std::unordered_map<ui16, ui32> umap;
+
+            umap[(ui16)1] = 2;
+            umap[(ui16)2] = 3;
+            umap[(ui16)3] = 4;
+
+            Save(&S_, umap);
+        }
+
+        {
+            THashMultiMap<TString, int> mm;
+
+            mm.insert({"one", 1});
+            mm.insert({"two", 2});
+            mm.insert({"two", 22});
+
+            Save(&S_, mm);
+        }
+
+        {
+            TSet<int> s;
+
+            s.insert(2);
+            s.insert(3);
+            s.insert(4);
+
+            Save(&S_, s);
+        }
+
+        {
+            std::set<int> s;
+
+            s.insert(2);
+            s.insert(3);
+            s.insert(4);
+
+            Save(&S_, s);
+        }
+
+        {
+            THashSet<int> hs;
+
+            hs.insert(2);
+            hs.insert(3);
+            hs.insert(4);
+
+            Save(&S_, hs);
+        }
+
+        {
+            std::unordered_set<int> us;
+
+            us.insert(2);
+            us.insert(3);
+            us.insert(4);
+
+            Save(&S_, us);
+        }
+
         {
             TSaveHelper helper;
 
@@ -214,17 +306,7 @@ class TSaveLoadTest: public TTestBase {
             Save(&S_, h);
         }
 
-        {
-            THashMultiMap<TString, int> mm;
-
-            mm.insert({"one", 1});
-            mm.insert({"two", 2});
-            mm.insert({"two", 22});
-
-            Save(&S_, mm);
-        }
-
-        //load part
+        // load part
         {
             ui8 val;
 
@@ -273,6 +355,16 @@ class TSaveLoadTest: public TTestBase {
             UNIT_ASSERT_EQUAL(map[(ui16)3], 4);
         }
 
+        {
+            std::map<ui16, ui32> map;
+
+            Load(&S_, map);
+            UNIT_ASSERT_EQUAL(map.size(), 3);
+            UNIT_ASSERT_EQUAL(map[(ui16)1], 2);
+            UNIT_ASSERT_EQUAL(map[(ui16)2], 3);
+            UNIT_ASSERT_EQUAL(map[(ui16)3], 4);
+        }
+
         {
             TMultiMap<ui16, ui32> multimap;
 
@@ -293,6 +385,101 @@ class TSaveLoadTest: public TTestBase {
             UNIT_ASSERT_EQUAL(values.contains(5), true);
         }
 
+        {
+            std::multimap<ui16, ui32> multimap;
+
+            Load(&S_, multimap);
+            UNIT_ASSERT_EQUAL(multimap.size(), 5);
+            UNIT_ASSERT_EQUAL(multimap.find((ui16)1)->second, 2);
+            UNIT_ASSERT_EQUAL(multimap.find((ui16)3)->second, 6);
+
+            std::set<ui32> values;
+            auto range = multimap.equal_range((ui16)2);
+            for (auto i = range.first; i != range.second; ++i) {
+                values.insert(i->second);
+            }
+
+            UNIT_ASSERT_EQUAL(values.size(), 3);
+            UNIT_ASSERT_EQUAL(values.contains(3), true);
+            UNIT_ASSERT_EQUAL(values.contains(4), true);
+            UNIT_ASSERT_EQUAL(values.contains(5), true);
+        }
+
+        {
+            THashMap<ui16, ui32> hmap;
+
+            Load(&S_, hmap);
+            UNIT_ASSERT_EQUAL(hmap.size(), 3);
+            UNIT_ASSERT_EQUAL(hmap[(ui16)1], 2);
+            UNIT_ASSERT_EQUAL(hmap[(ui16)2], 3);
+            UNIT_ASSERT_EQUAL(hmap[(ui16)3], 4);
+        }
+
+        {
+            std::unordered_map<ui16, ui32> umap;
+
+            Load(&S_, umap);
+            UNIT_ASSERT_EQUAL(umap.size(), 3);
+            UNIT_ASSERT_EQUAL(umap[(ui16)1], 2);
+            UNIT_ASSERT_EQUAL(umap[(ui16)2], 3);
+            UNIT_ASSERT_EQUAL(umap[(ui16)3], 4);
+        }
+
+        {
+            THashMultiMap<TString, int> mm;
+
+            Load(&S_, mm);
+
+            UNIT_ASSERT_EQUAL(mm.size(), 3);
+            UNIT_ASSERT_EQUAL(mm.count("one"), 1);
+            auto oneIter = mm.equal_range("one").first;
+            UNIT_ASSERT_EQUAL(oneIter->second, 1);
+            UNIT_ASSERT_EQUAL(mm.count("two"), 2);
+            auto twoIter = mm.equal_range("two").first;
+            UNIT_ASSERT_EQUAL(twoIter->second, 2);
+            UNIT_ASSERT_EQUAL((++twoIter)->second, 22);
+        }
+
+        {
+            TSet<int> s;
+
+            Load(&S_, s);
+            UNIT_ASSERT_EQUAL(s.size(), 3);
+            UNIT_ASSERT_EQUAL(s.contains(2), true);
+            UNIT_ASSERT_EQUAL(s.contains(3), true);
+            UNIT_ASSERT_EQUAL(s.contains(4), true);
+        }
+
+        {
+            std::set<int> s;
+
+            Load(&S_, s);
+            UNIT_ASSERT_EQUAL(s.size(), 3);
+            UNIT_ASSERT_EQUAL(s.contains(2), true);
+            UNIT_ASSERT_EQUAL(s.contains(3), true);
+            UNIT_ASSERT_EQUAL(s.contains(4), true);
+        }
+
+        {
+            THashSet<int> hs;
+
+            Load(&S_, hs);
+            UNIT_ASSERT_EQUAL(hs.size(), 3);
+            UNIT_ASSERT_EQUAL(hs.contains(2), true);
+            UNIT_ASSERT_EQUAL(hs.contains(3), true);
+            UNIT_ASSERT_EQUAL(hs.contains(4), true);
+        }
+
+        {
+            std::unordered_set<int> us;
+
+            Load(&S_, us);
+            UNIT_ASSERT_EQUAL(us.size(), 3);
+            UNIT_ASSERT_EQUAL(us.contains(2), true);
+            UNIT_ASSERT_EQUAL(us.contains(3), true);
+            UNIT_ASSERT_EQUAL(us.contains(4), true);
+        }
+
         {
             TSaveHelper helper;
 
@@ -363,21 +550,6 @@ class TSaveLoadTest: public TTestBase {
             Load(&S_, h);
             UNIT_ASSERT(!h);
         }
-
-        {
-            THashMultiMap<TString, int> mm;
-
-            Load(&S_, mm);
-
-            UNIT_ASSERT_EQUAL(mm.size(), 3);
-            UNIT_ASSERT_EQUAL(mm.count("one"), 1);
-            auto oneIter = mm.equal_range("one").first;
-            UNIT_ASSERT_EQUAL(oneIter->second, 1);
-            UNIT_ASSERT_EQUAL(mm.count("two"), 2);
-            auto twoIter = mm.equal_range("two").first;
-            UNIT_ASSERT_EQUAL(twoIter->second, 2);
-            UNIT_ASSERT_EQUAL((++twoIter)->second, 22);
-        }
     }
 
     inline void TestSaveLoadEmptyStruct() {
@@ -463,7 +635,7 @@ class TSaveLoadTest: public TTestBase {
         TestOptionalImpl(std::optional<ui64>(std::nullopt));
     }
 
-    //  tests serialization of class with three public string members
+    // tests serialization of class with three public string members
     template <class TDerived, class TInterface = TDerived>
     void TestInheritClassImpl() {
         TBufferStream s;
@@ -500,6 +672,7 @@ class TSaveLoadTest: public TTestBase {
         struct IInterface {
             virtual void Save(IOutputStream* out) const = 0;
             virtual void Load(IInputStream* in) = 0;
+            virtual ~IInterface() = default;
         };
         struct TBaseVirtual: IInterface {
             TString Str1;