release candidate 4.0.6 (#2464 )

fixing issue 2458 (#2461 )
Fixing issue 2462 (#2463 )
2026-06-08 17:27:07 +00:00 · 2025-09-21 08:13:48 -06:00 · 2025-09-20 22:23:09 -06:00 · 2025-09-20 22:22:57 -06:00 · 2025-09-18 15:17:32 -06:00 · 2025-09-18 15:16:38 -06:00
50 changed files with 2220 additions and 1448 deletions
@@ -31,4 +31,4 @@ jobs:
          echo -e '#include <simdjson.h>\nint main(int argc,char**argv) {simdjson::dom::parser parser;simdjson::dom::element tweets = parser.load(argv[1]); }' > tmp.cpp && c++ -Idestination/include -Ldestination/lib -std=c++17 -Wl,-rpath,destination/lib -o linkandrun tmp.cpp -lsimdjson && ./linkandrun jsonexamples/twitter.json &&
          mkdir testfindpackage &&
          cd testfindpackage &&
-          echo -e 'cmake_minimum_required(VERSION 3.1)\nproject(simdjsontester)\nset(CMAKE_CXX_STANDARD 17)\nfind_package(simdjson REQUIRED)'> CMakeLists.txt && mkdir build && cd build && cmake -DCMAKE_INSTALL_PREFIX:PATH=../destination .. &&  cmake --build .
+          echo -e 'cmake_minimum_required(VERSION 3.14)\nproject(simdjsontester)\nset(CMAKE_CXX_STANDARD 17)\nfind_package(simdjson REQUIRED)'> CMakeLists.txt && mkdir build && cd build && cmake -DCMAKE_INSTALL_PREFIX:PATH=../destination .. &&  cmake --build .
@@ -31,4 +31,4 @@ jobs:
          echo -e '#include <simdjson.h>\nint main(int argc,char**argv) {simdjson::dom::parser parser;simdjson::dom::element tweets = parser.load(argv[1]); }' > tmp.cpp && c++ -Idestination/include -Ldestination/lib -std=c++17 -Wl,-rpath,destination/lib -o linkandrun tmp.cpp -lsimdjson && ./linkandrun jsonexamples/twitter.json &&
          mkdir testfindpackage &&
          cd testfindpackage &&
-          echo -e 'cmake_minimum_required(VERSION 3.1)\nproject(simdjsontester)\nset(CMAKE_CXX_STANDARD 17)\nfind_package(simdjson REQUIRED)'> CMakeLists.txt && mkdir build && cd build && cmake -DCMAKE_INSTALL_PREFIX:PATH=../destination .. &&  cmake --build .
+          echo -e 'cmake_minimum_required(VERSION 3.14)\nproject(simdjsontester)\nset(CMAKE_CXX_STANDARD 17)\nfind_package(simdjson REQUIRED)'> CMakeLists.txt && mkdir build && cd build && cmake -DCMAKE_INSTALL_PREFIX:PATH=../destination .. &&  cmake --build .
@@ -88,7 +88,6 @@ objs
 # Build outputs
 /build*/
 /visual_studio/
-/originbuild/

 # Fuzzer outputs generated by instructions in fuzz/Fuzzing.md
 /corpus.zip
@@ -3,7 +3,7 @@ cmake_minimum_required(VERSION 3.14)
 project(
    simdjson
    # The version number is modified by tools/release.py
-    VERSION 4.0.2
+    VERSION 4.0.6
    DESCRIPTION "Parsing gigabytes of JSON per second"
    HOMEPAGE_URL "https://simdjson.org/"
    LANGUAGES CXX C
@@ -38,7 +38,7 @@ PROJECT_NAME           = simdjson
 # could be handy for archiving the generated documentation or if some version
 # control system is used.

-PROJECT_NUMBER         = "4.0.2"
+PROJECT_NUMBER         = "4.0.6"

 # Using the PROJECT_BRIEF tag one can provide an optional one line description
 # for a project that appears at the top of each page and should give viewer a
@@ -62,6 +62,7 @@ Real-world usage
 - [WasmEdge](https://wasmedge.org)
 - [RonDB](https://github.com/logicalclocks/rondb)
 - [GreptimeDB](https://github.com/GreptimeTeam/greptimedb)
+- [mamba](https://github.com/mamba-org/mamba)


 If you are planning to use simdjson in a product, please work from one of our releases.
@@ -117,9 +118,9 @@ Godbolt
 -------------

 Some users may want to browse code along with the compiled assembly. You want to check out the following lists of examples:
+* [C++26 reflection example](https://godbolt.org/z/K3Px64TqK)
 * [simdjson examples with errors handled through exceptions](https://godbolt.org/z/7G5qE4sr9)
 * [simdjson examples with errors without exceptions](https://godbolt.org/z/e9dWb9E4v)
-* [C++26 reflection example](https://godbolt.org/z/xK5TGKdPb)

 Performance results
 -------------------
@@ -6,38 +6,42 @@ CPMAddPackage(
  EXCLUDE_FROM_ALL YES
 )

+option(SIMDJSON_USE_RUST "Build the static_reflect benchmark" OFF)

-
-if(NOT WIN32)
-# We want the check whether Rust is available before trying to build a crate.
-CPMAddPackage(
-  NAME corrosion
-  GITHUB_REPOSITORY corrosion-rs/corrosion
-  VERSION 0.4.4
-  DOWNLOAD_ONLY ON
-  OPTIONS "Rust_FIND_QUIETLY OFF"
-)
-include("${corrosion_SOURCE_DIR}/cmake/FindRust.cmake")
-endif()
-
-if(RUST_FOUND)
-  message(STATUS "Rust found: " ${Rust_VERSION} )
-  add_subdirectory("${corrosion_SOURCE_DIR}" "${PROJECT_BINARY_DIR}/_deps/corrosion" EXCLUDE_FROM_ALL)
-  # Important: we want to build in release mode!
-  corrosion_import_crate(MANIFEST_PATH "serde-benchmark/Cargo.toml" NO_LINKER_OVERRIDE PROFILE release)
-else()
-  message(STATUS "Rust/Cargo is unavailable." )
-  message(STATUS "We will not benchmark serde-benchmark." )
-  if (${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
-    message(STATUS "Under macOS, you may be able to install rust with")
-    message(STATUS "curl https://sh.rustup.rs -sSf | sh")
-  elseif(CMAKE_SYSTEM_NAME STREQUAL "Linux")
-    message(STATUS "Under Linux, you may be able to install rust with a command such as")
-    message(STATUS "apt-get install cargo" )
-    message(STATUS "or" )
-    message(STATUS "curl https://sh.rustup.rs -sSf | sh")
+if(SIMDJSON_USER_RUST)
+  if(NOT WIN32)
+  # We want the check whether Rust is available before trying to build a crate.
+  CPMAddPackage(
+    NAME corrosion
+    GITHUB_REPOSITORY corrosion-rs/corrosion
+    VERSION 0.4.4
+    DOWNLOAD_ONLY ON
+    OPTIONS "Rust_FIND_QUIETLY OFF"
+  )
+  include("${corrosion_SOURCE_DIR}/cmake/FindRust.cmake")
  endif()
-endif()
+
+  if(RUST_FOUND)
+    message(STATUS "Rust found: " ${Rust_VERSION} )
+    add_subdirectory("${corrosion_SOURCE_DIR}" "${PROJECT_BINARY_DIR}/_deps/corrosion" EXCLUDE_FROM_ALL)
+    # Important: we want to build in release mode!
+    corrosion_import_crate(MANIFEST_PATH "serde-benchmark/Cargo.toml" NO_LINKER_OVERRIDE PROFILE release)
+  else()
+    message(STATUS "Rust/Cargo is unavailable." )
+    message(STATUS "We will not benchmark serde-benchmark." )
+    if (${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
+      message(STATUS "Under macOS, you may be able to install rust with")
+      message(STATUS "curl https://sh.rustup.rs -sSf | sh")
+    elseif(CMAKE_SYSTEM_NAME STREQUAL "Linux")
+      message(STATUS "Under Linux, you may be able to install rust with a command such as")
+      message(STATUS "apt-get install cargo" )
+      message(STATUS "or" )
+      message(STATUS "curl https://sh.rustup.rs -sSf | sh")
+    endif()
+  endif()
+else(SIMDJSON_USER_RUST)
+  message(STATUS "We will not benchmark serde-benchmark." )
+endif(SIMDJSON_USER_RUST)

 # Add the benchmark executable targets
 add_subdirectory(twitter_benchmark)
@@ -174,6 +174,10 @@ else()
      -Werror -Wall -Wextra -Weffc++ -Wsign-compare -Wshadow -Wwrite-strings
      -Wpointer-arith -Winit-self -Wconversion -Wno-sign-conversion
  )
+  if(CMAKE_CXX_STANDARD VERSION_GREATER_EQUAL 20)
+    target_compile_options(simdjson-internal-flags INTERFACE -Wctad-maybe-unsupported)
+  endif()
+
 endif()

 option(SIMDJSON_GLIBCXX_ASSERTIONS "Set _GLIBCXX_ASSERTIONS" OFF)
@@ -1,7 +1,7 @@
 #
 # Implementation selection
 #
-set(SIMDJSON_ALL_IMPLEMENTATIONS fallback westmere haswell icelake arm64 ppc64 rvv)
+set(SIMDJSON_ALL_IMPLEMENTATIONS fallback westmere haswell icelake arm64 ppc64)

 set(
    SIMDJSON_IMPLEMENTATION ""
@@ -15,7 +15,7 @@ set(
    SIMDJSON_EXCLUDE_IMPLEMENTATION ""
    CACHE STRING "\
 Semicolon-separated list of implementations to exclude \
-(icelake/haswell/westmere/arm64/ppc64/rvv/fallback). By default, excludes any \
+(icelake/haswell/westmere/arm64/ppc64/fallback). By default, excludes any \
 implementations that are unsupported at compile time or cannot be selected at \
 runtime."
 )
@@ -1395,11 +1395,14 @@ Car c = doc.get<Car>();

 We try to automate the parsing of any given structure or class
 by looking at its non-static public members. At compile-time,
-the library looks at a simple structre like `Car` and
+the library looks at a simple structure like `Car` and
 maps it to parsing code. We call the default constructor,
 and then assign values to the public members.


+If a key is missing in the JSON document, an error is generated (`NO_SUCH_FIELD`),
+except if the attribute is of a type like `std::optional` (`simdjson::concepts::optional_type`).
+
 #### Special cases

 However, there are instances where the construction cannot
@@ -1450,7 +1453,7 @@ struct complicated_weather_data {
 };
 ```

-The code might as simple as the following.
+The code might be as simple as the following.

 ```cpp
 auto padded = R"({"time":["2023-03-15T12:00:00Z"],"temperature":[42]})"_padded;
@@ -1477,6 +1480,12 @@ type without a document instance like so:
 Car car = simdjson::from(json);
 ```

+You can also use the `simdjson::from` syntax without exceptions, like so:
+```cpp
+Car car;
+simdjson::error_code err = simdjson::from(json_car).get(car);
+```
+
 You can also use the `simdjson::from` syntax to iterate over an array.

 ```cpp
@@ -34,14 +34,15 @@ It has the following methods to add content to the string:
 - `append_null()`: Appends the string "null" to the JSON buffer.
 - `clear()`: Clears the contents of the JSON buffer, resetting the position to 0 while retaining the allocated capacity.
 - `escape_and_append(std::string_view input)`: Appends a string view to the JSON buffer after escaping special characters (e.g., quotes, backslashes) as required by JSON.
- `escape_and_append_with_quotes(std::string_view input)` Appends a string view surrounded by double quotes (e.g., "input") to the JSON buffer after escaping special characters.
-Parameters:
+- `escape_and_append_with_quotes(std::string_view input)` Appends a string view surrounded by double quotes (e.g., "input") to the JSON buffer after escaping special characters. For constant strings, you may also do `escape_and_append_with_quotes<"mystring">()`.
 - `escape_and_append_with_quotes(char input)`: Appends a single character surrounded by double quotes (e.g., "c") to the JSON buffer after escaping it if necessary.
 - `append_raw(const char *c)`: Appends a null-terminated C string directly to the JSON buffer without escaping.
 - `append_raw(std::string_view input)`: Appends a string view directly to the JSON buffer without escaping.
 - `append_raw(const char *str, size_t len)`: Appends a specified number of characters from a C string directly to the JSON
+- `append_key_value(key,value)`: Appends a key and a value (`"json":somevalue`)
+- `append_key_value<"mykey">(value)`: Appends a key and a value (`"json":somevalue`), useful when the key is a compile-time constant (C++20).

-After writting the content, if you have reasons to believe that the content might violate UTF-8 conventions, you can check it as follows:
+After writing the content, if you have reasons to believe that the content might violate UTF-8 conventions, you can check it as follows:

 - `validate_unicode()`: Checks if the content in the JSON buffer is valid UTF-8. Returns: true if the content is valid UTF-8, false otherwise.

@@ -52,7 +53,7 @@ Once you are satisfied, you can recover the string as follows:

 - `operator std::string()`: Converts the JSON buffer to an std::string. (Might throw if an error occurred.)
 - `operator std::string_view()`: Converts the JSON buffer to an std::string_view.  (Might throw if an error occurred.)
- `view()`: Returns a view of the written JSON buffer as a `simdjson_result<std::string_view>`.
+- `view()`: Returns a view of the written JSON buffer as a `simdjson_result<std::string_view>` (C++20).

 The later method (`view()`) is recommended.  For performance reasons, we expect you to explicitly call `validate_unicode()` as needed (e.g., prior to calling `view()`).

@@ -131,20 +132,20 @@ In all cases, the `std::string_view` instance depends the corresponding `string_



-If you have C++20, you can simplify the code, as the `std::vector<double>` is automatically
-supported.
+If you have C++20, you can simplify the code, as the `std::vector<double>` is automatically supported. Further, we can pass the keys (which are compile-time
+constant) as template parameter (for improved performance).

 ```cpp
    Car c = {"Toyota", "Corolla", 2017, {30.0,30.2,30.513,30.79}};
    simdjson::builder::string_builder sb;
    sb.start_object();
-    sb.append_key_value("make", c.make);
+    sb.append_key_value<"make">(c.make);
    sb.append_comma();
-    sb.append_key_value("model", c.model);
+    sb.append_key_value<"model">(c.model);
    sb.append_comma();
-    sb.append_key_value("year", c.year);
+    sb.append_key_value<"year">(c.year);
    sb.append_comma();
-    sb.append_key_value("tire_pressure", c.tire_pressure);
+    sb.append_key_value<"tire_pressure">(c.tire_pressure);
    sb.end_object();
    std::string_view p = sb.view();
 ```
@@ -175,9 +176,52 @@ std::vector<std::vector<double>> c = {{1.0, 2.0}, {3.0, 4.0}};
 std::string json = simdjson::to_json(c);
 ```

+We also have an overload for when you want to reuse the same `std::string` instance:
+
+
+```cpp
+std::vector<std::vector<double>> c = {{1.0, 2.0}, {3.0, 4.0}};
+std::string json;
+auto error = simdjson::to_json(c, json);
+if(error) { /* there was an error */ }
+```
+
+
 We do recommend that you create and reuse the `string_builder` instance for performance
 reasons.

+You can also add custom serialization functions using a `tag_invoke` function.
+For example, the following
+function will allow you to serialize instances of the type `Car`.
+
+```cpp
+#include <simdjson>
+
+struct Car {
+  std::string make;
+  std::string model;
+  int64_t year;
+  std::vector<float> tire_pressure;
+};
+
+namespace simdjson {
+
+template <typename builder_type>
+void tag_invoke(serialize_tag, builder_type &builder, const Car& car) {
+  builder.start_object();
+  builder.append_key_value("make", car.make);
+  builder.append_comma();
+  builder.append_key_value("model", car.model);
+  builder.append_comma();
+  builder.append_key_value("year", car.year);
+  builder.append_comma();
+  builder.append_key_value("tire_pressure", car.tire_pressure);
+  builder.end_object();
+}
+
+} // namespace simdjson
+```
+
 C++26 static reflection
 ------------------------

@@ -239,7 +283,17 @@ with the `simdjson::to_json` template function.
 If you know the output size, in bytes, of your JSON string, you may
 pass it as a second parameter (e.g., `simdjson::to_json(c, 31123)`).

+Sometimes you may want to reuse the same `std::string` instance. We
+have an overload for this purpose:

+```cpp
+Car c = {"Toyota", "Corolla", 2017, {30.0,30.2,30.513,30.79}};
+std::string s;
+auto error = simdjson::to_json(c, s);
+if(error) { /* there was an error */ }
+```
+
+You can then also add a third parameter for the expected output size in bytes.

 ### Without `string_buffer` instance but with explicit error handling

@@ -248,9 +302,44 @@ pattern:

 ```cpp
  std::string json;
-  if(simdjson::to(c).get(json)) {
+  if(simdjson::to_json(c).get(json)) {
    // there was an error
  } else {
    // json contain the serialized JSON
  }
+```
+
+### Customization
+
+If you want to serialize a value in a custome way, you can do it with a
+`tag_invoke` specialization like the following example which will map
+the year attribute to a string.
+
+
+```cpp
+#include <simdjson>
+
+struct Car {
+  std::string make;
+  std::string model;
+  int64_t year;
+  std::vector<float> tire_pressure;
+};
+
+namespace simdjson {
+
+template <typename builder_type>
+void tag_invoke(serialize_tag, builder_type &builder, const Car& car) {
+  builder.start_object();
+  builder.append_key_value("make", car.make);
+  builder.append_comma();
+  builder.append_key_value("model", car.model);
+  builder.append_comma();
+  builder.append_key_value("year", std::to_string(car.year));
+  builder.append_comma();
+  builder.append_key_value("tire_pressure", car.tire_pressure);
+  builder.end_object();
+}
+
+} // namespace simdjson
 ```
@@ -129,7 +129,7 @@ Once you have an element, you can navigate it with idiomatic C++ iterators, oper
  The strings contain unescaped valid UTF-8 strings: no unmatched surrogate is allowed.
  Internally, numbers are stored as either 64-bit integers or 64-bit floating-point numbers.
  Thus it is possible to get the full 64-bit integer range (either signed or  unsigned).
-  By default, the string `-0` is parsed as the integer 0 as in Pytho or C++. If you set the macro
+  By default, the string `-0` is parsed as the integer 0 as in Python or C++. If you set the macro
  `SIMDJSON_MINUS_ZERO_AS_FLOAT` to `1` when building simdjson, you can get that `-0` is mapped to `-0.0`
  as in JavaScript. You can get the desired effect by building simdjson with cmake setting the
  `SIMDJSON_MINUS_ZERO_AS_FLOAT` to on: `cmake -B build -D SIMDJSON_MINUS_ZERO_AS_FLOAT=ON`.
@@ -24,8 +24,6 @@
 #include "simdjson/lsx.h"
 #elif SIMDJSON_BUILTIN_IMPLEMENTATION_IS(lasx)
 #include "simdjson/lasx.h"
-#elif SIMDJSON_BUILTIN_IMPLEMENTATION_IS(rvv)
-#include "simdjson/rvv.h"
 #else
 #error Unknown SIMDJSON_BUILTIN_IMPLEMENTATION
 #endif
@@ -21,8 +21,6 @@ namespace simdjson {
  namespace lsx {}
 #elif SIMDJSON_BUILTIN_IMPLEMENTATION_IS(lasx)
  namespace lasx {}
-#elif SIMDJSON_BUILTIN_IMPLEMENTATION_IS(rvv)
-  namespace rvv {}
 #else
 #error Unknown SIMDJSON_BUILTIN_IMPLEMENTATION
 #endif
@@ -23,8 +23,6 @@
 #include "simdjson/lsx/implementation.h"
 #elif SIMDJSON_BUILTIN_IMPLEMENTATION_IS(lasx)
 #include "simdjson/lasx/implementation.h"
-#elif SIMDJSON_BUILTIN_IMPLEMENTATION_IS(rvv)
-#include "simdjson/rvv/implementation.h"
 #else
 #error Unknown SIMDJSON_BUILTIN_IMPLEMENTATION
 #endif
@@ -24,8 +24,6 @@
 #include "simdjson/lsx/ondemand.h"
 #elif SIMDJSON_BUILTIN_IMPLEMENTATION_IS(lasx)
 #include "simdjson/lasx/ondemand.h"
-#elif SIMDJSON_BUILTIN_IMPLEMENTATION_IS(rvv)
-#include "simdjson/rvv/ondemand.h"
 #else
 #error Unknown SIMDJSON_BUILTIN_IMPLEMENTATION
 #endif
@@ -122,11 +122,32 @@ concept optional_type = requires(std::remove_cvref_t<T> obj) {
    } -> std::convertible_to<typename std::remove_cvref_t<T>::value_type>;
  };
  { static_cast<bool>(obj) } -> std::same_as<bool>; // convertible to bool
+  { obj.reset() } noexcept -> std::same_as<void>;
 };



+
+
 } // namespace concepts
+
+
+/**
+ * We use tag_invoke as our customization point mechanism.
+ */
+template <typename Tag, typename... Args>
+concept tag_invocable = requires(Tag tag, Args... args) {
+  tag_invoke(std::forward<Tag>(tag), std::forward<Args>(args)...);
+};
+
+template <typename Tag, typename... Args>
+concept nothrow_tag_invocable =
+    tag_invocable<Tag, Args...> && requires(Tag tag, Args... args) {
+      {
+        tag_invoke(std::forward<Tag>(tag), std::forward<Args>(args)...)
+      } noexcept;
+    };
+
 } // namespace simdjson
 #endif // SIMDJSON_SUPPORTS_CONCEPTS
 #endif // SIMDJSON_CONCEPTS_H
@@ -58,6 +58,12 @@ inline simdjson_result<T> auto_parser<parser_type>::result() noexcept(is_nothrow
  return m_doc.get<T>();
 }

+template <typename parser_type>
+template <typename T>
+simdjson_warn_unused simdjson_inline error_code auto_parser<parser_type>::get(T &value) && noexcept(is_nothrow_gettable<T>) {
+  return result<T>().get(value);
+}
+
 template <typename parser_type>
 inline simdjson_result<ondemand::array> auto_parser<parser_type>::array() noexcept {
  return result<ondemand::array>();
@@ -73,12 +79,7 @@ inline simdjson_result<ondemand::number> auto_parser<parser_type>::number() noex
  return result<ondemand::number>();
 }

-template <typename parser_type>
-template <typename T>
-inline auto_parser<parser_type>::operator simdjson_result<T>() noexcept(is_nothrow_gettable<T>) {
-  return result<T>();
-}
-
+#if SIMDJSON_EXCEPTIONS
 template <typename parser_type>
 template <typename T>
 inline auto_parser<parser_type>::operator T() noexcept(false) {
@@ -87,6 +88,7 @@ inline auto_parser<parser_type>::operator T() noexcept(false) {
  }
  return m_doc.get<T>();
 }
+#endif // SIMDJSON_EXCEPTIONS

 template <typename parser_type>
 template <typename T>
@@ -109,13 +111,23 @@ inline T to_adaptor<T>::operator()(simdjson_result<ondemand::value> &val) const

 template <typename T>
 inline auto to_adaptor<T>::operator()(padded_string_view const str) const noexcept {
-  return auto_parser{str};
+  return auto_parser<ondemand::parser *>{str};
 }

 template <typename T>
 inline auto to_adaptor<T>::operator()(ondemand::parser &parser, padded_string_view const str) const noexcept {
  return auto_parser<ondemand::parser *>{parser, str};
 }
+
+template <typename T>
+inline auto to_adaptor<T>::operator()(std::string str) const noexcept {
+  return auto_parser<ondemand::parser *>{pad_with_reserve(str)};
+}
+
+template <typename T>
+inline auto to_adaptor<T>::operator()(ondemand::parser &parser, std::string str) const noexcept {
+  return auto_parser<ondemand::parser *>{parser, pad_with_reserve(str)};
+}
 } // namespace internal
 } // namespace convert
 } // namespace simdjson
@@ -46,16 +46,19 @@ public:

 	template <typename T>
 	simdjson_warn_unused simdjson_inline simdjson_result<T> result() noexcept(is_nothrow_gettable<T>);
+	template <typename T>
+	simdjson_warn_unused simdjson_inline error_code get(T &value) && noexcept(is_nothrow_gettable<T>);
+

 	simdjson_warn_unused simdjson_inline simdjson_result<ondemand::array> array() noexcept;
 	simdjson_warn_unused simdjson_inline simdjson_result<ondemand::object> object() noexcept;
 	simdjson_warn_unused simdjson_inline simdjson_result<ondemand::number> number() noexcept;

-	template <typename T>
-	simdjson_warn_unused simdjson_inline explicit(false) operator simdjson_result<T>() noexcept(is_nothrow_gettable<T>);

+#if SIMDJSON_EXCEPTIONS
 	template <typename T>
 	simdjson_warn_unused simdjson_inline explicit(false) operator T() noexcept(false);
+#endif // SIMDJSON_EXCEPTIONS

 	template <typename T>
 	simdjson_warn_unused simdjson_inline std::optional<T> optional() noexcept(is_nothrow_gettable<T>);
@@ -72,7 +75,14 @@ struct to_adaptor {
 	T operator()(simdjson_result<ondemand::value> &val) const noexcept;
 	auto operator()(padded_string_view const str) const noexcept;
 	auto operator()(ondemand::parser &parser, padded_string_view const str) const noexcept;
+	// The std::string is padded with reserve to ensure there is enough space for padding.
+	// Some sanitizers may not like this, so you can use simdjson::pad instead.
+	// simdjson::from(simdjson::pad(str))
+	auto operator()(std::string str) const noexcept;
+	auto operator()(ondemand::parser &parser, std::string str) const noexcept;
 };
+// deduction guide
+auto_parser(padded_string_view const str) -> auto_parser<ondemand::parser*>;
 } // namespace internal
 } // namespace convert

@@ -7,55 +7,8 @@
 #include "simdjson/generic/ondemand/array.h"
 #endif // SIMDJSON_CONDITIONAL_INCLUDE

-#include <concepts>
 namespace simdjson {

-namespace tag_invoke_fn_ns {
-void tag_invoke();
-
-struct tag_invoke_fn {
-  template <typename Tag, typename... Args>
-    requires requires(Tag tag, Args &&...args) {
-      tag_invoke(std::forward<Tag>(tag), std::forward<Args>(args)...);
-    }
-  constexpr auto operator()(Tag tag, Args &&...args) const
-      noexcept(noexcept(tag_invoke(std::forward<Tag>(tag),
-                                   std::forward<Args>(args)...)))
-          -> decltype(tag_invoke(std::forward<Tag>(tag),
-                                 std::forward<Args>(args)...)) {
-    return tag_invoke(std::forward<Tag>(tag), std::forward<Args>(args)...);
-  }
-};
-} // namespace tag_invoke_fn_ns
-
-inline namespace tag_invoke_ns {
-inline constexpr tag_invoke_fn_ns::tag_invoke_fn tag_invoke = {};
-} // namespace tag_invoke_ns
-
-template <typename Tag, typename... Args>
-concept tag_invocable = requires(Tag tag, Args... args) {
-  tag_invoke(std::forward<Tag>(tag), std::forward<Args>(args)...);
-};
-
-template <typename Tag, typename... Args>
-concept nothrow_tag_invocable =
-    tag_invocable<Tag, Args...> && requires(Tag tag, Args... args) {
-      {
-        tag_invoke(std::forward<Tag>(tag), std::forward<Args>(args)...)
-      } noexcept;
-    };
-
-template <typename Tag, typename... Args>
-using tag_invoke_result =
-    std::invoke_result<decltype(tag_invoke), Tag, Args...>;
-
-template <typename Tag, typename... Args>
-using tag_invoke_result_t =
-    std::invoke_result_t<decltype(tag_invoke), Tag, Args...>;
-
-template <auto &Tag> using tag_t = std::decay_t<decltype(Tag)>;
-
-
 struct deserialize_tag;

 /// These types are deserializable in a built-in way
@@ -38,7 +38,7 @@ concept container_but_not_string =
    !std::is_same_v<T, std::string_view> && !std::is_same_v<T, const char *>;

 template <class T>
-  requires(container_but_not_string<T>)
+  requires(container_but_not_string<T> && !require_custom_serialization<T>)
 constexpr void atom(string_builder &b, const T &t) {
  if (t.size() == 0) {
    b.append_raw("[]");
@@ -63,6 +63,7 @@ constexpr void atom(string_builder &b, const T &t) {
 }

 template <concepts::string_view_keyed_map T>
+  requires(!require_custom_serialization<T>)
 constexpr void atom(string_builder &b, const T &m) {
  if (m.empty()) {
    b.append_raw("{}");
@@ -99,7 +100,7 @@ template <class T>
           !std::is_same_v<T, std::string> &&
           !std::is_same_v<T, std::string_view> &&
           !std::is_same_v<T, const char*> &&
-           !std::is_same_v<T, char>)
+           !std::is_same_v<T, char> && !require_custom_serialization<T>)
 constexpr void atom(string_builder &b, const T &t) {
  int i = 0;
  b.append('{');
@@ -117,6 +118,7 @@ constexpr void atom(string_builder &b, const T &t) {

 // Support for optional types (std::optional, etc.)
 template <concepts::optional_type T>
+  requires(!require_custom_serialization<T>)
 constexpr void atom(string_builder &b, const T &opt) {
  if (opt) {
    atom(b, opt.value());
@@ -127,6 +129,7 @@ constexpr void atom(string_builder &b, const T &opt) {

 // Support for smart pointers (std::unique_ptr, std::shared_ptr, etc.)
 template <concepts::smart_pointer T>
+  requires(!require_custom_serialization<T>)
 constexpr void atom(string_builder &b, const T &ptr) {
  if (ptr) {
    atom(b, *ptr);
@@ -137,7 +140,7 @@ constexpr void atom(string_builder &b, const T &ptr) {

 // Support for enums - serialize as string representation using expand approach from P2996R12
 template <typename T>
-  requires(std::is_enum_v<T>)
+  requires(std::is_enum_v<T> && !require_custom_serialization<T>)
 void atom(string_builder &b, const T &e) {
 #if SIMDJSON_STATIC_REFLECTION
  constexpr auto enumerators = std::define_static_array(std::meta::enumerators_of(^^T));
@@ -161,7 +164,7 @@ template <concepts::appendable_containers T>
  requires(!container_but_not_string<T> && !concepts::string_view_keyed_map<T> &&
           !concepts::optional_type<T> && !concepts::smart_pointer<T> &&
           !std::is_same_v<T, std::string> &&
-           !std::is_same_v<T, std::string_view> && !std::is_same_v<T, const char*>)
+           !std::is_same_v<T, std::string_view> && !std::is_same_v<T, const char*> && !require_custom_serialization<T>)
 constexpr void atom(string_builder &b, const T &container) {
  if (container.empty()) {
    b.append_raw("[]");
@@ -196,11 +199,13 @@ void append(string_builder &b, const T &t) {
 }

 template <concepts::optional_type T>
+  requires(!require_custom_serialization<T>)
 void append(string_builder &b, const T &t) {
  atom(b, t);
 }

 template <concepts::smart_pointer T>
+  requires(!require_custom_serialization<T>)
 void append(string_builder &b, const T &t) {
  atom(b, t);
 }
@@ -209,12 +214,13 @@ template <concepts::appendable_containers T>
  requires(!container_but_not_string<T> && !concepts::string_view_keyed_map<T> &&
           !concepts::optional_type<T> && !concepts::smart_pointer<T> &&
           !std::is_same_v<T, std::string> &&
-           !std::is_same_v<T, std::string_view> && !std::is_same_v<T, const char*>)
+           !std::is_same_v<T, std::string_view> && !std::is_same_v<T, const char*> && !require_custom_serialization<T>)
 void append(string_builder &b, const T &t) {
  atom(b, t);
 }

 template <concepts::string_view_keyed_map T>
+  requires(!require_custom_serialization<T>)
 void append(string_builder &b, const T &t) {
  atom(b, t);
 }
@@ -229,7 +235,7 @@ template <class Z>
           !std::is_same_v<Z, std::string> &&
           !std::is_same_v<Z, std::string_view> &&
           !std::is_same_v<Z, const char*> &&
-           !std::is_same_v<Z, char>)
+           !std::is_same_v<Z, char> && !require_custom_serialization<Z>)
 void append(string_builder &b, const Z &z) {
  int i = 0;
  b.append('{');
@@ -247,7 +253,7 @@ void append(string_builder &b, const Z &z) {

 // works for container
 template <class Z>
-  requires(container_but_not_string<Z>)
+  requires(container_but_not_string<Z> && !require_custom_serialization<Z>)
 void append(string_builder &b, const Z &z) {
  if (z.size() == 0) {
    b.append_raw("[]");
@@ -263,7 +269,14 @@ void append(string_builder &b, const Z &z) {
 }

 template <class Z>
-simdjson_result<std::string> to_json_string(const Z &z, size_t initial_capacity = 1024) {
+  requires (require_custom_serialization<Z>)
+void append(string_builder &b, const Z &z) {
+  b.append(z);
+}
+
+
+template <class Z>
+simdjson_warn_unused simdjson_result<std::string> to_json_string(const Z &z, size_t initial_capacity = string_builder::DEFAULT_INITIAL_CAPACITY) {
  string_builder b(initial_capacity);
  append(b, z);
  std::string_view s;
@@ -272,8 +285,8 @@ simdjson_result<std::string> to_json_string(const Z &z, size_t initial_capacity
 }

 template <class Z>
-simdjson_error to_json(const Z &z, std::string &s) {
-  string_builder b;
+simdjson_warn_unused simdjson_error to_json(const Z &z, std::string &s, size_t initial_capacity = string_builder::DEFAULT_INITIAL_CAPACITY) {
+  string_builder b(initial_capacity);
  append(b, z);
  std::string_view view;
  if(auto e = b.view().get(view); e) { return e; }
@@ -290,9 +303,13 @@ string_builder& operator<<(string_builder& b, const Z& z) {
 } // namespace SIMDJSON_IMPLEMENTATION
 // Alias the function template to 'to' in the global namespace
 template <class Z>
-simdjson_result<std::string> to_json(const Z &z, size_t initial_capacity = 1024) {
+simdjson_warn_unused simdjson_result<std::string> to_json(const Z &z, size_t initial_capacity = SIMDJSON_IMPLEMENTATION::builder::string_builder::DEFAULT_INITIAL_CAPACITY) {
  return SIMDJSON_IMPLEMENTATION::builder::to_json_string(z, initial_capacity);
 }
+template <class Z>
+simdjson_warn_unused simdjson_error to_json(const Z &z, std::string &s, size_t initial_capacity = SIMDJSON_IMPLEMENTATION::builder::string_builder::DEFAULT_INITIAL_CAPACITY) {
+  return SIMDJSON_IMPLEMENTATION::builder::to_json(z, s, initial_capacity);
+}
 } // namespace simdjson

 #endif // SIMDJSON_STATIC_REFLECTION
@@ -284,10 +284,12 @@ simdjson_inline void string_builder::clear() noexcept {

 namespace internal {

-// We could specialize further for 32-bit integers.
-simdjson_really_inline int int_log2(uint32_t x) { return (63 - leading_zeroes(x | 1)); }

-simdjson_really_inline int fast_digit_count(uint32_t x) {
+template <typename number_type, typename = typename std::enable_if<
+                                    std::is_unsigned<number_type>::value>::type>
+simdjson_really_inline int int_log2(number_type x) { return 63 - leading_zeroes(uint64_t(x) | 1); }
+
+simdjson_really_inline int fast_digit_count_32(uint32_t x) {
  static uint64_t table[] = {
      4294967296,  8589934582,  8589934582,  8589934582,  12884901788,
      12884901788, 12884901788, 17179868184, 17179868184, 17179868184,
@@ -299,9 +301,8 @@ simdjson_really_inline int fast_digit_count(uint32_t x) {
  return uint32_t((x + table[int_log2(x)]) >> 32);
 }

-simdjson_really_inline int int_log2(uint64_t x) { return 63 - leading_zeroes(x | 1); }

-simdjson_really_inline int fast_digit_count(uint64_t x) {
+simdjson_really_inline int fast_digit_count_64(uint64_t x) {
  static uint64_t table[] = {9,
                             99,
                             999,
@@ -332,7 +333,11 @@ simdjson_really_inline size_t digit_count(number_type v) noexcept {
  static_assert(sizeof(number_type) == 8 || sizeof(number_type) == 4 ||
                    sizeof(number_type) == 2 || sizeof(number_type) == 1,
                "We only support 8-bit, 16-bit, 32-bit and 64-bit numbers");
-  return fast_digit_count(v);
+  SIMDJSON_IF_CONSTEXPR(sizeof(number_type) <= 4) {
+    return fast_digit_count_32(static_cast<uint32_t>(v));
+  } else {
+    return fast_digit_count_64(static_cast<uint64_t>(v));
+  }
 }
 static const char decimal_table[200] = {
  0x30, 0x30, 0x30, 0x31, 0x30, 0x32, 0x30, 0x33, 0x30, 0x34, 0x30, 0x35,
@@ -355,6 +360,7 @@ static const char decimal_table[200] = {
 };
 } // namespace internal

+
 template <typename number_type, typename>
 simdjson_inline void string_builder::append(number_type v) noexcept {
  static_assert(std::is_same<number_type, bool>::value ||
@@ -470,6 +476,12 @@ simdjson_inline void string_builder::escape_and_append_with_quotes(const char* i
  std::string_view cinput(input);
  escape_and_append_with_quotes(cinput);
 }
+#if SIMDJSON_SUPPORTS_CONCEPTS
+template<internal::fixed_string key>
+simdjson_inline void string_builder::escape_and_append_with_quotes()  noexcept {
+  escape_and_append_with_quotes(internal::string_constant<key>::value);
+}
+#endif

 simdjson_inline void string_builder::append_raw(const char *c) noexcept {
  size_t len = std::strlen(c);
@@ -494,6 +506,7 @@ simdjson_inline void string_builder::append_raw(const char *str,
 #if SIMDJSON_SUPPORTS_CONCEPTS
 // Support for optional types (std::optional, etc.)
 template <concepts::optional_type T>
+ requires(!require_custom_serialization<T>)
 simdjson_inline void string_builder::append(const T &opt) {
  if (opt) {
    append(*opt);
@@ -501,9 +514,17 @@ simdjson_inline void string_builder::append(const T &opt) {
    append_null();
  }
 }
+
+
+template <typename T>
+requires(require_custom_serialization<T>)
+simdjson_inline void string_builder::append(const T &val) {
+  serialize(*this, val);
+}
+
 template <typename T>
 requires(std::is_convertible<T, std::string_view>::value ||
-std::is_same<T, const char*>::value )
+std::is_same<T, const char*>::value)
 simdjson_inline void string_builder::append(const T &value) {
  escape_and_append_with_quotes(value);
 }
@@ -649,6 +670,25 @@ simdjson_inline void string_builder::append_key_value(key_type key, value_type v
  }
 }

+#if SIMDJSON_SUPPORTS_CONCEPTS
+template<internal::fixed_string key, typename value_type>
+simdjson_inline void string_builder::append_key_value(value_type value) noexcept {
+  escape_and_append_with_quotes<key>();
+  append_colon();
+  SIMDJSON_IF_CONSTEXPR(std::is_same<value_type, std::nullptr_t>::value) {
+    append_null();
+  } else SIMDJSON_IF_CONSTEXPR(std::is_same<value_type, char>::value) {
+    escape_and_append_with_quotes(value);
+  } else SIMDJSON_IF_CONSTEXPR(std::is_convertible<value_type, std::string_view>::value) {
+    escape_and_append_with_quotes(value);
+  } else SIMDJSON_IF_CONSTEXPR(std::is_same<value_type, const char*>::value) {
+    escape_and_append_with_quotes(value);
+  } else {
+    append(value);
+  }
+}
+#endif
+
 } // namespace builder
 } // namespace SIMDJSON_IMPLEMENTATION
 } // namespace simdjson
@@ -10,9 +10,62 @@
 #endif // SIMDJSON_CONDITIONAL_INCLUDE

 namespace simdjson {
+
+
+#if SIMDJSON_SUPPORTS_CONCEPTS
+
 namespace SIMDJSON_IMPLEMENTATION {
 namespace builder {
+  class string_builder;
+}}

+template <typename T, typename = void>
+struct has_custom_serialization : std::false_type {};
+
+inline constexpr struct serialize_tag {
+  template <typename T>
+    requires custom_deserializable<T>
+  constexpr void operator()(SIMDJSON_IMPLEMENTATION::builder::string_builder& b, T& obj) const{
+    return tag_invoke(*this, b, obj);
+  }
+
+
+} serialize{};
+template <typename T>
+struct has_custom_serialization<T, std::void_t<
+    decltype(tag_invoke(serialize, std::declval<SIMDJSON_IMPLEMENTATION::builder::string_builder&>(), std::declval<T&>()))
+>> : std::true_type {};
+
+template <typename T>
+constexpr bool require_custom_serialization = has_custom_serialization<T>::value;
+#else
+struct has_custom_serialization : std::false_type {};
+#endif // SIMDJSON_SUPPORTS_CONCEPTS
+
+namespace SIMDJSON_IMPLEMENTATION {
+namespace builder {
+#if SIMDJSON_SUPPORTS_CONCEPTS
+// Helper to create string constants
+namespace internal {
+template <std::size_t N>
+struct fixed_string {
+    constexpr fixed_string(const char (&str)[N])  {
+        for (std::size_t i = 0; i < N; ++i) {
+            data[i] = str[i];
+        }
+    }
+    char data[N];
+    constexpr std::string_view view() const { return {data, N - 1}; }
+};
+template <std::size_t N>
+fixed_string(const char (&)[N]) -> fixed_string<N>;
+
+template <fixed_string str>
+struct string_constant {
+    static constexpr std::string_view value = str.view();
+};
+} // namespace internal
+#endif // SIMDJSON_SUPPORTS_CONCEPTS
 /**
 * A builder for JSON strings representing documents. This is a low-level
 * builder that is not meant to be used directly by end-users. Though it
@@ -24,7 +77,9 @@ namespace builder {
 */
 class string_builder {
 public:
-  simdjson_inline string_builder(size_t initial_capacity = 1024);
+  simdjson_inline string_builder(size_t initial_capacity = DEFAULT_INITIAL_CAPACITY);
+
+  static constexpr size_t DEFAULT_INITIAL_CAPACITY = 1024;

  /**
   * Append number (includes Booleans). Booleans are mapped to the strings
@@ -33,7 +88,7 @@ public:
   * represents the number.
   */
  template<typename number_type,
-         typename = typename std::enable_if<std::is_arithmetic<number_type>::value>::type>
+    typename = typename std::enable_if<std::is_arithmetic<number_type>::value>::type>
  simdjson_inline void append(number_type v) noexcept;

  /**
@@ -62,7 +117,10 @@ public:
   * There is no UTF-8 validation.
   */
  simdjson_inline void escape_and_append_with_quotes(std::string_view input)  noexcept;
-
+#if SIMDJSON_SUPPORTS_CONCEPTS
+  template<internal::fixed_string key>
+  simdjson_inline void escape_and_append_with_quotes()  noexcept;
+#endif
  /**
   * Append the character surrounded by double quotes, after escaping it.
   * There is no UTF-8 validation.
@@ -116,13 +174,21 @@ public:
   * The key is escaped and surrounded by double quotes.
   * The value is escaped if it is a string.
   */
-   template<typename key_type, typename value_type>
+  template<typename key_type, typename value_type>
  simdjson_inline void append_key_value(key_type key, value_type value) noexcept;
 #if SIMDJSON_SUPPORTS_CONCEPTS
+  template<internal::fixed_string key, typename value_type>
+  simdjson_inline void append_key_value(value_type value) noexcept;
+
  // Support for optional types (std::optional, etc.)
  template <concepts::optional_type T>
+  requires(!require_custom_serialization<T>)
  simdjson_inline void append(const T &opt);

+  template <typename T>
+  requires(require_custom_serialization<T>)
+  simdjson_inline void append(const T &val);
+
  // Support for string-like types
  template <typename T>
  requires(std::is_convertible<T, std::string_view>::value ||
@@ -232,7 +298,7 @@ private:
 #if !SIMDJSON_STATIC_REFLECTION
 // fallback implementation until we have static reflection
 template <class Z>
-simdjson_result<std::string> to_json(const Z &z, size_t initial_capacity = 1024) {
+simdjson_warn_unused simdjson_result<std::string> to_json(const Z &z, size_t initial_capacity = simdjson::SIMDJSON_IMPLEMENTATION::builder::string_builder::DEFAULT_INITIAL_CAPACITY) {
  simdjson::SIMDJSON_IMPLEMENTATION::builder::string_builder b(initial_capacity);
  b.append(z);
  std::string_view s;
@@ -240,8 +306,20 @@ simdjson_result<std::string> to_json(const Z &z, size_t initial_capacity = 1024)
  if(e) { return e; }
  return std::string(s);
 }
+template <class Z>
+simdjson_warn_unused simdjson_error to_json(const Z &z, std::string &s, size_t initial_capacity = simdjson::SIMDJSON_IMPLEMENTATION::builder::string_builder::DEFAULT_INITIAL_CAPACITY) {
+  simdjson::SIMDJSON_IMPLEMENTATION::builder::string_builder b(initial_capacity);
+  b.append(z);
+  std::string_view sv;
+  auto e = b.view().get(sv);
+  if(e) { return e; }
+  s.assign(sv.data(), sv.size());
+  return simdjson::SUCCESS;
+}
 #endif

+#if SIMDJSON_SUPPORTS_CONCEPTS
+#endif // SIMDJSON_SUPPORTS_CONCEPTS

 } // namespace simdjson

@@ -16,15 +16,12 @@
 #endif

 namespace simdjson {
-template <typename T>
-constexpr bool require_custom_serialization = false;

 //////////////////////////////
 // Number deserialization
 //////////////////////////////

 template <std::unsigned_integral T>
-  requires(!require_custom_serialization<T>)
 error_code tag_invoke(deserialize_tag, auto &val, T &out) noexcept {
  using limits = std::numeric_limits<T>;

@@ -38,7 +35,6 @@ error_code tag_invoke(deserialize_tag, auto &val, T &out) noexcept {
 }

 template <std::floating_point T>
-  requires(!require_custom_serialization<T>)
 error_code tag_invoke(deserialize_tag, auto &val, T &out) noexcept {
  double x;
  SIMDJSON_TRY(val.get_double().get(x));
@@ -47,7 +43,6 @@ error_code tag_invoke(deserialize_tag, auto &val, T &out) noexcept {
 }

 template <std::signed_integral T>
-  requires(!require_custom_serialization<T>)
 error_code tag_invoke(deserialize_tag, auto &val, T &out) noexcept {
  using limits = std::numeric_limits<T>;

@@ -77,7 +72,6 @@ error_code tag_invoke(deserialize_tag, auto &val, char &out) noexcept {

 // any string-like type (can be constructed from std::string_view)
 template <concepts::constructible_from_string_view T, typename ValT>
-  requires(!require_custom_serialization<T>)
 error_code tag_invoke(deserialize_tag, ValT &val, T &out) noexcept(std::is_nothrow_constructible_v<T, std::string_view>) {
  std::string_view str;
  SIMDJSON_TRY(val.get_string().get(str));
@@ -94,7 +88,6 @@ error_code tag_invoke(deserialize_tag, ValT &val, T &out) noexcept(std::is_nothr
 * doc.get<std::vector<int>>().
 */
 template <concepts::appendable_containers T, typename ValT>
-  requires(!require_custom_serialization<T>)
 error_code tag_invoke(deserialize_tag, ValT &val, T &out) noexcept(false) {
  using value_type = typename std::remove_cvref_t<T>::value_type;
  static_assert(
@@ -140,7 +133,6 @@ error_code tag_invoke(deserialize_tag, ValT &val, T &out) noexcept(false) {
 * string-keyed types.
 */
 template <concepts::string_view_keyed_map T, typename ValT>
- requires(!require_custom_serialization<T>)
 error_code tag_invoke(deserialize_tag, ValT &val, T &out) noexcept(false) {
  using value_type = typename std::remove_cvref_t<T>::mapped_type;
  static_assert(
@@ -222,7 +214,6 @@ error_code tag_invoke(deserialize_tag, SIMDJSON_IMPLEMENTATION::ondemand::docume
 * @return status of the conversion
 */
 template <concepts::smart_pointer T, typename ValT>
-  requires(!require_custom_serialization<T>)
 error_code tag_invoke(deserialize_tag, ValT &val, T &out) noexcept(nothrow_deserializable<typename std::remove_cvref_t<T>::element_type, ValT>) {
  using element_type = typename std::remove_cvref_t<T>::element_type;

@@ -248,7 +239,6 @@ error_code tag_invoke(deserialize_tag, ValT &val, T &out) noexcept(nothrow_deser
 * This CPO (Customization Point Object) will help deserialize into optional types.
 */
 template <concepts::optional_type T>
-  requires(!require_custom_serialization<T>)
 error_code tag_invoke(deserialize_tag, auto &val, T &out) noexcept(nothrow_deserializable<typename std::remove_cvref_t<T>::value_type, decltype(val)>) {
  using value_type = typename std::remove_cvref_t<T>::value_type;

@@ -274,7 +264,7 @@ error_code tag_invoke(deserialize_tag, auto &val, T &out) noexcept(nothrow_deser
 template <typename T>
 constexpr bool user_defined_type = (std::is_class_v<T>
 && !std::is_same_v<T, std::string> && !std::is_same_v<T, std::string_view> && !concepts::optional_type<T> &&
-!concepts::appendable_containers<T> && !require_custom_serialization<T>);
+!concepts::appendable_containers<T>);


 template <typename T, typename ValT>
@@ -286,18 +276,26 @@ error_code tag_invoke(deserialize_tag, ValT &val, T &out) noexcept {
  } else {
    SIMDJSON_TRY(val.get_object().get(obj));
  }
-  error_code e = simdjson::SUCCESS;
  template for (constexpr auto mem : std::define_static_array(std::meta::nonstatic_data_members_of(^^T, std::meta::access_context::unchecked()))) {
-        if constexpr (!std::meta::is_const(mem) && std::meta::is_public(mem)) {
+    if constexpr (!std::meta::is_const(mem) && std::meta::is_public(mem)) {
      constexpr std::string_view key = std::define_static_string(std::meta::identifier_of(mem));
-      // Note: removed static assert as optional types are now handled generically
-      // as long we are succesful or the field is not found, we continue
-      if(e == simdjson::SUCCESS || e == simdjson::NO_SUCH_FIELD) {
-        e = obj[key].get(out.[:mem:]);
+      if constexpr (concepts::optional_type<decltype(out.[:mem:])>) {
+        // for optional members, it's ok if the key is missing
+        auto error = obj[key].get(out.[:mem:]);
+        if (error && error != NO_SUCH_FIELD) {
+          if(error == NO_SUCH_FIELD) {
+            out.[:mem:].reset();
+            continue;
+          }
+          return error;
+        }
+      } else {
+        // for non-optional members, the key must be present
+        SIMDJSON_TRY(obj[key].get(out.[:mem:]));
      }
    }
  };
-  return e;
+  return simdjson::SUCCESS;
 }

 // Support for enum deserialization - deserialize from string representation using expand approach from P2996R12
@@ -12,7 +12,6 @@
 #define SIMDJSON_IMPLEMENTATION_ID_westmere 6
 #define SIMDJSON_IMPLEMENTATION_ID_lsx 7
 #define SIMDJSON_IMPLEMENTATION_ID_lasx 8
-#define SIMDJSON_IMPLEMENTATION_ID_rvv 9

 #define SIMDJSON_IMPLEMENTATION_ID_FOR(IMPL) SIMDJSON_CAT(SIMDJSON_IMPLEMENTATION_ID_, IMPL)
 #define SIMDJSON_IMPLEMENTATION_ID SIMDJSON_IMPLEMENTATION_ID_FOR(SIMDJSON_IMPLEMENTATION)
@@ -24,15 +23,6 @@
 // in which we include them.
 //

-#ifndef SIMDJSON_IMPLEMENTATION_RVV
-#define SIMDJSON_IMPLEMENTATION_RVV (SIMDJSON_IS_RISCV64 && SIMDJSON_IS_RVV)
-#endif
-#if SIMDJSON_IMPLEMENTATION_RVV && SIMDJSON_IS_RISCV64 && SIMDJSON_IS_RVV
-#define SIMDJSON_CAN_ALWAYS_RUN_RVV 1
-#else
-#define SIMDJSON_CAN_ALWAYS_RUN_RVV 0
-#endif
-
 #ifndef SIMDJSON_IMPLEMENTATION_ARM64
 #define SIMDJSON_IMPLEMENTATION_ARM64 (SIMDJSON_IS_ARM64)
 #endif
@@ -138,7 +128,7 @@

 // Default Fallback to on unless a builtin implementation has already been selected.
 #ifndef SIMDJSON_IMPLEMENTATION_FALLBACK
-#if SIMDJSON_CAN_ALWAYS_RUN_ARM64 || SIMDJSON_CAN_ALWAYS_RUN_ICELAKE || SIMDJSON_CAN_ALWAYS_RUN_HASWELL || SIMDJSON_CAN_ALWAYS_RUN_WESTMERE || SIMDJSON_CAN_ALWAYS_RUN_PPC64 || SIMDJSON_CAN_ALWAYS_RUN_LSX || SIMDJSON_CAN_ALWAYS_RUN_LASX || SIMDJSON_CAN_ALWAYS_RUN_RVV
+#if SIMDJSON_CAN_ALWAYS_RUN_ARM64 || SIMDJSON_CAN_ALWAYS_RUN_ICELAKE || SIMDJSON_CAN_ALWAYS_RUN_HASWELL || SIMDJSON_CAN_ALWAYS_RUN_WESTMERE || SIMDJSON_CAN_ALWAYS_RUN_PPC64 || SIMDJSON_CAN_ALWAYS_RUN_LSX || SIMDJSON_CAN_ALWAYS_RUN_LASX
 // if anything at all except fallback can always run, then disable fallback.
 #define SIMDJSON_IMPLEMENTATION_FALLBACK 0
 #else
@@ -164,8 +154,6 @@
 #define SIMDJSON_BUILTIN_IMPLEMENTATION lsx
 #elif SIMDJSON_CAN_ALWAYS_RUN_LASX
 #define SIMDJSON_BUILTIN_IMPLEMENTATION lasx
-#elif SIMDJSON_CAN_ALWAYS_RUN_RVV
-#define SIMDJSON_BUILTIN_IMPLEMENTATION rvv
 #elif SIMDJSON_CAN_ALWAYS_RUN_FALLBACK
 #define SIMDJSON_BUILTIN_IMPLEMENTATION fallback
 #else
@@ -1,8 +0,0 @@
-#ifndef SIMDJSON_RVV_H
-#define SIMDJSON_RVV_H
-
-#include "simdjson/rvv/begin.h"
-#include "simdjson/generic/amalgamated.h"
-#include "simdjson/rvv/end.h"
-
-#endif // SIMDJSON_RVV_H
@@ -1,20 +0,0 @@
-#ifndef SIMDJSON_RVV_BASE_H
-#define SIMDJSON_RVV_BASE_H
-
-#ifndef SIMDJSON_CONDITIONAL_INCLUDE
-#include "simdjson/base.h"
-#endif // SIMDJSON_CONDITIONAL_INCLUDE
-namespace simdjson {
-namespace rvv {
-
-class implementation;
-
-namespace {
-namespace simd {
-template <typename T> struct simd8;
-template <typename T> struct simd8x64;
-} // namespace simd
-} // unnamed namespace
-} // namespace rvv
-} // namespace simdjson
-#endif // SIMDJSON_RVV_BASE_H
@@ -1,13 +0,0 @@
-#define SIMDJSON_IMPLEMENTATION rvv
-
-// include RVV intrinsics and definitions
-#include <riscv_vector.h>
-#include "simdjson/rvv/base.h"
-#include "simdjson/rvv/intrinsics.h"
-#include "simdjson/rvv/bitmanipulation.h"
-#include "simdjson/rvv/bitmask.h"
-#include "simdjson/rvv/numberparsing_defs.h"
-#include "simdjson/rvv/simd.h"
-#include "simdjson/rvv/stringparsing_defs.h"
-
-#define SIMDJSON_SKIP_BACKSLASH_SHORT_CIRCUIT 1
@@ -1,54 +0,0 @@
-#ifndef SIMDJSON_RVV_BITMANIPULATION_H
-#define SIMDJSON_RVV_BITMANIPULATION_H
-
-#ifndef SIMDJSON_CONDITIONAL_INCLUDE
-#include "simdjson/rvv/base.h"
-#endif // SIMDJSON_CONDITIONAL_INCLUDE
-
-namespace simdjson {
-namespace rvv {
-namespace {
-
-/* result might be undefined when input_num is zero */
-simdjson_inline int leading_zeroes(uint64_t input_num) {
-#if defined(_MSC_VER) && !defined(__clang__)
-    unsigned long leading_zero = 0;
-    if (_BitScanReverse64(&leading_zero, input_num))
-        return (int)(63 - leading_zero);
-    else
-        return 64;
-#else
-    return __builtin_clzll(input_num);
-#endif
-}
-
-simdjson_inline uint64_t clear_lowest_bit(uint64_t input_num) {
-    return input_num & (input_num - 1);
-}
-
-simdjson_inline int count_ones(uint64_t input_num) {
-    return __builtin_popcountll(input_num);
-}
-
-
-inline simdjson::internal::value128 full_multiplication(uint64_t a, uint64_t b) {
-#if __SIZEOF_INT128__
-    unsigned __int128 p = (unsigned __int128)a * b;
-    return { (uint64_t)p, (uint64_t)(p >> 64) };
-#else
-    uint64_t lo = a * b;
-    uint64_t a0 = (uint32_t)a, a1 = a >> 32;
-    uint64_t b0 = (uint32_t)b, b1 = b >> 32;
-    uint64_t mid1 = a0 * b1;
-    uint64_t mid2 = a1 * b0;
-    uint64_t carry = ((mid1 & 0xFFFFFFFF) + (mid2 & 0xFFFFFFFF) + (lo >> 32)) >> 32;
-    uint64_t hi = a1 * b1 + (mid1 >> 32) + (mid2 >> 32) + carry;
-    return { lo, hi };
-#endif
-}
-
-} // unnamed namespace
-} // namespace rvv
-} // namespace simdjson
-
-#endif // SIMDJSON_RVV_BITMANIPULATION_H
@@ -1,6 +0,0 @@
-#ifndef SIMDJSON_CONDITIONAL_INCLUDE
-#include "simdjson/rvv/base.h"
-#endif // SIMDJSON_CONDITIONAL_INCLUDE
-
-#undef SIMDJSON_SKIP_BACKSLASH_SHORT_CIRCUIT
-#undef SIMDJSON_IMPLEMENTATION
@@ -1,29 +0,0 @@
-#ifndef SIMDJSON_RVV_IMPLEMENTATION_H
-#define SIMDJSON_RVV_IMPLEMENTATION_H
-
-#ifndef SIMDJSON_CONDITIONAL_INCLUDE
-#define SIMDJSON_CONDITIONAL_INCLUDE
-#include "simdjson/base.h"
-#include "simdjson/implementation.h"
-#include "simdjson/internal/instruction_set.h"
-#endif // SIMDJSON_CONDITIONAL_INCLUDE
-
-namespace simdjson {
-namespace rvv {
-
-class implementation final: public simdjson::implementation {
-public:
-  simdjson_inline implementation() : simdjson::implementation("rvv", "RISC-V Vector Extension", 0) {}
-  simdjson_warn_unused error_code create_dom_parser_implementation(
-    size_t capacity,
-    size_t max_depth,
-    std::unique_ptr<internal::dom_parser_implementation>& dst
-  ) const noexcept final;
-  simdjson_warn_unused error_code minify(const uint8_t *buf, size_t len, uint8_t *dst, size_t &dst_len) const noexcept final;
-  simdjson_warn_unused bool validate_utf8(const char *buf, size_t len) const noexcept final;
-};
-
-} // namespace rvv
-} // namespace simdjson
-
-#endif // SIMDJSON_RVV_IMPLEMENTATION_H
@@ -1,8 +0,0 @@
-#ifndef SIMDJSON_RVV_INTRINSICS_H
-#define SIMDJSON_RVV_INTRINSICS_H
-
-
-#ifndef SIMDJSON_CONDITIONAL_INCLUDE
-#include "simdjson/rvv/base.h"
-#endif // SIMDJSON_CONDITIONAL_INCLUDE
-#endif // SIMDJSON_RVV_INTRINSICS_H
@@ -1,9 +0,0 @@
-#ifndef SIMDJSON_RVV_ONDEMAND_H
-#define SIMDJSON_RVV_ONDEMAND_H
-
-#include "simdjson/rvv/begin.h"
-#include "simdjson/generic/ondemand/amalgamated.h"
-#include "simdjson/rvv/end.h"
-
-#endif // SIMDJSON_RVV_ONDEMAND_H
-
@@ -1,298 +0,0 @@
-#ifndef SIMDJSON_RVV_SIMD_H
-#define SIMDJSON_RVV_SIMD_H
-
-#ifndef SIMDJSON_CONDITIONAL_INCLUDE
-#include "simdjson/rvv/base.h"
-#include "simdjson/rvv/intrinsics.h"
-#include "simdjson/internal/simdprune_tables.h"
-#endif // SIMDJSON_CONDITIONAL_INCLUDE
-
-namespace simdjson {
-namespace rvv {
-namespace {
-namespace simd {
-
-// ---------- 128-bit fixed vectors ----------
-using vuint8x16 = vuint8m1_t __attribute__((riscv_rvv_vector_bits(128)));
-using vint8x16  = vint8m1_t  __attribute__((riscv_rvv_vector_bits(128)));
-using vbool8x16 = vbool8_t;
-static constexpr size_t fixed_vl = 16;
-
-// ---------- forward ----------
-template<typename T> struct simd8;
-template<typename T> struct simd8x64;
-
-// ---------- base<Child> ----------
-template<typename Child>
-struct base {
-    vuint8x16 value{};
-    base() = default;
-    base(vuint8x16 v) : value(v) {}
-    operator vuint8x16() const { return value; }
-    operator vuint8x16&()      { return value; }
-
-    simdjson_inline Child operator|(const Child o) const { return __riscv_vor_vv_u8m1(value, o, fixed_vl); }
-    simdjson_inline Child operator&(const Child o) const { return __riscv_vand_vv_u8m1(value, o, fixed_vl); }
-    simdjson_inline Child operator^(const Child o) const { return __riscv_vxor_vv_u8m1(value, o, fixed_vl); }
-    simdjson_inline Child bit_andnot(const Child o) const { return __riscv_vandn_vv_u8m1(value, o, fixed_vl); }
-
-    simdjson_inline Child& operator|=(const Child o) { auto* c = static_cast<Child*>(this); *c = *c | o; return *c; }
-    simdjson_inline Child& operator&=(const Child o) { auto* c = static_cast<Child*>(this); *c = *c & o; return *c; }
-    simdjson_inline Child& operator^=(const Child o) { auto* c = static_cast<Child*>(this); *c = *c ^ o; return *c; }
-};
-
-// ---------- base8<T,Mask> ----------
-template<typename T, typename Mask = simd8<bool>>
-struct base8 : base<simd8<T>> {
-    using base<simd8<T>>::value;
-    using bitmask_t = uint32_t;
-    base8() = default;
-    base8(vuint8x16 v) : base<simd8<T>>(v) {}
-
-    friend simdjson_inline Mask operator==(const simd8<T> a, const simd8<T> b) {
-        return simd8<bool>(__riscv_vmseq_vv_u8m1_b8(a, b, fixed_vl));
-    }
-    template<int N=1>
-    simdjson_inline simd8<T> prev(const simd8<T> prev_chunk) const {
-        return __riscv_vslideup_vx_u8m1(prev_chunk, value, fixed_vl - N, 2 * fixed_vl);
-    }
-};
-
-// ---------- simd8<bool> ----------
-template<>
-struct simd8<bool> : base8<bool> {
-    simd8() = default;
-    simd8(vuint8x16 v) : base8(v) {}
-    simd8(vbool8_t m) : base8(__riscv_vmerge_vvm_u8m1(
-                                    __riscv_vmv_v_x_u8m1(0, fixed_vl),
-                                    __riscv_vmv_v_x_u8m1(0xFFu, fixed_vl),
-                                    m, fixed_vl)) {}
-
-    static simdjson_inline simd8<bool> splat(bool b) {
-        return __riscv_vmv_v_x_u8m1(uint8_t(-b), fixed_vl);
-    }
-    simdjson_inline simd8(bool b) : simd8(splat(b)) {}
-
-    simdjson_inline int to_bitmask() const {
-        vuint8x16 bits = __riscv_vand_vx_u8m1(value, 0xFFu, fixed_vl);
-        vbool8x16 mask = __riscv_vmseq_vx_u8m1_b8(bits, 0xFFu, fixed_vl);
-        return __riscv_vcpop_m_b8(mask, fixed_vl);
-    }
-    simdjson_inline bool any_bits_set_anywhere() const {
-        return to_bitmask() != 0;
-    }
-    simdjson_inline simd8<bool> operator~() const { return *this ^ splat(true); }
-};
-
-// ---------- simd8<uint8_t> ----------
-template<>
-struct simd8<uint8_t> : base8<uint8_t> {
-    simd8() = default;
-    simd8(vuint8x16 v) : base8(v) {}
-    static simdjson_inline simd8<uint8_t> splat(uint8_t v) {
-        return __riscv_vmv_v_x_u8m1(v, fixed_vl);
-    }
-    static simdjson_inline simd8<uint8_t> zero() { return splat(0); }
-    static simdjson_inline simd8<uint8_t> load(const uint8_t* p) {
-        return __riscv_vle8_v_u8m1(p, fixed_vl);
-    }
-    simdjson_inline simd8(uint8_t v) : simd8(splat(v)) {}
-    simdjson_inline simd8(const uint8_t* p) : simd8(load(p)) {}
-
-    simdjson_inline void store(uint8_t* p) const {
-        __riscv_vse8_v_u8m1(p, value, fixed_vl);
-    }
-
-    simdjson_inline simd8<uint8_t> operator+(const simd8<uint8_t> o) const {
-        return __riscv_vadd_vv_u8m1(value, o, fixed_vl);
-    }
-    simdjson_inline simd8<uint8_t> operator-(const simd8<uint8_t> o) const {
-        return __riscv_vsub_vv_u8m1(value, o, fixed_vl);
-    }
-    simdjson_inline simd8<uint8_t>& operator+=(const simd8<uint8_t> o) {
-        *this = *this + o; return *this;
-    }
-    simdjson_inline simd8<uint8_t>& operator-=(const simd8<uint8_t> o) {
-        *this = *this - o; return *this;
-    }
-
-    simdjson_inline simd8<uint8_t> saturating_add(const simd8<uint8_t> o) const {
-        return __riscv_vsaddu_vv_u8m1(value, o, fixed_vl);
-    }
-    simdjson_inline simd8<uint8_t> saturating_sub(const simd8<uint8_t> o) const {
-        return __riscv_vssubu_vv_u8m1(value, o, fixed_vl);
-    }
-    simdjson_inline simd8<uint8_t> max_val(const simd8<uint8_t> o) const {
-        return __riscv_vmaxu_vv_u8m1(value, o, fixed_vl);
-    }
-    simdjson_inline simd8<uint8_t> min_val(const simd8<uint8_t> o) const {
-        return __riscv_vminu_vv_u8m1(value, o, fixed_vl);
-    }
-    simdjson_inline simd8<bool> operator>(const simd8<uint8_t> o) const {
-        return simd8<bool>(__riscv_vmsgtu_vv_u8m1_b8(value, o, fixed_vl));
-    }
-    simdjson_inline simd8<bool> operator<(const simd8<uint8_t> o) const {
-        return simd8<bool>(__riscv_vmsgtu_vv_u8m1_b8(o, value, fixed_vl));
-    }
-    simdjson_inline simd8<bool> operator<=(const simd8<uint8_t> o) const {
-        return simd8<bool>(__riscv_vmsleu_vv_u8m1_b8(value, o, fixed_vl));
-    }
-    simdjson_inline simd8<bool> operator>=(const simd8<uint8_t> o) const {
-        return simd8<bool>(__riscv_vmsleu_vv_u8m1_b8(o, value, fixed_vl));
-    }
-    template<int NS>
-    simdjson_inline simd8<uint8_t> shr() const {
-        return __riscv_vsrl_vx_u8m1(value, NS, fixed_vl);
-    }
-    template<int NS>
-    simdjson_inline simd8<uint8_t> shl() const {
-        return __riscv_vsll_vx_u8m1(value, NS, fixed_vl);
-    }
-    template <typename Ret>
-    simdjson_inline simd8<Ret> lookup_16(const Ret* table) const {
-        alignas(16) uint8_t idx[16];
-        store(idx);
-        alignas(16) Ret res[16];
-        for (int i = 0; i < 16; ++i) res[i] = table[idx[i]];
-        return simd8<Ret>::load(reinterpret_cast<const Ret*>(res));
-    }
-    simdjson_inline void compress(uint16_t mask, uint8_t* out) const {
-        alignas(16) uint8_t tmp[16];
-        store(tmp);
-        for (int i = 0, j = 0; i < 16; ++i)
-            if (mask & (1u << i)) out[j++] = tmp[i];
-    }
-    simdjson_inline uint64_t gt_bits(uint8_t max_value) const {
-        return (*this > splat(max_value)).to_bitmask();
-    }
-    simdjson_inline uint64_t gt_bits(const simd8<uint8_t>& max_vec) const {
-        return (*this > max_vec).to_bitmask();
-    }
-    simdjson_inline bool any_bits_set_anywhere() const {
-        return (*this > zero()).any_bits_set_anywhere();
-    }
-};
-
-// ---------- simd8<int8_t> ----------
-template<>
-struct simd8<int8_t> {
-    vint8x16 value{};
-    simd8() = default;
-    simd8(vint8x16 v) : value(v) {}
-    static simdjson_inline simd8<int8_t> splat(int8_t v) {
-        return __riscv_vmv_v_x_i8m1(v, fixed_vl);
-    }
-    static simdjson_inline simd8<int8_t> zero() { return splat(0); }
-        static simdjson_inline simd8<int8_t> load(const int8_t* p) {
-        return __riscv_vle8_v_i8m1(p, fixed_vl);
-    }
-    simdjson_inline simd8(int8_t v) : simd8(splat(v)) {}
-    simdjson_inline simd8(const int8_t* p) : simd8(load(p)) {}
-
-    simdjson_inline void store(int8_t* p) const {
-        __riscv_vse8_v_i8m1(p, value, fixed_vl);
-    }
-    simdjson_inline simd8<int8_t> operator+(const simd8<int8_t> o) const {
-        return __riscv_vadd_vv_i8m1(value, o.value, fixed_vl);
-    }
-    simdjson_inline simd8<int8_t> operator-(const simd8<int8_t> o) const {
-        return __riscv_vsub_vv_i8m1(value, o.value, fixed_vl);
-    }
-    simdjson_inline simd8<int8_t> max_val(const simd8<int8_t> o) const {
-        return __riscv_vmax_vv_i8m1(value, o.value, fixed_vl);
-    }
-    simdjson_inline simd8<int8_t> min_val(const simd8<int8_t> o) const {
-        return __riscv_vmin_vv_i8m1(value, o.value, fixed_vl);
-    }
-    simdjson_inline simd8<bool> operator>(const simd8<int8_t> o) const {
-        return simd8<bool>(__riscv_vmsgt_vv_i8m1_b8(value, o.value, fixed_vl));
-    }
-    simdjson_inline simd8<bool> operator<(const simd8<int8_t> o) const {
-        return simd8<bool>(__riscv_vmsgt_vv_i8m1_b8(o.value, value, fixed_vl));
-    }
-    simdjson_inline simd8<bool> operator==(const simd8<int8_t> o) const {
-        return simd8<bool>(__riscv_vmseq_vv_i8m1_b8(value, o.value, fixed_vl));
-    }
-    template<int N=1>
-    simdjson_inline simd8<int8_t> prev(const simd8<int8_t> prev_chunk) const {
-        return __riscv_vslideup_vx_i8m1(prev_chunk.value, value, fixed_vl - N, 2 * fixed_vl);
-    }
-};
-
-// ---------- simd8x64<T> ----------
-template<typename T>
-struct simd8x64 {
-    static constexpr int NUM_CHUNKS = 64 / sizeof(simd8<T>);
-    static_assert(NUM_CHUNKS == 4, "RVV kernel uses 4×128-bit chunks per 64-byte block.");
-    const simd8<T> chunks[4];
-
-    simd8x64(const simd8x64&) = delete;
-    simd8x64& operator=(const simd8x64&) = delete;
-    simd8x64() = delete;
-
-    simdjson_inline simd8x64(const simd8<T> c0, const simd8<T> c1,
-                             const simd8<T> c2, const simd8<T> c3)
-        : chunks{c0, c1, c2, c3} {}
-    simdjson_inline simd8x64(const T* ptr)
-        : chunks{simd8<T>::load(ptr),
-                 simd8<T>::load(ptr + 16),
-                 simd8<T>::load(ptr + 32),
-                 simd8<T>::load(ptr + 48)} {}
-
-    simdjson_inline void store(T* ptr) const {
-        chunks[0].store(ptr);
-        chunks[1].store(ptr + 16);
-        chunks[2].store(ptr + 32);
-        chunks[3].store(ptr + 48);
-    }
-    simdjson_inline simd8<T> reduce_or() const {
-        return (chunks[0] | chunks[1]) | (chunks[2] | chunks[3]);
-    }
-    simdjson_inline uint64_t to_bitmask() const {
-        uint16_t m0 = uint16_t(chunks[0].to_bitmask());
-        uint16_t m1 = uint16_t(chunks[1].to_bitmask());
-        uint16_t m2 = uint16_t(chunks[2].to_bitmask());
-        uint16_t m3 = uint16_t(chunks[3].to_bitmask());
-        return m0 | (uint64_t(m1) << 16) | (uint64_t(m2) << 32) | (uint64_t(m3) << 48);
-    }
-    simdjson_inline uint64_t eq(const T m) const {
-        simd8<T> spl = simd8<T>::splat(m);
-        return simd8x64<bool>(chunks[0] == spl,
-                              chunks[1] == spl,
-                              chunks[2] == spl,
-                              chunks[3] == spl).to_bitmask();
-    }
-    simdjson_inline uint64_t lteq(const T m) const {
-        simd8<T> spl = simd8<T>::splat(m);
-        return simd8x64<bool>(chunks[0] <= spl,
-                              chunks[1] <= spl,
-                              chunks[2] <= spl,
-                              chunks[3] <= spl).to_bitmask();
-    }
-    simdjson_inline uint64_t compress(uint64_t mask, T* out) const {
-        using internal::BitsSetTable256mul2;
-        uint32_t m0 = uint32_t(mask);
-        uint32_t m1 = uint32_t(mask >> 16);
-        uint32_t m2 = uint32_t(mask >> 32);
-        uint32_t m3 = uint32_t(mask >> 48);
-
-        int pop0 = BitsSetTable256mul2[uint8_t(m0)];
-        int pop1 = BitsSetTable256mul2[uint8_t(m1)];
-        int pop2 = BitsSetTable256mul2[uint8_t(m2)];
-
-        chunks[0].compress(uint16_t(m0), out);
-        chunks[1].compress(uint16_t(m1), out + 16 - pop0);
-        chunks[2].compress(uint16_t(m2), out + 32 - pop0 - pop1);
-        chunks[3].compress(uint16_t(m3), out + 48 - pop0 - pop1 - pop2);
-        return 64 - __builtin_popcountll(mask);
-    }
-};
-
-
-} // namespace simd
-} // unnamed namespace
-} // namespace rvv
-} // namespace simdjson
-
-
-#endif // SIMDJSON_RVV_SIMD_H
@@ -4,7 +4,7 @@
 #define SIMDJSON_SIMDJSON_VERSION_H

 /** The version of simdjson being used (major.minor.revision) */
-#define SIMDJSON_VERSION "4.0.2"
+#define SIMDJSON_VERSION "4.0.6"

 namespace simdjson {
 enum {
@@ -19,7 +19,7 @@ enum {
  /**
   * The revision (major.minor.REVISION) of simdjson being used.
   */
-  SIMDJSON_VERSION_REVISION = 2
+  SIMDJSON_VERSION_REVISION = 6
 };
 } // namespace simdjson

@@ -71,7 +71,7 @@ else:
 RelativeRoot = str # Literal['src','include'] # Literal not supported in Python 3.7 (CI)
 RELATIVE_ROOTS: List[RelativeRoot] = ['src', 'include' ]
 Implementation = str # Literal['arm64', 'fallback', 'haswell', 'icelake', 'ppc64', 'westmere', 'lsx', 'lasx'] # Literal not supported in Python 3.7 (CI)
-IMPLEMENTATIONS: List[Implementation] = [ 'arm64', 'haswell', 'icelake', 'lasx', 'lsx', 'ppc64', 'westmere', 'fallback', 'rvv' ]
+IMPLEMENTATIONS: List[Implementation] = [ 'arm64', 'haswell', 'icelake', 'lasx', 'lsx', 'ppc64', 'westmere', 'fallback' ]
 GENERIC_INCLUDE = "simdjson/generic"
 GENERIC_SRC = "generic"
 BUILTIN = "simdjson/builtin"
@@ -358,6 +358,7 @@ class Amalgamator:
        self.include_stack.append(file)

        file.processed = False
+
        self.write(f"/* begin file {self.file_to_str(file)} */")

        if file == BUILTIN_BEGIN_H:
@@ -1,4 +1,4 @@
-/* auto-generated on 2025-09-14 09:01:41 -0600. version 4.0.2 Do not edit! */
+/* auto-generated on 2025-09-20 22:23:09 -0600. version 4.0.6 Do not edit! */
 /* including simdjson.cpp:  */
 /* begin file simdjson.cpp */
 #define SIMDJSON_SRC_SIMDJSON_CPP
@@ -3009,11 +3009,32 @@ concept optional_type = requires(std::remove_cvref_t<T> obj) {
    } -> std::convertible_to<typename std::remove_cvref_t<T>::value_type>;
  };
  { static_cast<bool>(obj) } -> std::same_as<bool>; // convertible to bool
+  { obj.reset() } noexcept -> std::same_as<void>;
 };



+
+
 } // namespace concepts
+
+
+/**
+ * We use tag_invoke as our customization point mechanism.
+ */
+template <typename Tag, typename... Args>
+concept tag_invocable = requires(Tag tag, Args... args) {
+  tag_invoke(std::forward<Tag>(tag), std::forward<Args>(args)...);
+};
+
+template <typename Tag, typename... Args>
+concept nothrow_tag_invocable =
+    tag_invocable<Tag, Args...> && requires(Tag tag, Args... args) {
+      {
+        tag_invoke(std::forward<Tag>(tag), std::forward<Args>(args)...)
+      } noexcept;
+    };
+
 } // namespace simdjson
 #endif // SIMDJSON_SUPPORTS_CONCEPTS
 #endif // SIMDJSON_CONCEPTS_H
@@ -21,19 +21,6 @@ bool implementation::supported_by_runtime_system() const {

 #define SIMDJSON_CONDITIONAL_INCLUDE

-#if SIMDJSON_IMPLEMENTATION_RVV
-#include <simdjson/rvv/implementation.h>
-namespace simdjson {
-namespace internal {
-static const rvv::implementation* get_rvv_singleton() {
-  static const rvv::implementation rvv_singleton{};
-  return &rvv_singleton;
-}
-} // namespace internal
-} // namespace simdjson
-#endif // SIMDJSON_IMPLEMENTATION_RVV
-
-
 #if SIMDJSON_IMPLEMENTATION_ARM64
 #include <simdjson/arm64/implementation.h>
 namespace simdjson {
@@ -143,7 +130,6 @@ namespace internal {
             + SIMDJSON_IMPLEMENTATION_HASWELL + SIMDJSON_IMPLEMENTATION_WESTMERE \
             + SIMDJSON_IMPLEMENTATION_ARM64 + SIMDJSON_IMPLEMENTATION_PPC64 \
             + SIMDJSON_IMPLEMENTATION_LSX + SIMDJSON_IMPLEMENTATION_LASX \
-             + SIMDJSON_IMPLEMENTATION_RVV \
             + SIMDJSON_IMPLEMENTATION_FALLBACK == 1)

 #if SIMDJSON_SINGLE_IMPLEMENTATION
@@ -170,9 +156,6 @@ namespace internal {
 #if SIMDJSON_IMPLEMENTATION_LASX
    get_lasx_singleton();
 #endif
-#if SIMDJSON_IMPLEMENTATION_RVV
-    get_rvv_singleton();
-#endif
 #if SIMDJSON_IMPLEMENTATION_FALLBACK
    get_fallback_singleton();
 #endif
@@ -233,9 +216,6 @@ static const std::initializer_list<const implementation *>& get_available_implem
 #if SIMDJSON_IMPLEMENTATION_LASX
    get_lasx_singleton(),
 #endif
-#if SIMDJSON_IMPLEMENTATION_RVV
-    get_rvv_singleton(),
-#endif
 #if SIMDJSON_IMPLEMENTATION_FALLBACK
    get_fallback_singleton(),
 #endif
@@ -1,23 +0,0 @@
-#ifndef SIMDJSON_SRC_RVV_CPP
-#define SIMDJSON_SRC_RVV_CPP
-
-#ifndef SIMDJSON_CONDITIONAL_INCLUDE
-#include <base.h>
-#endif // SIMDJSON_CONDITIONAL_INCLUDE
-
-
-#include <simdjson/rvv.h>
-#include <simdjson/rvv/implementation.h>
-
-
-
-namespace simdjson {
-namespace rvv {
-error_code implementation::create_dom_parser_implementation(
-    size_t, size_t,
-    std::unique_ptr<simdjson::internal::dom_parser_implementation>&) const noexcept {
-  return error_code::UNSUPPORTED_ARCHITECTURE;
-}
-} // namespace rvv
-} // namespace simdjson
-#endif // SIMDJSON_SRC_RVV_CPP
@@ -41,9 +41,6 @@ SIMDJSON_PUSH_DISABLE_UNUSED_WARNINGS
 #if SIMDJSON_IMPLEMENTATION_LASX
 #include <lasx.cpp>
 #endif
-#if SIMDJSON_IMPLEMENTATION_RVV
-#include <rvv.cpp>
-#endif
 #if SIMDJSON_IMPLEMENTATION_FALLBACK
 #include <fallback.cpp>
 #endif
@@ -1,7 +1,8 @@
 # All remaining tests link with simdjson proper
 include_directories(..)
-add_cpp_test(builder_string_builder_tests              LABELS ondemand acceptance per_implementation)
+add_cpp_test(builder_string_builder_tests                LABELS ondemand acceptance per_implementation)
 if(SIMDJSON_STATIC_REFLECTION)
+  add_cpp_test(static_reflection_custom_tests            LABELS ondemand acceptance per_implementation)
  add_cpp_test(static_reflection_builder_tests           LABELS ondemand acceptance per_implementation)
  add_cpp_test(static_reflection_comprehensive_tests     LABELS ondemand acceptance per_implementation)
  add_cpp_test(static_reflection_edge_cases_tests        LABELS ondemand acceptance per_implementation)
@@ -331,8 +331,6 @@ namespace builder_tests {
        TEST_SUCCEED();
    }

-
-
    void serialize_car(const Car& car, simdjson::builder::string_builder& builder) {
        // start of JSON
        builder.start_object();
@@ -369,7 +367,43 @@ namespace builder_tests {
        builder.end_object();
    }

+#if SIMDJSON_SUPPORTS_CONCEPTS
+    void serialize_car_template(const Car& car, simdjson::builder::string_builder& builder) {
+        // start of JSON
+        builder.start_object();

+        // "make"
+        builder.append_key_value<"make">(car.make);
+        builder.append_comma();
+
+        // "model"
+        builder.append_key_value<"model">(car.model);
+
+        builder.append_comma();
+
+        // "year"
+        builder.append_key_value<"year">(car.year);
+
+        builder.append_comma();
+
+        // "tire_pressure"
+        builder.escape_and_append_with_quotes<"tire_pressure">();
+        builder.append_colon();
+        builder.start_array();
+        // vector tire_pressure
+        for (size_t i = 0; i < car.tire_pressure.size(); ++i) {
+            builder.append(car.tire_pressure[i]);
+            if (i < car.tire_pressure.size() - 1) {
+                builder.append_comma();
+            }
+        }
+        // end of array
+        builder.end_array();
+
+        // end of object
+        builder.end_object();
+    }
+#endif
    bool car_test() {
        TEST_START();
        simdjson::builder::string_builder sb;
@@ -381,7 +415,18 @@ namespace builder_tests {
        ASSERT_EQUAL(p, "{\"make\":\"Toyota\",\"model\":\"Corolla\",\"year\":2017,\"tire_pressure\":[30.0,30.2,30.513,30.79]}");
        TEST_SUCCEED();
    }
-    #if SIMDJSON_SUPPORTS_CONCEPTS
+#if SIMDJSON_SUPPORTS_CONCEPTS
+    bool car_test_template() {
+        TEST_START();
+        simdjson::builder::string_builder sb;
+        Car c = {"Toyota", "Corolla", 2017, {30.0,30.2,30.513,30.79}};
+        serialize_car_template(c, sb);
+        std::string_view p;
+        auto result = sb.view().get(p);
+        ASSERT_SUCCESS(result);
+        ASSERT_EQUAL(p, "{\"make\":\"Toyota\",\"model\":\"Corolla\",\"year\":2017,\"tire_pressure\":[30.0,30.2,30.513,30.79]}");
+        TEST_SUCCEED();
+    }
    bool serialize_optional() {
        TEST_START();
        simdjson::builder::string_builder sb;
@@ -399,7 +444,7 @@ namespace builder_tests {
        ASSERT_EQUAL(p, "null");
        TEST_SUCCEED();
    }
-    #endif
+#endif

    #if SIMDJSON_SUPPORTS_RANGES && SIMDJSON_SUPPORTS_CONCEPTS
    void serialize_car_simple(const Car& car, simdjson::builder::string_builder& builder) {
@@ -474,6 +519,20 @@ namespace builder_tests {
        ASSERT_EQUAL(s, "[[1.0,2.0],[3.0,4.0]]");
        TEST_SUCCEED();
    }
+    bool double_double_test_to_string() {
+        TEST_START();
+        std::vector<std::vector<double>> c = {{1.0, 2.0}, {3.0, 4.0}};
+        simdjson::builder::string_builder sb;
+        sb.append(c);
+        std::string_view p;
+        auto result = sb.view().get(p);
+        ASSERT_SUCCESS(result);
+        ASSERT_EQUAL(p, "[[1.0,2.0],[3.0,4.0]]");
+        std::string s;
+        simdjson::simdjson_error ec = simdjson::to_json(c,s);
+        ASSERT_EQUAL(s, "[[1.0,2.0],[3.0,4.0]]");
+        TEST_SUCCEED();
+    }
    #if SIMDJSON_EXCEPTIONS
    bool car_test_simple_complete_exceptions() {
        TEST_START();
@@ -522,6 +581,7 @@ namespace builder_tests {
    #if SIMDJSON_SUPPORTS_RANGES && SIMDJSON_SUPPORTS_CONCEPTS
            map_test() &&
            double_double_test() &&
+            double_double_test_to_string() &&
            car_test_simple() &&
            car_test_simple_complete() &&
        #if SIMDJSON_EXCEPTIONS
@@ -529,7 +589,8 @@ namespace builder_tests {
        #endif
    #endif
    #if SIMDJSON_SUPPORTS_CONCEPTS
-           serialize_optional() &&
+            car_test_template() &&
+            serialize_optional() &&
    #endif
            append_char() &&
            append_integer() &&
@@ -0,0 +1,138 @@
+
+
+
+#include "simdjson.h"
+#include "test_builder.h"
+#include <charconv>
+#include <string>
+
+using namespace simdjson;
+
+// Suppose that we want to serialize/deserialize Car using
+// strings for the year
+struct Car {
+  std::string make;
+  std::string model;
+  int64_t year;
+  std::vector<float> tire_pressure;
+};
+
+
+
+namespace simdjson {
+// This tag_invoke MUST be inside simdjson namespace
+template <typename simdjson_value>
+auto tag_invoke(deserialize_tag, simdjson_value &val, Car& car) {
+  ondemand::object obj;
+  auto error = val.get_object().get(obj);
+  if (error) {
+    return error;
+  }
+  if ((error = obj["make"].get_string(car.make))) {
+    return error;
+  }
+  if ((error = obj["model"].get_string(car.model))) {
+    return error;
+  }
+  std::string_view year_str;
+  if ((error = obj["year"].get(year_str))) {
+    return error;
+  }
+  int64_t year_value;
+  auto [ptr, ec] = std::from_chars(year_str.data(), year_str.data() + year_str.size(), year_value);
+  if (ec != std::errc{}) {
+    return INCORRECT_TYPE;
+  }
+  car.year = year_value;
+  if ((error = obj["tire_pressure"].get<std::vector<float>>().get(
+           car.tire_pressure))) {
+    return error;
+  }
+  return simdjson::SUCCESS;
+}
+
+template <typename builder_type>
+void tag_invoke(serialize_tag, builder_type &builder, const Car& car) {
+  builder.start_object();
+  builder.append_key_value("make", car.make);
+  builder.append_comma();
+  builder.append_key_value("model", car.model);
+  builder.append_comma();
+  builder.append_key_value("year", std::to_string(car.year));
+  builder.append_comma();
+  builder.append_key_value("tire_pressure", car.tire_pressure);
+  builder.end_object();
+}
+
+} // namespace simdjson
+namespace custom_tests {
+
+  bool test_car_deserialization() {
+    TEST_START();
+    auto json = R"({"make":"Toyota","model":"Camry","year":"2018","tire_pressure":[30.5,30.6,30.7,30.8]})"_padded;
+    ondemand::parser parser;
+    auto doc_result = parser.iterate(json);
+    ASSERT_SUCCESS(doc_result);
+    Car car;
+    ASSERT_SUCCESS(doc_result.get(car));
+    if (car.make != "Toyota" || car.model != "Camry" || std::to_string(car.year) != "2018" || car.tire_pressure.size() != 4 || car.tire_pressure[0] != 30.5f) {
+      return false;
+    }
+    TEST_SUCCEED();
+  }
+  bool test_car_serialization() {
+    TEST_START();
+    Car car{"Toyota", "Camry", 2018, {30.5f,30.6f,30.7f,30.8f}};
+    simdjson::builder::string_builder builder;
+    builder.append(car);
+    std::string_view json;
+    ASSERT_SUCCESS(builder.view().get(json));
+    TEST_SUCCEED();
+  }
+  bool test_car_roundtrip() {
+    TEST_START();
+    Car car{"Toyota", "Camry", 2018, {30.5f,30.6f,30.7f,30.8f}};
+    simdjson::builder::string_builder builder;
+    builder.append(car);
+    std::string json;
+    ASSERT_SUCCESS(builder.view().get(json));
+    ondemand::parser parser;
+    auto doc_result = parser.iterate(json);
+    ASSERT_SUCCESS(doc_result);
+    Car carback;
+    ASSERT_SUCCESS(doc_result.get(carback));
+
+    if (carback.make != car.make || carback.model != car.model || carback.year != car.year || carback.tire_pressure != car.tire_pressure) {
+      return false;
+    }
+
+    TEST_SUCCEED();
+  }
+
+  bool test_car_roundtrip_to_json() {
+    TEST_START();
+    Car car{"Toyota", "Camry", 2018, {30.5f,30.6f,30.7f,30.8f}};
+    std::string json;
+    ASSERT_SUCCESS(simdjson::to_json(car).get(json));
+    simdjson::builder::string_builder builder;
+    ondemand::parser parser;
+    auto doc_result = parser.iterate(json);
+    ASSERT_SUCCESS(doc_result);
+    Car carback;
+    ASSERT_SUCCESS(doc_result.get(carback));
+
+    if (carback.make != car.make || carback.model != car.model || carback.year != car.year || carback.tire_pressure != car.tire_pressure) {
+      return false;
+    }
+
+    TEST_SUCCEED();
+  }
+  bool run() {
+    return test_car_deserialization() && test_car_serialization() && test_car_roundtrip() && test_car_roundtrip_to_json();
+  }
+
+} // namespace builder_tests
+
+int main(int argc, char *argv[]) {
+  return test_main(argc, argv, custom_tests::run);
+}
@@ -123,7 +123,7 @@ endif()

 # Add the tests if we're on:
 #   1. Visual Studio 2022 v17.6 or later
-#   2. GCC v14.0.0 or later (GCC v13.0.0 cannot handle pipe oprator of lambda)
+#   2. GCC v14.0.0 or later (GCC v13.0.0 cannot handle pipe operator of lambda)
 #   3. Clang v15.0.0 or later (certain version C++ headers occur error when compiling)
 if(
  (MSVC AND MSVC_VERSION LESS 1930) OR
@@ -2,6 +2,7 @@
 #include "simdjson/convert.h"
 #include "test_ondemand.h"

+#include <chrono>
 #include <map>
 #include <ranges>
 #include <string>
@@ -21,6 +22,24 @@ private:
    std::string date_str;
 };

+
+struct Meeting {
+    std::string title;
+    std::vector<std::string> attendees;
+    std::optional<std::string> location;
+    bool is_recurring;
+};
+
+
+struct MeetingTime {
+    std::string title;
+    std::chrono::system_clock::time_point start_time;
+    std::vector<std::string> attendees;
+    std::optional<std::string> location;
+    bool is_recurring;
+};
+
+
 namespace simdjson {
 template <typename simdjson_value>
 auto tag_invoke(deserialize_tag, simdjson_value &val, MyDate& date) {
@@ -43,57 +62,6 @@ struct complicated_weather_data {
 #ifdef __cpp_lib_ranges

 namespace convert_tests {
-#if SIMDJSON_EXCEPTIONS && SIMDJSON_SUPPORTS_CONCEPTS
-struct Car {
-  std::string make{};
-  std::string model{};
-  int year{};
-  std::vector<double> tire_pressure{};
-
-  friend simdjson::error_code tag_invoke(simdjson::deserialize_tag, auto &val,
-                                         Car &car) {
-    simdjson::ondemand::object obj;
-    auto error = val.get_object().get(obj);
-    if (error) {
-      return error;
-    }
-    // Instead of repeatedly obj["something"], we iterate through the object
-    // which we expect to be faster.
-    for (auto field : obj) {
-      simdjson::ondemand::raw_json_string key;
-      error = field.key().get(key);
-      if (error) {
-        return error;
-      }
-      if (key == "make") {
-        error = field.value().get_string(car.make);
-        if (error) {
-          return error;
-        }
-      } else if (key == "model") {
-        error = field.value().get_string(car.model);
-        if (error) {
-          return error;
-        }
-      } else if (key == "year") {
-        error = field.value().get(car.year);
-        if (error) {
-          return error;
-        }
-      } else if (key == "tire_pressure") {
-        error = field.value().get(car.tire_pressure);
-        if (error) {
-          return error;
-        }
-      }
-    }
-    return simdjson::SUCCESS;
-  }
-};
-
-static_assert(simdjson::custom_deserializable<std::unique_ptr<Car>>,
-              "It should be deserializable");
-

 simdjson::padded_string json_car =
    R"( {
@@ -111,22 +79,114 @@ simdjson::padded_string json_cars =
       "tire_pressure": [ 29.8, 30.0 ] }
 ])"_padded;

-bool simple() {
-  TEST_START();
-  Car car = simdjson::from(json_car);
-  if (car.make != "Toyota" || car.model != "Camry" || car.year != 2018) {
-    return false;
+#if SIMDJSON_SUPPORTS_CONCEPTS
+  struct Car {
+    std::string make{};
+    std::string model{};
+    int year{};
+    std::vector<double> tire_pressure{};
+
+    friend simdjson::error_code tag_invoke(simdjson::deserialize_tag, auto &val,
+                                          Car &car) {
+      simdjson::ondemand::object obj;
+      auto error = val.get_object().get(obj);
+      if (error) {
+        return error;
+      }
+      // Instead of repeatedly obj["something"], we iterate through the object
+      // which we expect to be faster.
+      for (auto field : obj) {
+        simdjson::ondemand::raw_json_string key;
+        error = field.key().get(key);
+        if (error) {
+          return error;
+        }
+        if (key == "make") {
+          error = field.value().get_string(car.make);
+          if (error) {
+            return error;
+          }
+        } else if (key == "model") {
+          error = field.value().get_string(car.model);
+          if (error) {
+            return error;
+          }
+        } else if (key == "year") {
+          error = field.value().get(car.year);
+          if (error) {
+            return error;
+          }
+        } else if (key == "tire_pressure") {
+          error = field.value().get(car.tire_pressure);
+          if (error) {
+            return error;
+          }
+        }
+      }
+      return simdjson::SUCCESS;
+    }
+  };
+
+  static_assert(simdjson::custom_deserializable<std::unique_ptr<Car>>,
+                "It should be deserializable");
+
+
+  bool simple_no_except() {
+    TEST_START();
+    Car car;
+    ASSERT_SUCCESS(simdjson::from(json_car).get(car));
+    if (car.make != "Toyota" || car.model != "Camry" || car.year != 2018) {
+      return false;
+    }
+    TEST_SUCCEED();
  }
-  TEST_SUCCEED();
-}
-
+#endif // SIMDJSON_SUPPORTS_CONCEPTS
+#if SIMDJSON_EXCEPTIONS && SIMDJSON_SUPPORTS_CONCEPTS

+  bool simple() {
+    TEST_START();
+    Car car = simdjson::from(json_car);
+    if (car.make != "Toyota" || car.model != "Camry" || car.year != 2018) {
+      return false;
+    }
+    TEST_SUCCEED();
+  }
+  struct Player {
+      std::string username;
+      int level;
+      double health;
+  };
  struct BadPlayer {
      int username;  // Oops, should be string!
      int level;
      double health;
  };
+  struct OptionalPlayer {
+      std::string username;
+      std::optional<int> level;
+      double health;
+  };
 #if SIMDJSON_STATIC_REFLECTION
+  bool missing_key_player() {
+    TEST_START();
+    std::string json = R"({"username":"Alice","health":100.0})";
+    simdjson::padded_string padded(json);
+    Player p;
+    simdjson::ondemand::parser parser;
+    auto doc = parser.iterate(padded);
+    ASSERT_ERROR(doc.get(p), simdjson::NO_SUCH_FIELD);
+    TEST_SUCCEED();
+  }
+  bool missing_key_optional_player() {
+    TEST_START();
+    std::string json = R"({"username":"Alice","health":100.0})";
+    simdjson::padded_string padded(json);
+    OptionalPlayer p;
+    simdjson::ondemand::parser parser;
+    auto doc = parser.iterate(padded);
+    ASSERT_SUCCESS(doc.get(p));
+    TEST_SUCCEED();
+  }
  bool bad_player() {
    TEST_START();
    // username is a string but we declared it as an int
@@ -160,6 +220,38 @@ bool simple() {
    ASSERT_SUCCESS(doc.get(p));
    TEST_SUCCEED();
  }
+
+
+  bool meeting_test() {
+    TEST_START();
+    std::string json = simdjson::to_json(Meeting{
+        .title = "CppCon Planning",
+        .attendees = {"Alice", "Bob", "Charlie"},
+        .location = "Denver",
+        .is_recurring = true
+    });
+    Meeting m2 = simdjson::from(json);
+    std::cout << m2.title << std::endl;
+    TEST_SUCCEED();
+  }
+  bool meeting_time_test() {
+    TEST_START();
+    auto start_time = std::chrono::system_clock::now();
+    std::string json = simdjson::to_json(MeetingTime{
+        .title = "CppCon Planning",
+        .start_time = start_time,
+        .attendees = {"Alice", "Bob", "Charlie"},
+        .location = "Denver",
+        .is_recurring = true
+    });
+    std::cout << json << std::endl;
+    MeetingTime m2 = simdjson::from(json);
+    //ASSERT_EQUAL(m2.start_time, start_time);
+    std::cout << m2.title << std::endl;
+    TEST_SUCCEED();
+  }
+
+
 #endif
 bool broken() {
  TEST_START();
@@ -415,7 +507,10 @@ bool test_to_vs_from_equivalence() {
 bool run() {
  return
 #if SIMDJSON_STATIC_REFLECTION
-      bad_player() && good_player() && complicated_weather_test() &&
+      missing_key_optional_player() && missing_key_player() && meeting_time_test() && meeting_test() && bad_player() && good_player() && complicated_weather_test() &&
+#endif
+#if SIMDJSON_SUPPORTS_CONCEPTS
+      simple_no_except() &&
 #endif
 #if SIMDJSON_EXCEPTIONS && SIMDJSON_SUPPORTS_CONCEPTS
      broken() && simple() && simple_optional() && with_parser() && to_array() &&
Author	SHA1	Message	Date
Daniel Lemire	b2932d1b8f	release candidate 4.0.6 (#2464 )	2025-09-21 08:13:48 -06:00
Daniel Lemire	a7811090ef	fixing issue 2458 (#2461 )	2025-09-20 22:23:09 -06:00
Daniel Lemire	3320885fac	Fixing issue 2462 (#2463 ) * fun * progress * completing the documentation	2025-09-20 22:22:57 -06:00
Daniel Lemire	786c68b158	release 4.0.5	2025-09-18 15:17:32 -06:00
Daniel Lemire	703ef54bd9	allow string reuse (#2454 ) * allow string reuse * portability fix * using data and not begin	2025-09-18 15:16:38 -06:00
Daniel Lemire	2526068e2f	Add mamba link to README	2025-09-18 09:22:03 -06:00
Daniel Lemire	ddc7b8c7dd	update	2025-09-17 18:59:06 -06:00
Daniel Lemire	d8f90bdd14	modifying simdjson::from to avoid exceptions when needed. (#2452 ) * modifying simdjson::from to avoid exceptions when needed. * moved the function * moving the strings. * more moving around * updating cmake version in ci	2025-09-17 18:58:25 -06:00
Daniel Lemire	e38a4923e5	adding keys as templates in builder (#2453 ) * adding keys as templates in builder * more guarding * cmake update in ci * guarding. * guarding	2025-09-17 18:58:05 -06:00
Dirk Stolle	e6dfa2e0ed	remove trailing whitespace + fix typos (#2451 )	2025-09-16 22:41:14 -06:00
Daniel Lemire	1f369ef210	minor patch which allows us to pass mutable strings to simdjson::from… (#2448 ) * minor patch which allows us to pass mutable strings to simdjson::from and fix an issue with ambiguous integrals * compatibility patch.	2025-09-15 22:22:25 -06:00
Daniel Lemire	22dcdc9f1e	Update README.md	2025-09-15 18:52:15 -06:00
Dirk Stolle	dda2dafa30	fix some typos (#2446 )	2025-09-15 18:23:13 -06:00
Daniel Lemire	72e9d44e10	fixing indent	2025-09-15 17:08:12 -06:00