new feature tests, etc.

* adding a C++17 padded_input for convenience.

* adding header

* tuning.

* being explicit

* reworking the docu

* avoid windows.h

* Update include/simdjson/padded_string_view-inl.h

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

* Update tests/ondemand/ondemand_padded_input.cpp

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

* Update tests/ondemand/ondemand_readme_examples.cpp

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

* Update doc/performance.md

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

* minor update

---------

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

.github/workflows/ubuntu24.yml

@@ -22,4 +22,4 @@ jobs:
       - name: Build
         run: cmake --build build -j=2
       - name: Test
-        run: ctest --output-on-failure --test-dir build
+        run: ctest --output-on-failure --test-dir build

CMakeLists.txt

@@ -52,6 +52,20 @@ if(SIMDJSON_DISABLE_DEPRECATED_API)
   )
 endif()
 
+option(SIMDJSON_FEATURE_ONDEMAND_API "Enable ondemand API" ON)
+option(SIMDJSON_FEATURE_DOM_API "Enable DOM API" ON)
+option(SIMDJSON_FEATURE_BUILDER_API "Enable builder API" ON)
+
+if(NOT SIMDJSON_FEATURE_ONDEMAND_API)
+  add_compile_definitions(SIMDJSON_FEATURE_ONDEMAND_API=0)
+endif()
+if(NOT SIMDJSON_FEATURE_DOM_API)
+  add_compile_definitions(SIMDJSON_FEATURE_DOM_API=0)
+endif()
+if(NOT SIMDJSON_FEATURE_BUILDER_API)
+  add_compile_definitions(SIMDJSON_FEATURE_BUILDER_API=0)
+endif()
+
 if(${CMAKE_VERSION} VERSION_GREATER_EQUAL "3.25.0")
     option(SIMDJSON_STATIC_REFLECTION "Enables static reflection (experimental), requires C++26" OFF)
 else()
@@ -167,13 +181,37 @@ if(MSVC)
   endif()
 endif()
 
+
+
 if(SIMDJSON_STATIC_REFLECTION)
+
+
+  if(CMAKE_CXX_COMPILER_ID STREQUAL "Clang" AND CMAKE_CXX_COMPILER_VERSION MATCHES "^21")
+    execute_process(
+        COMMAND ${CMAKE_CXX_COMPILER} --version
+        OUTPUT_VARIABLE CLANG_VERSION_OUTPUT
+        ERROR_VARIABLE CLANG_VERSION_ERROR
+        RESULT_VARIABLE CLANG_VERSION_RESULT
+    )
+    if(CLANG_VERSION_RESULT EQUAL 0 AND CLANG_VERSION_OUTPUT MATCHES "https://github.com/bloomberg/clang-p2996.git")
+        set(IS_BLOOMBERG_P2996_CLANG ON)
+        message(STATUS "Using Bloomberg P2996 Clang fork")
+    endif()
+  endif()
+
   # We would like to require C++26, but no compiler supports that!
   # This is a hack:
+  if(IS_BLOOMBERG_P2996_CLANG)
   simdjson_add_props(
       target_compile_options PUBLIC
       -freflection -fexpansion-statements -stdlib=libc++ -std=c++26
   )
+  else()
+  simdjson_add_props(
+      target_compile_options PUBLIC
+      -freflection -std=c++26
+  )
+  endif()
 else()
   simdjson_add_props(target_compile_features PUBLIC cxx_std_11)
 endif()
@@ -387,18 +425,25 @@ add_subdirectory(fuzz)
 #
 # Source files should be just ASCII
 #
-find_program(FIND find)
-find_program(FILE file)
-find_program(GREP grep)
-if(FIND AND FILE AND GREP)
+find_program(FIND_CMD find)
+find_program(FILE_CMD file)
+find_program(GREP_CMD grep)
+if(FIND_CMD AND FILE_CMD AND GREP_CMD)
   add_test(
       NAME just_ascii
       COMMAND sh -c "\
-${FIND} include src windows tools singleheader tests examples benchmark \
--path benchmark/checkperf-reference -prune -name '*.h' -o -name '*.cpp' \
--type f -exec ${FILE} '{}' \; | ${GREP} -qv ASCII || exit 0  && exit 1"
+non_ascii=$(${FIND_CMD} include src windows tools singleheader tests examples benchmark \
+  -path benchmark/checkperf-reference -prune -name '*.h' -o -name '*.cpp' \
+  -type f -exec ${FILE_CMD} '{}' \; | ${GREP_CMD} -v ASCII); \
+if [ -n \"$non_ascii\" ]; then \
+  echo 'The following files contain non-ASCII characters:'; \
+  echo \"$non_ascii\"; \
+  exit 1; \
+fi"
       WORKING_DIRECTORY "${PROJECT_SOURCE_DIR}"
   )
+else()
+  message(WARNING "just_ascii test disabled because required tools were not found: find='${FIND_CMD}', file='${FILE_CMD}', grep='${GREP_CMD}'")
 endif()
 
 ##

HACKING.md

@@ -32,6 +32,24 @@ It is similar for Visual Studio users, please see the CMake or Visual Studio doc
 
 By default the library is built in Release mode.
 
+## Optional APIs (Feature Flags)
+
+simdjson provides three APIs:
+- DOM (`simdjson::dom`)
+- OnDemand (`simdjson::ondemand`)
+- Builder (`simdjson::builder`) — requires DOM
+
+You can enable or disable these APIs at compile time to reduce binary size and compile time.
+At least one of DOM or OnDemand must be enabled.
+
+### Configuration
+
+Using CMake:
+
+```bash
+cmake -DSIMDJSON_FEATURE_DOM_API=OFF \
+      -DSIMDJSON_FEATURE_ONDEMAND_API=ON \
+      -DSIMDJSON_FEATURE_BUILDER_API=OFF ..
 
 Assertions and development checks
 ------------------------------

benchmark/partial_tweets/tweet.h

@@ -10,7 +10,7 @@ namespace partial_tweets {
 //     {
 //       "created_at": "Sun Aug 31 00:29:15 +0000 2014",
 //       "id": 505874924095815700,
-//       "text": "@aym0566x \n\n名前:前田あゆみ\n第一印象:なんか怖っ！\n今の印象:とりあえずキモい。噛み合わない\n好きなところ:ぶすでキモいとこ😋✨✨\n思い出:んーーー、ありすぎ😊❤️\nLINE交換できる？:あぁ……ごめん✋\nトプ画をみて:照れますがな😘✨\n一言:お前は一生もんのダチ💖",
+//       "text": "@aym0566x ...",
 //       "in_reply_to_status_id": null,
 //       "user": {
 //         "id": 1186275104,

doc/basics.md

@@ -161,54 +161,77 @@ The basics: loading and parsing JSON documents
 ----------------------------------------------
 
 The simdjson library allows you to navigate and validate JSON documents ([RFC 8259](https://www.tbray.org/ongoing/When/201x/2017/12/14/rfc8259.html)).
-As required by the standard, your JSON document should be in a Unicode (UTF-8) string. The whole
-string, from the beginning to the end, needs to be valid: we do not attempt to tolerate bad
-inputs before or after a document.
+Your JSON document should be a valid Unicode (UTF-8) string.
 
-For efficiency reasons, simdjson requires a string with a few bytes (`simdjson::SIMDJSON_PADDING`)
-at the end, these bytes may be read but their content does not affect the parsing. In practice,
-it means that the JSON inputs should be stored in a memory region with `simdjson::SIMDJSON_PADDING`
-extra bytes at the end. You do not have to set these bytes to specific values though you may
-want to if you want to avoid runtime warnings with some sanitizers. We expect the user
-of the library to load the data (from disk or from the network) into a padded buffer. To make
-this easy, we provide the `padded_string::load` function which loads files from disk in a padded buffer.
-[You can similarly fetch a file from a URL to a padded string](https://github.com/simdjson/curltostring) using our `simdjson::padded_string_builder`. Advanced users may want to read the section Free Padding in [our performance notes](performance.md).
-
-The simdjson library offers a tree-like [API](https://en.wikipedia.org/wiki/API), which you can
-access by creating a `ondemand::parser` and calling the `iterate()` method. The iterate method
-quickly indexes the input string and may detect some errors. The following example illustrates
-how to get started with an input JSON file (`"twitter.json"`):
+To parse JSON, create a `ondemand::parser` and call its `iterate()` method on a padded input.
+The simplest way to load a JSON file is with `padded_string::load`:
 
 ```cpp
 ondemand::parser parser;
-auto json = padded_string::load("twitter.json"); // load JSON file 'twitter.json'.
-ondemand::document doc = parser.iterate(json); // position a pointer at the beginning of the JSON data
+auto json = padded_string::load("twitter.json");
+ondemand::document doc = parser.iterate(json);
 ```
 
-(Windows users compiling with C++17 or better may use `wchar_t` strings to support non-ASCII
-filenames: `padded_string::load(L"twitter.json")`.)
+For inline JSON strings, use the `_padded` suffix:
 
-If you prefer not to create your own `ondemand::parser` instance, you can access
-a thread-local version by calling `ondemand::parser.get_parser()`.
+```cpp
+ondemand::parser parser;
+auto json = "[1,2,3]"_padded;
+ondemand::document doc = parser.iterate(json);
+```
 
+If you are compiling with C++17 or better, you can use `simdjson::padded_input`
+which accepts any string-like input and handles padding automatically:
+
+```cpp
+ondemand::parser parser;
+std::string_view json = "[1,2,3]";
+simdjson::padded_input input(json);
+ondemand::document doc = parser.iterate(input);
+
+// Also works with std::string, considering reserved capacity
+std::string json_str = "[1,2,3]";
+json_str.reserve(100);  // Reserve extra space
+simdjson::padded_input input2(json_str);  // May avoid copying
+ondemand::document doc2 = parser.iterate(input2);
+```
+
+The simdjson library also accepts `std::string` instances directly---if the provided
+reference is non-const, it will allocate padding as needed:
+
+```cpp
+ondemand::parser parser;
+std::string json = "[1,2,3]";
+ondemand::document doc = parser.iterate(json);
+```
+
+By default, the simdjson library throws exceptions (`simdjson_error`) on errors. We omit `try`-`catch` clauses from our illustrating examples: if you omit `try`-`catch` in your code, an uncaught exception will halt your program. It is also possible to use simdjson without generating exceptions, and you may even build the library without exception support at all. See [Error handling](#error-handling) for details.
+
+
+### Advanced input options
+
+This section covers additional ways to provide JSON input to simdjson, including
+options for fine-grained control over padding and memory.
+
+**Thread-local parser.** If you prefer not to create your own `ondemand::parser` instance, you can access
+a thread-local version by calling `ondemand::parser.get_parser()`:
 
 ```cpp
 ondemand::document doc = ondemand::parser.get_parser().iterate(json);
 ```
 
-However, you should be careful because a parser instance can only be used for one
-document at a time, thus it is only applicable when you are only parsing one
+A parser instance can only be used for one document at a time, so
+the thread-local parser is only applicable when you parse one
 document per thread at any one time.
 
-You can also create a padded string---and call `iterate()`:
+**`padded_input` details (C++17+).** The actual padding only occurs when the JSON string ends near the boundary of a memory page, which is
+uncommon. Using a `simdjson::padded_input` is safe although sanitizers and tools like valgrind
+might report illegal reads (which are safe in our case because they remain in the mapped page). You should avoid `simdjson::padded_input`
+on systems without a page size of at least 4096: virtually all systems qualify except for
+some niche embedded systems running custom operating systems. Standard Linux, Windows, macOS, Android, iOS, etc., are all fine. Note that, most times, a `simdjson::padded_input` instance will not copy the data and will only act
+as a view (it does not own the memory).
 
-```cpp
-ondemand::parser parser;
-auto json = "[1,2,3]"_padded; // The _padded suffix creates a simdjson::padded_string instance
-ondemand::document doc = parser.iterate(json); // parse a string
-```
-
-If you have a buffer of your own with enough padding already (SIMDJSON_PADDING extra bytes allocated), you can use `padded_string_view` to pass it in:
+**User-managed buffers.** If you have a buffer of your own with enough padding already (`SIMDJSON_PADDING` extra bytes allocated), you can use `padded_string_view` to pass it in:
 
 ```cpp
 ondemand::parser parser;
@@ -217,73 +240,72 @@ strcpy(json, "[1]");
 ondemand::document doc = parser.iterate(json, strlen(json), sizeof(json));
 ```
 
-The simdjson library will also accept `std::string` instances. If the provided
-reference is non-const, it will allocate padding as needed.
-
-You can copy your data directly on a `simdjson::padded_string` as follows:
+**Copying into a `padded_string`.** You can copy your data directly into a `simdjson::padded_string`:
 
 ```cpp
 const char * data = "my data"; // 7 bytes
 simdjson::padded_string my_padded_data(data, 7); // copies to a padded buffer
 ```
 
-Or as follows...
+Or from a `std::string`:
 
 ```cpp
 std::string data = "my data";
 simdjson::padded_string my_padded_data(data); // copies to a padded buffer
 ```
 
-You can then parse the JSON data from the `simdjson::padded_string` instance:
-
-
-```cpp
-ondemand::document doc = parser.iterate(my_padded_data);
-```
-
-Whenever you pass an `std::string` reference to `parser::iterate`,
-the parser will access the bytes beyond the end of
+**`std::string` and sanitizer warnings.** Whenever you pass an `std::string` reference to `parser::iterate`,
+the parser may access bytes beyond the end of
 the string but before the end of the allocated memory (`std::string::capacity()`).
-If you are using a sanitizer that checks for reading uninitialized bytes or `std::string`'s
-container-overflow checks, you may encounter sanitizer warnings.
-You can safely ignore these warnings. Or you can call `simdjson::pad(std::string&)` to pad the
-string with `SIMDJSON_PADDING` spaces: this function returns a `simdjson::padding_string_view` which can be be passed to the parser's iterator function:
+Sanitizers that check for reading uninitialized bytes may produce warnings.
+You can safely ignore these warnings, or call `simdjson::pad(std::string&)` to pad the
+string explicitly:
 
 ```cpp
 std::string json = "[1]";
 ondemand::document doc = parser.iterate(simdjson::pad(json));
 ```
 
-We recommend against creating many `std::string` or many `std::padding_string` instances in your application to store your JSON data.
+We recommend against creating many `std::string` or many `std::padded_string` instances in your application to store your JSON data.
 Consider reusing the same buffers and limiting memory allocations.
 
-By default, the simdjson library throws exceptions (`simdjson_error`) on errors. We omit `try`-`catch` clauses from our illustrating examples: if you omit `try`-`catch` in your code, an uncaught exception will halt your program. It is also possible to use simdjson without generating exceptions, and you may even build the library without exception support at all. See [Error handling](#error-handling) for details.
+**Memory-file mapping (non-Windows).** You can use memory-file mapping to create a `simdjson::padded_string_view`
+from a file on disk:
 
-Some users may want to browse code along with the compiled assembly. You want to check out the following lists of examples:
+```cpp
+simdjson::padded_memory_map map(myfilename);
+if (!map.is_valid()) { /* handle error */ }
+simdjson::padded_string_view view = map.view();
+ondemand::document doc = parser.iterate(view);
+```
 
-* [simdjson examples with errors handled through exceptions](https://godbolt.org/z/98Kx9Kqjn)
-* [simdjson examples with errors without exceptions](https://godbolt.org/z/PKG7GdbPo)
-
-*Windows-specific*:  Windows users who need to read files with
+**Windows-specific notes.** Windows users compiling with C++17 or better may use `wchar_t` strings to support non-ASCII
+filenames: `padded_string::load(L"twitter.json")`. Windows users who need to read files with
 non-ANSI characters in the name should set their code page to
 UTF-8 (65001). This should be the default with Windows 11 and better.
 Further, they may use the AreFileApisANSI function to determine whether
 the filename is interpreted using the ANSI or the system default OEM
 codepage, and they may call SetFileApisToOEM accordingly.
 
+Some users may want to browse code along with the compiled assembly:
 
-**Advanced feature:**
-On non-Windows systems, you can use memory-file mapping to create a `simdjson::padded_string_view`
-from a file on disk.
+* [simdjson examples with errors handled through exceptions](https://godbolt.org/z/98Kx9Kqjn)
+* [simdjson examples with errors without exceptions](https://godbolt.org/z/PKG7GdbPo)
 
-```cpp
-// If the macro _WIN32 is defined, this will not work since we do not support memory-file mapping
-// under Windows at this time.
-simdjson::padded_memory_map map(myfilename);
-if (!map.is_valid()) { /* handle error */ }
-simdjson::padded_string_view view = map.view(); // view is usable while padded_memory_map is in scope
-ondemand::document doc = parser.iterate(view); // parse the JSON
-```
+**Summary of input types:**
+
+
+| Input Type / Method                          | Padding Requirement                                                                 | How Padding is Handled                                                                 | Ownership / Copying                          | Notes / Warnings                                                                 |
+|----------------------------------------------|-------------------------------------------------------------------------------------|----------------------------------------------------------------------------------------|----------------------------------------------|----------------------------------------------------------------------------------|
+| `padded_string::load("file.json")`           | Automatic (SIMDJSON_PADDING extra bytes)                                           | Library allocates padded buffer and loads file into it                                 | Owned by `padded_string`                     | Recommended for files; safest and simplest.                                      |
+| `"...json..."_padded` literal                | Automatic (built-in padding)                                                        | Creates `padded_string` with padding                                                   | Owned by `padded_string`                     | Convenient for small hardcoded JSON.                                             |
+| `simdjson::padded_input` (C++17+)            | Automatic when needed                                                               | Adds padding **only** if the string ends near a memory page boundary. For `std::string`, considers `capacity()` | Usually a non-owning view (no copy most times) | Safe on standard OS (page size ≥ 4096). May trigger sanitizer/valgrind warnings (harmless). Avoid on niche embedded systems. |
+| User buffer with explicit padding            | Must have at least `SIMDJSON_PADDING` extra allocated bytes after JSON content     | Pass via `iterate(ptr, json_length, total_allocated_size)` or `padded_string_view`     | User-owned (no copy)                         | Use `char buf[len + SIMDJSON_PADDING]`. Library reads (but never writes) into padding. |
+| `std::string` (non-const)                    | Library checks `capacity()`                                                         | If insufficient, library may allocate a padded copy                                    | May copy (depends on capacity)               | Can trigger sanitizer warnings on uninitialized bytes. Use `simdjson::pad(json)` to avoid. |
+| `simdjson::pad(std::string&)`                | Adds padding if needed                                                              | Returns `padded_string_view` pointing to the (possibly resized) string                 | References original string                   | Recommended to silence sanitizers when using `std::string`.                      |
+| `padded_string(data, length)` or `padded_string(std::string)` | Automatic (copies into padded buffer)                                              | Explicit copy into owned padded buffer                                                 | Owned by `padded_string`                     | Safe when you want full ownership and padding guaranteed.                        |
+| `padded_string_view` (manual)                | User guarantees `SIMDJSON_PADDING` extra bytes after the viewed length             | User provides pointer + length + capacity                                              | Non-owning view                              | Low-level; requires careful buffer management.                                   |
+| Memory-mapped file (`padded_memory_map`)     | Automatic via mapping (non-Windows only)                                            | Creates view with sufficient padding                                                   | Non-owning (tied to map lifetime)            | Advanced; efficient for large files on Linux/macOS/etc.                          |
 
 
 Documents are iterators
@@ -1300,10 +1322,6 @@ You can also use the custom `Car` type as part of a template such as `std::vecto
   simdjson::ondemand::parser parser;
   simdjson::ondemand::document doc = parser.iterate(json);
   std::vector<Car> cars(doc);
-  // visual studio users need an explicit call:
-  //   std::vector<Car> cars = doc.get<std::vector<Car>>();
-  // because the compiler does not know whether to convert
-  // doc to an unsigned int or to a vector.
   for(Car& c : cars) {
     std::cout << c.year << std::endl;
   }

doc/compile_time.md

@@ -32,6 +32,21 @@ your code with the `SIMDJSON_STATIC_REFLECTION` macro set:
 The `simdjson::compile_time::parse_json` function parses a JSON document at **compile time** and returns a `constexpr` structure reflecting its content. We support the full range of JSON values, which are mapped to C++ types as in
 the following table.
 
+For convenience, you can also use the `""_json` user-defined literal operator, which is available in the `simdjson::literals` namespace:
+
+```cpp
+using namespace simdjson::literals;
+
+constexpr auto cfg = R"(
+{
+    "port": 8080,
+    "host": "localhost"
+}
+)"_json;
+```
+
+Alternatively, you can use the qualified name `simdjson::literals::operator""_json`.
+
 
 | JSON type      | C++ type                         |
 |----------------|----------------------------------|
@@ -61,6 +76,8 @@ You can do so, at compile-time, as follows:
 
 
 ```cpp
+using namespace simdjson::literals;
+
 constexpr auto cfg = R"(
 
 {
@@ -79,6 +96,8 @@ constexpr auto cfg = R"(
 You can nest objects and arrays:
 
 ```cpp
+using namespace simdjson::literals;
+
 constexpr auto data = R"(
 
 {
@@ -98,6 +117,8 @@ constexpr auto data = R"(
 Top-level arrays are allowed:
 
 ```cpp
+using namespace simdjson::literals;
+
 constexpr auto arr = R"(
 
 [1, 2, 3]
@@ -116,6 +137,8 @@ want to check that it conforms to your expectation. You can do so with concepts.
 Let us consider this example:
 
 ```cpp
+    using namespace simdjson::literals;
+
     constexpr auto config = R"(
 
     [

doc/dom.md

@@ -882,6 +882,19 @@ simdjson::dom::element element = parser.parse(padded_json_copy.get(), json_len,
 
 Setting the `realloc_if_needed` parameter `false` in this manner may lead to better performance since copies are avoided, but it requires that the user takes more responsibilities: the simdjson library cannot verify that the input buffer was padded with SIMDJSON_PADDING extra bytes.
 
+If you are compiling your project with C++17 or better, you can use a `simdjson::padded_input`:
+
+```cpp
+simdjson::dom::parser parser;
+std::string_view json = "[1,2,3]";
+simdjson::padded_input input(json); // Automatically pads if needed
+simdjson::dom::element element = parser.parse(input);
+```
+
+The actual padding only occurs if the JSON string ends near the boundary of a memory page, which is uncommon. Using a `simdjson::padded_input` is safe although sanitizers and tools like valgrind might report illegal reads (which are safe in our case because they remain in the mapped page). You should avoid `simdjson::padded_input` on systems without a page size of at least 4096: virtually all systems qualify except for some niche embedded systems running custom operating systems. Standard Linux, Windows, macOS, Android, iOS, etc., are all fine.  Note that, most times, an `simdjson::padded_input` instance will not copy the data and will only act
+as a view (it does not own the memory).
+
+
 Performance Tips
 ---------------------
 

doc/performance.md

@@ -204,9 +204,25 @@ but can be significantly larger. E.g., Apple systems favour pages spanning 16 ki
 
 In effect, it means that you can almost always read a few bytes beyond your current buffer---without
 allocating extra memory. However, tools such as valgrind or memory sanitizers will flag such behavior as unsafe.
-Nevertheless, you can still make sure of this capability in your code if you are an expert
-programmer and you are willing to silence sanitizer warnings. The following code provides
-a portable example.
+You can still make sure of this capability in your code if you are an expert
+programmer and you are willing to silence sanitizer warnings.
+
+If you are building simdjson with C++17 or better, you can use `simdjson::padded_input`.
+The `padded_input` struct automatically manages padding for you. It can be constructed from a `std::string_view` or a C-style string with length. If the input already has sufficient padding (up to the end of the memory page), it creates a view without copying. Otherwise, it copies the data into a `padded_string` with proper padding.
+
+Example usage:
+
+```cpp
+std::string_view json = get_json_data();
+simdjson::padded_input input(json);  // Automatically pads if needed
+auto result = parser.parse(input);
+```
+
+This simplifies padding management compared to manually checking and allocating.
+
+
+More generally, the following code provides a portable example.
+
 
 
 The conditional compilation checks for the `_MSC_VER` macro (indicating Microsoft Visual Studio)
@@ -250,7 +266,7 @@ long page_size() {
 }
 
 // Returns true if the buffer + len + simdjson::SIMDJSON_PADDING crosses the
-// page boundary.
+// page boundary. Assumes len != 0.
 bool need_allocation(const char *buf, size_t len) {
   return ((reinterpret_cast<uintptr_t>(buf + len - 1) % page_size())
     + simdjson::SIMDJSON_PADDING >= static_cast<uintptr_t>(page_size()));

include/simdjson.h

@@ -35,6 +35,7 @@
  */
 
 #include "simdjson/common_defs.h"
+#include "simdjson/feature_macros.h"
 
 // This provides the public API for simdjson.
 // DOM and ondemand are amalgamated separately, in simdjson.h
@@ -45,19 +46,29 @@
 #include "simdjson/error.h"
 #include "simdjson/error-inl.h"
 #include "simdjson/implementation.h"
+#include "simdjson/builtin.h"
 #include "simdjson/minify.h"
 #include "simdjson/padded_string.h"
 #include "simdjson/padded_string-inl.h"
 #include "simdjson/padded_string_view.h"
 #include "simdjson/padded_string_view-inl.h"
 
+#if SIMDJSON_FEATURE_DOM_API
 #include "simdjson/dom.h"
+#if SIMDJSON_FEATURE_BUILDER_API
 #include "simdjson/builder.h"
+#endif // SIMDJSON_FEATURE_BUILDER_API
+#endif // SIMDJSON_FEATURE_DOM_API
+
+#if SIMDJSON_FEATURE_ONDEMAND_API
 #include "simdjson/ondemand.h"
+#endif // SIMDJSON_FEATURE_ONDEMAND_API
+
+#if SIMDJSON_FEATURE_DOM_API && SIMDJSON_FEATURE_ONDEMAND_API
 #include "simdjson/convert.h"
 #include "simdjson/convert-inl.h"
+#endif // SIMDJSON_FEATURE_DOM_API && SIMDJSON_FEATURE_ONDEMAND_API
 
-// Compile-time JSON parsing (C++26 P2996 reflection)
 #include "simdjson/compile_time_json.h"
 #include "simdjson/compile_time_json-inl.h"
 

include/simdjson/compile_time_json-inl.h

@@ -266,6 +266,12 @@ consteval std::pair<double, size_t> parse_double(const char *src,
 }
 } // namespace number_parsing
 
+consteval auto make_data_member_options(auto&& name_str) {
+  std::meta::data_member_options options{};
+  options.name = std::forward<decltype(name_str)>(name_str);
+  return options;
+}
+
 // JSON string may contain embedded nulls, and C++26 reflection does not yet
 // support std::string_view as a data member type. As a workaround, we define
 // a custom type that holds a const char* and a size.
@@ -320,7 +326,8 @@ using class_type = type_builder<meta_info...>::constructed_type;
 /**
  * @brief Variable template for constructing instances with values
  */
-template <typename T, auto... Vs> constexpr auto construct_from = T{Vs...};
+template <typename T, auto... Vs> constexpr T construct_from = T{Vs...};
+
 
 // in JSON, there are only a few whitespace characters that are allowed
 // outside of objects, arrays, strings, and numbers.
@@ -410,7 +417,7 @@ parse_number(std::string_view json,
         std::from_chars(json.data(), json.data() + json.size(), int_value);
     if (res.ec == std::errc()) {
       out = int_value;
-      if ((res.ptr - json.data()) != scope) {
+      if (static_cast<std::size_t>(res.ptr - json.data()) != scope) {
         simdjson_consteval_error(
             "Internal error: cannot agree on the character range of the float");
       }
@@ -424,7 +431,7 @@ parse_number(std::string_view json,
         std::from_chars(json.data(), json.data() + json.size(), uint_value);
     if (res.ec == std::errc()) {
       out = uint_value;
-      if ((res.ptr - json.data()) != scope) {
+      if (static_cast<std::size_t>(res.ptr - json.data()) != scope) {
         simdjson_consteval_error(
             "Internal error: cannot agree on the character range of the float");
       }
@@ -533,7 +540,7 @@ parse_string(std::string_view json) {
       // present, we have an error (isolated high surrogate), which we
       // tolerate by substituting the substitution_code_point.
       if (end - cursor < 6 || *cursor != '\\' ||
-          *(cursor + 1) != 'u' > 0xFFFF) {
+          *(cursor + 1) != 'u') {
         code_point = substitution_code_point;
       } else {       // we have \u following the high surrogate
         cursor += 2; // skip \u
@@ -887,10 +894,19 @@ parse_json_array_impl(const std::string_view json) {
   std::size_t count = values.size() - 1;
   // We assume all elements have the same type as the first element.
   // However, if the array is heterogeneous, we should use std::variant.
+  auto elem_type = std::meta::type_of(values[1]);
+  // String literals reflected via reflect_constant_string have type const
+  // char[N], but when passed as template auto parameters they decay to
+  // const char*.  Use const char* as the element type so that
+  // construct_from can aggregate-initialize the array.
+  if (std::meta::is_array_type(elem_type) &&
+      std::meta::remove_all_extents(elem_type) == ^^const char) {
+    elem_type = ^^const char *;
+  }
   auto array_type = std::meta::substitute(
       ^^std::array,
       {
-          std::meta::type_of(values[1]), std::meta::reflect_constant(count)});
+          elem_type, std::meta::reflect_constant(count)});
 
   // Create array instance with values
   values[0] = array_type;
@@ -957,8 +973,7 @@ parse_json_object_impl(std::string_view json) {
         simdjson_consteval_error("Expected '}'");
       }
       cursor += object_size;
-      auto dms = std::meta::data_member_spec(std::meta::type_of(parsed),
-                                             {.name = field_name});
+      auto dms = std::meta::data_member_spec(std::meta::type_of(parsed), make_data_member_options(field_name));
       members.push_back(std::meta::reflect_constant(dms));
       values.push_back(parsed);
 
@@ -967,8 +982,7 @@ parse_json_object_impl(std::string_view json) {
     case '[': {
       std::string_view value(cursor, end);
       auto [parsed, array_size] = parse_json_array_impl(value);
-      auto dms = std::meta::data_member_spec(std::meta::type_of(parsed),
-                                             {.name = field_name});
+      auto dms = std::meta::data_member_spec(std::meta::type_of(parsed), make_data_member_options(field_name));
       members.push_back(std::meta::reflect_constant(dms));
       values.push_back(parsed);
       if (*(cursor + array_size - 1) != ']') {
@@ -989,8 +1003,7 @@ parse_json_object_impl(std::string_view json) {
         }
       }
       auto dms =
-          std::meta::data_member_spec(^^const char *, {
-                                                          .name = field_name});
+          std::meta::data_member_spec(^^const char *, make_data_member_options(field_name));
       members.push_back(std::meta::reflect_constant(dms));
       values.push_back(std::meta::reflect_constant_string(value));
       break;
@@ -1001,8 +1014,7 @@ parse_json_object_impl(std::string_view json) {
       }
       cursor += 4;
 
-      auto dms = std::meta::data_member_spec(^^bool, {
-                                                         .name = field_name});
+      auto dms = std::meta::data_member_spec(^^bool, make_data_member_options(field_name));
       members.push_back(std::meta::reflect_constant(dms));
       values.push_back(std::meta::reflect_constant(true));
       break;
@@ -1013,8 +1025,7 @@ parse_json_object_impl(std::string_view json) {
       }
       cursor += 5;
 
-      auto dms = std::meta::data_member_spec(^^bool, {
-                                                         .name = field_name});
+      auto dms = std::meta::data_member_spec(^^bool, make_data_member_options(field_name));
       members.push_back(std::meta::reflect_constant(dms));
       values.push_back(std::meta::reflect_constant(false));
       break;
@@ -1025,9 +1036,7 @@ parse_json_object_impl(std::string_view json) {
       }
       cursor += 4;
 
-      auto dms = std::meta::data_member_spec(^^std::nullptr_t,
-                                             {
-                                                 .name = field_name});
+      auto dms = std::meta::data_member_spec(^^std::nullptr_t, make_data_member_options(field_name));
       members.push_back(std::meta::reflect_constant(dms));
       values.push_back(std::meta::reflect_constant(nullptr));
       break;
@@ -1051,22 +1060,19 @@ parse_json_object_impl(std::string_view json) {
       if (std::holds_alternative<int64_t>(out)) {
         int64_t int_value = std::get<int64_t>(out);
         auto dms =
-            std::meta::data_member_spec(^^int64_t, {
-                                                       .name = field_name});
+            std::meta::data_member_spec(^^int64_t, make_data_member_options(field_name));
         members.push_back(std::meta::reflect_constant(dms));
         values.push_back(std::meta::reflect_constant(int_value));
       } else if (std::holds_alternative<uint64_t>(out)) {
         uint64_t uint_value = std::get<uint64_t>(out);
         auto dms =
-            std::meta::data_member_spec(^^uint64_t, {
-                                                        .name = field_name});
+            std::meta::data_member_spec(^^uint64_t, make_data_member_options(field_name));
         members.push_back(std::meta::reflect_constant(dms));
         values.push_back(std::meta::reflect_constant(uint_value));
       } else {
         double float_value = std::get<double>(out);
         auto dms =
-            std::meta::data_member_spec(^^double, {
-                                                      .name = field_name});
+            std::meta::data_member_spec(^^double, make_data_member_options(field_name));
         members.push_back(std::meta::reflect_constant(dms));
         values.push_back(std::meta::reflect_constant(float_value));
       }
@@ -1111,16 +1117,11 @@ template <constevalutil::fixed_string json_str> consteval auto parse_json() {
                 "Only JSON objects and arrays are supported at the top level, this "
                 "limitation will be lifted in the future.");*/
 
-  constexpr auto result = json.front() == '['
-                              ? parse_json_array_impl(json)
-                              : parse_json_object_impl(json);
-  return [: result.first :];
-  /*
-  if(json.front() == '[') {
-      return [:parse_json_array_impl(json).first:];
-  } else if(json.front() == '{') {
-   //   return [:parse_json_object_impl(json).first:];
-  }*/
+  if constexpr (json.front() == '[') {
+    return [: parse_json_array_impl(json).first :];
+  } else {
+    return [: parse_json_object_impl(json).first :];
+  }
 }
 
 } // namespace compile_time

include/simdjson/compile_time_json.h

@@ -63,13 +63,16 @@ namespace compile_time {
 template <constevalutil::fixed_string json_str> consteval auto parse_json();
 
 } // namespace compile_time
-} // namespace simdjson
 
+inline namespace literals {
 
 template <simdjson::constevalutil::fixed_string str>
 consteval auto operator ""_json() {
   return simdjson::compile_time::parse_json<str>();
 }
 
+} // namespace literals
+} // namespace simdjson
+
 #endif // SIMDJSON_STATIC_REFLECTION
 #endif // SIMDJSON_GENERIC_COMPILE_TIME_JSON_H

include/simdjson/constevalutil.h

@@ -58,6 +58,11 @@ struct fixed_string {
             data[i] = str[i];
         }
     }
+    constexpr fixed_string(const unsigned char (&str)[N])  {
+        for (std::size_t i = 0; i < N; ++i) {
+            data[i] = static_cast<char>(str[i]);
+        }
+    }
     char data[N];
     constexpr std::string_view view() const { return {data, N - 1}; }
     constexpr size_t size() const { return N ; }

include/simdjson/feature_macros.h

@@ -0,0 +1,17 @@
+#pragma once
+
+#if !defined(SIMDJSON_FEATURE_DOM_API)
+#define SIMDJSON_FEATURE_DOM_API 1
+#endif
+
+#if !defined(SIMDJSON_FEATURE_ONDEMAND_API)
+#define SIMDJSON_FEATURE_ONDEMAND_API 1
+#endif
+
+#if !defined(SIMDJSON_FEATURE_BUILDER_API)
+#define SIMDJSON_FEATURE_BUILDER_API 1
+#endif
+
+#if !SIMDJSON_FEATURE_DOM_API && !SIMDJSON_FEATURE_ONDEMAND_API
+#error "simdjson: at least one of SIMDJSON_FEATURE_DOM_API or SIMDJSON_FEATURE_ONDEMAND_API must be enabled."
+#endif

include/simdjson/generic/builder/json_builder.h

@@ -22,7 +22,7 @@ namespace SIMDJSON_IMPLEMENTATION {
 namespace builder {
 
 template <class T>
-  requires(concepts::container_but_not_string<T> && !require_custom_serialization<T>)
+  requires(concepts::container_but_not_string<T> && ! concepts::optional_type<T> && !require_custom_serialization<T>)
 constexpr void atom(string_builder &b, const T &t) {
   auto it = t.begin();
   auto end = t.end();
@@ -130,7 +130,7 @@ template <typename 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));
+  static constexpr auto enumerators = std::define_static_array(std::meta::enumerators_of(^^T));
   template for (constexpr auto enum_val : enumerators) {
     constexpr auto enum_str = std::define_static_string(constevalutil::consteval_to_quoted_escaped(std::meta::identifier_of(enum_val)));
     if (e == [:enum_val:]) {
@@ -294,30 +294,23 @@ string_builder& operator<<(string_builder& b, const Z& z) {
 template<constevalutil::fixed_string... FieldNames, typename T>
   requires(std::is_class_v<T> && (sizeof...(FieldNames) > 0))
 void extract_from(string_builder &b, const T &obj) {
-  // Helper to check if a field name matches any of the requested fields
-  auto should_extract = [](std::string_view field_name) constexpr -> bool {
-    return ((FieldNames.view() == field_name) || ...);
-  };
-
   b.append('{');
   bool first = true;
-
   // Iterate through all members of T using reflection
-  template for (constexpr auto mem : std::define_static_array(
-      std::meta::nonstatic_data_members_of(^^T, std::meta::access_context::unchecked()))) {
-
+  static constexpr auto members = std::define_static_array(std::meta::nonstatic_data_members_of(^^T, std::meta::access_context::unchecked()));
+  template for (constexpr auto mem : members) {
     if constexpr (std::meta::is_public(mem)) {
-      constexpr std::string_view key = std::define_static_string(std::meta::identifier_of(mem));
+      static constexpr std::string_view key = std::define_static_string(std::meta::identifier_of(mem));
 
       // Only serialize this field if it's in our list of requested fields
-      if constexpr (should_extract(key)) {
+      if constexpr (((FieldNames.view() == key) || ...)) {
         if (!first) {
           b.append(',');
         }
         first = false;
 
         // Serialize the key
-        constexpr auto quoted_key = std::define_static_string(constevalutil::consteval_to_quoted_escaped(std::meta::identifier_of(mem)));
+        static constexpr auto quoted_key = std::define_static_string(constevalutil::consteval_to_quoted_escaped(std::meta::identifier_of(mem)));
         b.append_raw(quoted_key);
         b.append(':');
 

include/simdjson/generic/builder/json_string_builder-inl.h

@@ -505,7 +505,7 @@ simdjson_inline bool string_builder::capacity_check(size_t upcoming_bytes) {
   return is_valid;
 }
 
-simdjson_inline void string_builder::grow_buffer(size_t desired_capacity) {
+inline void string_builder::grow_buffer(size_t desired_capacity) {
   if (!is_valid) {
     return;
   }
@@ -842,7 +842,7 @@ simdjson_inline void string_builder::append(const T &value) {
 #if SIMDJSON_SUPPORTS_RANGES && SIMDJSON_SUPPORTS_CONCEPTS
 // Support for range-based appending (std::ranges::view, etc.)
 template <std::ranges::range R>
-  requires(!std::is_convertible<R, std::string_view>::value && !require_custom_serialization<R>)
+  requires(!std::is_convertible<R, std::string_view>::value && !concepts::optional_type<R> && !require_custom_serialization<R>)
 simdjson_inline void string_builder::append(const R &range) noexcept {
   auto it = std::ranges::begin(range);
   auto end = std::ranges::end(range);

include/simdjson/generic/builder/json_string_builder.h

@@ -171,7 +171,7 @@ public:
 #if SIMDJSON_SUPPORTS_RANGES && SIMDJSON_SUPPORTS_CONCEPTS
   // Support for range-based appending (std::ranges::view, etc.)
   template <std::ranges::range R>
-requires (!std::is_convertible<R, std::string_view>::value && !require_custom_serialization<R>)
+requires (!std::is_convertible<R, std::string_view>::value && !concepts::optional_type<R> && !require_custom_serialization<R>)
   simdjson_inline void append(const R &range) noexcept;
 #endif
   /**
@@ -249,7 +249,7 @@ private:
    * If the allocation fails, is_valid is set to false. We expect
    * that this function would not be repeatedly called.
    */
-  simdjson_inline void grow_buffer(size_t desired_capacity);
+  inline void grow_buffer(size_t desired_capacity);
 
   /**
    * We use this helper function to make sure that is_valid is kept consistent.

include/simdjson/generic/ondemand/amalgamated.h

@@ -1,4 +1,10 @@
-#if defined(SIMDJSON_CONDITIONAL_INCLUDE) && !defined(SIMDJSON_GENERIC_BUILDER_DEPENDENCIES_H)
+#ifndef SIMDJSON_CONDITIONAL_INCLUDE
+#include "simdjson/feature_macros.h"
+#endif // SIMDJSON_CONDITIONAL_INCLUDE
+
+#if SIMDJSON_FEATURE_ONDEMAND_API
+
+#if defined(SIMDJSON_CONDITIONAL_INCLUDE) && !defined(SIMDJSON_GENERIC_ONDEMAND_DEPENDENCIES_H)
 #error simdjson/generic/ondemand/dependencies.h must be included before simdjson/generic/ondemand/amalgamated.h!
 #endif
 
@@ -48,3 +54,5 @@
 // JSON path accessor (compile-time) - must be after inline definitions
 #include "simdjson/generic/ondemand/compile_time_accessors.h"
 
+#endif // SIMDJSON_FEATURE_ONDEMAND_API
+

include/simdjson/generic/ondemand/dependencies.h

@@ -8,6 +8,7 @@
 // Internal headers needed for ondemand generics.
 // All includes not under simdjson/generic/ondemand must be here!
 // Otherwise, amalgamation will fail.
+#include "simdjson/feature_macros.h"
 #include "simdjson/dom/base.h" // for MINIMAL_DOCUMENT_CAPACITY
 #include "simdjson/implementation.h"
 #include "simdjson/padded_string.h"

include/simdjson/generic/ondemand/document-inl.h

@@ -653,27 +653,27 @@ simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document>::op
 }
 simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document>::operator uint64_t() noexcept(false) {
   if (error()) { throw simdjson_error(error()); }
-  return first;
+  return first.get_uint64();
 }
 simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document>::operator int64_t() noexcept(false) {
   if (error()) { throw simdjson_error(error()); }
-  return first;
+  return first.get_int64();
 }
 simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document>::operator double() noexcept(false) {
   if (error()) { throw simdjson_error(error()); }
-  return first;
+  return first.get_double();
 }
 simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document>::operator std::string_view() noexcept(false) {
   if (error()) { throw simdjson_error(error()); }
-  return first;
+  return first.get_string();
 }
 simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document>::operator SIMDJSON_IMPLEMENTATION::ondemand::raw_json_string() noexcept(false) {
   if (error()) { throw simdjson_error(error()); }
-  return first;
+  return first.get_raw_json_string();
 }
 simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document>::operator bool() noexcept(false) {
   if (error()) { throw simdjson_error(error()); }
-  return first;
+  return first.get_bool();
 }
 simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document>::operator SIMDJSON_IMPLEMENTATION::ondemand::value() noexcept(false) {
   if (error()) { throw simdjson_error(error()); }
@@ -1042,27 +1042,27 @@ simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document_refe
 }
 simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document_reference>::operator uint64_t() noexcept(false) {
   if (error()) { throw simdjson_error(error()); }
-  return first;
+  return first.get_uint64();
 }
 simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document_reference>::operator int64_t() noexcept(false) {
   if (error()) { throw simdjson_error(error()); }
-  return first;
+  return first.get_int64();
 }
 simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document_reference>::operator double() noexcept(false) {
   if (error()) { throw simdjson_error(error()); }
-  return first;
+  return first.get_double();
 }
 simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document_reference>::operator std::string_view() noexcept(false) {
   if (error()) { throw simdjson_error(error()); }
-  return first;
+  return first.get_string();
 }
 simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document_reference>::operator SIMDJSON_IMPLEMENTATION::ondemand::raw_json_string() noexcept(false) {
   if (error()) { throw simdjson_error(error()); }
-  return first;
+  return first.get_raw_json_string();
 }
 simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document_reference>::operator bool() noexcept(false) {
   if (error()) { throw simdjson_error(error()); }
-  return first;
+  return first.get_bool();
 }
 simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document_reference>::operator SIMDJSON_IMPLEMENTATION::ondemand::value() noexcept(false) {
   if (error()) { throw simdjson_error(error()); }

include/simdjson/generic/ondemand/document.h

@@ -319,21 +319,21 @@ public:
    * @returns A signed 64-bit integer.
    * @exception simdjson_error(INCORRECT_TYPE) If the JSON value is not a 64-bit unsigned integer.
    */
-  simdjson_inline operator uint64_t() noexcept(false);
+  explicit simdjson_inline operator uint64_t() noexcept(false);
   /**
    * Cast this JSON value to a signed integer.
    *
    * @returns A signed 64-bit integer.
    * @exception simdjson_error(INCORRECT_TYPE) If the JSON value is not a 64-bit integer.
    */
-  simdjson_inline operator int64_t() noexcept(false);
+  explicit simdjson_inline operator int64_t() noexcept(false);
   /**
    * Cast this JSON value to a double.
    *
    * @returns A double.
    * @exception simdjson_error(INCORRECT_TYPE) If the JSON value is not a valid floating-point number.
    */
-  simdjson_inline operator double() noexcept(false);
+  explicit simdjson_inline operator double() noexcept(false);
   /**
    * Cast this JSON value to a string.
    *
@@ -343,7 +343,7 @@ public:
    *          time it parses a document or when it is destroyed.
    * @exception simdjson_error(INCORRECT_TYPE) if the JSON value is not a string.
    */
-  simdjson_inline operator std::string_view() noexcept(false) simdjson_lifetime_bound;
+  explicit simdjson_inline operator std::string_view() noexcept(false) simdjson_lifetime_bound;
   /**
    * Cast this JSON value to a raw_json_string.
    *
@@ -352,14 +352,14 @@ public:
    * @returns A pointer to the raw JSON for the given string.
    * @exception simdjson_error(INCORRECT_TYPE) if the JSON value is not a string.
    */
-  simdjson_inline operator raw_json_string() noexcept(false) simdjson_lifetime_bound;
+  explicit simdjson_inline operator raw_json_string() noexcept(false) simdjson_lifetime_bound;
   /**
    * Cast this JSON value to a bool.
    *
    * @returns A bool value.
    * @exception simdjson_error(INCORRECT_TYPE) if the JSON value is not true or false.
    */
-  simdjson_inline operator bool() noexcept(false);
+  explicit simdjson_inline operator bool() noexcept(false);
   /**
    * Cast this JSON value to a value when the document is an object or an array.
    *
@@ -945,12 +945,12 @@ public:
   explicit simdjson_inline operator T() noexcept(false);
   simdjson_inline operator array() & noexcept(false);
   simdjson_inline operator object() & noexcept(false);
-  simdjson_inline operator uint64_t() noexcept(false);
-  simdjson_inline operator int64_t() noexcept(false);
-  simdjson_inline operator double() noexcept(false);
-  simdjson_inline operator std::string_view() noexcept(false);
-  simdjson_inline operator raw_json_string() noexcept(false);
-  simdjson_inline operator bool() noexcept(false);
+  explicit simdjson_inline operator uint64_t() noexcept(false);
+  explicit simdjson_inline operator int64_t() noexcept(false);
+  explicit simdjson_inline operator double() noexcept(false);
+  explicit simdjson_inline operator std::string_view() noexcept(false);
+  explicit simdjson_inline operator raw_json_string() noexcept(false);
+  explicit simdjson_inline operator bool() noexcept(false);
   simdjson_inline operator value() noexcept(false);
 #endif
   simdjson_inline simdjson_result<size_t> count_elements() & noexcept;
@@ -1030,12 +1030,12 @@ public:
   explicit simdjson_inline operator T() noexcept(false);
   simdjson_inline operator SIMDJSON_IMPLEMENTATION::ondemand::array() & noexcept(false);
   simdjson_inline operator SIMDJSON_IMPLEMENTATION::ondemand::object() & noexcept(false);
-  simdjson_inline operator uint64_t() noexcept(false);
-  simdjson_inline operator int64_t() noexcept(false);
-  simdjson_inline operator double() noexcept(false);
-  simdjson_inline operator std::string_view() noexcept(false);
-  simdjson_inline operator SIMDJSON_IMPLEMENTATION::ondemand::raw_json_string() noexcept(false);
-  simdjson_inline operator bool() noexcept(false);
+  explicit simdjson_inline operator uint64_t() noexcept(false);
+  explicit simdjson_inline operator int64_t() noexcept(false);
+  explicit simdjson_inline operator double() noexcept(false);
+  explicit simdjson_inline operator std::string_view() noexcept(false);
+  explicit simdjson_inline operator SIMDJSON_IMPLEMENTATION::ondemand::raw_json_string() noexcept(false);
+  explicit simdjson_inline operator bool() noexcept(false);
   simdjson_inline operator SIMDJSON_IMPLEMENTATION::ondemand::value() noexcept(false);
 #endif
   simdjson_inline simdjson_result<size_t> count_elements() & noexcept;
@@ -1116,12 +1116,12 @@ public:
   explicit simdjson_inline operator T() noexcept(false);
   simdjson_inline operator SIMDJSON_IMPLEMENTATION::ondemand::array() & noexcept(false);
   simdjson_inline operator SIMDJSON_IMPLEMENTATION::ondemand::object() & noexcept(false);
-  simdjson_inline operator uint64_t() noexcept(false);
-  simdjson_inline operator int64_t() noexcept(false);
-  simdjson_inline operator double() noexcept(false);
-  simdjson_inline operator std::string_view() noexcept(false);
-  simdjson_inline operator SIMDJSON_IMPLEMENTATION::ondemand::raw_json_string() noexcept(false);
-  simdjson_inline operator bool() noexcept(false);
+  explicit simdjson_inline operator uint64_t() noexcept(false);
+  explicit simdjson_inline operator int64_t() noexcept(false);
+  explicit simdjson_inline operator double() noexcept(false);
+  explicit simdjson_inline operator std::string_view() noexcept(false);
+  explicit simdjson_inline operator SIMDJSON_IMPLEMENTATION::ondemand::raw_json_string() noexcept(false);
+  explicit simdjson_inline operator bool() noexcept(false);
   simdjson_inline operator SIMDJSON_IMPLEMENTATION::ondemand::value() noexcept(false);
 #endif
   simdjson_inline simdjson_result<size_t> count_elements() & noexcept;

include/simdjson/generic/ondemand/std_deserialize.h

@@ -305,7 +305,7 @@ error_code tag_invoke(deserialize_tag, ValT &val, T &out) noexcept {
 #if SIMDJSON_STATIC_REFLECTION
   std::string_view str;
   SIMDJSON_TRY(val.get_string().get(str));
-  constexpr auto enumerators = std::define_static_array(std::meta::enumerators_of(^^T));
+  static constexpr auto enumerators = std::define_static_array(std::meta::enumerators_of(^^T));
   template for (constexpr auto enum_val : enumerators) {
     if (str == std::meta::identifier_of(enum_val)) {
       out = [:enum_val:];

include/simdjson/ondemand.h

@@ -8,12 +8,14 @@ namespace simdjson {
    * @copydoc simdjson::builtin::ondemand
    */
   namespace ondemand = builtin::ondemand;
+#if SIMDJSON_FEATURE_BUILDER_API
   /**
    * @copydoc simdjson::builtin::builder
    */
   namespace builder = builtin::builder;
+#endif // SIMDJSON_FEATURE_BUILDER_API
 
-#if SIMDJSON_STATIC_REFLECTION
+#if SIMDJSON_STATIC_REFLECTION && SIMDJSON_FEATURE_BUILDER_API
   /**
    * Create a JSON string from any user-defined type using static reflection.
    * Only available when SIMDJSON_STATIC_REFLECTION is enabled.

include/simdjson/padded_string_view-inl.h

@@ -6,6 +6,15 @@
 
 #include <cstring> /* memcmp */
 
+// for page size computation.
+#if defined(__unix__) || defined(__APPLE__) || defined(__linux__)
+  #include <unistd.h>
+  #if defined(__APPLE__)
+    #include <sys/sysctl.h>
+  #endif
+#endif
+
+
 namespace simdjson {
 
 inline padded_string_view::padded_string_view(const char* s, size_t len, size_t capacity) noexcept
@@ -95,7 +104,83 @@ inline padded_string_view pad_with_reserve(std::string& s) noexcept {
   return padded_string_view(s.data(), s.size(), s.capacity());
 }
 
+inline uint32_t get_page_size() noexcept {
+#if defined(_WINDOWS_) // if and only if someone loaded Windows.h, we can get the page size from there.
+// Otherwise, we assume 4096.
+    static const uint32_t cached = []() -> uint32_t {
+      SYSTEM_INFO si;
+      GetSystemInfo(&si);
+      return static_cast<std::uint32_t>(si.dwPageSize);
+    }();
+    return cached;
+#elif defined(__unix__) || defined(__APPLE__) || defined(__linux__)
+    static const uint32_t cached = []() -> uint32_t {
+      long page_size = sysconf(_SC_PAGESIZE);
+      if (page_size > 0) {
+          return static_cast<uint32_t>(page_size);
+      }
+      return 4096; // fallback
+    }();
+    return cached;
+#else
+    return 4096; // fallback
+#endif
+}
+#if SIMDJSON_CPLUSPLUS17
 
+inline padded_input::padded_input(std::string_view sv)
+    : storage(simdjson::padded_string_view{}) {
+  if (needs_allocation(sv.data(), sv.size())) {
+      storage = simdjson::padded_string(sv);
+  } else {
+      storage = simdjson::padded_string_view(
+          sv.data(), sv.size(), sv.size() + simdjson::SIMDJSON_PADDING);
+  }
+}
+
+inline padded_input::padded_input(const char *data, size_t length)
+    : storage(simdjson::padded_string_view{}) {
+  if (needs_allocation(data, length)) {
+      storage = simdjson::padded_string(data, length);
+  } else {
+      storage = simdjson::padded_string_view(
+          data, length, length + simdjson::SIMDJSON_PADDING);
+  }
+}
+
+inline padded_input::padded_input(const std::string &s)
+    : storage(simdjson::padded_string_view{}) {
+  const size_t len = s.size();
+  const size_t cap = s.capacity();
+  // Here we have the string content from data() to data() + size(),
+  // but the memory is accessible from data() to data() + capacity().
+  const size_t needed_padding = (cap - len) < simdjson::SIMDJSON_PADDING
+    ? simdjson::SIMDJSON_PADDING - (cap - len) : 0;
+  if (needed_padding > 0 && needs_allocation(s.data(), cap, needed_padding)) {
+      storage = simdjson::padded_string(s);
+  } else {
+      storage = simdjson::padded_string_view(
+          s.data(), len, len + simdjson::SIMDJSON_PADDING);
+  }
+}
+
+inline bool padded_input::is_view() const noexcept {
+  return std::holds_alternative<simdjson::padded_string_view>(storage);
+}
+
+inline padded_input::operator simdjson::padded_string_view() const noexcept {
+  return std::visit([](const auto& p) -> simdjson::padded_string_view {
+      return p;
+  }, storage);
+}
+
+inline bool padded_input::needs_allocation(const char* buf, size_t len, size_t padding) noexcept {
+  if(len == 0) { return false; }
+  const auto page_size = get_page_size();
+  return ((reinterpret_cast<uintptr_t>(buf + len - 1) % page_size)
+          + padding >= static_cast<uintptr_t>(page_size));
+}
+#endif // SIMDJSON_CPLUSPLUS17
 
 } // namespace simdjson
 

include/simdjson/padded_string_view.h

@@ -9,6 +9,9 @@
 #include <memory>
 #include <string>
 #include <ostream>
+#if SIMDJSON_CPLUSPLUS17
+#include <variant>
+#endif
 
 namespace simdjson {
 
@@ -73,6 +76,68 @@ public:
 
 }; // padded_string_view
 
+/**
+ * Get the system's memory page size. By default, we return
+ * 4096 bytes, which is the most common page size. On systems
+ * where the page size is not a multiple of 4096 bytes, and not
+ * a unix-like system, nor Windows, this function may return an
+ * incorrect value.
+ *
+ * @return The page size in bytes.
+ */
+inline uint32_t get_page_size() noexcept;
+
+#if SIMDJSON_CPLUSPLUS17
+/**
+ * A padded_input is a wrapper around either a padded_string_view or a padded_string.
+ * It will automatically pad a string_view if it does not have sufficient padding
+ * up to the end of the memory page. Note that a requirement for this method to
+ * make sense is to be on a system with a page size of at least 4096 (which is
+ * universal except on some embedded systems).
+ */
+struct padded_input {
+    /**
+     * Construct a padded_input from a string_view. If the string_view does not have sufficient padding,
+     * the data will be copied into a padded_string and the padded_string_view will point to the
+     * padded_string's data. Otherwise, the padded_string_view will point to the original string_view's data.
+     */
+     inline explicit padded_input(std::string_view sv);
+    /**
+     * Construct a padded_input from a C-style string (length specified). If the string does not have sufficient padding,
+     * the data will be copied into a padded_string and the padded_string_view will point to the
+     * padded_string's data. Otherwise, the padded_string_view will point to the original string's data.
+     */
+     inline explicit padded_input(const char *data, size_t length);
+    /**
+     * Construct a padded_input from a std::string. If the string does not have sufficient padding
+     * (considering its capacity), the data will be copied into a padded_string and the padded_string_view
+     * will point to the padded_string's data. Otherwise, the padded_string_view will point to the
+     * original string's data.
+     */
+     inline explicit padded_input(const std::string &s);
+
+    /**
+     * Check if the padded_input is a view.
+     *
+     * @return true if the padded_input is a view, false otherwise.
+     */
+     inline bool is_view() const noexcept;
+
+    /**
+     * Convert the padded_input to a padded_string_view.
+     *
+     * @return The padded_string_view.
+     */
+     inline operator simdjson::padded_string_view() const noexcept;
+
+private:
+    std::variant<simdjson::padded_string_view, simdjson::padded_string> storage;
+    // whether we cross a page boundary and need to allocate a new padded string.
+    static inline bool needs_allocation(const char* buf, size_t len, size_t padding = SIMDJSON_PADDING) noexcept;
+};
+
+#endif // SIMDJSON_CPLUSPLUS17
+
 #if SIMDJSON_EXCEPTIONS
 /**
  * Send padded_string instance to an output stream.
@@ -105,6 +170,7 @@ inline padded_string_view pad(std::string& s) noexcept;
  * @return The padded string.
  */
 inline padded_string_view pad_with_reserve(std::string& s) noexcept;
+
 } // namespace simdjson
 
 #endif // SIMDJSON_PADDED_STRING_VIEW_H

jsonexamples/example_config.json

@@ -0,0 +1,11 @@
+{
+  "app_name": "MyApp",
+  "version": "1.0.0",
+  "port": 8080,
+  "debug": true,
+  "features": ["logging", "caching"],
+  "database": {
+    "host": "localhost",
+    "port": 5432
+  }
+}

singleheader/all_features_test.py

@@ -0,0 +1,226 @@
+#!/usr/bin/env python3
+"""
+Amalgamates simdjson into temporary files, then builds and runs 7 feature-flag
+test programs.  Reports compile time and binary size for each configuration.
+"""
+
+import os
+import sys
+import subprocess
+import tempfile
+import time
+import shutil
+
+SCRIPTPATH = os.path.dirname(os.path.abspath(__file__))
+PROJECTPATH = os.path.dirname(SCRIPTPATH)
+TESTSRC = os.path.join(PROJECTPATH, "tests", "feature_flag_tests")
+
+# ── feature-flag configurations ──────────────────────────────────────────────
+CONFIGS = [
+    {
+        "name": "dom_only",
+        "flags": {"SIMDJSON_FEATURE_DOM_API": 1,
+                  "SIMDJSON_FEATURE_ONDEMAND_API": 0,
+                  "SIMDJSON_FEATURE_BUILDER_API": 0},
+    },
+    {
+        "name": "ondemand_only",
+        "flags": {"SIMDJSON_FEATURE_DOM_API": 1,
+                  "SIMDJSON_FEATURE_ONDEMAND_API": 1,
+                  "SIMDJSON_FEATURE_BUILDER_API": 0},
+    },
+    {
+        "name": "dom_and_ondemand",
+        "flags": {"SIMDJSON_FEATURE_DOM_API": 1,
+                  "SIMDJSON_FEATURE_ONDEMAND_API": 1,
+                  "SIMDJSON_FEATURE_BUILDER_API": 0},
+    },
+    {
+        "name": "builder_and_dom",
+        "flags": {"SIMDJSON_FEATURE_DOM_API": 1,
+                  "SIMDJSON_FEATURE_ONDEMAND_API": 0,
+                  "SIMDJSON_FEATURE_BUILDER_API": 1},
+    },
+    {
+        "name": "builder_and_ondemand",
+        "flags": {"SIMDJSON_FEATURE_DOM_API": 1,
+                  "SIMDJSON_FEATURE_ONDEMAND_API": 1,
+                  "SIMDJSON_FEATURE_BUILDER_API": 1},
+    },
+    {
+        "name": "builder_dom_and_ondemand",
+        "flags": {"SIMDJSON_FEATURE_DOM_API": 1,
+                  "SIMDJSON_FEATURE_ONDEMAND_API": 1,
+                  "SIMDJSON_FEATURE_BUILDER_API": 1},
+    },
+    {
+        "name": "builder_only",
+        "flags": {"SIMDJSON_FEATURE_DOM_API": 1,
+                  "SIMDJSON_FEATURE_ONDEMAND_API": 0,
+                  "SIMDJSON_FEATURE_BUILDER_API": 1},
+    },
+]
+
+CXX = os.environ.get("CXX", "c++")
+CXXSTD = os.environ.get("CXXSTD", "-std=c++17")
+OPT = os.environ.get("OPT", "-O2")
+
+
+def amalgamate(output_dir):
+    """Run amalgamate.py, writing simdjson.h / simdjson.cpp into *output_dir*."""
+    env = os.environ.copy()
+    env["AMALGAMATE_OUTPUT_PATH"] = output_dir
+    cmd = [sys.executable, os.path.join(SCRIPTPATH, "amalgamate.py")]
+    result = subprocess.run(cmd, env=env, capture_output=True, text=True)
+    if result.returncode != 0:
+        print("amalgamate.py failed:")
+        print(result.stdout)
+        print(result.stderr)
+        sys.exit(1)
+    header = os.path.join(output_dir, "simdjson.h")
+    source = os.path.join(output_dir, "simdjson.cpp")
+    assert os.path.isfile(header), f"missing {header}"
+    assert os.path.isfile(source), f"missing {source}"
+    return header, source
+
+
+def compile_and_run(name, flags, amal_dir, build_dir):
+    """
+    1. Compile simdjson.cpp -> simdjson.o  (timed, size reported)
+    2. Compile test .cpp -> test.o         (timed, size reported)
+    3. Link and run the test program
+
+    Returns (lib_time, lib_size, test_time, test_size) or Nones on failure.
+    """
+    src = os.path.join(TESTSRC, f"{name}.cpp")
+    simdjson_cpp = os.path.join(amal_dir, "simdjson.cpp")
+    simdjson_o = os.path.join(build_dir, f"{name}_simdjson.o")
+    test_o = os.path.join(build_dir, f"{name}.o")
+    binary = os.path.join(build_dir, name)
+
+    defs = [f"-D{k}={v}" for k, v in flags.items()]
+
+    # ── compile simdjson.o (timed) ────────────────────────────────────────
+    cmd_lib = [CXX, CXXSTD, OPT, "-c"] + defs + [
+        f"-I{amal_dir}", "-o", simdjson_o, simdjson_cpp,
+    ]
+    t0 = time.monotonic()
+    result = subprocess.run(cmd_lib, capture_output=True, text=True)
+    lib_time = time.monotonic() - t0
+
+    if result.returncode != 0:
+        print(f"  COMPILE FAILED (simdjson.o): {name}")
+        print(f"  command: {' '.join(cmd_lib)}")
+        print(result.stderr)
+        return None, None, None, None
+
+    lib_size = os.path.getsize(simdjson_o)
+
+    # ── compile test source (timed) ───────────────────────────────────────
+    cmd_test = [CXX, CXXSTD, OPT, "-c"] + defs + [
+        f"-I{amal_dir}", "-o", test_o, src,
+    ]
+    t0 = time.monotonic()
+    result = subprocess.run(cmd_test, capture_output=True, text=True)
+    test_time = time.monotonic() - t0
+
+    if result.returncode != 0:
+        print(f"  COMPILE FAILED (test): {name}")
+        print(f"  command: {' '.join(cmd_test)}")
+        print(result.stderr)
+        return None, None, None, None
+
+    test_size = os.path.getsize(test_o)
+
+    # ── link ──────────────────────────────────────────────────────────────
+    cmd_link = [CXX, "-o", binary, test_o, simdjson_o]
+    result = subprocess.run(cmd_link, capture_output=True, text=True)
+    if result.returncode != 0:
+        print(f"  LINK FAILED: {name}")
+        print(f"  command: {' '.join(cmd_link)}")
+        print(result.stderr)
+        return None, None, None, None
+
+    # ── run ───────────────────────────────────────────────────────────────
+    result = subprocess.run([binary], capture_output=True, text=True)
+    if result.returncode != 0:
+        print(f"  RUN FAILED: {name}")
+        print(result.stdout)
+        print(result.stderr)
+        return lib_time, lib_size, test_time, test_size
+
+    print(f"  {result.stdout.strip()}")
+    return lib_time, lib_size, test_time, test_size
+
+
+def human_size(n):
+    """Return e.g. '1.23 MB' or '456 KB'."""
+    if n is None:
+        return "N/A"
+    if n >= 1_000_000:
+        return f"{n / 1_000_000:.2f} MB"
+    if n >= 1_000:
+        return f"{n / 1_000:.1f} KB"
+    return f"{n} B"
+
+
+def main():
+    tmpdir = tempfile.mkdtemp(prefix="simdjson_features_")
+    amal_dir = os.path.join(tmpdir, "amalgamated")
+    build_dir = os.path.join(tmpdir, "build")
+    os.makedirs(amal_dir, exist_ok=True)
+    os.makedirs(build_dir, exist_ok=True)
+
+    print(f"Working directory: {tmpdir}")
+    print(f"Compiler: {CXX}  flags: {CXXSTD} {OPT}")
+    print()
+
+    # ── amalgamate ────────────────────────────────────────────────────────
+    print("Amalgamating...")
+    amalgamate(amal_dir)
+    print("Amalgamation done.\n")
+
+    # ── build & run each configuration ────────────────────────────────────
+    results = []
+    for cfg in CONFIGS:
+        name = cfg["name"]
+        flags = cfg["flags"]
+        enabled = [k.replace("SIMDJSON_FEATURE_", "").replace("_API", "")
+                   for k, v in flags.items() if v]
+        label = " + ".join(enabled) if enabled else "none"
+        print(f"[{name}] ({label})")
+        lib_time, lib_size, test_time, test_size = \
+            compile_and_run(name, flags, amal_dir, build_dir)
+        results.append((name, label, lib_time, lib_size, test_time, test_size))
+
+    print()
+
+    # ── summary table ─────────────────────────────────────────────────────
+    name_w = max(len(r[0]) for r in results)
+    label_w = max(len(r[1]) for r in results)
+    hdr = (f"{'Test':<{name_w}}  {'APIs':<{label_w}}"
+           f"  {'lib time':>9}  {'simdjson.o':>11}"
+           f"  {'test time':>10}  {'test .o':>11}")
+    print(hdr)
+    print("-" * len(hdr))
+    for name, label, lt, ls, tt, ts in results:
+        lt_s = f"{lt:.2f} s" if lt is not None else "FAIL"
+        ls_s = human_size(ls)
+        tt_s = f"{tt:.2f} s" if tt is not None else "FAIL"
+        ts_s = human_size(ts)
+        print(f"{name:<{name_w}}  {label:<{label_w}}"
+              f"  {lt_s:>9}  {ls_s:>11}"
+              f"  {tt_s:>10}  {ts_s:>11}")
+
+    # ── cleanup ───────────────────────────────────────────────────────────
+    shutil.rmtree(tmpdir, ignore_errors=True)
+
+    # exit non-zero if anything failed
+    if any(lt is None for _, _, lt, _, _, _ in results):
+        print("\nSome tests FAILED.")
+        sys.exit(1)
+    print("\nAll tests passed.")
+
+
+if __name__ == "__main__":
+    main()

singleheader/amalgamate.py

@@ -268,7 +268,21 @@ class SimdjsonFile:
         print(f"    Adding include: {self} includes {include}")
         if self.is_conditional_include:
             # If I have a dependency file, I can only include something that has a dependency file.
-            assert include.is_conditional_include, f"Error: Amalgamated file '{self}' is trying to include '{include}', but '{include}' is not an amalgamated file. Amalgamated files can only include other amalgamated files to maintain conditional inclusion structure. Check the inclusion rules in the script's 'rules' variable. {rules}"
+            if not include.is_conditional_include:
+                dep = self.dependency_file
+                dep_hint = f" and add it to the dependency file '{dep}'" if dep else ""
+                raise AssertionError(
+                    f"Error: Amalgamated file '{self}' is trying to include '{include}', "
+                    f"but '{include}' is not an amalgamated file.\n\n"
+                    f"FIX: Wrap the #include \"{include}\" in a conditional block:\n\n"
+                    f"    #ifndef SIMDJSON_CONDITIONAL_INCLUDE\n"
+                    f"    #include \"{include}\"\n"
+                    f"    #endif // SIMDJSON_CONDITIONAL_INCLUDE\n\n"
+                    f"This makes the include editor-only (skipped during amalgamation){dep_hint}.\n\n"
+                    f"During amalgamation, '{include}' is already included earlier in the "
+                    f"amalgamated output, so it does not need to be included again.\n\n"
+                    f"{rules}"
+                )
             # TODO make sure we only include amalgamated files that are guaranteed to be included with us (or before us)
             # if include.amalgamator_file:
             #     assert include.amalgamator_file == self, f"{self} cannot include {include}: it should be included from {include.amalgamator_file} instead."
@@ -425,8 +439,10 @@ class Amalgamator:
             self.implementation = "SIMDJSON_BUILTIN_IMPLEMENTATION"
 
         assert not self.editor_only_region, f"Error: Already in an editor-only region when starting to write '{file}'. Ensure proper nesting of conditional blocks."
+        editor_only_start_line = None
+        bare_endif_lines = []
         with open(file.absolute_path, 'r') as fid2:
-            for line in fid2:
+            for line_number, line in enumerate(fid2, 1):
                 line = line.rstrip('\n')
 
                 # Ignore #pragma once, it causes warnings if it ends up in a .cpp file
@@ -439,6 +455,7 @@ class Amalgamator:
                     assert self.in_conditional_include_block, f"Error: File '{file}' uses '#ifndef SIMDJSON_CONDITIONAL_INCLUDE' without a prior '#define SIMDJSON_CONDITIONAL_INCLUDE'. Ensure the define comes first. Stack: {self.include_stack}. {rules}"
                     assert not self.editor_only_region, f"Error: File '{file}' uses '#ifndef SIMDJSON_CONDITIONAL_INCLUDE' twice in a row. Ensure conditional blocks are properly nested and closed. {rules}"
                     self.editor_only_region = True
+                    editor_only_start_line = line_number
 
                 # Handle ignored lines (and ending ignore blocks)
                 end_ignore = endif_conditional_re.search(line)
@@ -453,6 +470,12 @@ class Amalgamator:
                             file.add_editor_only_include(included_file)
                     if end_ignore:
                         self.editor_only_region = False
+                        editor_only_start_line = None
+                    else:
+                        # Track bare #endif lines that might be the intended closer
+                        stripped = line.strip()
+                        if stripped == '#endif' or (stripped.startswith('#endif') and 'SIMDJSON_CONDITIONAL_INCLUDE' not in stripped):
+                            bare_endif_lines.append((line_number, line.strip()))
                     continue
 
                 assert not end_ignore, f"Error: File '{file}' has '#endif // SIMDJSON_CONDITIONAL_INCLUDE' without a matching '#ifndef'. Ensure proper conditional block structure. {rules}"
@@ -501,7 +524,35 @@ class Amalgamator:
 
                 self.write(line)
 
-            assert not self.editor_only_region, f"Error: File '{file}' ended without closing the '#endif // SIMDJSON_CONDITIONAL_INCLUDE'. Ensure all conditional blocks are properly closed. {rules}"
+            if self.editor_only_region:
+                msg = (
+                    f"Error: File '{file}' ended without closing the "
+                    f"'#endif // SIMDJSON_CONDITIONAL_INCLUDE' block "
+                    f"(opened at line {editor_only_start_line}).\n\n"
+                )
+                if bare_endif_lines:
+                    msg += (
+                        f"HINT: Found #endif line(s) inside the block that are missing "
+                        f"the required comment. The amalgamation script looks for exactly:\n\n"
+                        f"    #endif // SIMDJSON_CONDITIONAL_INCLUDE\n\n"
+                        f"but found:\n"
+                    )
+                    for ln, text in bare_endif_lines:
+                        msg += f"    line {ln}: {text}\n"
+                    msg += (
+                        f"\nFIX: Change the #endif to:\n\n"
+                        f"    #endif // SIMDJSON_CONDITIONAL_INCLUDE\n\n"
+                        f"The '// SIMDJSON_CONDITIONAL_INCLUDE' comment is required "
+                        f"for the amalgamation script to recognize it as the closing "
+                        f"of the conditional block.\n"
+                    )
+                else:
+                    msg += (
+                        f"FIX: Add '#endif // SIMDJSON_CONDITIONAL_INCLUDE' to close "
+                        f"the '#ifndef SIMDJSON_CONDITIONAL_INCLUDE' block.\n"
+                    )
+                msg += f"\n{rules}"
+                raise AssertionError(msg)
 
         self.write(f"/* end file {self.file_to_str(file)} */")
 

src/arm64.cpp

@@ -2,6 +2,7 @@
 #define SIMDJSON_SRC_ARM64_CPP
 
 #ifndef SIMDJSON_CONDITIONAL_INCLUDE
+#include "simdjson/feature_macros.h"
 #include <base.h>
 #endif // SIMDJSON_CONDITIONAL_INCLUDE
 
@@ -142,6 +143,7 @@ simdjson_warn_unused bool implementation::validate_utf8(const char *buf, size_t
   return arm64::stage1::generic_validate_utf8(buf,len);
 }
 
+#if SIMDJSON_FEATURE_DOM_API
 simdjson_warn_unused error_code dom_parser_implementation::stage2(dom::document &_doc) noexcept {
   return stage2::tape_builder::parse_document<false>(*this, _doc);
 }
@@ -149,6 +151,7 @@ simdjson_warn_unused error_code dom_parser_implementation::stage2(dom::document
 simdjson_warn_unused error_code dom_parser_implementation::stage2_next(dom::document &_doc) noexcept {
   return stage2::tape_builder::parse_document<true>(*this, _doc);
 }
+#endif // SIMDJSON_FEATURE_DOM_API
 
 SIMDJSON_NO_SANITIZE_MEMORY
 simdjson_warn_unused uint8_t *dom_parser_implementation::parse_string(const uint8_t *src, uint8_t *dst, bool allow_replacement) const noexcept {
@@ -159,11 +162,13 @@ simdjson_warn_unused uint8_t *dom_parser_implementation::parse_wobbly_string(con
   return arm64::stringparsing::parse_wobbly_string(src, dst);
 }
 
+#if SIMDJSON_FEATURE_DOM_API
 simdjson_warn_unused error_code dom_parser_implementation::parse(const uint8_t *_buf, size_t _len, dom::document &_doc) noexcept {
   auto error = stage1(_buf, _len, stage1_mode::regular);
   if (error) { return error; }
   return stage2(_doc);
 }
+#endif // SIMDJSON_FEATURE_DOM_API
 
 } // namespace arm64
 } // namespace simdjson

src/fallback.cpp

@@ -2,6 +2,7 @@
 #define SIMDJSON_SRC_FALLBACK_CPP
 
 #ifndef SIMDJSON_CONDITIONAL_INCLUDE
+#include "simdjson/feature_macros.h"
 #include <base.h>
 #endif // SIMDJSON_CONDITIONAL_INCLUDE
 
@@ -11,10 +12,13 @@
 #include <simdjson/fallback/begin.h>
 #include <generic/stage1/find_next_document_index.h>
 #include <generic/stage2/stringparsing.h>
+
+#if SIMDJSON_FEATURE_DOM_API
 #include <generic/stage2/logger.h>
 #include <generic/stage2/json_iterator.h>
 #include <generic/stage2/tape_writer.h>
 #include <generic/stage2/tape_builder.h>
+#endif // SIMDJSON_FEATURE_DOM_API
 
 //
 // Stage 1
@@ -436,6 +440,7 @@ simdjson_warn_unused bool implementation::validate_utf8(const char *buf, size_t
 namespace simdjson {
 namespace fallback {
 
+#if SIMDJSON_FEATURE_DOM_API
 simdjson_warn_unused error_code dom_parser_implementation::stage2(dom::document &_doc) noexcept {
   return stage2::tape_builder::parse_document<false>(*this, _doc);
 }
@@ -443,6 +448,7 @@ simdjson_warn_unused error_code dom_parser_implementation::stage2(dom::document
 simdjson_warn_unused error_code dom_parser_implementation::stage2_next(dom::document &_doc) noexcept {
   return stage2::tape_builder::parse_document<true>(*this, _doc);
 }
+#endif // SIMDJSON_FEATURE_DOM_API
 
 SIMDJSON_NO_SANITIZE_MEMORY
 simdjson_warn_unused uint8_t *dom_parser_implementation::parse_string(const uint8_t *src, uint8_t *dst, bool replacement_char) const noexcept {
@@ -453,11 +459,13 @@ simdjson_warn_unused uint8_t *dom_parser_implementation::parse_wobbly_string(con
   return fallback::stringparsing::parse_wobbly_string(src, dst);
 }
 
+#if SIMDJSON_FEATURE_DOM_API
 simdjson_warn_unused error_code dom_parser_implementation::parse(const uint8_t *_buf, size_t _len, dom::document &_doc) noexcept {
   auto error = stage1(_buf, _len, stage1_mode::regular);
   if (error) { return error; }
   return stage2(_doc);
 }
+#endif // SIMDJSON_FEATURE_DOM_API
 
 } // namespace fallback
 } // namespace simdjson

src/generic/dependencies.h

@@ -5,6 +5,7 @@
 #ifndef SIMDJSON_SRC_GENERIC_DEPENDENCIES_H
 #define SIMDJSON_SRC_GENERIC_DEPENDENCIES_H
 
+#include "simdjson/feature_macros.h"
 #include <base.h>
 
 #endif // SIMDJSON_SRC_GENERIC_DEPENDENCIES_H

src/generic/stage2/amalgamated.h

@@ -1,3 +1,7 @@
+#include <generic/stage2/stringparsing.h>
+
+#if SIMDJSON_FEATURE_DOM_API
+
 // Stuff other things depend on
 #include <generic/stage2/base.h>
 #include <generic/stage2/tape_writer.h>
@@ -5,6 +9,7 @@
 
 // All other declarations
 #include <generic/stage2/json_iterator.h>
-#include <generic/stage2/stringparsing.h>
 #include <generic/stage2/structural_iterator.h>
 #include <generic/stage2/tape_builder.h>
+
+#endif // SIMDJSON_FEATURE_DOM_API

src/haswell.cpp

@@ -2,6 +2,7 @@
 #define SIMDJSON_SRC_HASWELL_CPP
 
 #ifndef SIMDJSON_CONDITIONAL_INCLUDE
+#include "simdjson/feature_macros.h"
 #include <base.h>
 #endif // SIMDJSON_CONDITIONAL_INCLUDE
 
@@ -139,6 +140,7 @@ simdjson_warn_unused bool implementation::validate_utf8(const char *buf, size_t
   return haswell::stage1::generic_validate_utf8(buf,len);
 }
 
+#if SIMDJSON_FEATURE_DOM_API
 simdjson_warn_unused error_code dom_parser_implementation::stage2(dom::document &_doc) noexcept {
   return stage2::tape_builder::parse_document<false>(*this, _doc);
 }
@@ -146,6 +148,7 @@ simdjson_warn_unused error_code dom_parser_implementation::stage2(dom::document
 simdjson_warn_unused error_code dom_parser_implementation::stage2_next(dom::document &_doc) noexcept {
   return stage2::tape_builder::parse_document<true>(*this, _doc);
 }
+#endif // SIMDJSON_FEATURE_DOM_API
 
 SIMDJSON_NO_SANITIZE_MEMORY
 simdjson_warn_unused uint8_t *dom_parser_implementation::parse_string(const uint8_t *src, uint8_t *dst, bool replacement_char) const noexcept {
@@ -156,15 +159,17 @@ simdjson_warn_unused uint8_t *dom_parser_implementation::parse_wobbly_string(con
   return haswell::stringparsing::parse_wobbly_string(src, dst);
 }
 
+#if SIMDJSON_FEATURE_DOM_API
 simdjson_warn_unused error_code dom_parser_implementation::parse(const uint8_t *_buf, size_t _len, dom::document &_doc) noexcept {
   auto error = stage1(_buf, _len, stage1_mode::regular);
   if (error) { return error; }
   return stage2(_doc);
 }
+#endif // SIMDJSON_FEATURE_DOM_API
 
 } // namespace SIMDJSON_IMPLEMENTATION
 } // namespace simdjson
 
 #include <simdjson/haswell/end.h>
 
-#endif // SIMDJSON_SRC_HASWELL_CPP
+#endif // SIMDJSON_SRC_HASWELL_CPP

src/icelake.cpp

@@ -2,6 +2,7 @@
 #define SIMDJSON_SRC_ICELAKE_CPP
 
 #ifndef SIMDJSON_CONDITIONAL_INCLUDE
+#include "simdjson/feature_macros.h"
 #include <base.h>
 #endif // SIMDJSON_CONDITIONAL_INCLUDE
 
@@ -185,6 +186,7 @@ simdjson_warn_unused bool implementation::validate_utf8(const char *buf, size_t
   return icelake::stage1::generic_validate_utf8(buf,len);
 }
 
+#if SIMDJSON_FEATURE_DOM_API
 simdjson_warn_unused error_code dom_parser_implementation::stage2(dom::document &_doc) noexcept {
   return stage2::tape_builder::parse_document<false>(*this, _doc);
 }
@@ -192,6 +194,7 @@ simdjson_warn_unused error_code dom_parser_implementation::stage2(dom::document
 simdjson_warn_unused error_code dom_parser_implementation::stage2_next(dom::document &_doc) noexcept {
   return stage2::tape_builder::parse_document<true>(*this, _doc);
 }
+#endif // SIMDJSON_FEATURE_DOM_API
 
 SIMDJSON_NO_SANITIZE_MEMORY
 simdjson_warn_unused uint8_t *dom_parser_implementation::parse_string(const uint8_t *src, uint8_t *dst, bool replacement_char) const noexcept {
@@ -202,11 +205,13 @@ simdjson_warn_unused uint8_t *dom_parser_implementation::parse_wobbly_string(con
   return icelake::stringparsing::parse_wobbly_string(src, dst);
 }
 
+#if SIMDJSON_FEATURE_DOM_API
 simdjson_warn_unused error_code dom_parser_implementation::parse(const uint8_t *_buf, size_t _len, dom::document &_doc) noexcept {
   auto error = stage1(_buf, _len, stage1_mode::regular);
   if (error) { return error; }
   return stage2(_doc);
 }
+#endif // SIMDJSON_FEATURE_DOM_API
 
 } // namespace icelake
 } // namespace simdjson

src/lasx.cpp

@@ -2,6 +2,7 @@
 #define SIMDJSON_SRC_LASX_CPP
 
 #ifndef SIMDJSON_CONDITIONAL_INCLUDE
+#include "simdjson/feature_macros.h"
 #include <base.h>
 #endif // SIMDJSON_CONDITIONAL_INCLUDE
 
@@ -102,6 +103,7 @@ simdjson_warn_unused bool implementation::validate_utf8(const char *buf, size_t
   return lasx::stage1::generic_validate_utf8(buf,len);
 }
 
+#if SIMDJSON_FEATURE_DOM_API
 simdjson_warn_unused error_code dom_parser_implementation::stage2(dom::document &_doc) noexcept {
   return stage2::tape_builder::parse_document<false>(*this, _doc);
 }
@@ -109,6 +111,7 @@ simdjson_warn_unused error_code dom_parser_implementation::stage2(dom::document
 simdjson_warn_unused error_code dom_parser_implementation::stage2_next(dom::document &_doc) noexcept {
   return stage2::tape_builder::parse_document<true>(*this, _doc);
 }
+#endif // SIMDJSON_FEATURE_DOM_API
 
 SIMDJSON_NO_SANITIZE_MEMORY
 simdjson_warn_unused uint8_t *dom_parser_implementation::parse_string(const uint8_t *src, uint8_t *dst, bool allow_replacement) const noexcept {
@@ -119,11 +122,13 @@ simdjson_warn_unused uint8_t *dom_parser_implementation::parse_wobbly_string(con
   return lasx::stringparsing::parse_wobbly_string(src, dst);
 }
 
+#if SIMDJSON_FEATURE_DOM_API
 simdjson_warn_unused error_code dom_parser_implementation::parse(const uint8_t *_buf, size_t _len, dom::document &_doc) noexcept {
   auto error = stage1(_buf, _len, stage1_mode::regular);
   if (error) { return error; }
   return stage2(_doc);
 }
+#endif // SIMDJSON_FEATURE_DOM_API
 
 } // namespace lasx
 } // namespace simdjson

src/lsx.cpp

@@ -2,6 +2,7 @@
 #define SIMDJSON_SRC_LSX_CPP
 
 #ifndef SIMDJSON_CONDITIONAL_INCLUDE
+#include "simdjson/feature_macros.h"
 #include <base.h>
 #endif // SIMDJSON_CONDITIONAL_INCLUDE
 
@@ -106,6 +107,7 @@ simdjson_warn_unused bool implementation::validate_utf8(const char *buf, size_t
   return lsx::stage1::generic_validate_utf8(buf,len);
 }
 
+#if SIMDJSON_FEATURE_DOM_API
 simdjson_warn_unused error_code dom_parser_implementation::stage2(dom::document &_doc) noexcept {
   return stage2::tape_builder::parse_document<false>(*this, _doc);
 }
@@ -113,6 +115,7 @@ simdjson_warn_unused error_code dom_parser_implementation::stage2(dom::document
 simdjson_warn_unused error_code dom_parser_implementation::stage2_next(dom::document &_doc) noexcept {
   return stage2::tape_builder::parse_document<true>(*this, _doc);
 }
+#endif // SIMDJSON_FEATURE_DOM_API
 
 SIMDJSON_NO_SANITIZE_MEMORY
 simdjson_warn_unused uint8_t *dom_parser_implementation::parse_string(const uint8_t *src, uint8_t *dst, bool allow_replacement) const noexcept {
@@ -123,11 +126,13 @@ simdjson_warn_unused uint8_t *dom_parser_implementation::parse_wobbly_string(con
   return lsx::stringparsing::parse_wobbly_string(src, dst);
 }
 
+#if SIMDJSON_FEATURE_DOM_API
 simdjson_warn_unused error_code dom_parser_implementation::parse(const uint8_t *_buf, size_t _len, dom::document &_doc) noexcept {
   auto error = stage1(_buf, _len, stage1_mode::regular);
   if (error) { return error; }
   return stage2(_doc);
 }
+#endif // SIMDJSON_FEATURE_DOM_API
 
 } // namespace lsx
 } // namespace simdjson

src/ppc64.cpp

@@ -2,6 +2,7 @@
 #define SIMDJSON_SRC_PPC64_CPP
 
 #ifndef SIMDJSON_CONDITIONAL_INCLUDE
+#include "simdjson/feature_macros.h"
 #include <base.h>
 #endif // SIMDJSON_CONDITIONAL_INCLUDE
 
@@ -112,6 +113,7 @@ simdjson_warn_unused bool implementation::validate_utf8(const char *buf, size_t
   return ppc64::stage1::generic_validate_utf8(buf,len);
 }
 
+#if SIMDJSON_FEATURE_DOM_API
 simdjson_warn_unused error_code dom_parser_implementation::stage2(dom::document &_doc) noexcept {
   return stage2::tape_builder::parse_document<false>(*this, _doc);
 }
@@ -119,6 +121,7 @@ simdjson_warn_unused error_code dom_parser_implementation::stage2(dom::document
 simdjson_warn_unused error_code dom_parser_implementation::stage2_next(dom::document &_doc) noexcept {
   return stage2::tape_builder::parse_document<true>(*this, _doc);
 }
+#endif // SIMDJSON_FEATURE_DOM_API
 
 SIMDJSON_NO_SANITIZE_MEMORY
 simdjson_warn_unused uint8_t *dom_parser_implementation::parse_string(const uint8_t *src, uint8_t *dst, bool replacement_char) const noexcept {
@@ -129,11 +132,13 @@ simdjson_warn_unused uint8_t *dom_parser_implementation::parse_wobbly_string(con
   return ppc64::stringparsing::parse_wobbly_string(src, dst);
 }
 
+#if SIMDJSON_FEATURE_DOM_API
 simdjson_warn_unused error_code dom_parser_implementation::parse(const uint8_t *_buf, size_t _len, dom::document &_doc) noexcept {
   auto error = stage1(_buf, _len, stage1_mode::regular);
   if (error) { return error; }
   return stage2(_doc);
 }
+#endif // SIMDJSON_FEATURE_DOM_API
 
 } // namespace ppc64
 } // namespace simdjson

src/rvv-vls.cpp

@@ -2,6 +2,7 @@
 #define SIMDJSON_SRC_RVV_VLS_CPP
 
 #ifndef SIMDJSON_CONDITIONAL_INCLUDE
+#include "simdjson/feature_macros.h"
 #include <base.h>
 #endif // SIMDJSON_CONDITIONAL_INCLUDE
 
@@ -101,6 +102,7 @@ simdjson_warn_unused bool implementation::validate_utf8(const char *buf, size_t
   return rvv_vls::stage1::generic_validate_utf8(buf,len);
 }
 
+#if SIMDJSON_FEATURE_DOM_API
 simdjson_warn_unused error_code dom_parser_implementation::stage2(dom::document &_doc) noexcept {
   return stage2::tape_builder::parse_document<false>(*this, _doc);
 }
@@ -108,6 +110,7 @@ simdjson_warn_unused error_code dom_parser_implementation::stage2(dom::document
 simdjson_warn_unused error_code dom_parser_implementation::stage2_next(dom::document &_doc) noexcept {
   return stage2::tape_builder::parse_document<true>(*this, _doc);
 }
+#endif // SIMDJSON_FEATURE_DOM_API
 
 SIMDJSON_NO_SANITIZE_MEMORY
 simdjson_warn_unused uint8_t *dom_parser_implementation::parse_string(const uint8_t *src, uint8_t *dst, bool allow_replacement) const noexcept {
@@ -118,11 +121,13 @@ simdjson_warn_unused uint8_t *dom_parser_implementation::parse_wobbly_string(con
   return rvv_vls::stringparsing::parse_wobbly_string(src, dst);
 }
 
+#if SIMDJSON_FEATURE_DOM_API
 simdjson_warn_unused error_code dom_parser_implementation::parse(const uint8_t *_buf, size_t _len, dom::document &_doc) noexcept {
   auto error = stage1(_buf, _len, stage1_mode::regular);
   if (error) { return error; }
   return stage2(_doc);
 }
+#endif // SIMDJSON_FEATURE_DOM_API
 
 } // namespace rvv_vls
 } // namespace simdjson

src/simdjson.cpp

@@ -1,5 +1,7 @@
 #define SIMDJSON_SRC_SIMDJSON_CPP
 
+#include "simdjson/feature_macros.h"
+
 #include <base.h>
 
 SIMDJSON_PUSH_DISABLE_UNUSED_WARNINGS
@@ -13,8 +15,11 @@ SIMDJSON_PUSH_DISABLE_UNUSED_WARNINGS
 
 #include <simdjson/generic/dependencies.h>
 #include <generic/dependencies.h>
+
+#if SIMDJSON_FEATURE_DOM_API
 #include <generic/stage1/dependencies.h>
 #include <generic/stage2/dependencies.h>
+#endif
 
 #include <implementation.cpp>
 
@@ -50,4 +55,3 @@ SIMDJSON_PUSH_DISABLE_UNUSED_WARNINGS
 #undef SIMDJSON_CONDITIONAL_INCLUDE
 
 SIMDJSON_POP_DISABLE_UNUSED_WARNINGS
-

src/westmere.cpp

@@ -2,6 +2,7 @@
 #define SIMDJSON_SRC_WESTMERE_CPP
 
 #ifndef SIMDJSON_CONDITIONAL_INCLUDE
+#include "simdjson/feature_macros.h"
 #include <base.h>
 #endif // SIMDJSON_CONDITIONAL_INCLUDE
 
@@ -144,6 +145,7 @@ simdjson_warn_unused bool implementation::validate_utf8(const char *buf, size_t
   return westmere::stage1::generic_validate_utf8(buf,len);
 }
 
+#if SIMDJSON_FEATURE_DOM_API
 simdjson_warn_unused error_code dom_parser_implementation::stage2(dom::document &_doc) noexcept {
   return stage2::tape_builder::parse_document<false>(*this, _doc);
 }
@@ -151,6 +153,7 @@ simdjson_warn_unused error_code dom_parser_implementation::stage2(dom::document
 simdjson_warn_unused error_code dom_parser_implementation::stage2_next(dom::document &_doc) noexcept {
   return stage2::tape_builder::parse_document<true>(*this, _doc);
 }
+#endif // SIMDJSON_FEATURE_DOM_API
 
 SIMDJSON_NO_SANITIZE_MEMORY
 simdjson_warn_unused uint8_t *dom_parser_implementation::parse_string(const uint8_t *src, uint8_t *dst, bool replacement_char) const noexcept {
@@ -161,14 +164,16 @@ simdjson_warn_unused uint8_t *dom_parser_implementation::parse_wobbly_string(con
   return westmere::stringparsing::parse_wobbly_string(src, dst);
 }
 
+#if SIMDJSON_FEATURE_DOM_API
 simdjson_warn_unused error_code dom_parser_implementation::parse(const uint8_t *_buf, size_t _len, dom::document &_doc) noexcept {
   auto error = stage1(_buf, _len, stage1_mode::regular);
   if (error) { return error; }
   return stage2(_doc);
 }
+#endif // SIMDJSON_FEATURE_DOM_API
 } // namespace westmere
 } // namespace simdjson
 
 #include <simdjson/westmere/end.h>
 
-#endif // SIMDJSON_SRC_WESTMERE_CPP
+#endif // SIMDJSON_SRC_WESTMERE_CPP

tests/CMakeLists.txt

@@ -29,4 +29,5 @@ add_cpp_test(checkimplementation LABELS other per_implementation)
 
 add_subdirectory(compilation_failure_tests)
 add_subdirectory(builder)
-add_subdirectory(compile_time)
+add_subdirectory(compile_time)
+add_subdirectory(feature_flag_tests)

tests/builder/CMakeLists.txt

@@ -1,5 +1,8 @@
 # All remaining tests link with simdjson proper
 include_directories(..)
+if(NOT SIMDJSON_FEATURE_BUILDER_API)
+  return()
+endif()
 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)

tests/builder/static_reflection_builder_tests.cpp

@@ -6,40 +6,40 @@
 
 using namespace simdjson;
 struct Car {
-  std::string make;
-  std::string model;
-  int64_t year;
-  std::vector<double> tire_pressure;
+  std::string make{};
+  std::string model{};
+  int64_t year{};
+  std::vector<double> tire_pressure{};
 };
 
 struct kid {
-  int age;
-  std::string name;
-  std::vector<std::string> toys;
+  int age{};
+  std::string name{};
+  std::vector<std::string> toys{};
   bool operator<=> (const kid&) const = default;
 };
 
 struct Z {
-  int x;
+  int x{};
   bool operator<=> (const Z&) const = default;
 };
 
 struct Y {
-  int g;
-  std::string h;
-  std::vector<int> i;
-  Z z;
+  int g{};
+  std::string h{};
+  std::vector<int> i{};
+  Z z{};
   bool operator<=> (const Y&) const = default;
 };
 
 struct X {
-  char a;
-  int b;
-  int c;
-  std::string d;
-  std::vector<int> e;
-  std::vector<std::string> f;
-  Y y;
+  char a{};
+  int b{};
+  int c{};
+  std::string d{};
+  std::vector<int> e{};
+  std::vector<std::string> f{};
+  Y y{};
   bool operator<=> (const X&) const = default;
 };
 

tests/builder/static_reflection_comprehensive_tests.cpp

@@ -16,8 +16,8 @@ namespace builder_tests {
 #if SIMDJSON_STATIC_REFLECTION
   // Custom type for testing tag_invoke with extract_into
   struct Price {
-    double amount;
-    std::string currency;
+    double amount{};
+    std::string currency{};
 
     // Custom deserializer that applies currency conversion
     friend error_code tag_invoke(deserialize_tag,
@@ -46,17 +46,37 @@ namespace builder_tests {
       return SUCCESS;
     }
   };
-
+  struct Car {
+    std::string make{};
+    std::string model{};
+    int year{};
+    double price{};
+    bool electric{};
+  };
+  struct CarOpt {
+    std::string make;
+    std::string model;
+    int year;
+    double price;
+    std::optional<std::string> color;
+  };
+  struct CarColor {
+    std::string make;
+    std::string model;
+    int year;
+    double price;
+    std::string color;
+  };
   struct Product {
-    std::string name;
-    Price price;  // Custom deserializable type
-    int stock;
+    std::string name{};
+    Price price{};  // Custom deserializable type
+    int stock{};
   };
 
   // Another custom type for testing
   struct Dimensions {
-    double value;
-    std::string unit;
+    double value{};
+    std::string unit{};
 
     // Custom deserializer that converts to metric
     friend error_code tag_invoke(deserialize_tag,
@@ -89,6 +109,13 @@ namespace builder_tests {
     Dimensions weight;
     Dimensions length;
   };
+
+  struct Person {
+    std::string name;
+    int age;
+    std::optional<std::string> email;
+    std::optional<std::string> phone;
+  };
 #endif
 
   bool test_primitive_types() {
@@ -132,8 +159,8 @@ namespace builder_tests {
     TEST_START();
 #if SIMDJSON_STATIC_REFLECTION
     struct StringTypes {
-      std::string string_val;
-      std::string_view string_view_val;
+      std::string string_val{};
+      std::string_view string_view_val{};
     };
 
     StringTypes test{"hello world", "test_view"};
@@ -159,10 +186,10 @@ namespace builder_tests {
     TEST_START();
 #if SIMDJSON_STATIC_REFLECTION
     struct OptionalTypes {
-      std::optional<int> opt_int_with_value;
-      std::optional<std::string> opt_string_with_value;
-      std::optional<int> opt_int_null;
-      std::optional<std::string> opt_string_null;
+      std::optional<int> opt_int_with_value{};
+      std::optional<std::string> opt_string_with_value{};
+      std::optional<int> opt_int_null{};
+      std::optional<std::string> opt_string_null{};
     };
 
     OptionalTypes test;
@@ -200,11 +227,11 @@ namespace builder_tests {
     TEST_START();
 #if SIMDJSON_STATIC_REFLECTION
     struct SmartPointerTypes {
-      std::unique_ptr<int> unique_int_with_value;
-      std::shared_ptr<std::string> shared_string_with_value;
-      std::unique_ptr<bool> unique_bool_with_value;
-      std::unique_ptr<int> unique_int_null;
-      std::shared_ptr<std::string> shared_string_null;
+      std::unique_ptr<int> unique_int_with_value{};
+      std::shared_ptr<std::string> shared_string_with_value{};
+      std::unique_ptr<bool> unique_bool_with_value{};
+      std::unique_ptr<int> unique_int_null{};
+      std::shared_ptr<std::string> shared_string_null{};
     };
 
     SmartPointerTypes test;
@@ -245,9 +272,9 @@ namespace builder_tests {
 #if SIMDJSON_STATIC_REFLECTION
     // Test basic container types
     struct ContainerTypes {
-      std::vector<int> int_vector;
-      std::set<std::string> string_set;
-      std::map<std::string, int> string_map;
+      std::vector<int> int_vector{};
+      std::set<std::string> string_set{};
+      std::map<std::string, int> string_map{};
     };
 
     ContainerTypes test;
@@ -278,8 +305,8 @@ namespace builder_tests {
 
     // Test std::list with iterator-based serialization
     struct ListContainer {
-      std::list<int> int_list;
-      std::list<std::string> string_list;
+      std::list<int> int_list{};
+      std::list<std::string> string_list{};
     };
 
     ListContainer list_test;
@@ -319,13 +346,7 @@ namespace builder_tests {
   bool test_extract_into() {
     TEST_START();
 #if SIMDJSON_STATIC_REFLECTION
-    struct Car {
-      std::string make;
-      std::string model;
-      int year;
-      double price;
-      std::optional<std::string> color;
-    };
+
 
     ondemand::parser parser;
 
@@ -341,7 +362,7 @@ namespace builder_tests {
         "transmission": "Automatic"
       })"_padded;
 
-      Car car{};
+      CarOpt car{};
       ondemand::document doc;
       ASSERT_SUCCESS( parser.iterate(padded).get(doc) );
 
@@ -377,7 +398,7 @@ namespace builder_tests {
         "color": "Red"
       })"_padded;
 
-      Car car{};
+      CarOpt car{};
       ondemand::document doc;
       ASSERT_SUCCESS(parser.iterate(padded).get(doc));
 
@@ -402,7 +423,7 @@ namespace builder_tests {
         "price": 35999.99
       })"_padded;
 
-      Car car{};
+      CarOpt car{};
       ondemand::document doc;
       ASSERT_SUCCESS(parser.iterate(padded).get(doc));
 
@@ -495,13 +516,6 @@ namespace builder_tests {
 #if SIMDJSON_STATIC_REFLECTION
     // Test 1: Extract specific fields from Car struct
     {
-      struct Car {
-        std::string make;
-        std::string model;
-        int year;
-        double price;
-        bool electric;
-      };
 
       Car car{"Tesla", "Model 3", 2023, 42000.0, true};
 
@@ -533,13 +547,7 @@ namespace builder_tests {
 
     // Test 2: Extract different field combination
     {
-      struct Car {
-        std::string make;
-        std::string model;
-        int year;
-        double price;
-        bool electric;
-      };
+
 
       Car car{"Ford", "F-150", 2024, 55000.0, false};
 
@@ -566,13 +574,6 @@ namespace builder_tests {
 
     // Test 3: Extract from struct with optional fields
     {
-      struct Person {
-        std::string name;
-        int age;
-        std::optional<std::string> email;
-        std::optional<std::string> phone;
-      };
-
       Person person{"John Doe", 30, "john@example.com", std::nullopt};
 
       // Extract name and email
@@ -594,13 +595,6 @@ namespace builder_tests {
 
     // Test 4: Extract with optional that has value
     {
-      struct Person {
-        std::string name;
-        int age;
-        std::optional<std::string> email;
-        std::optional<std::string> phone;
-      };
-
       Person person{"Jane Smith", 25, "jane@example.com", "555-1234"};
 
       // Extract name, age, and phone
@@ -629,21 +623,21 @@ namespace builder_tests {
 
     // Test 5: Round-trip test - serialize with extract_from, deserialize with extract_into
     {
-      struct Product {
-        std::string id;
-        std::string name;
-        double price;
-        int stock;
+      struct MyProduct {
+        std::string id{};
+        std::string name{};
+        double price{};
+        int stock{};
       };
 
-      Product original{"P123", "Widget", 19.99, 100};
+      MyProduct original{"P123", "Widget", 19.99, 100};
 
       // Extract specific fields to JSON
       std::string json;
       ASSERT_SUCCESS((extract_from<"id", "name", "price">(original).get(json)));
 
       // Parse and extract back
-      Product restored{"", "", 0.0, 0};
+      MyProduct restored{"", "", 0.0, 0};
       auto padded = pad(json);
       ondemand::parser parser;
       auto doc = parser.iterate(padded);

tests/builder/static_reflection_custom_tests.cpp

@@ -11,10 +11,10 @@ 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;
+  std::string make{};
+  std::string model{};
+  int64_t year{};
+  std::vector<float> tire_pressure{};
 };
 
 

tests/builder/static_reflection_edge_cases_tests.cpp

@@ -14,11 +14,11 @@ namespace builder_tests {
     TEST_START();
 #if SIMDJSON_STATIC_REFLECTION
     struct EmptyValues {
-      std::string empty_string;
-      std::vector<int> empty_vector;
-      std::optional<int> null_optional;
-      std::unique_ptr<int> null_unique_ptr;
-      std::shared_ptr<std::string> null_shared_ptr;
+      std::string empty_string{};
+      std::vector<int> empty_vector{};
+      std::optional<int> null_optional{};
+      std::unique_ptr<int> null_unique_ptr{};
+      std::shared_ptr<std::string> null_shared_ptr{};
     };
 
     EmptyValues test;
@@ -56,18 +56,18 @@ namespace builder_tests {
     TEST_START();
 #if SIMDJSON_STATIC_REFLECTION
     struct SpecialChars {
-      std::string quotes;
-      std::string backslashes;
-      std::string newlines;
-      std::string unicode;
-      char null_char;
+      std::string quotes{};
+      std::string backslashes{};
+      std::string newlines{};
+      std::string unicode{};
+      char null_char{};
     };
 
     SpecialChars test;
     test.quotes = "He said \"Hello\"";
     test.backslashes = "Path\\to\\file";
     test.newlines = "Line1\nLine2\tTabbed";
-    test.unicode = "Café résumé";
+    test.unicode = "Caf\xc3\xa9 r\xc3\xa9sum\xc3\xa9";
     test.null_char = '\0';
 
     std::string json;
@@ -82,10 +82,10 @@ namespace builder_tests {
 
     // Test round-trip (excluding null char which has special handling)
     struct SpecialCharsNoNull {
-      std::string quotes;
-      std::string backslashes;
-      std::string newlines;
-      std::string unicode;
+      std::string quotes{};
+      std::string backslashes{};
+      std::string newlines{};
+      std::string unicode{};
     };
 
     SpecialCharsNoNull test_no_null;
@@ -157,15 +157,15 @@ namespace builder_tests {
     TEST_START();
 #if SIMDJSON_STATIC_REFLECTION
     struct Inner {
-      int value;
-      std::string name;
+      int value{};
+      std::string name{};
     };
 
     struct Outer {
-      Inner inner_obj;
-      std::vector<Inner> inner_vector;
-      std::optional<Inner> optional_inner;
-      std::unique_ptr<Inner> unique_inner;
+      Inner inner_obj{};
+      std::vector<Inner> inner_vector{};
+      std::optional<Inner> optional_inner{};
+      std::unique_ptr<Inner> unique_inner{};
     };
 
     Outer test;
@@ -213,4 +213,4 @@ namespace builder_tests {
 
 int main(int argc, char *argv[]) {
   return test_main(argc, argv, builder_tests::run);
-}
+}

tests/builder/static_reflection_enum_tests.cpp

@@ -51,8 +51,8 @@ namespace builder_tests {
     };
 
     struct StatusStruct {
-      Status status;
-      std::string name;
+      Status status{};
+      std::string name{};
     };
 
     // Test deserialization of different enum values with string representation
@@ -104,9 +104,9 @@ namespace builder_tests {
     };
 
     struct Task {
-      Priority priority;
-      std::string description;
-      int id;
+      Priority priority{};
+      std::string description{};
+      int id{};
     };
 
     Task original{Priority::High, "Important task", 123};
@@ -144,8 +144,8 @@ namespace builder_tests {
     };
 
     struct Response {
-      ErrorCode error;
-      std::string message;
+      ErrorCode error{};
+      std::string message{};
     };
 
     Response test{ErrorCode::NotFound, "Resource not found"};

tests/builder/static_reflection_fractured_json_tests.cpp

@@ -8,26 +8,26 @@ using namespace simdjson;
 
 // Test structures for FracturedJson builder integration
 struct SimpleUser {
-  int id;
-  std::string name;
-  bool active;
+  int id{};
+  std::string name{};
+  bool active{};
 };
 
 struct UserWithEmail {
-  int id;
-  std::string name;
-  std::string email;
-  bool active;
+  int id{};
+  std::string name{};
+  std::string email{};
+  bool active{};
 };
 
 struct NestedData {
-  std::string title;
-  std::vector<SimpleUser> users;
-  int count;
+  std::string title{};
+  std::vector<SimpleUser> users{};
+  int count{};
 };
 
 struct TableTestData {
-  std::vector<SimpleUser> records;
+  std::vector<SimpleUser> records{};
 };
 
 namespace fractured_json_builder_tests {

tests/compile_time/compile_time_json_tests.cpp

@@ -10,6 +10,7 @@
 
 using namespace std::string_view_literals;
 using namespace simdjson;
+using namespace simdjson::literals;
 
 namespace compile_time_json_tests {
 /**
@@ -666,27 +667,27 @@ bool test_array_of_objects_with_concept() {
 /**
  * Test: #embed support for external JSON files (C++26)
  */
-bool test_embed_twitter_json() {
+bool test_embed_example_config_json() {
     TEST_START();
 
     // C++26 #embed allows embedding files directly into the binary at compile time
     // This creates a const char array with the file contents plus null terminator
-    constexpr const char twitter_json[] = {
-        #embed TWITTER_JSON
+    constexpr const unsigned char example_config_json[] = {
+        #embed "../../jsonexamples/example_config.json"
         , 0
     };
 
     // Parse the embedded JSON at compile time
-    constexpr auto parsed_twitter = simdjson::compile_time::parse_json<twitter_json>();
+    constexpr auto parsed_example_config = simdjson::compile_time::parse_json<example_config_json>();
 
-    // Verify the structure - twitter.json should have a "statuses" array
-    static_assert(parsed_twitter.statuses.size() > 0);
+    // Verify the structure - example_config.json should have an "app_name" field
+    static_assert(std::string_view(parsed_example_config.app_name) == "MyApp");
 
     // Runtime verification
-    ASSERT_TRUE(parsed_twitter.statuses.size() > 0);
+    ASSERT_TRUE(std::string_view(parsed_example_config.app_name) == "MyApp");
 
-    std::cout << "Successfully parsed embedded twitter.json with "
-              << parsed_twitter.statuses.size() << " statuses" << std::endl;
+    std::cout << "Successfully parsed embedded example_config.json with "
+              << parsed_example_config.app_name << " as app_name" << std::endl;
 
     TEST_SUCCEED();
 }
@@ -718,11 +719,10 @@ bool run() {
            test_top_level_array_example() &&
            test_array_of_objects_with_concept()
 #ifdef TEST_EMBED_SUPPORTED
-           && test_embed_twitter_json()
+           && test_embed_example_config_json()
 #endif
 ;
 }
-
 } // namespace compile_time_json_tests
 
 int main(int argc, char *argv[]) {

tests/dom/big_integer_tests.cpp

@@ -79,7 +79,7 @@ namespace big_integer_tests {
     std::string output = simdjson::to_string(doc);
     // Raw digits should appear
     ASSERT_TRUE(output.find("123456789012345678901") != std::string::npos);
-    // Must not be quoted — it's a number, not a string
+    // Must not be quoted - it's a number, not a string
     ASSERT_EQUAL(output.find("\"123456789012345678901\""), std::string::npos);
     TEST_SUCCEED();
   }

tests/dom/readme_examples.cpp

@@ -1,5 +1,6 @@
 #include <iostream>
 #include "simdjson.h"
+#include "simdjson/padded_string_view.h"
 
 using namespace std;
 using namespace simdjson;
@@ -531,6 +532,35 @@ void simplepad() {
   if(error) { exit(-1); }
 }
 
+#if SIMDJSON_CPLUSPLUS17
+void simpleinputpad_dom1() {
+  std::string_view json = "[1,2,3]";
+  simdjson::padded_input input(json);
+  dom::parser parser;
+  dom::element doc;
+  auto error = parser.parse(input).get(doc);
+  if(error) { exit(-1); }
+}
+
+void simpleinputpad_dom2() {
+  const char *jsonpointer = R"(
+        {
+            "key": "value"
+        }
+    )";
+  size_t len = strlen(jsonpointer);
+  simdjson::padded_input input(jsonpointer, len);
+  dom::parser parser;
+  dom::element doc;
+  auto error = parser.parse(input).get(doc);
+  if(error) { exit(-1); }
+  std::string_view val;
+  error = doc["key"].get(val);
+  if(error) { exit(-1); }
+  if(val != "value") { exit(-1); }
+}
+#endif // SIMDJSON_CPLUSPLUS17
+
 void jsondollar() {
   dom::parser parser;
   auto json = R"( { "c" :{ "foo": { "a": [ 10, 20, 30 ] }}, "d": { "foo2": { "a": [ 10, 20, 30 ] }} , "e": 120 })"_padded;

tests/feature_flag_tests/CMakeLists.txt

@@ -0,0 +1,36 @@
+# Feature flag tests: compile and run against the amalgamated single-header file.
+# Each test uses target_compile_definitions to set its own feature macros,
+# independent of the project-wide settings.
+
+set(SINGLEHEADER_DIR ${PROJECT_SOURCE_DIR}/singleheader)
+
+function(add_feature_flag_test TEST_NAME)
+  cmake_parse_arguments(PARSE_ARGV 1 ARG "" "" "DEFS")
+  add_executable(${TEST_NAME} ${TEST_NAME}.cpp ${SINGLEHEADER_DIR}/simdjson.cpp)
+  target_include_directories(${TEST_NAME} PRIVATE ${SINGLEHEADER_DIR})
+  target_compile_features(${TEST_NAME} PRIVATE cxx_std_17)
+  # Override any inherited feature flag definitions with our own.
+  target_compile_definitions(${TEST_NAME} PRIVATE ${ARG_DEFS})
+  # Remove inherited link libraries (simdjson-internal-flags brings -Werror
+  # which conflicts with the amalgamated header's warning profile).
+  set_target_properties(${TEST_NAME} PROPERTIES LINK_LIBRARIES "")
+  add_test(NAME ${TEST_NAME} COMMAND ${TEST_NAME})
+  set_property(TEST ${TEST_NAME} APPEND PROPERTY LABELS feature_flags acceptance)
+endfunction()
+
+add_feature_flag_test(dom_only DEFS
+  SIMDJSON_FEATURE_DOM_API=1 SIMDJSON_FEATURE_ONDEMAND_API=0 SIMDJSON_FEATURE_BUILDER_API=0)
+# Note: OnDemand tests also enable DOM because the builtin infrastructure
+# is currently included via the DOM/builtin path in the amalgamated header.
+add_feature_flag_test(ondemand_only DEFS
+  SIMDJSON_FEATURE_DOM_API=1 SIMDJSON_FEATURE_ONDEMAND_API=1 SIMDJSON_FEATURE_BUILDER_API=0)
+add_feature_flag_test(dom_and_ondemand DEFS
+  SIMDJSON_FEATURE_DOM_API=1 SIMDJSON_FEATURE_ONDEMAND_API=1 SIMDJSON_FEATURE_BUILDER_API=0)
+add_feature_flag_test(builder_and_dom DEFS
+  SIMDJSON_FEATURE_DOM_API=1 SIMDJSON_FEATURE_ONDEMAND_API=0 SIMDJSON_FEATURE_BUILDER_API=1)
+add_feature_flag_test(builder_and_ondemand DEFS
+  SIMDJSON_FEATURE_DOM_API=1 SIMDJSON_FEATURE_ONDEMAND_API=1 SIMDJSON_FEATURE_BUILDER_API=1)
+add_feature_flag_test(builder_dom_and_ondemand DEFS
+  SIMDJSON_FEATURE_DOM_API=1 SIMDJSON_FEATURE_ONDEMAND_API=1 SIMDJSON_FEATURE_BUILDER_API=1)
+add_feature_flag_test(builder_only DEFS
+  SIMDJSON_FEATURE_DOM_API=1 SIMDJSON_FEATURE_ONDEMAND_API=0 SIMDJSON_FEATURE_BUILDER_API=1)

tests/feature_flag_tests/builder_and_dom.cpp

@@ -0,0 +1,42 @@
+// Test: Builder + DOM APIs (OnDemand disabled)
+// Feature flags set via target_compile_definitions in CMakeLists.txt
+#include "simdjson.h"
+#include <iostream>
+
+int main() {
+  auto json = R"({"key": "value"})"_padded;
+
+  // Use DOM API
+  simdjson::dom::parser parser;
+  simdjson::dom::element doc;
+  auto error = parser.parse(json).get(doc);
+  if (error) {
+    std::cerr << "DOM parse error: " << error << std::endl;
+    return EXIT_FAILURE;
+  }
+  std::string_view val;
+  error = doc["key"].get_string().get(val);
+  if (error || val != "value") {
+    std::cerr << "DOM key lookup failed" << std::endl;
+    return EXIT_FAILURE;
+  }
+
+  // Use Builder API
+  simdjson::builder::string_builder sb;
+  sb.start_object();
+  sb.append_key_value("greeting", "hello");
+  sb.end_object();
+  std::string_view result;
+  error = sb.view().get(result);
+  if (error) {
+    std::cerr << "Builder error: " << error << std::endl;
+    return EXIT_FAILURE;
+  }
+  if (result != R"({"greeting":"hello"})") {
+    std::cerr << "Builder output mismatch: " << result << std::endl;
+    return EXIT_FAILURE;
+  }
+
+  std::cout << "Builder+DOM test passed." << std::endl;
+  return EXIT_SUCCESS;
+}

tests/feature_flag_tests/builder_and_ondemand.cpp

@@ -0,0 +1,45 @@
+// Test: Builder + OnDemand APIs (DOM also enabled since Builder depends on it)
+// Feature flags set via target_compile_definitions in CMakeLists.txt
+#include "simdjson.h"
+#include <iostream>
+
+int main() {
+  // Use OnDemand API
+  auto json = R"({"key": "value"})"_padded;
+  simdjson::ondemand::parser parser;
+  simdjson::ondemand::document doc;
+  auto error = parser.iterate(json).get(doc);
+  if (error) {
+    std::cerr << "OnDemand parse error: " << error << std::endl;
+    return EXIT_FAILURE;
+  }
+  std::string_view val;
+  error = doc["key"].get_string().get(val);
+  if (error || val != "value") {
+    std::cerr << "OnDemand key lookup failed" << std::endl;
+    return EXIT_FAILURE;
+  }
+
+  // Use Builder API
+  simdjson::builder::string_builder sb;
+  sb.start_array();
+  sb.append(1);
+  sb.append_comma();
+  sb.append(2);
+  sb.append_comma();
+  sb.append(3);
+  sb.end_array();
+  std::string_view result;
+  error = sb.view().get(result);
+  if (error) {
+    std::cerr << "Builder error: " << error << std::endl;
+    return EXIT_FAILURE;
+  }
+  if (result != "[1,2,3]") {
+    std::cerr << "Builder output mismatch: " << result << std::endl;
+    return EXIT_FAILURE;
+  }
+
+  std::cout << "Builder+OnDemand test passed." << std::endl;
+  return EXIT_SUCCESS;
+}

tests/feature_flag_tests/builder_dom_and_ondemand.cpp

@@ -0,0 +1,59 @@
+// Test: All three APIs enabled (Builder + DOM + OnDemand)
+// Feature flags set via target_compile_definitions in CMakeLists.txt
+#include "simdjson.h"
+#include <iostream>
+
+int main() {
+  auto json = R"({"name": "simdjson", "version": 5})"_padded;
+
+  // Use DOM API
+  simdjson::dom::parser dom_parser;
+  simdjson::dom::element dom_doc;
+  auto error = dom_parser.parse(json).get(dom_doc);
+  if (error) {
+    std::cerr << "DOM parse error: " << error << std::endl;
+    return EXIT_FAILURE;
+  }
+  std::string_view name;
+  error = dom_doc["name"].get_string().get(name);
+  if (error || name != "simdjson") {
+    std::cerr << "DOM name lookup failed" << std::endl;
+    return EXIT_FAILURE;
+  }
+
+  // Use OnDemand API
+  simdjson::ondemand::parser od_parser;
+  simdjson::ondemand::document od_doc;
+  error = od_parser.iterate(json).get(od_doc);
+  if (error) {
+    std::cerr << "OnDemand parse error: " << error << std::endl;
+    return EXIT_FAILURE;
+  }
+  std::string_view od_name;
+  error = od_doc["name"].get_string().get(od_name);
+  if (error || od_name != "simdjson") {
+    std::cerr << "OnDemand name lookup failed" << std::endl;
+    return EXIT_FAILURE;
+  }
+
+  // Use Builder API
+  simdjson::builder::string_builder sb;
+  sb.start_object();
+  sb.append_key_value("name", "simdjson");
+  sb.append_comma();
+  sb.append_key_value("version", 5);
+  sb.end_object();
+  std::string_view result;
+  error = sb.view().get(result);
+  if (error) {
+    std::cerr << "Builder error: " << error << std::endl;
+    return EXIT_FAILURE;
+  }
+  if (result != R"({"name":"simdjson","version":5})") {
+    std::cerr << "Builder output mismatch: " << result << std::endl;
+    return EXIT_FAILURE;
+  }
+
+  std::cout << "Builder+DOM+OnDemand test passed." << std::endl;
+  return EXIT_SUCCESS;
+}

tests/feature_flag_tests/builder_only.cpp

@@ -0,0 +1,27 @@
+// Test: Builder API only (OnDemand disabled, DOM enabled since Builder depends on it)
+// Feature flags set via target_compile_definitions in CMakeLists.txt
+#include "simdjson.h"
+#include <iostream>
+
+int main() {
+  // Use Builder API
+  simdjson::builder::string_builder sb;
+  sb.start_object();
+  sb.append_key_value("count", 2);
+  sb.append_comma();
+  sb.append_key_value("name", "test");
+  sb.end_object();
+  std::string_view result;
+  auto error = sb.view().get(result);
+  if (error) {
+    std::cerr << "Builder error: " << error << std::endl;
+    return EXIT_FAILURE;
+  }
+  if (result != R"({"count":2,"name":"test"})") {
+    std::cerr << "Builder output mismatch: " << result << std::endl;
+    return EXIT_FAILURE;
+  }
+
+  std::cout << "Builder-only test passed." << std::endl;
+  return EXIT_SUCCESS;
+}

tests/feature_flag_tests/dom_and_ondemand.cpp

@@ -0,0 +1,41 @@
+// Test: Both DOM and OnDemand APIs (Builder disabled)
+// Feature flags set via target_compile_definitions in CMakeLists.txt
+#include "simdjson.h"
+#include <iostream>
+
+int main() {
+  auto json = R"({"key": "value", "number": 42})"_padded;
+
+  // Use DOM API
+  simdjson::dom::parser dom_parser;
+  simdjson::dom::element dom_doc;
+  auto error = dom_parser.parse(json).get(dom_doc);
+  if (error) {
+    std::cerr << "DOM parse error: " << error << std::endl;
+    return EXIT_FAILURE;
+  }
+  std::string_view dom_val;
+  error = dom_doc["key"].get_string().get(dom_val);
+  if (error || dom_val != "value") {
+    std::cerr << "DOM key lookup failed" << std::endl;
+    return EXIT_FAILURE;
+  }
+
+  // Use OnDemand API
+  simdjson::ondemand::parser od_parser;
+  simdjson::ondemand::document od_doc;
+  error = od_parser.iterate(json).get(od_doc);
+  if (error) {
+    std::cerr << "OnDemand parse error: " << error << std::endl;
+    return EXIT_FAILURE;
+  }
+  std::string_view od_val;
+  error = od_doc["key"].get_string().get(od_val);
+  if (error || od_val != "value") {
+    std::cerr << "OnDemand key lookup failed" << std::endl;
+    return EXIT_FAILURE;
+  }
+
+  std::cout << "DOM+OnDemand test passed." << std::endl;
+  return EXIT_SUCCESS;
+}

tests/feature_flag_tests/dom_only.cpp

@@ -0,0 +1,29 @@
+// Test: DOM API only (OnDemand and Builder disabled)
+// Feature flags set via target_compile_definitions in CMakeLists.txt
+#include "simdjson.h"
+#include <iostream>
+
+int main() {
+  simdjson::dom::parser parser;
+  auto json = R"({"key": "value", "number": 42})"_padded;
+  simdjson::dom::element doc;
+  auto error = parser.parse(json).get(doc);
+  if (error) {
+    std::cerr << "DOM parse error: " << error << std::endl;
+    return EXIT_FAILURE;
+  }
+  std::string_view val;
+  error = doc["key"].get_string().get(val);
+  if (error || val != "value") {
+    std::cerr << "DOM key lookup failed" << std::endl;
+    return EXIT_FAILURE;
+  }
+  int64_t num;
+  error = doc["number"].get_int64().get(num);
+  if (error || num != 42) {
+    std::cerr << "DOM number lookup failed" << std::endl;
+    return EXIT_FAILURE;
+  }
+  std::cout << "DOM-only test passed." << std::endl;
+  return EXIT_SUCCESS;
+}

tests/feature_flag_tests/ondemand_only.cpp

@@ -0,0 +1,25 @@
+// Test: OnDemand API only (Builder disabled)
+// Note: DOM must remain enabled because the builtin infrastructure
+// (SIMDJSON_BUILTIN_IMPLEMENTATION_IS) is currently included via the DOM path.
+// Feature flags set via target_compile_definitions in CMakeLists.txt
+#include "simdjson.h"
+#include <iostream>
+
+int main() {
+  simdjson::ondemand::parser parser;
+  auto json = R"({"key": "value", "number": 42})"_padded;
+  simdjson::ondemand::document doc;
+  auto error = parser.iterate(json).get(doc);
+  if (error) {
+    std::cerr << "OnDemand parse error: " << error << std::endl;
+    return EXIT_FAILURE;
+  }
+  std::string_view val;
+  error = doc["key"].get_string().get(val);
+  if (error || val != "value") {
+    std::cerr << "OnDemand key lookup failed" << std::endl;
+    return EXIT_FAILURE;
+  }
+  std::cout << "OnDemand-only test passed." << std::endl;
+  return EXIT_SUCCESS;
+}

tests/fractured_json_tests.cpp

@@ -475,11 +475,11 @@ bool unicode_test() {
   std::cout << "Running " << __func__ << std::endl;
 
   const char* json = R"({
-    "greeting": "Hello, 世界!",
-    "emoji": "🎉🚀✨",
-    "arabic": "مرحبا",
-    "russian": "Привет",
-    "mixed": "café résumé naïve"
+    "greeting": "Hello, \u4e16\u754c!",
+    "emoji": "\ud83c\udf89\ud83d\ude80\u2728",
+    "arabic": "\u0645\u0631\u062d\u0628\u0627",
+    "russian": "\u041f\u0440\u0438\u0432\u0435\u0442",
+    "mixed": "caf\u00e9 r\u00e9sum\u00e9 na\u00efve"
   })";
 
   simdjson::dom::parser parser;

tests/ondemand/CMakeLists.txt

@@ -40,6 +40,7 @@ add_cpp_test(ondemand_convert_tests                  LABELS ondemand acceptance
 add_cpp_test(ondemand_unknown_tests                  LABELS ondemand acceptance per_implementation)
 add_cpp_test(ondemand_wildcard_tests                 LABELS ondemand acceptance per_implementation)
 if(NOT SIMDJSON_SANITIZE)
+  add_cpp_test(ondemand_padded_input              LABELS ondemand acceptance per_implementation)
   add_cpp_test(ondemand_cacheline              LABELS ondemand acceptance per_implementation)
 endif()
 

tests/ondemand/ondemand_cacheline.cpp

@@ -20,7 +20,7 @@ long page_size() {
 }
 
 // Returns true if the buffer + len + simdjson::SIMDJSON_PADDING crosses the
-// page boundary.
+// page boundary. Assumes len != 0.
 bool need_allocation(const char *buf, size_t len) {
   return ((reinterpret_cast<uintptr_t>(buf + len - 1) % page_size())
     + simdjson::SIMDJSON_PADDING >= static_cast<uintptr_t>(page_size()));

tests/ondemand/ondemand_convert_tests.cpp

@@ -19,7 +19,7 @@ public:
         return date_str;
     }
 private:
-    std::string date_str;
+    std::string date_str{};
 };
 
 
@@ -52,8 +52,8 @@ auto tag_invoke(deserialize_tag, simdjson_value &val, MyDate& date) {
 } // namespace simdjson
 
 struct complicated_weather_data {
-    std::vector<MyDate> time;
-    std::vector<float> temperature;
+    std::vector<MyDate> time{};
+    std::vector<float> temperature{};
 };
 
 
@@ -152,19 +152,19 @@ simdjson::padded_string json_cars =
     TEST_SUCCEED();
   }
   struct Player {
-      std::string username;
-      int level;
-      double health;
+      std::string username{};
+      int level{};
+      double health{};
   };
   struct BadPlayer {
-      int username;  // Oops, should be string!
-      int level;
-      double health;
+      int username{};  // Oops, should be string!
+      int level{};
+      double health{};
   };
   struct OptionalPlayer {
-      std::string username;
-      std::optional<int> level;
-      double health;
+      std::string username{};
+      std::optional<int> level{};
+      double health{};
   };
 #if SIMDJSON_STATIC_REFLECTION
   bool missing_key_player() {

tests/ondemand/ondemand_padded_input.cpp

@@ -0,0 +1,197 @@
+#include "simdjson.h"
+#include "simdjson/padded_string_view.h"
+#include <cstdio>
+#include <cstring>
+#include <cstdlib>
+#include <string>
+#include <string_view>
+
+#if SIMDJSON_CPLUSPLUS17
+
+bool test_padded_input_from_string_view() {
+  std::string_view json = "[1,2,3]";
+  simdjson::padded_input input(json);
+  simdjson::ondemand::parser parser;
+  simdjson::ondemand::document doc;
+  auto error = parser.iterate(input).get(doc);
+  if (error) {
+    printf("FAILED: test_padded_input_from_string_view (iterate error: %s)\n",
+           simdjson::error_message(error));
+    return false;
+  }
+  size_t count = 0;
+  for (auto val : doc) {
+    int64_t v;
+    error = val.get_int64().get(v);
+    if (error) {
+      printf("FAILED: test_padded_input_from_string_view (get_int64 error)\n");
+      return false;
+    }
+    count++;
+  }
+  if (count != 3) {
+    printf("FAILED: test_padded_input_from_string_view (expected 3 elements, got %zu)\n", count);
+    return false;
+  }
+  printf("OK: test_padded_input_from_string_view\n");
+  return true;
+}
+
+bool test_padded_input_from_cstring() {
+  const char *json = R"({"key": "value"})";
+  size_t len = std::strlen(json);
+  simdjson::padded_input input(json, len);
+  simdjson::ondemand::parser parser;
+  simdjson::ondemand::document doc;
+  auto error = parser.iterate(input).get(doc);
+  if (error) {
+    printf("FAILED: test_padded_input_from_cstring (iterate error: %s)\n",
+           simdjson::error_message(error));
+    return false;
+  }
+  std::string_view val;
+  error = doc["key"].get_string().get(val);
+  if (error) {
+    printf("FAILED: test_padded_input_from_cstring (get_string error)\n");
+    return false;
+  }
+  if (val != "value") {
+    printf("FAILED: test_padded_input_from_cstring (expected 'value', got '%.*s')\n",
+           (int)val.size(), val.data());
+    return false;
+  }
+  printf("OK: test_padded_input_from_cstring\n");
+  return true;
+}
+
+bool test_padded_input_is_view() {
+  // A short string at a "safe" position should typically be a view (no copy).
+  // We can't guarantee this in all environments, but we can at least test
+  // that is_view() returns a valid boolean and parsing works either way.
+  std::string_view json = "[1]";
+  simdjson::padded_input input(json);
+  bool view = input.is_view();
+  printf("  is_view() = %s\n", view ? "true" : "false");
+  simdjson::ondemand::parser parser;
+  simdjson::ondemand::document doc;
+  auto error = parser.iterate(input).get(doc);
+  if (error) {
+    printf("FAILED: test_padded_input_is_view (iterate error: %s)\n",
+           simdjson::error_message(error));
+    return false;
+  }
+  printf("OK: test_padded_input_is_view\n");
+  return true;
+}
+
+bool test_padded_input_nested_json() {
+  std::string_view json = R"({"a":{"b":[1,2,{"c":true}]}})";
+  simdjson::padded_input input(json);
+  simdjson::ondemand::parser parser;
+  simdjson::ondemand::document doc;
+  auto error = parser.iterate(input).get(doc);
+  if (error) {
+    printf("FAILED: test_padded_input_nested_json (iterate error: %s)\n",
+           simdjson::error_message(error));
+    return false;
+  }
+  bool c_val;
+  error = doc["a"]["b"].at(2)["c"].get_bool().get(c_val);
+  if (error) {
+    printf("FAILED: test_padded_input_nested_json (get_bool error)\n");
+    return false;
+  }
+  if (!c_val) {
+    printf("FAILED: test_padded_input_nested_json (expected true)\n");
+    return false;
+  }
+  printf("OK: test_padded_input_nested_json\n");
+  return true;
+}
+
+bool test_padded_input_dom() {
+  std::string_view json = "[1,2,3]";
+  simdjson::padded_input input(json);
+  simdjson::dom::parser parser;
+  simdjson::dom::element doc;
+  auto error = parser.parse(input).get(doc);
+  if (error) {
+    printf("FAILED: test_padded_input_dom (parse error: %s)\n",
+           simdjson::error_message(error));
+    return false;
+  }
+  printf("OK: test_padded_input_dom\n");
+  return true;
+}
+
+bool test_padded_input_dom_object() {
+  const char *json = R"({"name":"simdjson","version":42})";
+  size_t len = std::strlen(json);
+  simdjson::padded_input input(json, len);
+  simdjson::dom::parser parser;
+  simdjson::dom::element doc;
+  auto error = parser.parse(input).get(doc);
+  if (error) {
+    printf("FAILED: test_padded_input_dom_object (parse error: %s)\n",
+           simdjson::error_message(error));
+    return false;
+  }
+  std::string_view name;
+  error = doc["name"].get(name);
+  if (error || name != "simdjson") {
+    printf("FAILED: test_padded_input_dom_object (name mismatch)\n");
+    return false;
+  }
+  printf("OK: test_padded_input_dom_object\n");
+  return true;
+}
+
+bool test_padded_input_from_std_string() {
+  std::string json = R"({"key": "value"})";
+  // Reserve extra space to test capacity handling
+  json.reserve(json.size() + 100);
+  simdjson::padded_input input(json);
+  simdjson::ondemand::parser parser;
+  simdjson::ondemand::document doc;
+  auto error = parser.iterate(input).get(doc);
+  if (error) {
+    printf("FAILED: test_padded_input_from_std_string (iterate error: %s)\n",
+           simdjson::error_message(error));
+    return false;
+  }
+  std::string_view key;
+  error = doc["key"].get(key);
+  if (error || key != "value") {
+    printf("FAILED: test_padded_input_from_std_string (key/value mismatch)\n");
+    return false;
+  }
+  printf("OK: test_padded_input_from_std_string\n");
+  return true;
+}
+
+int main() {
+  bool ok = true;
+  ok = test_padded_input_from_string_view() && ok;
+  ok = test_padded_input_from_cstring() && ok;
+  ok = test_padded_input_from_std_string() && ok;
+  ok = test_padded_input_is_view() && ok;
+  ok = test_padded_input_nested_json() && ok;
+  ok = test_padded_input_dom() && ok;
+  ok = test_padded_input_dom_object() && ok;
+  if (ok) {
+    printf("\nAll padded_input tests passed.\n");
+    return EXIT_SUCCESS;
+  } else {
+    printf("\nSome padded_input tests FAILED.\n");
+    return EXIT_FAILURE;
+  }
+}
+
+#else // !SIMDJSON_CPLUSPLUS17
+
+int main() {
+  printf("padded_input requires C++17 or better. Skipping.\n");
+  return EXIT_SUCCESS;
+}
+
+#endif // SIMDJSON_CPLUSPLUS17

tests/ondemand/ondemand_readme_examples.cpp

@@ -1,4 +1,5 @@
 #include "simdjson.h"
+#include "simdjson/padded_string_view.h"
 #include "test_ondemand.h"
 #if __cpp_lib_optional >= 201606L
 #include <optional>
@@ -49,6 +50,33 @@ bool simplepad() {
   return error == SUCCESS;
 }
 
+
+#if SIMDJSON_CPLUSPLUS17
+bool simpleinputpad1() {
+  std::string json = "[1]";
+  simdjson::padded_input padded_json(json);
+  ondemand::parser parser;
+  ondemand::document doc;
+  auto error = parser.iterate(padded_json).get(doc);
+  return error == SUCCESS;
+}
+
+bool simpleinputpad2() {
+  const char *jsonpointer = R"(
+        {
+            "key": "value"
+        }
+    )";
+  size_t len = strlen(jsonpointer);
+
+  simdjson::padded_input padded_json(jsonpointer, len);
+  ondemand::parser parser;
+  ondemand::document doc;
+  auto error = parser.iterate(padded_json).get(doc);
+  return error == SUCCESS;
+}
+#endif // SIMDJSON_CPLUSPLUS17
+
 bool string1() {
   const char * data = "my data"; // 7 bytes
   simdjson::padded_string my_padded_data(data, 7); // copies to a padded buffer

tests/ondemand/ondemand_wrong_type_error_tests.cpp

@@ -15,9 +15,9 @@ namespace wrong_type_error_tests {
     return false; \
   } \
   { \
-    padded_string a_json(std::string(R"({ "a": )") + JSON + " }"); \
+    std::string a_json(R"({ "a": )"); a_json += JSON; a_json += " }"; \
     std::cout << R"(- Subtest: get_)" << (#TYPE) << "() - JSON: " << a_json << std::endl; \
-    if (!test_ondemand_doc(a_json, [&](auto doc_result) { \
+    if (!test_ondemand_doc(simdjson::pad(a_json), [&](auto doc_result) { \
       ASSERT_ERROR( doc_result["a"].get_##TYPE(), (ERROR) ); \
       return true; \
     })) { \