diff --git a/gbench/files.cpp b/gbench/files.cpp
index b4536a1d..f7be9da2 100644
--- a/gbench/files.cpp
+++ b/gbench/files.cpp
@@ -3,6 +3,7 @@
 #include "types.hpp"
 #include <tgbm/api/types_all.hpp>
 #include <tgbm/tools/json_tools/all.hpp>
+#include <tgbm/tools/json_tools/parse_dom/all.hpp>
 
 template <typename T>
 void execute_handler_rapid(std::string_view json) {
diff --git a/include/tgbm/tools/json_tools/all.hpp b/include/tgbm/tools/json_tools/all.hpp
index 9d0a00a8..4b67b428 100644
--- a/include/tgbm/tools/json_tools/all.hpp
+++ b/include/tgbm/tools/json_tools/all.hpp
@@ -5,6 +5,7 @@
 #include <tgbm/tools/json_tools/boost_parse_handler.hpp>
 #include <tgbm/tools/json_tools/generator_parser/all.hpp>
 #include <tgbm/tools/json_tools/handler_parser/all.hpp>
+#include <tgbm/tools/json_tools/parse_dom/all.hpp>
 #include <tgbm/tools/json_tools/rapid_parse_handler.hpp>
 #include <tgbm/tools/json_tools/rapid_parse_dom.hpp>
 #include <tgbm/tools/json_tools/exceptions.hpp>
diff --git a/include/tgbm/tools/json_tools/boost_parse_dom.hpp b/include/tgbm/tools/json_tools/boost_parse_dom.hpp
index 96085be1..20822656 100644
--- a/include/tgbm/tools/json_tools/boost_parse_dom.hpp
+++ b/include/tgbm/tools/json_tools/boost_parse_dom.hpp
@@ -1,8 +1,6 @@
 #pragma once
 
 #include <boost/json.hpp>
-#include "boost/pfr/core_name.hpp"
-#include "boost/pfr/tuple_size.hpp"
 #include <tgbm/tools/box.hpp>
 #include <tgbm/tools/pfr_extension.hpp>
 #include <tgbm/tools/traits.hpp>
@@ -12,191 +10,115 @@
 #include <boost/container/string.hpp>
 #include <tgbm/tools/api_utils.hpp>
 #include <tgbm/tools/json_tools/exceptions.hpp>
+#include <tgbm/tools/json_tools/json_traits.hpp>
+#include <tgbm/tools/json_tools/parse_dom/basic.hpp>
 
-namespace boost::json {
+namespace tgbm::json {
+struct boost_json_traits {
+  using type = ::boost::json::value;
 
-template <tgbm::aggregate T>
-T tag_invoke(const value_to_tag<T>&, const value& jv) {
-  if (!jv.is_object()) {
-    TGBM_JSON_PARSE_ERROR;
+  static bool is_bool(const type& json) {
+    return json.is_bool();
   }
-  auto& object = jv.as_object();
 
-  auto construct_field = [&]<std::size_t I>() {
-    using Field = pfr::tuple_element_t<I, T>;
-    auto it = object.find(pfr_extension::get_name<I, T>());
-    boost::json::value null(nullptr);
-    return boost::json::value_to<Field>(it != object.end() ? *it : null);
-  };
-
-  return [&]<std::size_t... I>(std::index_sequence<I...>) {
-    return T{construct_field.template operator()<I>()...};
-  }(std::make_index_sequence<pfr_extension::tuple_size_v<T>>{});
-}
-
-namespace details {
-
-template <std::size_t I, typename T>
-auto construct_field(const boost::json::object& object) {
-  using Field = pfr::tuple_element_t<I, T>;
-  constexpr std::string_view name = pfr_extension::get_name<I, T>();
-  auto it = object.find(name);
-  if (it == object.end()) {
-    if constexpr (T::is_optional_field(name)) {
-      return Field{};
-    } else {
-      TGBM_JSON_PARSE_ERROR;
-    }
+  static bool is_integer(const type& json) {
+    return json.is_int64();
   }
-  return boost::json::value_to<Field>(it->value());
-}
 
-template <std::size_t I, typename T>
-auto construct_req_field(const boost::json::object& object) {
-  using Field = pfr::tuple_element_t<I, T>;
-  constexpr std::string_view name = pfr_extension::element_name_v<I, T>;
-  auto it = object.find(name);
-  if (it == object.end()) {
-    TGBM_JSON_PARSE_ERROR;
+  static bool is_uinteger(const type& json) {
+    return json.is_uint64();
   }
-  return boost::json::value_to<Field>(it->value());
-}
 
-}  // namespace details
-
-template <tgbm::common_api_type T>
-T tag_invoke(const value_to_tag<T>&, const value& jv) {
-  if (!jv.is_object()) {
-    TGBM_JSON_PARSE_ERROR;
+  static bool is_floating(const type& json) {
+    return json.is_double();
   }
-  auto& object = jv.as_object();
 
-  return [&]<std::size_t... I>(std::index_sequence<I...>) {
-    return T(details::construct_field<I, T>(object)...);
-  }(std::make_index_sequence<pfr_extension::tuple_size_v<T>>{});
-}
-
-inline tgbm::api::Integer tag_invoke(const value_to_tag<tgbm::api::Integer>&, const value& jv) {
-  tgbm::api::Integer result;
-  if (!jv.is_int64()) {
-    TGBM_JSON_PARSE_ERROR;
+  static bool is_string(const type& json) {
+    return json.is_string();
   }
-  auto data = jv.as_int64();
-  if (data > result.max) {
-    TGBM_JSON_PARSE_ERROR;
+
+  static bool is_object(const type& json) {
+    return json.is_object();
   }
-  return data;
-}
 
-template <tgbm::discriminated_api_type T>
-T tag_invoke(const value_to_tag<T>&, const value& jv) {
-  constexpr std::string_view discriminator = T::discriminator;
-  if (!jv.is_object()) {
-    TGBM_JSON_PARSE_ERROR;
+  static bool is_array(const type& json) {
+    return json.is_array();
   }
-  auto& object = jv.as_object();
-  auto d_value = object.find(discriminator);
-  if (d_value == object.end()) [[unlikely]] {
-    TGBM_JSON_PARSE_ERROR;
+
+  static bool is_null(const type& json) {
+    return json.is_null();
   }
-  if (!d_value->value().is_string()) [[unlikely]] {
-    TGBM_JSON_PARSE_ERROR;
+
+  // Получение значений
+  static bool get_bool(const type& json) {
+    return json.as_bool();
   }
-  return T::discriminate(d_value->value().as_string(), [&]<typename U>() -> T {
-    if constexpr (std::same_as<U, void>) {
-      TGBM_JSON_PARSE_ERROR;
-    } else {
-      return T{boost::json::value_to<U>(jv)};
-    }
-  });
-}
 
-template <typename T>
-tgbm::box<T> tag_invoke(const value_to_tag<tgbm::box<T>>&, const value& jv) {
-  if (jv.is_null()) [[unlikely]] {
-    return nullptr;
+  static std::int64_t get_integer(const type& json) {
+    return json.as_int64();
   }
-  return tgbm::box<T>{std::in_place, boost::json::value_to<T>(jv)};
-}
 
-template <typename T>
-std::vector<T> tag_invoke(const value_to_tag<std::vector<T>>&, const value& jv) {
-  if (!jv.is_array()) {
-    TGBM_JSON_PARSE_ERROR;
+  static std::uint64_t get_uinteger(const type& json) {
+    return json.as_uint64();
   }
-  auto ja = jv.as_array();
-  std::vector<T> result;
-  result.reserve(ja.size());
-  for (auto& elem : ja) {
-    result.emplace_back(boost::json::value_to<T>(elem));
+
+  static double get_floating(const type& json) {
+    return json.as_double();
   }
-  return result;
-}
 
-template <typename T>
-std::optional<T> tag_invoke(const value_to_tag<std::optional<T>>&, const value& jv) {
-  if (jv.is_null()) [[unlikely]] {
-    return std::nullopt;
+  static std::string_view get_string(const type& json) {
+    return std::string_view{json.as_string().data(), json.as_string().size()};
   }
-  return std::optional<T>{boost::json::value_to<T>(jv)};
-}
 
-template <typename T>
-tgbm::api::optional<T> tag_invoke(const value_to_tag<tgbm::api::optional<T>>&, const value& jv) {
-  if (jv.is_null()) [[unlikely]] {
-    return std::nullopt;
+  // Обработка ошибок
+  static void on_error() {
+    throw std::runtime_error("JSON Error");
   }
-  return tgbm::api::optional<T>{boost::json::value_to<T>(jv)};
-}
 
-inline tgbm::api::Double tag_invoke(const value_to_tag<tgbm::api::Double>&, const value& jv) {
-  if (!jv.is_double()) {
-    TGBM_JSON_PARSE_ERROR;
+  // Поиск поля в объекте
+  static const type* find_field(const type& json, std::string_view key) {
+    assert(json.is_object());
+    auto& obj = json.as_object();
+    auto it = obj.find(key);
+    if (it != obj.end()) {
+      return &it->value();
+    }
+    return nullptr;
   }
-  return jv.as_double();
-}
 
-inline tgbm::api::True tag_invoke(const value_to_tag<tgbm::api::True>&, const value& jv) {
-  if (!jv.is_bool() || !jv.as_bool()) {
-    TGBM_JSON_PARSE_ERROR;
+  // Доступ к элементу по индексу
+  static const type& element_by_index(const type& json, std::size_t index) {
+    assert(json.is_array());
+    auto& arr = json.as_array();
+    if (index >= arr.size()) {
+      on_error();
+    }
+    return arr[index];
   }
-  return {};
-}
 
-inline tgbm::nothing_t tag_invoke(const value_to_tag<tgbm::nothing_t>&, const value& jv) {
-  if (!jv.is_object()) {
-    TGBM_JSON_PARSE_ERROR;
+  // Размер объекта или массива
+  static std::size_t size(const type& json) {
+    assert(json.is_object() || json.is_array());
+    if (json.is_object()) {
+      return json.as_object().size();
+    } else {
+      return json.as_array().size();
+    }
+    unreachable();
   }
-  return {};
-}
 
-template <tgbm::oneof_field_api_type T>
-T tag_invoke(const value_to_tag<T>&, const value& jv) {
-  if (!jv.is_object()) {
-    TGBM_JSON_PARSE_ERROR;
-  }
-  auto& jv_obj = jv.as_object();
-  constexpr std::size_t N = tgbm::oneof_field_utils::N<T>;
-
-  using Data = decltype(T::data);
-  auto construct_data_field = [&]() {
-    Data data;
-    for (auto&& [key, value] : jv_obj) {
-      if (!tgbm::oneof_field_utils::is_required<T>(key)) {
-        tgbm::oneof_field_utils::emplace_field<T, void>(
-            data, key, [&]<typename Field>(Field& field) { field = boost::json::value_to<Field>(value); },
-            [] { TGBM_JSON_PARSE_ERROR; }, [] {});
-      }
+  // Диапазон членов объекта
+  static auto& member_range(const type& json) {
+    if (!json.is_object()) {
+      on_error();
     }
-    return data;
-  };
 
-  return tgbm::call_on_indexes<N>([&]<std::size_t... I> {
-    return T{details::construct_req_field<I, T>(jv_obj)..., construct_data_field()};
-  });
-}
+    return json.as_object();
+  }
+};
 
-}  // namespace boost::json
+static_assert(json_traits<boost_json_traits, ::boost::json::value>);
+}  // namespace tgbm::json
 
 namespace tgbm::json::boost {
 
@@ -204,7 +126,9 @@ template <typename T>
 T parse_dom(std::string_view val) {
   using namespace ::boost::json;
   value j = parse(val);
-  return value_to<T>(j);
+  T out;
+  parse_dom::parser<T>::template parse<::boost::json::value, boost_json_traits>(j, out);
+  return out;
 }
 
 }  // namespace tgbm::json::boost
diff --git a/include/tgbm/tools/json_tools/generator_parser/discriminated_api.hpp b/include/tgbm/tools/json_tools/generator_parser/discriminated_api.hpp
index d73658a9..aae5ec8d 100644
--- a/include/tgbm/tools/json_tools/generator_parser/discriminated_api.hpp
+++ b/include/tgbm/tools/json_tools/generator_parser/discriminated_api.hpp
@@ -1,6 +1,6 @@
 #pragma once
 #include <tgbm/tools/json_tools/generator_parser/basic_parser.hpp>
-#include "tgbm/tools/json_tools/generator_parser/ignore_parser.hpp"
+#include "tgbm/tools/traits.hpp"
 
 namespace tgbm::generator_parser {
 
diff --git a/include/tgbm/tools/json_tools/json_traits.hpp b/include/tgbm/tools/json_tools/json_traits.hpp
new file mode 100644
index 00000000..5073ceb9
--- /dev/null
+++ b/include/tgbm/tools/json_tools/json_traits.hpp
@@ -0,0 +1,54 @@
+#pragma once
+
+#include <concepts>
+#include <cstdint>
+#include <string_view>
+#include <ranges>
+
+namespace tgbm::json {
+template <typename Traits, typename Json = typename Traits::type>
+concept json_traits = requires(const Json& json, std::string_view str, std::size_t sz) {
+  requires std::same_as<typename Traits::type, Json>;
+
+  { Traits::is_bool(json) } -> std::same_as<bool>;
+
+  { Traits::is_integer(json) } -> std::same_as<bool>;
+
+  { Traits::is_uinteger(json) } -> std::same_as<bool>;
+
+  { Traits::is_floating(json) } -> std::same_as<bool>;
+
+  { Traits::is_string(json) } -> std::same_as<bool>;
+
+  { Traits::is_object(json) } -> std::same_as<bool>;
+
+  { Traits::is_array(json) } -> std::same_as<bool>;
+
+  { Traits::is_object(json) } -> std::same_as<bool>;
+
+  { Traits::is_null(json) } -> std::same_as<bool>;
+
+  { Traits::get_bool(json) } -> std::same_as<bool>;
+
+  { Traits::on_error() };
+
+  { Traits::get_integer(json) } -> std::same_as<std::int64_t>;
+
+  { Traits::get_uinteger(json) } -> std::same_as<std::uint64_t>;
+
+  { Traits::get_string(json) } -> std::convertible_to<std::string_view>;
+
+  { Traits::get_floating(json) } -> std::same_as<double>;
+
+  { Traits::find_field(json, str) };
+
+  { Traits::element_by_index(json, sz) } -> std::same_as<const Json&>;
+
+  { Traits::size(json) } -> std::same_as<std::size_t>;
+
+  { Traits::member_range(json) } -> std::ranges::range;
+};
+
+template <typename T>
+struct default_json_traits {};
+}  // namespace tgbm::json
diff --git a/include/tgbm/tools/json_tools/parse_dom/all.hpp b/include/tgbm/tools/json_tools/parse_dom/all.hpp
new file mode 100644
index 00000000..51a09478
--- /dev/null
+++ b/include/tgbm/tools/json_tools/parse_dom/all.hpp
@@ -0,0 +1,9 @@
+#pragma once
+
+#include <tgbm/tools/json_tools/parse_dom/array.hpp>
+#include <tgbm/tools/json_tools/parse_dom/basic.hpp>
+#include <tgbm/tools/json_tools/parse_dom/common_api.hpp>
+#include <tgbm/tools/json_tools/parse_dom/discriminated_api.hpp>
+#include <tgbm/tools/json_tools/parse_dom/fundamental.hpp>
+#include <tgbm/tools/json_tools/parse_dom/oneof_field_api_type.hpp>
+#include <tgbm/tools/json_tools/parse_dom/optional.hpp>
diff --git a/include/tgbm/tools/json_tools/parse_dom/array.hpp b/include/tgbm/tools/json_tools/parse_dom/array.hpp
new file mode 100644
index 00000000..318f7369
--- /dev/null
+++ b/include/tgbm/tools/json_tools/parse_dom/array.hpp
@@ -0,0 +1,23 @@
+#pragma once
+#include <tgbm/tools/json_tools/parse_dom/basic.hpp>
+#include <tgbm/tools/json_tools/json_traits.hpp>
+#include <vector>
+
+namespace tgbm::json::parse_dom {
+
+template <typename T>
+struct parser<std::vector<T>> {
+  template <typename Json, json::json_traits Traits>
+  static void parse(const Json& json, std::vector<T>& out) {
+    if (!Traits::is_array(json)) {
+      Traits::on_error();
+    }
+    std::size_t size = Traits::size(json);
+    out.reserve(size);
+    for (std::size_t i = 0; i < size; i++) {
+      auto& element_node = Traits::element_by_index(json, i);
+      parser<T>::template parse<Json, Traits>(element_node, out.emplace_back());
+    }
+  }
+};
+}  // namespace tgbm::json::parse_dom
diff --git a/include/tgbm/tools/json_tools/parse_dom/basic.hpp b/include/tgbm/tools/json_tools/parse_dom/basic.hpp
new file mode 100644
index 00000000..257980a4
--- /dev/null
+++ b/include/tgbm/tools/json_tools/parse_dom/basic.hpp
@@ -0,0 +1,12 @@
+#pragma once
+
+namespace tgbm::json::parse_dom {
+
+template <typename T>
+struct parser {
+  template <typename Json, typename Traits>
+  static void parse(const Json&, T&) {
+    static_assert(sizeof(Json) == 0, "Write your specialization");
+  }
+};
+}  // namespace tgbm::json::parse_dom
diff --git a/include/tgbm/tools/json_tools/parse_dom/common_api.hpp b/include/tgbm/tools/json_tools/parse_dom/common_api.hpp
new file mode 100644
index 00000000..4458f052
--- /dev/null
+++ b/include/tgbm/tools/json_tools/parse_dom/common_api.hpp
@@ -0,0 +1,32 @@
+#pragma once
+#include <tgbm/tools/json_tools/parse_dom/basic.hpp>
+#include <tgbm/tools/json_tools/json_traits.hpp>
+#include <tgbm/api/common.hpp>
+#include "tgbm/tools/pfr_extension.hpp"
+#include "tgbm/tools/traits.hpp"
+
+namespace tgbm::json::parse_dom {
+
+template <common_api_type T>
+struct parser<T> {
+  template <typename Json, json::json_traits Traits>
+  static void parse(const Json& json, T& out) {
+    if (!Traits::is_object(json)) {
+      Traits::on_error();
+    }
+    pfr_extension::visit_object(out, [&]<typename Info, typename Field>(Field& field) {
+      constexpr std::string_view name = Info::name.AsStringView();
+      auto json_field = Traits::find_field(json, name);
+      if (!json_field) [[unlikely]] {
+        if constexpr (T::is_optional_field(name)) {
+          field = Field{};
+          return;
+        } else {
+          Traits::on_error();
+        }
+      }
+      parser<Field>::template parse<Json, Traits>(*json_field, field);
+    });
+  }
+};
+}  // namespace tgbm::json::parse_dom
diff --git a/include/tgbm/tools/json_tools/parse_dom/discriminated_api.hpp b/include/tgbm/tools/json_tools/parse_dom/discriminated_api.hpp
new file mode 100644
index 00000000..9a15b690
--- /dev/null
+++ b/include/tgbm/tools/json_tools/parse_dom/discriminated_api.hpp
@@ -0,0 +1,39 @@
+#pragma once
+#include <tgbm/tools/json_tools/parse_dom/basic.hpp>
+#include <tgbm/tools/json_tools/json_traits.hpp>
+#include <tgbm/api/common.hpp>
+#include "tgbm/tools/traits.hpp"
+
+namespace tgbm::json::parse_dom {
+
+template <discriminated_api_type T>
+struct parser<T> {
+  template <typename Json, json::json_traits Traits>
+  static void parse(const Json& json, T& out) {
+    if (!Traits::is_object(json)) {
+      Traits::on_error();
+    }
+    constexpr std::string_view discriminator = T::discriminator;
+
+    auto d_node = Traits::find_field(json, discriminator);
+    if (!d_node) [[unlikely]] {
+      Traits::on_error();
+    }
+    auto& d_ref = *d_node;
+
+    if (!Traits::is_string(d_ref)) [[unlikely]] {
+      Traits::on_error();
+    }
+
+    auto str = Traits::get_string(d_ref);
+
+    T::discriminate(str, [&]<typename U>() {
+      if constexpr (std::same_as<U, void>) {
+        Traits::on_error();
+      } else {
+        parser<U>::template parse<Json, Traits>(json, out.data.template emplace<U>());
+      }
+    });
+  }
+};
+}  // namespace tgbm::json::parse_dom
diff --git a/include/tgbm/tools/json_tools/parse_dom/fundamental.hpp b/include/tgbm/tools/json_tools/parse_dom/fundamental.hpp
new file mode 100644
index 00000000..733f68a1
--- /dev/null
+++ b/include/tgbm/tools/json_tools/parse_dom/fundamental.hpp
@@ -0,0 +1,97 @@
+#pragma once
+#include <concepts>
+#include <tgbm/tools/json_tools/parse_dom/basic.hpp>
+#include <tgbm/tools/json_tools/json_traits.hpp>
+#include <tgbm/api/common.hpp>
+#include <string>
+#include "tgbm/tools/math.hpp"
+
+namespace tgbm::json::parse_dom {
+
+template <>
+struct parser<std::string> {
+  template <typename Json, json::json_traits Traits = json::default_json_traits<Json>>
+  static void parse(const Json& json, std::string& out) {
+    if (Traits::is_string(json)) {
+      out = Traits::get_string(json);
+    } else {
+      Traits::on_error();
+    }
+  }
+};
+
+template <std::integral T>
+struct parser<T> {
+  template <typename Json, json::json_traits Traits = json::default_json_traits<Json>>
+  static void parse(const Json& json, T& out) {
+    if (Traits::is_uinteger(json)) {
+      safe_write(out, Traits::get_uinteger(json));
+    } else if (Traits::is_integer(json)) {
+      safe_write(out, Traits::get_integer(json));
+    } else {
+      Traits::on_error();
+    }
+  }
+};
+
+template <std::floating_point T>
+struct parser<T> {
+  template <typename Json, json::json_traits Traits>
+  static void parse(const Json& json, T& out) {
+    if (Traits::is_floating(json)) {
+      out = Traits::get_floating(json);
+    } else {
+      Traits::on_error();
+    }
+  }
+};
+
+template <>
+struct parser<tgbm::api::Integer> {
+  template <typename Json, json::json_traits Traits>
+  static void parse(const Json& json, tgbm::api::Integer& out) {
+    if (Traits::is_integer(json)) {
+      safe_write(out, Traits::get_integer(json));
+    } else if (Traits::is_uinteger(json)) {
+      safe_write(out, Traits::get_uinteger(json));
+    } else {
+      Traits::on_error();
+    }
+  }
+};
+
+template <>
+struct parser<bool> {
+  template <typename Json, json::json_traits Traits>
+  static void parse(const Json& json, bool& out) {
+    if (Traits::is_bool(json)) {
+      out = Traits::get_bool(json);
+    } else {
+      Traits::on_error();
+    }
+  }
+};
+
+template <>
+struct parser<tgbm::api::True> {
+  template <typename Json, json::json_traits Traits>
+  static void parse(const Json& json, tgbm::api::True& out) {
+    if (!Traits::is_bool(json) || !Traits::get_bool(json)) {
+      Traits::on_error();
+    }
+  }
+};
+
+template <>
+struct parser<api::Double> {
+  template <typename Json, json::json_traits Traits>
+  static void parse(const Json& json, api::Double& out) {
+    if (Traits::is_floating(json)) {
+      out = Traits::get_floating(json);
+    } else {
+      Traits::on_error();
+    }
+  }
+};
+
+}  // namespace tgbm::json::parse_dom
diff --git a/include/tgbm/tools/json_tools/parse_dom/oneof_field_api_type.hpp b/include/tgbm/tools/json_tools/parse_dom/oneof_field_api_type.hpp
new file mode 100644
index 00000000..c5f4dd9f
--- /dev/null
+++ b/include/tgbm/tools/json_tools/parse_dom/oneof_field_api_type.hpp
@@ -0,0 +1,49 @@
+#pragma once
+#include <tgbm/tools/json_tools/parse_dom/basic.hpp>
+#include <tgbm/tools/json_tools/json_traits.hpp>
+#include <tgbm/api/common.hpp>
+#include <tgbm/tools/api_utils.hpp>
+#include <tgbm/tools/traits.hpp>
+
+namespace tgbm::json::parse_dom {
+
+template <oneof_field_api_type T>
+struct parser<T> {
+  template <typename Json, json::json_traits Traits>
+  static void parse(const Json& json, T& out) {
+    if (!Traits::is_object(json)) [[unlikely]] {
+      Traits::on_error();
+    }
+    constexpr std::size_t N = tgbm::oneof_field_utils::N<T>;
+
+    using Data = decltype(T::data);
+
+    // clang-format off
+    auto m = matcher{
+      [&]<typename Info, typename Field>(Field& req_field) {
+        constexpr std::string_view name = Info::name.AsStringView();
+        auto node = Traits::find_field(json, name);
+        if (!node || Traits::is_null(*node)){
+          Traits::on_error();
+        }
+        parser<Field>::template parse<Json, Traits>(*node, req_field);
+      }, 
+      [&]<typename Info>(Data& data){
+        for (auto&& [key, value] : Traits::member_range(json)) {
+          if (!tgbm::oneof_field_utils::is_required<T>(key)) {
+            tgbm::oneof_field_utils::emplace_field<T, void>(
+                data, key,
+                [&]<typename Field>(Field& field) { parser<Field>::template parse<Json, Traits>(value, field); },
+                [] { Traits::on_error(); }, [] {});
+            return;
+          }
+        }
+      }
+    };
+    // clang-format on
+
+    pfr_extension::visit_object(out, m);
+  }
+};
+
+}  // namespace tgbm::json::parse_dom
diff --git a/include/tgbm/tools/json_tools/parse_dom/optional.hpp b/include/tgbm/tools/json_tools/parse_dom/optional.hpp
new file mode 100644
index 00000000..bdf1b9f5
--- /dev/null
+++ b/include/tgbm/tools/json_tools/parse_dom/optional.hpp
@@ -0,0 +1,39 @@
+#pragma once
+#include <tgbm/tools/json_tools/parse_dom/basic.hpp>
+#include <tgbm/tools/json_tools/json_traits.hpp>
+#include <tgbm/api/common.hpp>
+
+namespace tgbm::json::parse_dom {
+
+template <template <typename> typename Optional, typename T>
+struct basic_optional_parser {
+  template <typename Json, json::json_traits Traits>
+  static void parse(const Json& j, Optional<T>& out) {
+    if (Traits::is_null(j)) {
+      return;
+    } else {
+      parser<T>::template parse<Json, Traits>(j, out.emplace());
+    }
+  }
+};
+
+template <typename T>
+struct parser<box<T>> : basic_optional_parser<box, T> {};
+
+template <typename T>
+struct parser<tgbm::api::optional<T>> : basic_optional_parser<tgbm::api::optional, T> {};
+
+template <typename T>
+struct parser<std::optional<T>> : basic_optional_parser<std::optional, T> {};
+
+template <>
+struct parser<nothing_t> {
+  template <typename Json, json::json_traits Traits>
+  static void parse(const Json& j, nothing_t& out) {
+    if (!Traits::is_null(j)) {
+      Traits::on_error();
+    }
+  }
+};
+
+}  // namespace tgbm::json::parse_dom
diff --git a/include/tgbm/tools/json_tools/rapid_parse_dom.hpp b/include/tgbm/tools/json_tools/rapid_parse_dom.hpp
index aa55607f..7b73a2a8 100644
--- a/include/tgbm/tools/json_tools/rapid_parse_dom.hpp
+++ b/include/tgbm/tools/json_tools/rapid_parse_dom.hpp
@@ -2,224 +2,140 @@
 
 #include <rapidjson/reader.h>
 #include <rapidjson/document.h>
-#include <tgbm/tools/json_tools/handler_parser/basic_parser.hpp>
+#include <cassert>
+#include <ranges>
 #include <tgbm/api/common.hpp>
 #include <tgbm/tools/api_utils.hpp>
 #include <tgbm/tools/traits.hpp>
 #include <tgbm/tools/json_tools/exceptions.hpp>
+#include "tgbm/tools/json_tools/json_traits.hpp"
 #include <rapidjson/error/en.h>
+#include <tgbm/tools/json_tools/parse_dom/basic.hpp>
 
-namespace tgbm::rapid_dom_parser {
+namespace tgbm::json {
 
-using Doc = rapidjson::GenericValue<rapidjson::UTF8<>>;
+struct rapid_json_traits {
+  using type = rapidjson::GenericValue<rapidjson::UTF8<>>;
+  static bool is_bool(const type& json) {
+    return json.IsBool();
+  }
 
-template <typename T>
-struct rapid_parser {
-  // static T parse(Doc& doc);
-};
+  static bool is_integer(const type& json) {
+    return json.IsInt64() || json.IsInt();
+  }
 
-template <std::floating_point T>
-struct rapid_parser<T> {
-  static void parse(const Doc& doc, T& t) {
-    if (doc.IsDouble()) {
-      t = doc.GetDouble();
-      return;
-    }
-    TGBM_JSON_PARSE_ERROR;
+  static bool is_uinteger(const type& json) {
+    return json.IsUint64() || json.IsUint();
   }
-};
 
-template <std::integral T>
-struct rapid_parser<T> {
-  static void parse(const Doc& doc, T& t) {
-    if (doc.IsInt()) {
-      t = doc.GetInt();
-      return;
-    } else if (doc.IsUint()) {
-      t = doc.GetUint();
-      return;
-    } else if (doc.IsInt64()) {
-      t = doc.GetInt64();
-      return;
-    } else if (doc.IsUint64()) {
-      t = doc.GetUint64();
-      return;
-    }
-    TGBM_JSON_PARSE_ERROR;
+  static bool is_floating(const type& json) {
+    return json.IsDouble();
   }
-};
 
-template <>
-struct rapid_parser<std::string> {
-  static void parse(const Doc& doc, std::string& t) {
-    if (doc.IsString()) {
-      t = std::string{doc.GetString(), doc.GetStringLength()};
-      return;
-    }
-    TGBM_JSON_PARSE_ERROR;
+  static bool is_string(const type& json) {
+    return json.IsString();
   }
-};
 
-template <>
-struct rapid_parser<api::Integer> {
-  static void parse(const Doc& doc, api::Integer& t) {
-    rapid_parser<std::int64_t>::parse(doc, t.value);
+  static bool is_object(const type& json) {
+    return json.IsObject();
   }
-};
 
-template <>
-struct rapid_parser<api::Double> {
-  static void parse(const Doc& doc, api::Double& t) {
-    rapid_parser<double>::parse(doc, t.value);
+  static bool is_array(const type& json) {
+    return json.IsArray();
   }
-};
 
-template <>
-struct rapid_parser<api::True> {
-  static void parse(const Doc& doc, api::True& t) {
-    if (!doc.IsBool()) {
-      TGBM_JSON_PARSE_ERROR;
-    }
-    if (!doc.GetBool()) {
-      TGBM_JSON_PARSE_ERROR;
-    }
+  static bool is_null(const type& json) {
+    return json.IsNull();
   }
-};
 
-template <>
-struct rapid_parser<bool> {
-  static void parse(const Doc& doc, bool& t) {
-    if (!doc.IsBool()) {
-      TGBM_JSON_PARSE_ERROR;
+  // Получение значений
+  static bool get_bool(const type& json) {
+    if (!json.IsBool()) {
+      on_error();
     }
-    t = doc.GetBool();
+    return json.GetBool();
   }
-};
 
-template <typename T>
-struct rapid_parser<api::optional<T>> {
-  static void parse(const Doc& doc, api::optional<T>& t) {
-    if (doc.IsNull()) {
-      return;
+  static std::int64_t get_integer(const type& json) {
+    assert(json.IsInt64() || json.IsInt());
+    if (json.IsInt64()) {
+      return json.GetInt64();
+    } else {
+      return json.GetInt();
     }
-    rapid_parser<T>::parse(doc, t.emplace());
   }
-};
 
-template <typename T>
-struct rapid_parser<std::optional<T>> {
-  static void parse(const Doc& doc, std::optional<T>& t) {
-    if (doc.IsNull()) {
-      return;
+  static std::uint64_t get_uinteger(const type& json) {
+    assert(json.IsUint() || json.IsUint64());
+    if (json.IsUint64()) {
+      return json.GetInt64();
+    } else {
+      return json.GetInt();
     }
-    rapid_parser<T>::parse(doc, t.emplace());
   }
-};
 
-template <typename T>
-struct rapid_parser<box<T>> {
-  static void parse(const Doc& doc, box<T>& t) {
-    if (doc.IsNull()) {
-      return;
-    }
-    rapid_parser<T>::parse(doc, t.emplace());
+  static double get_floating(const type& json) {
+    assert(json.IsDouble());
+    return json.GetDouble();
   }
-};
 
-template <typename T>
-struct rapid_parser<std::vector<T>> {
-  static void parse(const Doc& doc, std::vector<T>& t) {
-    if (!doc.IsArray()) {
-      TGBM_JSON_PARSE_ERROR;
-    }
-    t.reserve(doc.Size());
-    for (auto it = doc.Begin(); it != doc.End(); it++) {
-      rapid_parser<T>::parse(*it, t.emplace_back());
-    }
+  static std::string_view get_string(const type& json) {
+    assert(json.IsString());
+    return std::string_view(json.GetString(), json.GetStringLength());
   }
-};
 
-template <common_api_type T>
-struct rapid_parser<T> {
-  static void parse(const Doc& doc, T& t) {
-    if (!doc.IsObject()) {
-      TGBM_JSON_PARSE_ERROR;
-    }
-    pfr_extension::visit_object(t, [&]<typename Info, typename Field>(Field& field) {
-      constexpr std::string_view name = Info::name;
-      rapidjson::GenericStringRef<char> name_ref(name.data(), name.size());
-      auto it = doc.FindMember(name_ref);
-      if (it == doc.MemberEnd()) {
-        if constexpr (T::is_optional_field(name)) {
-          return;
-        }
-        rapid_parser<Field>::parse(Doc{}, field);
-      } else {
-        rapid_parser<Field>::parse(it->value, field);
-      }
-    });
+  // Обработка ошибок
+  static void on_error() {
+    throw std::runtime_error("JSON Error");
   }
-};
 
-template <discriminated_api_type T>
-struct rapid_parser<T> {
-  static void parse(const Doc& doc, T& t) {
-    if (doc.IsNull()) {
-    }
-    if (!doc.IsObject()) {
-      TGBM_JSON_PARSE_ERROR;
-    }
-    constexpr std::string_view discriminator = T::discriminator;
-    rapidjson::GenericStringRef<char> discrim_ref(discriminator.data(), discriminator.size());
-    auto d_value = doc.FindMember(discrim_ref);
-    if (d_value == doc.MemberEnd()) {
-      TGBM_JSON_PARSE_ERROR;
+  // Поиск поля в объекте
+  static const type* find_field(const type& json, std::string_view key) {
+    assert(json.IsObject());
+    auto it = json.FindMember(key.data());
+    if (it != json.MemberEnd()) {
+      return &it->value;
     }
-    if (!d_value->value.IsString()) {
-      TGBM_JSON_PARSE_ERROR;
-    }
-    std::string_view val{d_value->value.GetString(), d_value->value.GetStringLength()};
-    T::discriminate(val, [&]<typename U>() {
-      if constexpr (std::same_as<U, void>) {
-        TGBM_JSON_PARSE_ERROR;
-      } else {
-        auto& u = t.data.template emplace<U>();
-        rapid_parser<U>::parse(doc, u);
-      }
-    });
+    return nullptr;
   }
-};
 
-template <oneof_field_api_type T>
-struct rapid_parser<T> {
-  static void parse(const Doc& doc, T& t) {
-    constexpr std::size_t N = oneof_field_utils::N<T>;
-    if (!doc.IsObject()) {
-      TGBM_JSON_PARSE_ERROR;
-    }
-    pfr_extension::visit_object<N>(t, [&]<typename Info, typename Field>(Field& field) {
-      constexpr std::string_view name = Info::name;
-      rapidjson::GenericStringRef<char> name_ref(name.data(), name.size());
-      auto it = doc.FindMember(name_ref);
-      if (it != doc.MemberEnd()) {
-        rapid_parser<Field>::parse(it->value, field);
-      } else {
-        TGBM_JSON_PARSE_ERROR;
-      }
-    });
-    auto& data = t.data;
-    for (auto it = doc.MemberBegin(); it != doc.MemberEnd(); ++it) {
-      auto key = std::string_view{it->name.GetString(), it->name.GetStringLength()};
-      if (!oneof_field_utils::is_required<T>(key)) {
-        oneof_field_utils::emplace_field<T, void>(
-            t.data, key, [&]<typename Field>(Field& field) { rapid_parser<Field>::parse(it->value, field); },
-            [] { TGBM_JSON_PARSE_ERROR; }, [] {});
-      }
+  // Доступ к элементу по индексу
+  static const type& element_by_index(const type& json, std::size_t index) {
+    assert(json.IsArray());
+    assert(index < json.Size());
+    return json[index];
+  }
+
+  // Размер объекта или массива
+  static std::size_t size(const type& json) {
+    assert(json.IsObject() || json.IsArray());
+    if (json.IsObject()) {
+      return json.MemberCount();
+    } else {
+      return json.Size();
     }
   }
+  struct key_value {
+    std::string_view name;
+    const type& value;
+  };
+
+  // Диапазон членов объекта
+  static auto member_range(const type& json) {
+    if (!json.IsObject()) {
+      on_error();
+    }
+    auto transformer = [](type::ConstMemberIterator it) {
+      return key_value{.name = {it->name.GetString(), it->name.GetStringLength()}, .value = it->value};
+    };
+    return std::ranges::views::iota(json.MemberBegin(), json.MemberEnd()) |
+           std::ranges::views::transform(transformer);
+  }
 };
 
-}  // namespace tgbm::rapid_dom_parser
+static_assert(tgbm::json::json_traits<rapid_json_traits>);
+
+}  // namespace tgbm::json
 
 namespace tgbm::json::rapid {
 
@@ -227,12 +143,11 @@ template <typename T>
 inline T parse_dom(std::string_view sv) {
   T t;
   rapidjson::Document document;
-  rapid_dom_parser::Doc doc;
   document.Parse(sv.data(), sv.size());
   if (document.HasParseError()) {
     TGBM_JSON_PARSE_ERROR;
   }
-  rapid_dom_parser::rapid_parser<T>::parse(document, t);
+  tgbm::json::parse_dom::parser<T>::template parse<rapid_json_traits::type, rapid_json_traits>(document, t);
   return t;
 }
 
diff --git a/include/tgbm/tools/math.hpp b/include/tgbm/tools/math.hpp
index 9195b3db..dd3f05ea 100644
--- a/include/tgbm/tools/math.hpp
+++ b/include/tgbm/tools/math.hpp
@@ -19,16 +19,30 @@ struct numeric_limits<api::Integer> {
   static constexpr api::Integer max = api::Integer::max;
 };
 
-// template <>
-// struct numeric_limits<>
+namespace details {
+constexpr auto unstrongef(auto v) {
+  if constexpr (requires { v.value; }) {
+    return v.value;
+  } else
+    return v;
+}
+
+constexpr bool cmp_less(auto l, auto r) {
+  return std::cmp_less(unstrongef(l), unstrongef(r));
+}
 
-template <class R, class T>
+constexpr bool cmp_greater(auto l, auto r) {
+  return std::cmp_greater(unstrongef(l), unstrongef(r));
+}
+
+template <typename R, typename T>
 constexpr bool in_range(T t) noexcept {
   constexpr auto T_min = numeric_limits<T>::min;
   constexpr auto R_min = numeric_limits<R>::min;
 
-  if constexpr (T_min < R_min) {
-    if (t < T(R_min)) {
+  if constexpr (cmp_less(T_min, R_min)) {
+    T cmp(R_min);
+    if (t < cmp) {
       return false;
     }
   }
@@ -36,18 +50,19 @@ constexpr bool in_range(T t) noexcept {
   constexpr auto T_max = numeric_limits<T>::max;
   constexpr auto R_max = numeric_limits<R>::max;
 
-  if constexpr (T_max > R_max) {
-    if (t > T(R_max)) {
+  if constexpr (cmp_greater(T_max, R_max)) {
+    T cmp(R_max);
+    if (t > cmp) {
       return false;
     }
   }
 
   return true;
 }
-
+}  // namespace details
 template <typename To, typename From>
 To safe_cast(From from) {
-  if (!in_range<To>(from)) {
+  if (!details::in_range<To>(from)) {
     throw std::overflow_error(fmt::format("Can't cast [{}] to {}", from, aa::noexport::n<To>()));
   }
   return To(from);