patch 4.6.3

.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

@@ -12,7 +12,7 @@ endif()
 project(
     simdjson
     # The version number is modified by tools/release.py
-    VERSION 4.6.1
+    VERSION 4.6.3
     DESCRIPTION "Parsing gigabytes of JSON per second"
     HOMEPAGE_URL "https://simdjson.org/"
     LANGUAGES CXX C
@@ -167,37 +167,13 @@ 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()
@@ -411,25 +387,18 @@ add_subdirectory(fuzz)
 #
 # Source files should be just ASCII
 #
-find_program(FIND_CMD find)
-find_program(FILE_CMD file)
-find_program(GREP_CMD grep)
-if(FIND_CMD AND FILE_CMD AND GREP_CMD)
+find_program(FIND find)
+find_program(FILE file)
+find_program(GREP grep)
+if(FIND AND FILE AND GREP)
   add_test(
       NAME just_ascii
       COMMAND sh -c "\
-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"
+${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"
       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()
 
 ##

Doxyfile

@@ -38,7 +38,7 @@ PROJECT_NAME           = simdjson
 # could be handy for archiving the generated documentation or if some version
 # control system is used.
 
-PROJECT_NUMBER         = "4.6.1"
+PROJECT_NUMBER         = "4.6.3"
 
 # Using the PROJECT_BRIEF tag one can provide an optional one line description
 # for a project that appears at the top of each page and should give viewer a

benchmark/CMakeLists.txt

@@ -15,7 +15,6 @@ if (TARGET benchmark::benchmark)
   link_libraries(benchmark::benchmark)
   add_executable(bench_parse_call bench_parse_call.cpp)
   add_executable(bench_dom_api bench_dom_api.cpp)
-  add_executable(bench_stream_formats bench_stream_formats.cpp)
   if(SIMDJSON_EXCEPTIONS)
     add_executable(bench_ondemand bench_ondemand.cpp)
     if(TARGET yyjson)

benchmark/bench_ondemand.cpp

@@ -124,7 +124,6 @@ SIMDJSON_POP_DISABLE_WARNINGS
 #include "kostya/boostjson.h"
 
 #include "large_random/simdjson_ondemand.h"
-#include "large_random/simdjson_ondemand_ranges.h"
 #if SIMDJSON_COMPETITION_ONDEMAND_UNORDERED
 #include "large_random/simdjson_ondemand_unordered.h"
 #endif // SIMDJSON_COMPETITION_ONDEMAND_UNORDERED

benchmark/bench_stream_formats.cpp

@@ -1,216 +0,0 @@
-#include <benchmark/benchmark.h>
-#include <string>
-#include "simdjson.h"
-
-using namespace simdjson;
-
-namespace {
-
-enum class stream_case {
-  ndjson_small,
-  ndjson_large,
-  rfc7464_small,
-  rfc7464_large,
-  comma_delimited_small,
-  comma_delimited_large
-};
-
-constexpr size_t TARGET_BYTES = 128 * 1000 * 1000;
-constexpr size_t SMALL_PAYLOAD = 16;
-constexpr size_t LARGE_PAYLOAD = 4096;
-constexpr size_t BATCH_SIZE = 1 << 20;
-
-struct stream_dataset {
-  padded_string json;
-  size_t count{};
-};
-
-std::string make_document(size_t id, size_t payload_size) {
-  return std::string{"{\"id\":"} + std::to_string(id) +
-    ",\"name\":\"aaaaaaaa\",\"payload\":\"" +
-    std::string(payload_size, 'x') + "\",\"flag\":true}";
-}
-
-stream_dataset build_dataset(stream_case which) {
-  const bool small = which == stream_case::ndjson_small ||
-                     which == stream_case::rfc7464_small ||
-                     which == stream_case::comma_delimited_small;
-  const bool rfc = which == stream_case::rfc7464_small ||
-                   which == stream_case::rfc7464_large;
-  const bool comma = which == stream_case::comma_delimited_small ||
-                     which == stream_case::comma_delimited_large;
-  const size_t payload_size = small ? SMALL_PAYLOAD : LARGE_PAYLOAD;
-  const size_t count = TARGET_BYTES / (payload_size + 48);
-  std::string out;
-  out.reserve(count * (payload_size + 64));
-  for (size_t i = 0; i < count; i++) {
-    if (rfc) {
-      out += char(0x1E);
-    }
-    if (comma && i > 0) {
-      out += ',';
-    }
-    out += make_document(i, payload_size);
-    if (!comma) {
-      out += '\n';
-    }
-  }
-  return {padded_string(out), count};
-}
-
-const stream_dataset &get_dataset(stream_case which) {
-  static const stream_dataset ndjson_small =
-    build_dataset(stream_case::ndjson_small);
-  static const stream_dataset ndjson_large =
-    build_dataset(stream_case::ndjson_large);
-  static const stream_dataset rfc_small =
-    build_dataset(stream_case::rfc7464_small);
-  static const stream_dataset rfc_large =
-    build_dataset(stream_case::rfc7464_large);
-  static const stream_dataset comma_small =
-    build_dataset(stream_case::comma_delimited_small);
-  static const stream_dataset comma_large =
-    build_dataset(stream_case::comma_delimited_large);
-  switch (which) {
-    case stream_case::ndjson_small:
-      return ndjson_small;
-    case stream_case::ndjson_large:
-      return ndjson_large;
-    case stream_case::rfc7464_small:
-      return rfc_small;
-    case stream_case::rfc7464_large:
-      return rfc_large;
-    case stream_case::comma_delimited_small:
-      return comma_small;
-    case stream_case::comma_delimited_large:
-      return comma_large;
-  }
-  return ndjson_small;
-}
-
-void set_counters(benchmark::State &state, const stream_dataset &dataset) {
-  state.SetBytesProcessed(int64_t(state.iterations()) * int64_t(dataset.json.size()));
-  state.SetItemsProcessed(int64_t(state.iterations()) * int64_t(dataset.count));
-}
-
-template <stream_case which, bool threaded = true>
-static void bench_ondemand(benchmark::State &state) {
-  const auto &dataset = get_dataset(which);
-  ondemand::parser parser;
-  parser.threaded = threaded;
-  stream_format format = stream_format::whitespace_delimited;
-  if constexpr (which == stream_case::rfc7464_small ||
-                which == stream_case::rfc7464_large) {
-    format = stream_format::json_sequence;
-  } else if constexpr (which == stream_case::comma_delimited_small ||
-                       which == stream_case::comma_delimited_large) {
-    format = stream_format::comma_delimited;
-  }
-  for (const auto _ : state) {
-    ondemand::document_stream docs;
-    auto error = parser.iterate_many(dataset.json, BATCH_SIZE, format).get(docs);
-    if (error) {
-      state.SkipWithError(error_message(error));
-      return;
-    }
-    uint64_t sum = 0;
-    for (auto doc : docs) {
-      ondemand::object obj;
-      if ((error = doc.get_object().get(obj))) {
-        state.SkipWithError(error_message(error));
-        return;
-      }
-      uint64_t id;
-      if ((error = obj["id"].get_uint64().get(id))) {
-        state.SkipWithError(error_message(error));
-        return;
-      }
-      sum += id;
-    }
-    benchmark::DoNotOptimize(sum);
-  }
-  set_counters(state, dataset);
-}
-
-template <stream_case which>
-static void bench_dom(benchmark::State &state) {
-  const auto &dataset = get_dataset(which);
-  dom::parser parser;
-  parser.threaded = true;
-  stream_format format = stream_format::whitespace_delimited;
-  if constexpr (which == stream_case::rfc7464_small ||
-                which == stream_case::rfc7464_large) {
-    format = stream_format::json_sequence;
-  } else if constexpr (which == stream_case::comma_delimited_small ||
-                       which == stream_case::comma_delimited_large) {
-    format = stream_format::comma_delimited;
-  }
-  for (const auto _ : state) {
-    dom::document_stream docs;
-    auto error = parser.parse_many(dataset.json, BATCH_SIZE, format).get(docs);
-    if (error) {
-      state.SkipWithError(error_message(error));
-      return;
-    }
-    uint64_t sum = 0;
-    for (auto doc : docs) {
-      uint64_t id;
-      if ((error = doc["id"].get(id))) {
-        state.SkipWithError(error_message(error));
-        return;
-      }
-      sum += id;
-    }
-    benchmark::DoNotOptimize(sum);
-  }
-  set_counters(state, dataset);
-}
-
-} // namespace
-
-BENCHMARK(bench_ondemand<stream_case::ndjson_small>)
-    ->UseRealTime()
-    ->DisplayAggregatesOnly(true);
-BENCHMARK(bench_ondemand<stream_case::ndjson_large>)
-    ->UseRealTime()
-    ->DisplayAggregatesOnly(true);
-BENCHMARK(bench_ondemand<stream_case::rfc7464_small>)
-    ->UseRealTime()
-    ->DisplayAggregatesOnly(true);
-BENCHMARK(bench_ondemand<stream_case::rfc7464_large>)
-    ->UseRealTime()
-    ->DisplayAggregatesOnly(true);
-BENCHMARK(bench_ondemand<stream_case::comma_delimited_small>)
-    ->UseRealTime()
-    ->DisplayAggregatesOnly(true);
-BENCHMARK(bench_ondemand<stream_case::comma_delimited_large>)
-    ->UseRealTime()
-    ->DisplayAggregatesOnly(true);
-// Non-threaded comma_delimited for comparison
-BENCHMARK(bench_ondemand<stream_case::comma_delimited_small, false>)
-    ->UseRealTime()
-    ->DisplayAggregatesOnly(true);
-BENCHMARK(bench_ondemand<stream_case::comma_delimited_large, false>)
-    ->UseRealTime()
-    ->DisplayAggregatesOnly(true);
-
-BENCHMARK(bench_dom<stream_case::ndjson_small>)
-    ->UseRealTime()
-    ->DisplayAggregatesOnly(true);
-BENCHMARK(bench_dom<stream_case::ndjson_large>)
-    ->UseRealTime()
-    ->DisplayAggregatesOnly(true);
-BENCHMARK(bench_dom<stream_case::rfc7464_small>)
-    ->UseRealTime()
-    ->DisplayAggregatesOnly(true);
-BENCHMARK(bench_dom<stream_case::rfc7464_large>)
-    ->UseRealTime()
-    ->DisplayAggregatesOnly(true);
-BENCHMARK(bench_dom<stream_case::comma_delimited_small>)
-    ->UseRealTime()
-    ->DisplayAggregatesOnly(true);
-BENCHMARK(bench_dom<stream_case::comma_delimited_large>)
-    ->UseRealTime()
-    ->DisplayAggregatesOnly(true);
-
-BENCHMARK_MAIN();

benchmark/large_random/simdjson_ondemand_ranges.h

@@ -1,32 +0,0 @@
-#pragma once
-
-#if SIMDJSON_EXCEPTIONS && SIMDJSON_SUPPORTS_RANGES
-
-#include "large_random.h"
-
-namespace large_random {
-
-using namespace simdjson;
-
-// Identical to simdjson_ondemand but uses get_range() for iteration.
-// Demonstrates that the ranges wrapper has zero per-element overhead.
-struct simdjson_ondemand_ranges {
-  static constexpr diff_flags DiffFlags = diff_flags::NONE;
-
-  ondemand::parser parser{};
-
-  bool run(simdjson::padded_string &json, std::vector<point> &result) {
-    auto doc = parser.iterate(json);
-    for (auto coord_result : ondemand::get_range(doc.get_array())) {
-      ondemand::object coord = coord_result;
-      result.emplace_back(json_benchmark::point{coord.find_field("x"), coord.find_field("y"), coord.find_field("z")});
-    }
-    return true;
-  }
-};
-
-BENCHMARK_TEMPLATE(large_random, simdjson_ondemand_ranges)->UseManualTime();
-
-} // namespace large_random
-
-#endif // SIMDJSON_EXCEPTIONS && SIMDJSON_SUPPORTS_RANGES

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

doc/basics.md

@@ -28,6 +28,8 @@ separate document](https://github.com/simdjson/simdjson/blob/master/doc/builder.
 - [UTF-8 validation (alone)](#utf-8-validation-alone)
 - [JSON Pointer](#json-pointer)
 - [JSONPath](#jsonpath)
+  * [Using `for_each_at_path_with_wildcard` for JSONPath Queries (On-Demand)](#using-for_each_at_path_with_wildcard-for-jsonpath-queries-on-demand)
+    + [Example Usage](#example-usage)
 - [Compile-Time JSONPath and JSON Pointer (C++26 Reflection)](#compile-time-jsonpath-and-json-pointer-c26-reflection)
 - [Error handling](#error-handling)
   * [Error handling examples without exceptions](#error-handling-examples-without-exceptions)
@@ -161,77 +163,54 @@ 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)).
-Your JSON document should be a valid Unicode (UTF-8) string.
+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.
 
-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`:
+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"`):
 
 ```cpp
 ondemand::parser parser;
-auto json = padded_string::load("twitter.json");
-ondemand::document doc = parser.iterate(json);
+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
 ```
 
-For inline JSON strings, use the `_padded` suffix:
+(Windows users compiling with C++17 or better may use `wchar_t` strings to support non-ASCII
+filenames: `padded_string::load(L"twitter.json")`.)
 
-```cpp
-ondemand::parser parser;
-auto json = "[1,2,3]"_padded;
-ondemand::document doc = parser.iterate(json);
-```
+If you prefer not to create your own `ondemand::parser` instance, you can access
+a thread-local version by calling `ondemand::parser.get_parser()`.
 
-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);
 ```
 
-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
+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
 document per thread at any one time.
 
-**`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).
+You can also create a padded string---and call `iterate()`:
 
-**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;
+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:
 
 ```cpp
 ondemand::parser parser;
@@ -240,72 +219,73 @@ strcpy(json, "[1]");
 ondemand::document doc = parser.iterate(json, strlen(json), sizeof(json));
 ```
 
-**Copying into a `padded_string`.** You can copy your data directly into a `simdjson::padded_string`:
+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:
 
 ```cpp
 const char * data = "my data"; // 7 bytes
 simdjson::padded_string my_padded_data(data, 7); // copies to a padded buffer
 ```
 
-Or from a `std::string`:
+Or as follows...
 
 ```cpp
 std::string data = "my data";
 simdjson::padded_string my_padded_data(data); // copies to a padded buffer
 ```
 
-**`std::string` and sanitizer warnings.** Whenever you pass an `std::string` reference to `parser::iterate`,
-the parser may access bytes beyond the end of
+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
 the string but before the end of the allocated memory (`std::string::capacity()`).
-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:
+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:
 
 ```cpp
 std::string json = "[1]";
 ondemand::document doc = parser.iterate(simdjson::pad(json));
 ```
 
-We recommend against creating many `std::string` or many `std::padded_string` instances in your application to store your JSON data.
+We recommend against creating many `std::string` or many `std::padding_string` instances in your application to store your JSON data.
 Consider reusing the same buffers and limiting memory allocations.
 
-**Memory-file mapping (non-Windows).** You can use memory-file mapping to create a `simdjson::padded_string_view`
-from a file on disk:
+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.
 
-```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);
-```
+Some users may want to browse code along with the compiled assembly. You want to check out the following lists of examples:
 
-**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
+* [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
 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:
 
-* [simdjson examples with errors handled through exceptions](https://godbolt.org/z/98Kx9Kqjn)
-* [simdjson examples with errors without exceptions](https://godbolt.org/z/PKG7GdbPo)
+**Advanced feature:**
+On non-Windows systems, you can use memory-file mapping to create a `simdjson::padded_string_view`
+from a file on disk.
 
-**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.                          |
+```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
+```
 
 
 Documents are iterators
@@ -1322,6 +1302,10 @@ 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;
   }
@@ -1415,8 +1399,6 @@ With this code, deserializing an `std::list<Car>` instance would capture only th
 that are not made by Toyota.
 
 
-**Performance tip**: You will get better performance if you order the attributes (make, model)
-in the order they appear in the JSON document.
 
 
 ### 3. Using static reflection (C++26)
@@ -1493,10 +1475,6 @@ void f() {
 }
 ```
 
-
-**Performance tip**: You will get better performance if you order the attributes (make, model)
-in the order they appear in the JSON document.
-
 #### Special cases
 
 However, there are instances where the construction cannot
@@ -1814,15 +1792,15 @@ int64_t x = obj.at_path("$.c.foo.a[1]"); // 20
 x = obj.at_path("$.d.foo2.a.2"); // 30
 ```
 
-## Using `at_path_with_wildcard` for JSONPath Queries (On-Demand)
+## Using `for_each_at_path_with_wildcard` for JSONPath Queries (On-Demand)
 
-The `at_path_with_wildcard` function in simdjson extends the JSONPath querying capabilities by supporting wildcard expressions (`*`) in JSON paths. This allows users to retrieve multiple elements from a JSON document in a single query. For example, you can use `$.address.*` to fetch all fields within the `address` object or `$.phoneNumbers[*].numbers[*]` to retrieve all phone numbers across multiple objects in an array.
+The `for_each_at_path_with_wildcard` function in simdjson extends the JSONPath querying capabilities by supporting wildcard expressions (`*`) in JSON paths. It calls a user-provided callback for each matching element, avoiding the need to materialize all results into a vector. For example, you can use `$.address.*` to fetch all fields within the `address` object or `$.phoneNumbers[*].numbers[*]` to retrieve all phone numbers across multiple objects in an array.
 
-The `*` wildcard matches all elements at a specific level. For instance, `$.address.*` retrieves all key-value pairs in the `address` object, while `$.*.streetAddress` fetches all `streetAddress` fields across objects at the root level. You can combine wildcards with array indexing. For example, `$.phoneNumbers[*].numbers[1]` retrieves the second number from each `numbers` array in the `phoneNumbers` array. If no elements match the wildcard query, the function returns an empty result. For instance, querying `$.empty_object.*` or `$.empty_array.*` will yield an empty set.
+The `*` wildcard matches all elements at a specific level. For instance, `$.address.*` retrieves all key-value pairs in the `address` object, while `$.*.streetAddress` fetches all `streetAddress` fields across objects at the root level. You can combine wildcards with array indexing. For example, `$.phoneNumbers[*].numbers[1]` retrieves the second number from each `numbers` array in the `phoneNumbers` array. If no elements match the wildcard query, the callback is simply never called. For instance, querying `$.empty_object.*` or `$.empty_array.*` will yield no callbacks.
 
 ### Example Usage
 
-Here is an example demonstrating the use of `at_path_with_wildcard`:
+Here is an example demonstrating the use of `for_each_at_path_with_wildcard`:
 
 ```cpp
 simdjson::padded_string json_string = R"(
@@ -1851,91 +1829,26 @@ ondemand::parser parser;
 ondemand::document doc = parser.iterate(json_string);
 
 // Fetch all fields in the address object
-std::vector<ondemand::value> values;
-auto error = doc.at_path_with_wildcard("$.address.*").get(values);
-if (!error) {
-  for (auto value : values) {
-    std::string_view field;
-    if (value.get(field) == SUCCESS) {
-      std::cout << field << std::endl;
-    }
-  }
-}
+auto error = doc.for_each_at_path_with_wildcard("$.address.*",
+    [](ondemand::value value) {
+      std::string_view field;
+      if (value.get(field) == SUCCESS) {
+        std::cout << field << std::endl;
+      }
+    });
 
 // Fetch all phone numbers
-error = doc.at_path_with_wildcard("$.phoneNumbers[*].numbers[*]").get(values);
-if (!error) {
-  for (auto value : values) {
-    std::string_view number;
-    if (value.get(number) == SUCCESS) {
-      std::cout << number << std::endl;
-    }
-  }
-}
+doc.for_each_at_path_with_wildcard("$.phoneNumbers[*].numbers[*]",
+    [](ondemand::value value) {
+      std::string_view number;
+      if (value.get(number) == SUCCESS) {
+        std::cout << number << std::endl;
+      }
+    });
 ```
 
 This function is particularly useful for extracting data from complex JSON structures with nested arrays and objects. By leveraging wildcards, you can simplify your queries and reduce the need for multiple iterations.
 
-## C++20 Ranges Support (On-Demand)
-
-When compiling with C++20 (or later), you can use `std::ranges` with the On-Demand API
-via the `get_range()` helper. This enables use of range adaptors such as `std::views::transform`.
-
-```cpp
-#include "simdjson.h"
-#include <ranges>
-#include <string>
-#include <vector>
-
-auto json = R"([
-  { "name": "Alice", "age": 30 },
-  { "name": "Bob",   "age": 25 },
-  { "name": "Carol", "age": 35 }
-])"_padded;
-
-ondemand::parser parser;
-auto doc = parser.iterate(json);
-auto arr = doc.get_array();
-
-// Use std::views::transform to extract names
-auto names = ondemand::get_range(arr)
-  | std::views::transform([](auto elem) -> std::string {
-      return std::string(std::string_view(elem["name"]));
-    });
-
-for (auto name : names) {
-  std::cout << name << std::endl;  // Alice, Bob, Carol
-}
-```
-
-The `get_range()` and `get_key_value_range()` functions wrap an `ondemand::array`
-or `ondemand::object` in a `std::ranges::view` that satisfies `std::ranges::input_range`.
-They work with both exception and non-exception code:
-
-```cpp
-// With exceptions:
-auto range = ondemand::get_range(doc.get_array());
-
-// Without exceptions:
-ondemand::array arr;
-if (doc.get_array().get(arr) == SUCCESS) {
-  auto range = ondemand::get_range(arr);
-  for (auto elem : range) { /* ... */ }
-}
-```
-
-Object iteration uses `get_key_value_range()` and yields `simdjson_result<ondemand::field>` elements:
-
-```cpp
-auto obj = doc.get_object();
-for (auto field_result : ondemand::get_key_value_range(obj)) {
-  std::cout << field_result.key() << std::endl;
-}
-```
-
-The range wrappers are zero-cost: they forward directly to the underlying
-On-Demand iterators with no value buffering or extra per-element overhead.
-
 ## Compile-Time JSONPath and JSON Pointer (C++26 Reflection)
 
 The simdjson library provides **compile-time validated** JSONPath and JSON Pointer accessors when using C++26 Static Reflection. These accessors validate paths against struct definitions at compile time and generate optimized code with zero runtime overhead. In some cases, we find that it is much faster. Furthermore, it is safer in the sense that the expression

doc/compile_time.md

@@ -32,21 +32,6 @@ 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                         |
 |----------------|----------------------------------|
@@ -76,8 +61,6 @@ You can do so, at compile-time, as follows:
 
 
 ```cpp
-using namespace simdjson::literals;
-
 constexpr auto cfg = R"(
 
 {
@@ -96,8 +79,6 @@ constexpr auto cfg = R"(
 You can nest objects and arrays:
 
 ```cpp
-using namespace simdjson::literals;
-
 constexpr auto data = R"(
 
 {
@@ -117,8 +98,6 @@ constexpr auto data = R"(
 Top-level arrays are allowed:
 
 ```cpp
-using namespace simdjson::literals;
-
 constexpr auto arr = R"(
 
 [1, 2, 3]
@@ -137,8 +116,6 @@ 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,19 +882,6 @@ 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/iterate_many.md

@@ -26,7 +26,6 @@ Contents
 - [Tracking your position](#tracking-your-position)
 - [Incomplete streams](#incomplete-streams)
 - [C++20 features](#c20-features)
-- [C++26 features (static reflection)](#c26-features-static-reflection)
 
 Motivation
 -----------
@@ -133,7 +132,7 @@ E.g., `[1,2]{"32":1}` is recognized as two documents.
 Some official formats **(non-exhaustive list)**:
 - [Newline-Delimited JSON (NDJSON)](https://github.com/ndjson/ndjson-spec/)
 - [JSON lines (JSONL)](http://jsonlines.org/)
-- [Record separator-delimited JSON (RFC 7464)](https://tools.ietf.org/html/rfc7464)
+- [Record separator-delimited JSON (RFC 7464)](https://tools.ietf.org/html/rfc7464) <- Not supported by simdjson!
 - [More on Wikipedia...](https://en.wikipedia.org/wiki/JSON_streaming)
 
 API
@@ -279,131 +278,39 @@ Importantly, you should only call `truncated_bytes()` after iterating through al
 Comma-separated documents
 -----------
 
-To parse comma-separated documents like `{"a":1},{"b":2},{"c":3}`, use the `stream_format::comma_delimited` parameter:
+We also support comma-separated documents, but with some performance limitations. The `iterate_many` function  takes in an option to allow parsing of comma separated documents (which defaults on false). In this mode, the entire buffer is processed in one batch. Therefore, the total size of the document should not exceed the maximal capacity of the parser (4 GB). This mode also effectively disallow multithreading. It is therefore mostly suitable for not "very large" inputs. In this mode, the batch_size parameter
+is effectively ignored, as it is set to at least the document size.
+
+Example:
 
 ```cpp
-auto json = R"({"a":1},{"b":2},{"c":3})"_padded;
-ondemand::parser parser;
-ondemand::document_stream stream;
-auto error = parser.iterate_many(json, ondemand::DEFAULT_BATCH_SIZE,
-                                 simdjson::stream_format::comma_delimited).get(stream);
-if (error) { std::cerr << error << std::endl; return; }
-for (auto doc : stream) {
-    std::cout << doc << std::endl;
-}
-// Prints: {"a":1}
-//         {"b":2}
-//         {"c":3}
+    auto json = R"( 1, 2, 3, 4, "a", "b", "c", {"hello": "world"} , [1, 2, 3])"_padded;
+    ondemand::parser parser;
+    ondemand::document_stream doc_stream;
+    // We pass '32' as the batch size, but it is a bogus parameter because, since
+    // we pass 'true' to the allow_comma parameter, the batch size will be set to at least
+    // the document size.
+    auto error = parser.iterate_many(json, 32, true).get(doc_stream);
+    if (error) { std::cerr << error << std::endl; return; }
+    for (auto doc : doc_stream) {
+        std::cout << doc.type() << std::endl;
+    }
+ ```
+
+ This will print:
+
 ```
-
-Whitespace around the commas is allowed:
-```cpp
-auto json = R"({"a":1} , {"b":2} , {"c":3})"_padded;  // Also works
+number
+number
+number
+number
+string
+string
+string
+object
+array
 ```
 
-Nested commas inside objects and arrays are preserved:
-```cpp
-auto json = R"({"arr":[1,2,3]},{"obj":{"x":1,"y":2}})"_padded;
-// Correctly parses as 2 documents, not 6
-```
-
-Mixed document types are supported:
-```cpp
-auto json = R"(1, 2, 3, 4, "a", "b", "c", {"hello": "world"}, [1, 2, 3])"_padded;
-ondemand::parser parser;
-ondemand::document_stream doc_stream;
-auto error = parser.iterate_many(json, ondemand::DEFAULT_BATCH_SIZE,
-                                 simdjson::stream_format::comma_delimited).get(doc_stream);
-if (error) { std::cerr << error << std::endl; return; }
-for (auto doc : doc_stream) {
-    std::cout << doc.type() << std::endl;
-}
-// Prints: number number number number string string string object array
-```
-
-Extra top-level separators are tolerated for compatibility with the legacy
-`allow_comma_separated` behavior. For example, leading commas, trailing commas,
-and repeated commas are treated as empty separators rather than documents.
-
-### Legacy `allow_comma_separated` parameter (deprecated)
-
-The `allow_comma_separated` boolean parameter is deprecated. When set to `true`, it now internally maps to `stream_format::comma_delimited`.
-
-The old single-batch limitation no longer applies - comma-delimited parsing now supports multi-batch processing and threading for optimal performance on large files.
-
-JSON Text Sequences (RFC 7464)
-------------------------------
-
-[RFC 7464](https://tools.ietf.org/html/rfc7464) defines a format for streaming JSON values using ASCII Record Separator (RS, 0x1E) as a delimiter. Each JSON text is preceded by RS and optionally followed by ASCII Line Feed (LF, 0x0A).
-
-Example input:
-```
-<RS>{"name":"doc1"}<LF>
-<RS>{"name":"doc2"}<LF>
-<RS>{"name":"doc3"}<LF>
-```
-
-To parse JSON text sequences, use the `stream_format::json_sequence` parameter:
-
-```cpp
-// Build input with RS (0x1E) and LF (0x0A) delimiters
-std::string input_str;
-input_str += '\x1e'; input_str += "{\"a\":1}"; input_str += '\x0a';
-input_str += '\x1e'; input_str += "{\"b\":2}"; input_str += '\x0a';
-input_str += '\x1e'; input_str += "{\"c\":3}"; input_str += '\x0a';
-simdjson::padded_string input(input_str);
-
-ondemand::parser parser;
-ondemand::document_stream stream;
-auto error = parser.iterate_many(input, ondemand::DEFAULT_BATCH_SIZE,
-                                 simdjson::stream_format::json_sequence).get(stream);
-if (error) { std::cerr << error << std::endl; return; }
-for (auto doc : stream) {
-    std::cout << doc << std::endl;
-}
-```
-
-The `stream_format` enum has the following values:
-- `stream_format::whitespace_delimited` (default): Standard NDJSON/JSON Lines format
-- `stream_format::json_sequence`: RFC 7464 format with RS delimiters
-- `stream_format::comma_delimited`: Comma-separated JSON documents
-- `stream_format::comma_delimited_array`: A single JSON array whose elements are iterated as comma-delimited documents (see below)
-
-The trailing LF after each JSON text is optional but recommended by the RFC for robustness.
-
-JSON Array As A Document Stream
--------------------------------
-
-Sometimes an input is a single, well-formed JSON array — `[{"a":1},{"b":2},{"c":3}]` — but you want to iterate its elements one at a time without materializing the whole array. Use `stream_format::comma_delimited_array`:
-
-```cpp
-auto json = R"([{"a":1},{"b":2},{"c":3}])"_padded;
-ondemand::parser parser;
-ondemand::document_stream stream;
-auto error = parser.iterate_many(json, ondemand::DEFAULT_BATCH_SIZE,
-                                 simdjson::stream_format::comma_delimited_array).get(stream);
-if (error) { std::cerr << error << std::endl; return; }
-for (auto doc : stream) {
-    std::cout << doc << std::endl;
-}
-// Prints: {"a":1}
-//         {"b":2}
-//         {"c":3}
-```
-
-The parser strips the outer `[` and `]` plus any surrounding JSON whitespace (space, tab, LF, CR) and then behaves exactly like `stream_format::comma_delimited` over the remaining bytes. All comma-delimited features are inherited: multi-batch processing, threading, mixed scalar types, and nested commas preserved inside inner objects and arrays.
-
-```cpp
-// All of these work:
-auto a = R"([1, "x", true, null, {"k":"v"}, [1,2]])"_padded;  // mixed scalars
-auto b = R"(  [ 1, 2, 3 ] )"_padded;                          // whitespace
-auto c = R"([])"_padded;                                      // empty array → 0 docs
-```
-
-If the input is not a well-formed outer array (missing `[`, missing `]`, or empty / all-whitespace), `iterate_many` returns `TAPE_ERROR`. Content **inside** the array is not validated up front — individual document parse errors surface when you iterate, just like `comma_delimited`.
-
-Positions reported via `current_index()` are relative to the **stripped** buffer (the bytes between `[` and `]`), not the original input, for consistency with the existing BOM-stripping behavior.
-
 
 C++20 features
 --------------------
@@ -511,161 +418,3 @@ Otherwise you may use this longer version for explicit handling of errors:
     cars.push_back(c);
   }
 ```
-
-**Performance tip**: You will get better performance if you order the attributes (make, model)
-in the order they appear in the JSON document.
-
-C++26 features (static reflection)
------------------------------------
-
-If you have a C++26 compatible compiler with [P2996](https://wg21.link/P2996)
-static reflection support, you can compile the simdjson library with the
-`SIMDJSON_STATIC_REFLECTION` macro set to `1`. When this is the case, simdjson
-can deserialize a stream of JSON documents directly into your own structures
-**without** writing any `tag_invoke` function. The library inspects the
-non-static public members of your type at compile time and produces the
-parsing code automatically.
-
-```cpp
-#define SIMDJSON_STATIC_REFLECTION 1
-#include "simdjson.h"
-```
-
-Consider the same `Car` structure used in the C++20 example, but **without**
-any `tag_invoke` glue:
-
-```cpp
-struct Car {
-  std::string make;
-  std::string model;
-  int year;
-  std::vector<double> tire_pressure;
-};
-```
-
-With C++26 static reflection enabled, you can iterate a stream of cars and
-push them into a `std::vector<Car>` directly:
-
-```cpp
-auto json = R"( { "make": "Toyota", "model": "Camry",  "year": 2018,
-                  "tire_pressure": [ 40.1, 39.9 ] }
-                { "make": "Kia",    "model": "Soul",   "year": 2012,
-                  "tire_pressure": [ 30.1, 31.0 ] }
-                { "make": "Toyota", "model": "Tercel", "year": 1999,
-                  "tire_pressure": [ 29.8, 30.0 ] } )"_padded;
-ondemand::parser parser;
-ondemand::document_stream stream;
-auto error = parser.iterate_many(json).get(stream);
-if (error) { /* handle error */ }
-std::vector<Car> cars;
-for (auto doc : stream) {
-  Car c;
-  if ((error = doc.get<Car>().get(c))) { /* handle error */ }
-  cars.push_back(c);
-}
-```
-
-This works for every `stream_format` value supported by `iterate_many`. The
-following examples each parse the same three cars, but laid out using a
-different streaming convention.
-
-### Whitespace-delimited (default, NDJSON / JSON Lines)
-
-```cpp
-auto json = R"( { "make": "Toyota", "model": "Camry",  "year": 2018,
-                  "tire_pressure": [ 40.1, 39.9 ] }
-                { "make": "Kia",    "model": "Soul",   "year": 2012,
-                  "tire_pressure": [ 30.1, 31.0 ] }
-                { "make": "Toyota", "model": "Tercel", "year": 1999,
-                  "tire_pressure": [ 29.8, 30.0 ] } )"_padded;
-ondemand::parser parser;
-ondemand::document_stream stream;
-auto error = parser.iterate_many(json, ondemand::DEFAULT_BATCH_SIZE,
-                                 simdjson::stream_format::whitespace_delimited).get(stream);
-if (error) { /* handle error */ }
-std::vector<Car> cars;
-for (auto doc : stream) {
-  cars.push_back((Car)doc); // throws on error
-}
-```
-
-### Comma-delimited documents
-
-```cpp
-auto json = R"( { "make": "Toyota", "model": "Camry",  "year": 2018,
-                  "tire_pressure": [ 40.1, 39.9 ] },
-                { "make": "Kia",    "model": "Soul",   "year": 2012,
-                  "tire_pressure": [ 30.1, 31.0 ] },
-                { "make": "Toyota", "model": "Tercel", "year": 1999,
-                  "tire_pressure": [ 29.8, 30.0 ] } )"_padded;
-ondemand::parser parser;
-ondemand::document_stream stream;
-auto error = parser.iterate_many(json, ondemand::DEFAULT_BATCH_SIZE,
-                                 simdjson::stream_format::comma_delimited).get(stream);
-if (error) { /* handle error */ }
-std::vector<Car> cars;
-for (auto doc : stream) {
-  Car c;
-  if ((error = doc.get<Car>().get(c))) { /* handle error */ }
-  cars.push_back(c);
-}
-```
-
-### A single JSON array as a stream of documents
-
-When the input is a single JSON array, you can stream its elements one at a
-time without materializing the entire array as a `std::vector` upfront:
-
-```cpp
-auto json = R"( [ { "make": "Toyota", "model": "Camry",  "year": 2018,
-                    "tire_pressure": [ 40.1, 39.9 ] },
-                  { "make": "Kia",    "model": "Soul",   "year": 2012,
-                    "tire_pressure": [ 30.1, 31.0 ] },
-                  { "make": "Toyota", "model": "Tercel", "year": 1999,
-                    "tire_pressure": [ 29.8, 30.0 ] } ] )"_padded;
-ondemand::parser parser;
-ondemand::document_stream stream;
-auto error = parser.iterate_many(json, ondemand::DEFAULT_BATCH_SIZE,
-                                 simdjson::stream_format::comma_delimited_array).get(stream);
-if (error) { /* handle error */ }
-std::vector<Car> cars;
-for (auto doc : stream) {
-  Car c;
-  if ((error = doc.get<Car>().get(c))) { /* handle error */ }
-  cars.push_back(c);
-}
-```
-
-### JSON Text Sequences (RFC 7464)
-
-```cpp
-// Build input with RS (0x1E) and LF (0x0A) delimiters
-std::string input_str;
-auto append = [&](std::string_view doc) {
-  input_str += '\x1e'; input_str += doc; input_str += '\x0a';
-};
-append(R"({ "make": "Toyota", "model": "Camry",  "year": 2018, "tire_pressure": [ 40.1, 39.9 ] })");
-append(R"({ "make": "Kia",    "model": "Soul",   "year": 2012, "tire_pressure": [ 30.1, 31.0 ] })");
-append(R"({ "make": "Toyota", "model": "Tercel", "year": 1999, "tire_pressure": [ 29.8, 30.0 ] })");
-simdjson::padded_string input(input_str);
-
-ondemand::parser parser;
-ondemand::document_stream stream;
-auto error = parser.iterate_many(input, ondemand::DEFAULT_BATCH_SIZE,
-                                 simdjson::stream_format::json_sequence).get(stream);
-if (error) { /* handle error */ }
-std::vector<Car> cars;
-for (auto doc : stream) {
-  Car c;
-  if ((error = doc.get<Car>().get(c))) { /* handle error */ }
-  cars.push_back(c);
-}
-```
-
-In every case, the user-defined type (`Car` here) does not need a hand-written
-`tag_invoke` overload: the library generates the deserialization code from the
-type's public data members at compile time.
-
-
-**Performance tip**: You will get better performance if you order the attributes (make, model)
-in the order they appear in the JSON document.

doc/parse_many.md

@@ -132,7 +132,7 @@ Whitespace Characters:
 Some official formats **(non-exhaustive list)**:
 - [Newline-Delimited JSON (NDJSON)](https://github.com/ndjson/ndjson-spec)
 - [JSON lines (JSONL)](http://jsonlines.org/)
-- [Record separator-delimited JSON (RFC 7464)](https://tools.ietf.org/html/rfc7464)
+- [Record separator-delimited JSON (RFC 7464)](https://tools.ietf.org/html/rfc7464) <- Not supported by simdjson!
 - [More on Wikipedia...](https://en.wikipedia.org/wiki/JSON_streaming)
 
 API
@@ -253,115 +253,3 @@ Consider the following example where a truncated document (`{"key":"intentionall
 
 
 Importantly, you should only call `truncated_bytes()` after iterating through all of the documents since the stream cannot tell whether there are truncated documents at the very end when it may not have accessed that part of the data yet.
-
-JSON Text Sequences (RFC 7464)
-------------------------------
-
-[RFC 7464](https://tools.ietf.org/html/rfc7464) defines a format for streaming JSON values using ASCII Record Separator (RS, 0x1E) as a delimiter. Each JSON text is preceded by RS and optionally followed by ASCII Line Feed (LF, 0x0A).
-
-Example input:
-```
-<RS>{"name":"doc1"}<LF>
-<RS>{"name":"doc2"}<LF>
-<RS>{"name":"doc3"}<LF>
-```
-
-To parse JSON text sequences, use the `stream_format::json_sequence` parameter:
-
-```cpp
-// Build input with RS (0x1E) and LF (0x0A) delimiters
-std::string input_str;
-input_str += '\x1e'; input_str += "{\"a\":1}"; input_str += '\x0a';
-input_str += '\x1e'; input_str += "{\"b\":2}"; input_str += '\x0a';
-input_str += '\x1e'; input_str += "{\"c\":3}"; input_str += '\x0a';
-simdjson::padded_string input(input_str);
-
-simdjson::dom::parser parser;
-simdjson::dom::document_stream stream;
-auto error = parser.parse_many(input, simdjson::dom::DEFAULT_BATCH_SIZE,
-                               simdjson::stream_format::json_sequence).get(stream);
-if (error) { std::cerr << error << std::endl; return; }
-for (auto doc : stream) {
-    std::cout << doc << std::endl;
-}
-```
-
-The `stream_format` enum has the following values:
-- `stream_format::whitespace_delimited` (default): Standard NDJSON/JSON Lines format
-- `stream_format::json_sequence`: RFC 7464 format with RS delimiters
-- `stream_format::comma_delimited`: Comma-separated JSON documents
-- `stream_format::comma_delimited_array`: A single JSON array whose elements are iterated as comma-delimited documents (see below)
-
-The trailing LF after each JSON text is optional but recommended by the RFC for robustness.
-
-Comma-Separated Documents
--------------------------
-
-Some systems produce JSON documents separated by commas, like `{"a":1},{"b":2},{"c":3}`. This is common when extracting elements from a JSON array or when APIs return comma-separated results.
-
-To parse comma-separated documents, use the `stream_format::comma_delimited` parameter:
-
-```cpp
-auto json = R"({"a":1},{"b":2},{"c":3})"_padded;
-simdjson::dom::parser parser;
-simdjson::dom::document_stream stream;
-auto error = parser.parse_many(json, simdjson::dom::DEFAULT_BATCH_SIZE,
-                               simdjson::stream_format::comma_delimited).get(stream);
-if (error) { std::cerr << error << std::endl; return; }
-for (auto doc : stream) {
-    std::cout << doc << std::endl;
-}
-// Prints: {"a":1}
-//         {"b":2}
-//         {"c":3}
-```
-
-Whitespace around the commas is allowed:
-```cpp
-auto json = R"({"a":1} , {"b":2} , {"c":3})"_padded;  // Also works
-```
-
-Nested commas inside objects and arrays are preserved:
-```cpp
-auto json = R"({"arr":[1,2,3]},{"obj":{"x":1,"y":2}})"_padded;
-// Correctly parses as 2 documents, not 6
-```
-
-Extra top-level separators are tolerated for compatibility with the legacy
-On-Demand comma-separated mode. Leading commas, trailing commas, and repeated
-commas are treated as empty separators rather than documents.
-
-Unlike the legacy `allow_comma_separated` parameter, `stream_format::comma_delimited` supports multi-batch processing and threading for optimal performance on large files.
-
-JSON Array As A Document Stream
--------------------------------
-
-Sometimes an input is a single, well-formed JSON array — `[{"a":1},{"b":2},{"c":3}]` — but you want to iterate its elements one at a time without materializing the whole array. Use `stream_format::comma_delimited_array`:
-
-```cpp
-auto json = R"([{"a":1},{"b":2},{"c":3}])"_padded;
-simdjson::dom::parser parser;
-simdjson::dom::document_stream stream;
-auto error = parser.parse_many(json, simdjson::dom::DEFAULT_BATCH_SIZE,
-                               simdjson::stream_format::comma_delimited_array).get(stream);
-if (error) { std::cerr << error << std::endl; return; }
-for (auto doc : stream) {
-    std::cout << doc << std::endl;
-}
-// Prints: {"a":1}
-//         {"b":2}
-//         {"c":3}
-```
-
-The parser strips the outer `[` and `]` plus any surrounding JSON whitespace (space, tab, LF, CR) and then behaves exactly like `stream_format::comma_delimited` over the remaining bytes. All comma-delimited features are inherited: multi-batch processing, threading, mixed scalar types, and nested commas preserved inside inner objects and arrays.
-
-```cpp
-// All of these work:
-auto a = R"([1, "x", true, null, {"k":"v"}, [1,2]])"_padded;  // mixed scalars
-auto b = R"(  [ 1, 2, 3 ] )"_padded;                          // whitespace
-auto c = R"([])"_padded;                                      // empty array → 0 docs
-```
-
-If the input is not a well-formed outer array (missing `[`, missing `]`, or empty / all-whitespace), `parse_many` returns `TAPE_ERROR`. Content **inside** the array is not validated up front — individual document parse errors surface when you iterate, just like `comma_delimited`.
-
-Positions reported via `current_index()` are relative to the **stripped** buffer (the bytes between `[` and `]`), not the original input, for consistency with the existing BOM-stripping behavior.

doc/performance.md

@@ -204,31 +204,9 @@ 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.
-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`, a C-style string with length, or a `std::string`. For `std::string`, it takes into account the reserved capacity when determining if sufficient padding exists. 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);
-
-// Also works with std::string, considering capacity
-std::string json_str = get_json_string();
-json_str.reserve(json_str.size() + 100);  // Reserve extra space
-simdjson::padded_input input2(json_str);  // May avoid copying if capacity is sufficient
-auto result2 = parser.parse(input2);
-```
-
-This simplifies padding management compared to manually checking and allocating.
-
-
-More generally, the following code provides a portable example.
-
+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.
 
 
 The conditional compilation checks for the `_MSC_VER` macro (indicating Microsoft Visual Studio)
@@ -272,7 +250,7 @@ long page_size() {
 }
 
 // Returns true if the buffer + len + simdjson::SIMDJSON_PADDING crosses the
-// page boundary. Assumes len != 0.
+// page boundary.
 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/base.h

@@ -21,10 +21,6 @@ SIMDJSON_PUSH_DISABLE_UNUSED_WARNINGS
 
 /** The maximum document size supported by simdjson. */
 constexpr size_t SIMDJSON_MAXSIZE_BYTES = 0xFFFFFFFF;
-/** The maximum depth of nested objects and arrays supported by simdjson.
- A depth of SIMDJSON_MAXSIZE_BYTES/2 is not reasonable and would be
- adversarial, but it serves as an upper bound for validation purposes. */
-constexpr size_t SIMDJSON_MAX_DEPTH = SIMDJSON_MAXSIZE_BYTES/2;
 
 /**
  * The amount of padding needed in a buffer to parse JSON.
@@ -50,21 +46,6 @@ struct padded_string;
 class padded_string_view;
 enum class stage1_mode;
 
-/**
- * Stream format for parse_many/iterate_many.
- */
-enum class stream_format {
-  whitespace_delimited, ///< Whitespace-delimited JSON documents (default, includes NDJSON/JSONL)
-  json_sequence,        ///< RFC 7464 JSON text sequences (RS-delimited)
-  comma_delimited,      ///< Comma-separated JSON documents (e.g., `{...},{...},{...}`)
-  comma_delimited_array ///< A single JSON array whose elements are iterated as
-                        ///< comma-separated documents (e.g., `[{...},{...},{...}]`).
-                        ///< The parser strips the outer `[` / `]` plus any
-                        ///< surrounding JSON whitespace (space, tab, LF, CR)
-                        ///< and then behaves like `comma_delimited` over the
-                        ///< remaining bytes.
-};
-
 namespace internal {
 
 template<typename T>

include/simdjson/compile_time_json-inl.h

@@ -266,12 +266,6 @@ 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.
@@ -326,8 +320,7 @@ using class_type = type_builder<meta_info...>::constructed_type;
 /**
  * @brief Variable template for constructing instances with values
  */
-template <typename T, auto... Vs> constexpr T construct_from = T{Vs...};
-
+template <typename T, auto... Vs> constexpr auto construct_from = T{Vs...};
 
 // in JSON, there are only a few whitespace characters that are allowed
 // outside of objects, arrays, strings, and numbers.
@@ -417,7 +410,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 (static_cast<std::size_t>(res.ptr - json.data()) != scope) {
+      if ((res.ptr - json.data()) != scope) {
         simdjson_consteval_error(
             "Internal error: cannot agree on the character range of the float");
       }
@@ -431,7 +424,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 (static_cast<std::size_t>(res.ptr - json.data()) != scope) {
+      if ((res.ptr - json.data()) != scope) {
         simdjson_consteval_error(
             "Internal error: cannot agree on the character range of the float");
       }
@@ -540,7 +533,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') {
+          *(cursor + 1) != 'u' > 0xFFFF) {
         code_point = substitution_code_point;
       } else {       // we have \u following the high surrogate
         cursor += 2; // skip \u
@@ -894,19 +887,10 @@ 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,
       {
-          elem_type, std::meta::reflect_constant(count)});
+          std::meta::type_of(values[1]), std::meta::reflect_constant(count)});
 
   // Create array instance with values
   values[0] = array_type;
@@ -973,7 +957,8 @@ 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), make_data_member_options(field_name));
+      auto dms = std::meta::data_member_spec(std::meta::type_of(parsed),
+                                             {.name = field_name});
       members.push_back(std::meta::reflect_constant(dms));
       values.push_back(parsed);
 
@@ -982,7 +967,8 @@ 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), make_data_member_options(field_name));
+      auto dms = std::meta::data_member_spec(std::meta::type_of(parsed),
+                                             {.name = field_name});
       members.push_back(std::meta::reflect_constant(dms));
       values.push_back(parsed);
       if (*(cursor + array_size - 1) != ']') {
@@ -1003,7 +989,8 @@ parse_json_object_impl(std::string_view json) {
         }
       }
       auto dms =
-          std::meta::data_member_spec(^^const char *, make_data_member_options(field_name));
+          std::meta::data_member_spec(^^const char *, {
+                                                          .name = field_name});
       members.push_back(std::meta::reflect_constant(dms));
       values.push_back(std::meta::reflect_constant_string(value));
       break;
@@ -1014,7 +1001,8 @@ parse_json_object_impl(std::string_view json) {
       }
       cursor += 4;
 
-      auto dms = std::meta::data_member_spec(^^bool, make_data_member_options(field_name));
+      auto dms = std::meta::data_member_spec(^^bool, {
+                                                         .name = field_name});
       members.push_back(std::meta::reflect_constant(dms));
       values.push_back(std::meta::reflect_constant(true));
       break;
@@ -1025,7 +1013,8 @@ parse_json_object_impl(std::string_view json) {
       }
       cursor += 5;
 
-      auto dms = std::meta::data_member_spec(^^bool, make_data_member_options(field_name));
+      auto dms = std::meta::data_member_spec(^^bool, {
+                                                         .name = field_name});
       members.push_back(std::meta::reflect_constant(dms));
       values.push_back(std::meta::reflect_constant(false));
       break;
@@ -1036,7 +1025,9 @@ parse_json_object_impl(std::string_view json) {
       }
       cursor += 4;
 
-      auto dms = std::meta::data_member_spec(^^std::nullptr_t, make_data_member_options(field_name));
+      auto dms = std::meta::data_member_spec(^^std::nullptr_t,
+                                             {
+                                                 .name = field_name});
       members.push_back(std::meta::reflect_constant(dms));
       values.push_back(std::meta::reflect_constant(nullptr));
       break;
@@ -1060,19 +1051,22 @@ 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, make_data_member_options(field_name));
+            std::meta::data_member_spec(^^int64_t, {
+                                                       .name = 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, make_data_member_options(field_name));
+            std::meta::data_member_spec(^^uint64_t, {
+                                                        .name = 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, make_data_member_options(field_name));
+            std::meta::data_member_spec(^^double, {
+                                                      .name = field_name});
         members.push_back(std::meta::reflect_constant(dms));
         values.push_back(std::meta::reflect_constant(float_value));
       }
@@ -1117,11 +1111,16 @@ 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.");*/
 
-  if constexpr (json.front() == '[') {
-    return [: parse_json_array_impl(json).first :];
-  } else {
-    return [: parse_json_object_impl(json).first :];
-  }
+  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:];
+  }*/
 }
 
 } // namespace compile_time

include/simdjson/compile_time_json.h

@@ -63,16 +63,13 @@ 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,11 +58,6 @@ 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/dom/document-inl.h

@@ -33,9 +33,6 @@ inline error_code document::allocate(size_t capacity) noexcept {
     allocated_capacity = 0;
     return SUCCESS;
   }
-  if (capacity > SIMDJSON_MAXSIZE_BYTES) {
-    return CAPACITY;
-  }
 
   // a pathological input like "[[[[..." would generate capacity tape elements, so
   // need a capacity of at least capacity + 1, but it is also possible to do

include/simdjson/dom/document_stream-inl.h

@@ -89,14 +89,12 @@ simdjson_inline document_stream::document_stream(
   dom::parser &_parser,
   const uint8_t *_buf,
   size_t _len,
-  size_t _batch_size,
-  stream_format _format
+  size_t _batch_size
 ) noexcept
   : parser{&_parser},
     buf{_buf},
     len{_len},
     batch_size{_batch_size <= MINIMAL_BATCH_SIZE ? MINIMAL_BATCH_SIZE : _batch_size},
-    format{_format},
     error{SUCCESS}
 #ifdef SIMDJSON_THREADS_ENABLED
     , use_thread(_parser.threaded) // we need to make a copy because _parser.threaded can change
@@ -114,7 +112,6 @@ simdjson_inline document_stream::document_stream() noexcept
     buf{nullptr},
     len{0},
     batch_size{0},
-    format{stream_format::whitespace_delimited},
     error{UNINITIALIZED}
 #ifdef SIMDJSON_THREADS_ENABLED
     , use_thread(false)
@@ -227,14 +224,7 @@ simdjson_inline std::string_view document_stream::iterator::source() const noexc
   } else {
     size_t next_doc_index = stream->batch_start + stream->parser->implementation->structural_indexes[stream->parser->implementation->next_structural_index];
     size_t svlen = next_doc_index - current_index();
-    // Trim trailing whitespace, NUL, and RS (0x1E). In RFC 7464 json_sequence
-    // mode the scanner classifies RS as a scalar character, so an RS-prefixed
-    // scalar document (number/true/false/null/string) has no closing structural
-    // index and the slice runs all the way up to the next document's RS. RS
-    // cannot legally appear in a JSON value at the source level (control
-    // characters in strings must be escaped as \u001E), so stripping it is
-    // safe in every stream_format.
-    while(svlen > 1 && (std::isspace(start[svlen-1]) || start[svlen-1] == '\0' || static_cast<uint8_t>(start[svlen-1]) == 0x1E)) {
+    while(svlen > 1 && (std::isspace(start[svlen-1]) || start[svlen-1] == '\0')) {
       svlen--;
     }
     return std::string_view(start, svlen);
@@ -284,35 +274,10 @@ inline size_t document_stream::next_batch_start() const noexcept {
 
 inline error_code document_stream::run_stage1(dom::parser &p, size_t _batch_start) noexcept {
   size_t remaining = len - _batch_start;
-  stage1_mode mode;
   if (remaining <= batch_size) {
-    // Final batch
-    switch (format) {
-      case stream_format::json_sequence:
-        mode = stage1_mode::json_sequence_final;
-        break;
-      case stream_format::comma_delimited:
-        mode = stage1_mode::comma_delimited_final;
-        break;
-      default:
-        mode = stage1_mode::streaming_final;
-        break;
-    }
-    return p.implementation->stage1(&buf[_batch_start], remaining, mode);
+    return p.implementation->stage1(&buf[_batch_start], remaining, stage1_mode::streaming_final);
   } else {
-    // Partial batch
-    switch (format) {
-      case stream_format::json_sequence:
-        mode = stage1_mode::json_sequence_partial;
-        break;
-      case stream_format::comma_delimited:
-        mode = stage1_mode::comma_delimited_partial;
-        break;
-      default:
-        mode = stage1_mode::streaming_partial;
-        break;
-    }
-    return p.implementation->stage1(&buf[_batch_start], batch_size, mode);
+    return p.implementation->stage1(&buf[_batch_start], batch_size, stage1_mode::streaming_partial);
   }
 }
 

include/simdjson/dom/document_stream.h

@@ -206,14 +206,12 @@ private:
    * @param buf is the raw byte buffer we need to process
    * @param len is the length of the raw byte buffer in bytes
    * @param batch_size is the size of the windows (must be strictly greater or equal to the largest JSON document)
-   * @param format is the stream format
    */
   simdjson_inline document_stream(
     dom::parser &parser,
     const uint8_t *buf,
     size_t len,
-    size_t batch_size,
-    stream_format format = stream_format::whitespace_delimited
+    size_t batch_size
   ) noexcept;
 
   /**
@@ -263,8 +261,6 @@ private:
   const uint8_t *buf;
   size_t len;
   size_t batch_size;
-  /** The stream format. */
-  stream_format format;
   /** The error (or lack thereof) from the current document. */
   error_code error;
   size_t batch_start{0};

include/simdjson/dom/parser-inl.h

@@ -170,7 +170,12 @@ simdjson_inline simdjson_result<element> parser::parse(const padded_string_view
 }
 
 inline simdjson_result<document_stream> parser::parse_many(const uint8_t *buf, size_t len, size_t batch_size) noexcept {
-  return parse_many(buf, len, batch_size, stream_format::whitespace_delimited);
+  if(batch_size < MINIMAL_BATCH_SIZE) { batch_size = MINIMAL_BATCH_SIZE; }
+  if((len >= 3) && (std::memcmp(buf, "\xEF\xBB\xBF", 3) == 0)) {
+    buf += 3;
+    len -= 3;
+  }
+  return document_stream(*this, buf, len, batch_size);
 }
 inline simdjson_result<document_stream> parser::parse_many(const char *buf, size_t len, size_t batch_size) noexcept {
   return parse_many(reinterpret_cast<const uint8_t *>(buf), len, batch_size);
@@ -182,42 +187,6 @@ inline simdjson_result<document_stream> parser::parse_many(const padded_string &
   return parse_many(s.data(), s.length(), batch_size);
 }
 
-inline simdjson_result<document_stream> parser::parse_many(const uint8_t *buf, size_t len, size_t batch_size, stream_format format) noexcept {
-  if(batch_size < MINIMAL_BATCH_SIZE) { batch_size = MINIMAL_BATCH_SIZE; }
-  if((len >= 3) && (std::memcmp(buf, "\xEF\xBB\xBF", 3) == 0)) {
-    buf += 3;
-    len -= 3;
-  }
-  if (format == stream_format::comma_delimited_array) {
-    // Strip leading JSON whitespace.
-    while (len > 0 && (buf[0] == ' ' || buf[0] == '\t' || buf[0] == '\n' || buf[0] == '\r')) {
-      buf++; len--;
-    }
-    // Expect the opening '['.
-    if (len == 0 || buf[0] != '[') { return TAPE_ERROR; }
-    buf++; len--;
-    // Strip trailing JSON whitespace.
-    while (len > 0 && (buf[len-1] == ' ' || buf[len-1] == '\t' || buf[len-1] == '\n' || buf[len-1] == '\r')) {
-      len--;
-    }
-    // Expect the closing ']'.
-    if (len == 0 || buf[len-1] != ']') { return TAPE_ERROR; }
-    len--;
-    // Fall through to comma_delimited over the array contents.
-    format = stream_format::comma_delimited;
-  }
-  return document_stream(*this, buf, len, batch_size, format);
-}
-inline simdjson_result<document_stream> parser::parse_many(const char *buf, size_t len, size_t batch_size, stream_format format) noexcept {
-  return parse_many(reinterpret_cast<const uint8_t *>(buf), len, batch_size, format);
-}
-inline simdjson_result<document_stream> parser::parse_many(const std::string &s, size_t batch_size, stream_format format) noexcept {
-  return parse_many(s.data(), s.length(), batch_size, format);
-}
-inline simdjson_result<document_stream> parser::parse_many(const padded_string &s, size_t batch_size, stream_format format) noexcept {
-  return parse_many(s.data(), s.length(), batch_size, format);
-}
-
 simdjson_inline size_t parser::capacity() const noexcept {
   return implementation ? implementation->capacity() : 0;
 }

include/simdjson/dom/parser.h

@@ -494,23 +494,6 @@ public:
   /** @private We do not want to allow implicit conversion from C string to std::string. */
   simdjson_result<document_stream> parse_many(const char *buf, size_t batch_size = dom::DEFAULT_BATCH_SIZE) noexcept = delete;
 
-  /**
-   * Parse a stream of JSON documents with explicit format specification.
-   *
-   * @param buf The concatenated JSON documents.
-   * @param len The length of the buffer.
-   * @param batch_size The batch size to use.
-   * @param format The stream format.
-   * @return A stream of documents, or an error.
-   */
-  inline simdjson_result<document_stream> parse_many(const uint8_t *buf, size_t len, size_t batch_size, stream_format format) noexcept;
-  /** @overload parse_many(const uint8_t *buf, size_t len, size_t batch_size, stream_format format) */
-  inline simdjson_result<document_stream> parse_many(const char *buf, size_t len, size_t batch_size, stream_format format) noexcept;
-  /** @overload parse_many(const uint8_t *buf, size_t len, size_t batch_size, stream_format format) */
-  inline simdjson_result<document_stream> parse_many(const std::string &s, size_t batch_size, stream_format format) noexcept;
-  /** @overload parse_many(const uint8_t *buf, size_t len, size_t batch_size, stream_format format) */
-  inline simdjson_result<document_stream> parse_many(const padded_string &s, size_t batch_size, stream_format format) noexcept;
-
   /**
    * Ensure this parser has enough memory to process JSON documents up to `capacity` bytes in length
    * and `max_depth` depth.

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> && ! concepts::optional_type<T> && !require_custom_serialization<T>)
+  requires(concepts::container_but_not_string<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
-  static constexpr auto enumerators = std::define_static_array(std::meta::enumerators_of(^^T));
+  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,23 +294,30 @@ 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
-  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) {
+  template for (constexpr auto mem : std::define_static_array(
+      std::meta::nonstatic_data_members_of(^^T, std::meta::access_context::unchecked()))) {
+
     if constexpr (std::meta::is_public(mem)) {
-      static constexpr std::string_view key = std::define_static_string(std::meta::identifier_of(mem));
+      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 (((FieldNames.view() == key) || ...)) {
+      if constexpr (should_extract(key)) {
         if (!first) {
           b.append(',');
         }
         first = false;
 
         // Serialize the key
-        static constexpr auto quoted_key = std::define_static_string(constevalutil::consteval_to_quoted_escaped(std::meta::identifier_of(mem)));
+        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;
 }
 
-inline void string_builder::grow_buffer(size_t desired_capacity) {
+simdjson_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 && !concepts::optional_type<R> && !require_custom_serialization<R>)
+  requires(!std::is_convertible<R, std::string_view>::value && !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 && !concepts::optional_type<R> && !require_custom_serialization<R>)
+requires (!std::is_convertible<R, std::string_view>::value && !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.
    */
-  inline void grow_buffer(size_t desired_capacity);
+  simdjson_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/dom_parser_implementation.h

@@ -74,7 +74,6 @@ inline simdjson_warn_unused error_code dom_parser_implementation::set_capacity(s
 }
 
 inline simdjson_warn_unused error_code dom_parser_implementation::set_max_depth(size_t max_depth) noexcept {
-  if(max_depth > SIMDJSON_MAX_DEPTH) { return CAPACITY; }
   // Stage 2 stacks
   open_containers.reset(new (std::nothrow) open_container[max_depth]);
   is_array.reset(new (std::nothrow) bool[max_depth]);

include/simdjson/generic/ondemand/amalgamated.h

@@ -22,7 +22,6 @@
 #include "simdjson/generic/ondemand/field.h"
 #include "simdjson/generic/ondemand/object.h"
 #include "simdjson/generic/ondemand/object_iterator.h"
-#include "simdjson/generic/ondemand/ranges.h"
 #include "simdjson/generic/ondemand/serialization.h"
 
 // Deserialization for standard types
@@ -40,7 +39,6 @@
 #include "simdjson/generic/ondemand/logger-inl.h"
 #include "simdjson/generic/ondemand/object-inl.h"
 #include "simdjson/generic/ondemand/object_iterator-inl.h"
-#include "simdjson/generic/ondemand/ranges-inl.h"
 #include "simdjson/generic/ondemand/parser-inl.h"
 #include "simdjson/generic/ondemand/raw_json_string-inl.h"
 #include "simdjson/generic/ondemand/token_iterator-inl.h"

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

@@ -170,46 +170,34 @@ inline simdjson_result<value> array::at_path(std::string_view json_path) noexcep
   return at_pointer(json_pointer);
 }
 
-inline simdjson_result<std::vector<value>> array::at_path_with_wildcard(std::string_view json_path) noexcept {
-  std::vector<value> result;
-
+#if SIMDJSON_SUPPORTS_CONCEPTS
+template <typename Func>
+  requires std::invocable<Func, value>
+#else
+template <typename Func>
+#endif
+inline error_code array::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept {
   auto result_pair = get_next_key_and_json_path(json_path);
   std::string_view key = result_pair.first;
   std::string_view remaining_path = result_pair.second;
   // Wildcard case
-  if(key=="*"){
-    for(auto element: *this){
-
-      if(element.error()){
-        return element.error();
-      }
-
-      if(remaining_path.empty()){
-        // Use value_unsafe() because we've already checked for errors above.
-        // The 'element' is a simdjson_result<value> wrapper, and we need to extract
-        // the underlying value. value_unsafe() is safe here because error() returned false.
-        result.push_back(std::move(element).value_unsafe());
-
-      }else{
-        auto nested_result = element.at_path_with_wildcard(remaining_path);
-
-        if(nested_result.error()){
-          return nested_result.error();
-        }
-        // Same logic as above.
-        std::vector<value> nested_matches = std::move(nested_result).value_unsafe();
-
-        result.insert(result.end(),
-                      std::make_move_iterator(nested_matches.begin()),
-                      std::make_move_iterator(nested_matches.end()));
+  if (key=="*"){
+    for(auto element: *this) {
+      value val;
+        SIMDJSON_TRY(element.get(val));
+      if (remaining_path.empty()) {
+        callback(val);
+      } else {
+        error_code err = element.for_each_at_path_with_wildcard(remaining_path, callback);
+        if(err) { return err; }
       }
     }
-    return result;
-  }else{
+    return SUCCESS;
+  } else {
     // Specific index case in which we access the element at the given index
-    size_t idx=0;
+    size_t idx = 0;
 
-    for(char c:key){
+    for (char c : key) {
       if(c < '0' || c > '9'){
         return INVALID_JSON_POINTER;
       }
@@ -217,16 +205,13 @@ inline simdjson_result<std::vector<value>> array::at_path_with_wildcard(std::str
     }
 
     auto element = at(idx);
-
-    if(element.error()){
-      return element.error();
-    }
-
-    if(remaining_path.empty()){
-      result.push_back(std::move(element).value_unsafe());
-      return result;
-    }else{
-      return element.at_path_with_wildcard(remaining_path);
+    value val;
+    SIMDJSON_TRY(element.get(val));
+    if (remaining_path.empty()){
+      callback(val);
+      return SUCCESS;
+    } else {
+      return element.for_each_at_path_with_wildcard(remaining_path, callback);
     }
   }
 }
@@ -289,9 +274,15 @@ simdjson_inline  simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> simdj
   if (error()) { return error(); }
   return first.at_path(json_path);
 }
-simdjson_inline simdjson_result<std::vector<SIMDJSON_IMPLEMENTATION::ondemand::value>> simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::array>::at_path_with_wildcard(std::string_view json_path) noexcept {
+#if SIMDJSON_SUPPORTS_CONCEPTS
+template <typename Func>
+  requires std::invocable<Func, SIMDJSON_IMPLEMENTATION::ondemand::value>
+#else
+template <typename Func>
+#endif
+simdjson_inline error_code simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::array>::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept {
   if (error()) { return error(); }
-  return first.at_path_with_wildcard(json_path);
+  return first.for_each_at_path_with_wildcard(json_path, std::forward<Func>(callback));
 }
 simdjson_inline  simdjson_result<std::string_view> simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::array>::raw_json() noexcept {
   if (error()) { return error(); }

include/simdjson/generic/ondemand/array.h

@@ -119,13 +119,21 @@ public:
   inline simdjson_result<value> at_path(std::string_view json_path) noexcept;
 
   /**
-   * Get all values matching the given JSONPath expression with wildcard support.
+   * Call the provided callback for each value matching the given JSONPath
+   * expression with wildcard support.
    * Supports wildcard patterns like "[*]" to match all array elements.
    *
    * @param json_path JSONPath expression with wildcards
-   * @return Vector of values matching the wildcard pattern
+   * @param callback Function called for each matching value
+   * @return error_code indicating success or failure
   */
-  inline simdjson_result<std::vector<value>> at_path_with_wildcard(std::string_view json_path) noexcept;
+#if SIMDJSON_SUPPORTS_CONCEPTS
+  template <typename Func>
+    requires std::invocable<Func, value>
+#else
+  template <typename Func>
+#endif
+  inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept;
 
   /**
    * Consumes the array and returns a string_view instance corresponding to the
@@ -249,7 +257,13 @@ public:
   simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> at(size_t index) noexcept;
   simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> at_pointer(std::string_view json_pointer) noexcept;
   simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> at_path(std::string_view json_path) noexcept;
-  simdjson_inline simdjson_result<std::vector<SIMDJSON_IMPLEMENTATION::ondemand::value>> at_path_with_wildcard(std::string_view json_path) noexcept;
+#if SIMDJSON_SUPPORTS_CONCEPTS
+  template <typename Func>
+    requires std::invocable<Func, SIMDJSON_IMPLEMENTATION::ondemand::value>
+#else
+  template <typename Func>
+#endif
+  simdjson_inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept;
   simdjson_inline simdjson_result<std::string_view> raw_json() noexcept;
 #if SIMDJSON_SUPPORTS_CONCEPTS
   // TODO: move this code into object-inl.h

include/simdjson/generic/ondemand/base.h

@@ -40,13 +40,6 @@ class token_iterator;
 class value;
 class value_iterator;
 
-#if SIMDJSON_SUPPORTS_RANGES
-class array_range;
-class array_range_iterator;
-class object_range;
-class object_range_iterator;
-#endif // SIMDJSON_SUPPORTS_RANGES
-
 } // namespace ondemand
 } // namespace SIMDJSON_IMPLEMENTATION
 } // namespace simdjson

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

@@ -365,8 +365,14 @@ simdjson_inline simdjson_result<value> document::at_path(std::string_view json_p
   }
 }
 
-simdjson_inline simdjson_result<std::vector<value>> document::at_path_with_wildcard(std::string_view json_path) noexcept {
-  rewind(); // Rewind the document each time at_path_with_wildcard is called
+#if SIMDJSON_SUPPORTS_CONCEPTS
+template <typename Func>
+  requires std::invocable<Func, value>
+#else
+template <typename Func>
+#endif
+simdjson_inline error_code document::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept {
+  rewind(); // Rewind the document each time for_each_at_path_with_wildcard is called
   if (json_path.empty()) {
       return INVALID_JSON_POINTER;
   }
@@ -374,9 +380,9 @@ simdjson_inline simdjson_result<std::vector<value>> document::at_path_with_wildc
   SIMDJSON_TRY(type().get(t));
   switch (t) {
   case json_type::array:
-      return (*this).get_array().at_path_with_wildcard(json_path);
+      return (*this).get_array().for_each_at_path_with_wildcard(json_path, std::forward<Func>(callback));
   case json_type::object:
-      return (*this).get_object().at_path_with_wildcard(json_path);
+      return (*this).get_object().for_each_at_path_with_wildcard(json_path, std::forward<Func>(callback));
   default:
       return INVALID_JSON_POINTER;
   }
@@ -653,27 +659,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.get_uint64();
+  return first;
 }
 simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document>::operator int64_t() noexcept(false) {
   if (error()) { throw simdjson_error(error()); }
-  return first.get_int64();
+  return first;
 }
 simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document>::operator double() noexcept(false) {
   if (error()) { throw simdjson_error(error()); }
-  return first.get_double();
+  return first;
 }
 simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document>::operator std::string_view() noexcept(false) {
   if (error()) { throw simdjson_error(error()); }
-  return first.get_string();
+  return first;
 }
 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.get_raw_json_string();
+  return first;
 }
 simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document>::operator bool() noexcept(false) {
   if (error()) { throw simdjson_error(error()); }
-  return first.get_bool();
+  return first;
 }
 simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document>::operator SIMDJSON_IMPLEMENTATION::ondemand::value() noexcept(false) {
   if (error()) { throw simdjson_error(error()); }
@@ -713,9 +719,15 @@ simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> simdjs
   return first.at_path(json_path);
 }
 
-simdjson_inline simdjson_result<std::vector<SIMDJSON_IMPLEMENTATION::ondemand::value>> simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document>::at_path_with_wildcard(std::string_view json_path) noexcept {
+#if SIMDJSON_SUPPORTS_CONCEPTS
+template <typename Func>
+  requires std::invocable<Func, SIMDJSON_IMPLEMENTATION::ondemand::value>
+#else
+template <typename Func>
+#endif
+simdjson_inline error_code simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document>::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept {
   if (error()) { return error(); }
-  return first.at_path_with_wildcard(json_path);
+  return first.for_each_at_path_with_wildcard(json_path, std::forward<Func>(callback));
 }
 
 #if SIMDJSON_STATIC_REFLECTION
@@ -826,7 +838,13 @@ simdjson_inline simdjson_result<number> document_reference::get_number() noexcep
 simdjson_inline simdjson_result<std::string_view> document_reference::raw_json_token() noexcept { return doc->raw_json_token(); }
 simdjson_inline simdjson_result<value> document_reference::at_pointer(std::string_view json_pointer) noexcept { return doc->at_pointer(json_pointer); }
 simdjson_inline simdjson_result<value> document_reference::at_path(std::string_view json_path) noexcept { return doc->at_path(json_path); }
-simdjson_inline simdjson_result<std::vector<value>> document_reference::at_path_with_wildcard(std::string_view json_path) noexcept { return doc->at_path_with_wildcard(json_path); }
+#if SIMDJSON_SUPPORTS_CONCEPTS
+template <typename Func>
+  requires std::invocable<Func, value>
+#else
+template <typename Func>
+#endif
+simdjson_inline error_code document_reference::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept { return doc->for_each_at_path_with_wildcard(json_path, std::forward<Func>(callback)); }
 simdjson_inline simdjson_result<std::string_view> document_reference::raw_json() noexcept { return doc->raw_json();}
 simdjson_inline document_reference::operator document&() const noexcept { return *doc; }
 #if SIMDJSON_SUPPORTS_CONCEPTS && SIMDJSON_STATIC_REFLECTION
@@ -1042,27 +1060,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.get_uint64();
+  return first;
 }
 simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document_reference>::operator int64_t() noexcept(false) {
   if (error()) { throw simdjson_error(error()); }
-  return first.get_int64();
+  return first;
 }
 simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document_reference>::operator double() noexcept(false) {
   if (error()) { throw simdjson_error(error()); }
-  return first.get_double();
+  return first;
 }
 simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document_reference>::operator std::string_view() noexcept(false) {
   if (error()) { throw simdjson_error(error()); }
-  return first.get_string();
+  return first;
 }
 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.get_raw_json_string();
+  return first;
 }
 simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document_reference>::operator bool() noexcept(false) {
   if (error()) { throw simdjson_error(error()); }
-  return first.get_bool();
+  return first;
 }
 simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document_reference>::operator SIMDJSON_IMPLEMENTATION::ondemand::value() noexcept(false) {
   if (error()) { throw simdjson_error(error()); }
@@ -1091,11 +1109,17 @@ simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> simdjs
   }
   return first.at_path(json_path);
 }
-simdjson_inline simdjson_result<std::vector<SIMDJSON_IMPLEMENTATION::ondemand::value>> simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document_reference>::at_path_with_wildcard(std::string_view json_path) noexcept {
+#if SIMDJSON_SUPPORTS_CONCEPTS
+template <typename Func>
+  requires std::invocable<Func, SIMDJSON_IMPLEMENTATION::ondemand::value>
+#else
+template <typename Func>
+#endif
+simdjson_inline error_code simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document_reference>::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept {
   if (error()) {
       return error();
   }
-  return first.at_path_with_wildcard(json_path);
+  return first.for_each_at_path_with_wildcard(json_path, std::forward<Func>(callback));
 }
 #if SIMDJSON_STATIC_REFLECTION
 template<constevalutil::fixed_string... FieldNames, typename T>

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.
    */
-  explicit simdjson_inline operator uint64_t() noexcept(false);
+  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.
    */
-  explicit simdjson_inline operator int64_t() noexcept(false);
+  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.
    */
-  explicit simdjson_inline operator double() noexcept(false);
+  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.
    */
-  explicit simdjson_inline operator std::string_view() noexcept(false) simdjson_lifetime_bound;
+  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.
    */
-  explicit simdjson_inline operator raw_json_string() noexcept(false) simdjson_lifetime_bound;
+  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.
    */
-  explicit simdjson_inline operator bool() noexcept(false);
+  simdjson_inline operator bool() noexcept(false);
   /**
    * Cast this JSON value to a value when the document is an object or an array.
    *
@@ -744,21 +744,24 @@ public:
   simdjson_inline simdjson_result<value> at_path(std::string_view json_path) noexcept;
 
   /**
-   * Get all values matching the given JSONPath expression with wildcard support.
+   * Call the provided callback for each value matching the given JSONPath
+   * expression with wildcard support.
    *
    * Supports wildcard patterns like "$.array[*]" or "$.object.*" to match multiple elements.
    *
-   * This method materializes all matching values into a vector.
    * The document will be consumed after this call.
    *
    * @param json_path JSONPath expression with wildcards
-   * @return Vector of values matching the wildcard pattern, or:
-   *         - INVALID_JSON_POINTER if the JSONPath cannot be parsed
-   *         - NO_SUCH_FIELD if a field does not exist
-   *         - INDEX_OUT_OF_BOUNDS if an array index is out of bounds
-   *         - INCORRECT_TYPE if path traversal encounters wrong type
+   * @param callback Function called for each matching value
+   * @return error_code indicating success or failure
    */
-  simdjson_inline simdjson_result<std::vector<value>> at_path_with_wildcard(std::string_view json_path) noexcept;
+#if SIMDJSON_SUPPORTS_CONCEPTS
+  template <typename Func>
+    requires std::invocable<Func, value>
+#else
+  template <typename Func>
+#endif
+  simdjson_inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept;
 
   /**
    * Consumes the document and returns a string_view instance corresponding to the
@@ -945,12 +948,12 @@ public:
   explicit simdjson_inline operator T() noexcept(false);
   simdjson_inline operator array() & noexcept(false);
   simdjson_inline operator object() & 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 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);
   simdjson_inline operator value() noexcept(false);
 #endif
   simdjson_inline simdjson_result<size_t> count_elements() & noexcept;
@@ -979,7 +982,13 @@ public:
   simdjson_inline simdjson_result<std::string_view> raw_json_token() noexcept;
   simdjson_inline simdjson_result<value> at_pointer(std::string_view json_pointer) noexcept;
   simdjson_inline simdjson_result<value> at_path(std::string_view json_path) noexcept;
-  simdjson_inline simdjson_result<std::vector<value>> at_path_with_wildcard(std::string_view json_path) noexcept;
+#if SIMDJSON_SUPPORTS_CONCEPTS
+  template <typename Func>
+    requires std::invocable<Func, value>
+#else
+  template <typename Func>
+#endif
+  simdjson_inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept;
 
 private:
   document *doc{nullptr};
@@ -1030,12 +1039,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);
-  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 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);
   simdjson_inline operator SIMDJSON_IMPLEMENTATION::ondemand::value() noexcept(false);
 #endif
   simdjson_inline simdjson_result<size_t> count_elements() & noexcept;
@@ -1065,7 +1074,13 @@ public:
 
   simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> at_pointer(std::string_view json_pointer) noexcept;
   simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> at_path(std::string_view json_path) noexcept;
-  simdjson_inline simdjson_result<std::vector<SIMDJSON_IMPLEMENTATION::ondemand::value>> at_path_with_wildcard(std::string_view json_path) noexcept;
+#if SIMDJSON_SUPPORTS_CONCEPTS
+  template <typename Func>
+    requires std::invocable<Func, SIMDJSON_IMPLEMENTATION::ondemand::value>
+#else
+  template <typename Func>
+#endif
+  simdjson_inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept;
 #if SIMDJSON_STATIC_REFLECTION
   template<constevalutil::fixed_string... FieldNames, typename T>
     requires(std::is_class_v<T> && (sizeof...(FieldNames) > 0))
@@ -1116,12 +1131,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);
-  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 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);
   simdjson_inline operator SIMDJSON_IMPLEMENTATION::ondemand::value() noexcept(false);
 #endif
   simdjson_inline simdjson_result<size_t> count_elements() & noexcept;
@@ -1150,7 +1165,13 @@ public:
 
   simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> at_pointer(std::string_view json_pointer) noexcept;
   simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> at_path(std::string_view json_path) noexcept;
-  simdjson_inline simdjson_result<std::vector<SIMDJSON_IMPLEMENTATION::ondemand::value>> at_path_with_wildcard(std::string_view json_path) noexcept;
+#if SIMDJSON_SUPPORTS_CONCEPTS
+  template <typename Func>
+    requires std::invocable<Func, SIMDJSON_IMPLEMENTATION::ondemand::value>
+#else
+  template <typename Func>
+#endif
+  simdjson_inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept;
 #if SIMDJSON_STATIC_REFLECTION
   template<constevalutil::fixed_string... FieldNames, typename T>
     requires(std::is_class_v<T> && (sizeof...(FieldNames) > 0))

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

@@ -95,15 +95,13 @@ simdjson_inline document_stream::document_stream(
   const uint8_t *_buf,
   size_t _len,
   size_t _batch_size,
-  bool _allow_comma_separated,
-  stream_format _format
+  bool _allow_comma_separated
 ) noexcept
   : parser{&_parser},
     buf{_buf},
     len{_len},
     batch_size{_batch_size <= MINIMAL_BATCH_SIZE ? MINIMAL_BATCH_SIZE : _batch_size},
     allow_comma_separated{_allow_comma_separated},
-    format{_format},
     error{SUCCESS}
     #ifdef SIMDJSON_THREADS_ENABLED
     , use_thread(_parser.threaded) // we need to make a copy because _parser.threaded can change
@@ -122,7 +120,6 @@ simdjson_inline document_stream::document_stream() noexcept
     len{0},
     batch_size{0},
     allow_comma_separated{false},
-    format{stream_format::whitespace_delimited},
     error{UNINITIALIZED}
     #ifdef SIMDJSON_THREADS_ENABLED
     , use_thread(false)
@@ -222,10 +219,7 @@ inline void document_stream::start() noexcept {
     error = run_stage1(*parser, batch_start);
   }
   if (error) { return; }
-  // For json_sequence mode, structural_indexes[0] points to the actual JSON value
-  // after the RS delimiter and any following whitespace. For regular mode, it is
-  // the offset from batch_start to the first document in the batch.
-  doc_index = batch_start + parser->implementation->structural_indexes[0];
+  doc_index = batch_start;
   doc = document(json_iterator(&buf[batch_start], parser));
   doc.iter._streaming = true;
 
@@ -306,7 +300,7 @@ inline void document_stream::next() noexcept {
        */
 
       if (error) { continue; } // If the error was EMPTY, we may want to load another batch.
-      doc_index = batch_start + parser->implementation->structural_indexes[0];
+      doc_index = batch_start;
     }
   }
 }
@@ -335,35 +329,10 @@ inline error_code document_stream::run_stage1(ondemand::parser &p, size_t _batch
   // This code only updates the structural index in the parser, it does not update any json_iterator
   // instance.
   size_t remaining = len - _batch_start;
-  stage1_mode mode;
   if (remaining <= batch_size) {
-    // Final batch
-    switch (format) {
-      case stream_format::json_sequence:
-        mode = stage1_mode::json_sequence_final;
-        break;
-      case stream_format::comma_delimited:
-        mode = stage1_mode::comma_delimited_final;
-        break;
-      default:
-        mode = stage1_mode::streaming_final;
-        break;
-    }
-    return p.implementation->stage1(&buf[_batch_start], remaining, mode);
+    return p.implementation->stage1(&buf[_batch_start], remaining, stage1_mode::streaming_final);
   } else {
-    // Partial batch
-    switch (format) {
-      case stream_format::json_sequence:
-        mode = stage1_mode::json_sequence_partial;
-        break;
-      case stream_format::comma_delimited:
-        mode = stage1_mode::comma_delimited_partial;
-        break;
-      default:
-        mode = stage1_mode::streaming_partial;
-        break;
-    }
-    return p.implementation->stage1(&buf[_batch_start], batch_size, mode);
+    return p.implementation->stage1(&buf[_batch_start], batch_size, stage1_mode::streaming_partial);
   }
 }
 
@@ -384,21 +353,14 @@ simdjson_inline std::string_view document_stream::iterator::source() const noexc
         depth--;
         break;
       default:    // Scalar value document
+        // TODO: We could remove trailing whitespaces
         // This returns a string spanning from start of value to the beginning of the next document (excluded)
         {
           auto next_index = stream->parser->implementation->structural_indexes[++cur_struct_index];
           // normally the length would be next_index - current_index() - 1, except for the last document
           size_t svlen = next_index - current_index();
           const char *start = reinterpret_cast<const char*>(stream->buf) + current_index();
-          // Trim trailing whitespace, NUL, and RS (0x1E). In RFC 7464
-          // json_sequence mode the scanner classifies RS as a scalar
-          // character, so an RS-prefixed scalar document (number / true /
-          // false / null / string) has no closing structural index and the
-          // slice runs all the way up to the next document's RS. RS cannot
-          // legally appear in a JSON value at the source level (control
-          // characters in strings must be escaped as \u001E), so stripping
-          // it is safe in every stream_format.
-          while(svlen > 1 && (std::isspace(start[svlen-1]) || start[svlen-1] == '\0' || static_cast<uint8_t>(start[svlen-1]) == 0x1E)) {
+          while(svlen > 1 && (std::isspace(start[svlen-1]) || start[svlen-1] == '\0')) {
             svlen--;
           }
           return std::string_view(start, svlen);
@@ -479,4 +441,4 @@ simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document_stre
 
 }
 
-#endif // SIMDJSON_GENERIC_ONDEMAND_DOCUMENT_STREAM_INL_H
+#endif // SIMDJSON_GENERIC_ONDEMAND_DOCUMENT_STREAM_INL_H

include/simdjson/generic/ondemand/document_stream.h

@@ -229,16 +229,13 @@ private:
    * @param buf is the raw byte buffer we need to process
    * @param len is the length of the raw byte buffer in bytes
    * @param batch_size is the size of the windows (must be strictly greater or equal to the largest JSON document)
-   * @param allow_comma_separated whether to allow comma-separated documents
-   * @param format the stream format
    */
   simdjson_inline document_stream(
     ondemand::parser &parser,
     const uint8_t *buf,
     size_t len,
     size_t batch_size,
-    bool allow_comma_separated,
-    stream_format format = stream_format::whitespace_delimited
+    bool allow_comma_separated
   ) noexcept;
 
   /**
@@ -287,7 +284,6 @@ private:
   size_t len;
   size_t batch_size;
   bool allow_comma_separated;
-  stream_format format;
   /**
    * We are going to use just one document instance. The document owns
    * the json_iterator. It implies that we only ever pass a reference

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

@@ -177,9 +177,13 @@ inline simdjson_result<value> object::at_path(std::string_view json_path) noexce
   return at_pointer(json_pointer);
 }
 
-inline simdjson_result<std::vector<value>> object::at_path_with_wildcard(std::string_view json_path) noexcept {
-  std::vector<value> result;
-
+#if SIMDJSON_SUPPORTS_CONCEPTS
+template <typename Func>
+  requires std::invocable<Func, value>
+#else
+template <typename Func>
+#endif
+inline error_code object::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept {
   auto result_pair = get_next_key_and_json_path(json_path);
   std::string_view key = result_pair.first;
   std::string_view remaining_path = result_pair.second;
@@ -189,34 +193,22 @@ inline simdjson_result<std::vector<value>> object::at_path_with_wildcard(std::st
     for (auto field : *this) {
       value val;
       SIMDJSON_TRY(field.value().get(val));
-
       if (remaining_path.empty()) {
-        result.push_back(std::move(val));
+        callback(val);
       } else {
-        auto nested_result = val.at_path_with_wildcard(remaining_path);
-
-        if (nested_result.error()) {
-          return nested_result.error();
-        }
-        // Extract and append all nested matches to our result
-        std::vector<value> nested_vec;
-        SIMDJSON_TRY(std::move(nested_result).get(nested_vec));
-
-        result.insert(result.end(),
-                     std::make_move_iterator(nested_vec.begin()),
-                     std::make_move_iterator(nested_vec.end()));
+        SIMDJSON_TRY(val.for_each_at_path_with_wildcard(remaining_path, callback));
       }
     }
-    return result;
+    return SUCCESS;
   } else {
     value val;
     SIMDJSON_TRY(find_field(key).get(val));
 
     if (remaining_path.empty()) {
-      result.push_back(std::move(val));
-      return result;
+      callback(val);
+      return SUCCESS;
     } else {
-      return val.at_path_with_wildcard(remaining_path);
+      return val.for_each_at_path_with_wildcard(remaining_path, callback);
     }
   }
 }
@@ -347,9 +339,15 @@ simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> simdjs
   return first.at_path(json_path);
 }
 
-simdjson_inline simdjson_result<std::vector<SIMDJSON_IMPLEMENTATION::ondemand::value>> simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::object>::at_path_with_wildcard(std::string_view json_path) noexcept {
+#if SIMDJSON_SUPPORTS_CONCEPTS
+template <typename Func>
+  requires std::invocable<Func, SIMDJSON_IMPLEMENTATION::ondemand::value>
+#else
+template <typename Func>
+#endif
+simdjson_inline error_code simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::object>::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept {
   if (error()) { return error(); }
-  return first.at_path_with_wildcard(json_path);
+  return first.for_each_at_path_with_wildcard(json_path, std::forward<Func>(callback));
 }
 
 inline simdjson_result<bool> simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::object>::reset() noexcept {

include/simdjson/generic/ondemand/object.h

@@ -172,13 +172,21 @@ public:
   inline simdjson_result<value> at_path(std::string_view json_path) noexcept;
 
   /**
-   * Get all values matching the given JSONPath expression with wildcard support.
+   * Call the provided callback for each value matching the given JSONPath
+   * expression with wildcard support.
    * Supports wildcard patterns like ".*" to match all object fields.
    *
    * @param json_path JSONPath expression with wildcards
-   * @return Vector of values matching the wildcard pattern
+   * @param callback Function called for each matching value
+   * @return error_code indicating success or failure
   */
-  inline simdjson_result<std::vector<value>> at_path_with_wildcard(std::string_view json_path) noexcept;
+#if SIMDJSON_SUPPORTS_CONCEPTS
+  template <typename Func>
+    requires std::invocable<Func, value>
+#else
+  template <typename Func>
+#endif
+  inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept;
 
   /**
    * Reset the iterator so that we are pointing back at the
@@ -328,7 +336,13 @@ public:
   simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> operator[](std::string_view key) && noexcept;
   simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> at_pointer(std::string_view json_pointer) noexcept;
   simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> at_path(std::string_view json_path) noexcept;
-  simdjson_inline simdjson_result<std::vector<SIMDJSON_IMPLEMENTATION::ondemand::value>> at_path_with_wildcard(std::string_view json_path) noexcept;
+#if SIMDJSON_SUPPORTS_CONCEPTS
+  template <typename Func>
+    requires std::invocable<Func, SIMDJSON_IMPLEMENTATION::ondemand::value>
+#else
+  template <typename Func>
+#endif
+  simdjson_inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept;
   inline simdjson_result<bool> reset() noexcept;
   inline simdjson_result<bool> is_empty() noexcept;
   inline simdjson_result<size_t> count_fields() & noexcept;

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

@@ -133,34 +133,6 @@ simdjson_warn_unused simdjson_inline simdjson_result<json_iterator> parser::iter
   return json_iterator(reinterpret_cast<const uint8_t *>(json.data()), this);
 }
 
-inline simdjson_result<document_stream> parser::iterate_many(const uint8_t *buf, size_t len, size_t batch_size) noexcept {
-  if(batch_size < MINIMAL_BATCH_SIZE) { batch_size = MINIMAL_BATCH_SIZE; }
-  if((len >= 3) && (std::memcmp(buf, "\xEF\xBB\xBF", 3) == 0)) {
-    buf += 3;
-    len -= 3;
-  }
-  return document_stream(*this, buf, len, batch_size, false, stream_format::whitespace_delimited);
-}
-inline simdjson_result<document_stream> parser::iterate_many(const char *buf, size_t len, size_t batch_size) noexcept {
-  return iterate_many(reinterpret_cast<const uint8_t *>(buf), len, batch_size);
-}
-inline simdjson_result<document_stream> parser::iterate_many(padded_string_view s, size_t batch_size) noexcept {
-  if (!s.has_sufficient_padding()) { return INSUFFICIENT_PADDING; }
-  return iterate_many(s.data(), s.length(), batch_size);
-}
-inline simdjson_result<document_stream> parser::iterate_many(const padded_string &s, size_t batch_size) noexcept {
-  return iterate_many(padded_string_view(s), batch_size);
-}
-inline simdjson_result<document_stream> parser::iterate_many(const std::string &s, size_t batch_size) noexcept {
-  return iterate_many(padded_string_view(s), batch_size);
-}
-inline simdjson_result<document_stream> parser::iterate_many(std::string &s, size_t batch_size) noexcept {
-  return iterate_many(pad(s), batch_size);
-}
-
-#ifndef SIMDJSON_DISABLE_DEPRECATED_API
-SIMDJSON_PUSH_DISABLE_WARNINGS
-SIMDJSON_DISABLE_DEPRECATED_WARNING
 inline simdjson_result<document_stream> parser::iterate_many(const uint8_t *buf, size_t len, size_t batch_size, bool allow_comma_separated) noexcept {
   // Warning: no check is done on the buffer padding. We trust the user.
   if(batch_size < MINIMAL_BATCH_SIZE) { batch_size = MINIMAL_BATCH_SIZE; }
@@ -168,11 +140,8 @@ inline simdjson_result<document_stream> parser::iterate_many(const uint8_t *buf,
     buf += 3;
     len -= 3;
   }
-  // Map allow_comma_separated to stream_format::comma_delimited
-  if (allow_comma_separated) {
-    return document_stream(*this, buf, len, batch_size, false, stream_format::comma_delimited);
-  }
-  return document_stream(*this, buf, len, batch_size, false, stream_format::whitespace_delimited);
+  if(allow_comma_separated && batch_size < len) { batch_size = len; }
+  return document_stream(*this, buf, len, batch_size, allow_comma_separated);
 }
 
 inline simdjson_result<document_stream> parser::iterate_many(const char *buf, size_t len, size_t batch_size, bool allow_comma_separated) noexcept {
@@ -192,48 +161,6 @@ inline simdjson_result<document_stream> parser::iterate_many(const std::string &
 inline simdjson_result<document_stream> parser::iterate_many(std::string &s, size_t batch_size, bool allow_comma_separated) noexcept {
   return iterate_many(pad(s), batch_size, allow_comma_separated);
 }
-SIMDJSON_POP_DISABLE_WARNINGS
-#endif // SIMDJSON_DISABLE_DEPRECATED_API
-
-inline simdjson_result<document_stream> parser::iterate_many(const uint8_t *buf, size_t len, size_t batch_size, stream_format format) noexcept {
-  if(batch_size < MINIMAL_BATCH_SIZE) { batch_size = MINIMAL_BATCH_SIZE; }
-  if((len >= 3) && (std::memcmp(buf, "\xEF\xBB\xBF", 3) == 0)) {
-    buf += 3;
-    len -= 3;
-  }
-  if (format == stream_format::comma_delimited_array) {
-    // Strip leading JSON whitespace.
-    while (len > 0 && (buf[0] == ' ' || buf[0] == '\t' || buf[0] == '\n' || buf[0] == '\r')) {
-      buf++; len--;
-    }
-    // Expect the opening '['.
-    if (len == 0 || buf[0] != '[') { return TAPE_ERROR; }
-    buf++; len--;
-    // Strip trailing JSON whitespace.
-    while (len > 0 && (buf[len-1] == ' ' || buf[len-1] == '\t' || buf[len-1] == '\n' || buf[len-1] == '\r')) {
-      len--;
-    }
-    // Expect the closing ']'.
-    if (len == 0 || buf[len-1] != ']') { return TAPE_ERROR; }
-    len--;
-    // Fall through to comma_delimited over the array contents.
-    format = stream_format::comma_delimited;
-  }
-  return document_stream(*this, buf, len, batch_size, false, format);
-}
-inline simdjson_result<document_stream> parser::iterate_many(const char *buf, size_t len, size_t batch_size, stream_format format) noexcept {
-  return iterate_many(reinterpret_cast<const uint8_t *>(buf), len, batch_size, format);
-}
-inline simdjson_result<document_stream> parser::iterate_many(padded_string_view s, size_t batch_size, stream_format format) noexcept {
-  if (!s.has_sufficient_padding()) { return INSUFFICIENT_PADDING; }
-  return iterate_many(s.data(), s.length(), batch_size, format);
-}
-inline simdjson_result<document_stream> parser::iterate_many(const std::string &s, size_t batch_size, stream_format format) noexcept {
-  return iterate_many(padded_string_view(s), batch_size, format);
-}
-inline simdjson_result<document_stream> parser::iterate_many(const padded_string &s, size_t batch_size, stream_format format) noexcept {
-  return iterate_many(padded_string_view(s), batch_size, format);
-}
 simdjson_pure simdjson_inline size_t parser::capacity() const noexcept {
   return _capacity;
 }
@@ -272,7 +199,7 @@ simdjson_inline simdjson_warn_unused ondemand::parser& parser::get_parser() {
   return *parser::get_parser_instance();
 }
 
-simdjson_inline bool release_parser() {
+simdjson_inline bool parser::release_parser() {
   auto &parser_instance = parser::get_threadlocal_parser_if_exists();
   if (parser_instance) {
     parser_instance.reset();

include/simdjson/generic/ondemand/parser.h

@@ -244,66 +244,32 @@ public:
    *                   spot is cache-related: small enough to fit in cache, yet big enough to
    *                   parse as many documents as possible in one tight loop.
    *                   Defaults to 10MB, which has been a reasonable sweet spot in our tests.
-   * @param allow_comma_separated @deprecated Use stream_format::comma_delimited instead.
-   *                   When true, maps internally to stream_format::comma_delimited.
-   *                   Defaults to false.
+   * @param allow_comma_separated (defaults on false) This allows a mode where the documents are
+   *                   separated by commas instead of whitespace. It comes with a performance
+   *                   penalty because the entire document is indexed at once (and the document must be
+   *                   less than 4 GB), and there is no multithreading. In this mode, the batch_size parameter
+   *                   is effectively ignored, as it is set to at least the document size.
    * @return The stream, or an error. An empty input will yield 0 documents rather than an EMPTY error. Errors:
    *         - MEMALLOC if the parser does not have enough capacity and memory allocation fails
    *         - CAPACITY if the parser does not have enough capacity and batch_size > max_capacity.
    *         - other json errors if parsing fails. You should not rely on these errors to always the same for the
    *           same document: they may vary under runtime dispatch (so they may vary depending on your system and hardware).
    */
-  inline simdjson_result<document_stream> iterate_many(const uint8_t *buf, size_t len, size_t batch_size = DEFAULT_BATCH_SIZE) noexcept;
-  /** @overload iterate_many(const uint8_t *buf, size_t len, size_t batch_size) */
-  inline simdjson_result<document_stream> iterate_many(padded_string_view json, size_t batch_size = DEFAULT_BATCH_SIZE) noexcept;
-  /** @overload iterate_many(const uint8_t *buf, size_t len, size_t batch_size) */
-  inline simdjson_result<document_stream> iterate_many(const char *buf, size_t len, size_t batch_size = DEFAULT_BATCH_SIZE) noexcept;
-  /** @overload iterate_many(const uint8_t *buf, size_t len, size_t batch_size) */
-  inline simdjson_result<document_stream> iterate_many(const std::string &s, size_t batch_size = DEFAULT_BATCH_SIZE) noexcept;
-  /** @overload iterate_many(const uint8_t *buf, size_t len, size_t batch_size)
+  inline simdjson_result<document_stream> iterate_many(const uint8_t *buf, size_t len, size_t batch_size = DEFAULT_BATCH_SIZE, bool allow_comma_separated = false) noexcept;
+  /** @overload parse_many(const uint8_t *buf, size_t len, size_t batch_size) */
+  inline simdjson_result<document_stream> iterate_many(padded_string_view json, size_t batch_size = DEFAULT_BATCH_SIZE, bool allow_comma_separated = false) noexcept;
+  /** @overload parse_many(const uint8_t *buf, size_t len, size_t batch_size) */
+  inline simdjson_result<document_stream> iterate_many(const char *buf, size_t len, size_t batch_size = DEFAULT_BATCH_SIZE, bool allow_comma_separated = false) noexcept;
+  /** @overload parse_many(const uint8_t *buf, size_t len, size_t batch_size) */
+  inline simdjson_result<document_stream> iterate_many(const std::string &s, size_t batch_size = DEFAULT_BATCH_SIZE, bool allow_comma_separated = false) noexcept;
+  /** @overload parse_many(const uint8_t *buf, size_t len, size_t batch_size)
     the string might be automatically padded with up to SIMDJSON_PADDING whitespace characters */
-  inline simdjson_result<document_stream> iterate_many(std::string &s, size_t batch_size = DEFAULT_BATCH_SIZE) noexcept;
-  /** @overload iterate_many(const uint8_t *buf, size_t len, size_t batch_size) */
-  inline simdjson_result<document_stream> iterate_many(const padded_string &s, size_t batch_size = DEFAULT_BATCH_SIZE) noexcept;
+  inline simdjson_result<document_stream> iterate_many(std::string &s, size_t batch_size = DEFAULT_BATCH_SIZE, bool allow_comma_separated = false) noexcept;
+  /** @overload parse_many(const uint8_t *buf, size_t len, size_t batch_size) */
+  inline simdjson_result<document_stream> iterate_many(const padded_string &s, size_t batch_size = DEFAULT_BATCH_SIZE, bool allow_comma_separated = false) noexcept;
   /** @private We do not want to allow implicit conversion from C string to std::string. */
   simdjson_result<document_stream> iterate_many(const char *buf, size_t batch_size = DEFAULT_BATCH_SIZE) noexcept = delete;
 
-#ifndef SIMDJSON_DISABLE_DEPRECATED_API
-  /**
-   * @deprecated Use iterate_many with stream_format::comma_delimited instead.
-   */
-  simdjson_deprecated inline simdjson_result<document_stream> iterate_many(const uint8_t *buf, size_t len, size_t batch_size, bool allow_comma_separated) noexcept;
-  /** @overload iterate_many(const uint8_t *buf, size_t len, size_t batch_size, bool allow_comma_separated) */
-  simdjson_deprecated inline simdjson_result<document_stream> iterate_many(padded_string_view json, size_t batch_size, bool allow_comma_separated) noexcept;
-  /** @overload iterate_many(const uint8_t *buf, size_t len, size_t batch_size, bool allow_comma_separated) */
-  simdjson_deprecated inline simdjson_result<document_stream> iterate_many(const char *buf, size_t len, size_t batch_size, bool allow_comma_separated) noexcept;
-  /** @overload iterate_many(const uint8_t *buf, size_t len, size_t batch_size, bool allow_comma_separated) */
-  simdjson_deprecated inline simdjson_result<document_stream> iterate_many(const std::string &s, size_t batch_size, bool allow_comma_separated) noexcept;
-  /** @overload iterate_many(const uint8_t *buf, size_t len, size_t batch_size, bool allow_comma_separated) */
-  simdjson_deprecated inline simdjson_result<document_stream> iterate_many(std::string &s, size_t batch_size, bool allow_comma_separated) noexcept;
-  /** @overload iterate_many(const uint8_t *buf, size_t len, size_t batch_size, bool allow_comma_separated) */
-  simdjson_deprecated inline simdjson_result<document_stream> iterate_many(const padded_string &s, size_t batch_size, bool allow_comma_separated) noexcept;
-#endif // SIMDJSON_DISABLE_DEPRECATED_API
-
-  /**
-   * Parse a stream of JSON documents with explicit format specification.
-   *
-   * @param buf The concatenated JSON documents.
-   * @param len The length of the buffer.
-   * @param batch_size The batch size to use.
-   * @param format The stream format (whitespace_delimited, json_sequence, or comma_delimited).
-   * @return A stream of documents, or an error.
-   */
-  inline simdjson_result<document_stream> iterate_many(const uint8_t *buf, size_t len, size_t batch_size, stream_format format) noexcept;
-  /** @overload iterate_many(const uint8_t *buf, size_t len, size_t batch_size, stream_format format) */
-  inline simdjson_result<document_stream> iterate_many(const char *buf, size_t len, size_t batch_size, stream_format format) noexcept;
-  /** @overload iterate_many(const uint8_t *buf, size_t len, size_t batch_size, stream_format format) */
-  inline simdjson_result<document_stream> iterate_many(padded_string_view s, size_t batch_size, stream_format format) noexcept;
-  /** @overload iterate_many(const uint8_t *buf, size_t len, size_t batch_size, stream_format format) */
-  inline simdjson_result<document_stream> iterate_many(const std::string &s, size_t batch_size, stream_format format) noexcept;
-  /** @overload iterate_many(const uint8_t *buf, size_t len, size_t batch_size, stream_format format) */
-  inline simdjson_result<document_stream> iterate_many(const padded_string &s, size_t batch_size, stream_format format) noexcept;
-
   /** The capacity of this parser (the largest document it can process). */
   simdjson_pure simdjson_inline size_t capacity() const noexcept;
   /** The maximum capacity of this parser (the largest document it is allowed to process). */
@@ -422,8 +388,6 @@ public:
   static simdjson_inline bool release_parser();
 
 private:
-  friend bool release_parser();
-  friend ondemand::parser& get_parser();
   /** Get the thread-local parser instance, allocates it if needed */
   static simdjson_inline simdjson_warn_unused std::unique_ptr<ondemand::parser>& get_parser_instance();
   /** Get the thread-local parser instance, it might be null */
@@ -459,4 +423,4 @@ public:
 
 } // namespace simdjson
 
-#endif // SIMDJSON_GENERIC_ONDEMAND_PARSER_H
+#endif // SIMDJSON_GENERIC_ONDEMAND_PARSER_H

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

@@ -1,138 +0,0 @@
-#ifndef SIMDJSON_GENERIC_ONDEMAND_RANGES_INL_H
-
-#ifndef SIMDJSON_CONDITIONAL_INCLUDE
-#define SIMDJSON_GENERIC_ONDEMAND_RANGES_INL_H
-#include "simdjson/generic/ondemand/base.h"
-#include "simdjson/generic/ondemand/ranges.h"
-#include "simdjson/generic/ondemand/array-inl.h"
-#include "simdjson/generic/ondemand/array_iterator-inl.h"
-#include "simdjson/generic/ondemand/object-inl.h"
-#include "simdjson/generic/ondemand/object_iterator-inl.h"
-#endif // SIMDJSON_CONDITIONAL_INCLUDE
-
-#if SIMDJSON_SUPPORTS_RANGES
-
-namespace simdjson {
-namespace SIMDJSON_IMPLEMENTATION {
-namespace ondemand {
-
-//
-// array_range_iterator
-//
-
-simdjson_inline array_range_iterator::array_range_iterator(array_iterator iter) noexcept
-  : iter_{iter} {}
-
-simdjson_inline simdjson_result<value> array_range_iterator::operator*() const noexcept {
-  return *iter_;
-}
-
-simdjson_inline array_range_iterator& array_range_iterator::operator++() noexcept {
-  ++iter_;
-  return *this;
-}
-
-SIMDJSON_PUSH_DISABLE_ALL_WARNINGS
-simdjson_inline void array_range_iterator::operator++(int) noexcept {
-  ++*this;
-}
-SIMDJSON_POP_DISABLE_WARNINGS
-
-//
-// array_range
-//
-
-simdjson_inline array_range::array_range(array& arr) noexcept {
-  auto b = arr.begin();
-  if (b.error()) { error_ = b.error(); return; }
-  begin_ = b.value_unsafe();
-  end_ = arr.end().value_unsafe();
-}
-
-simdjson_inline array_range_iterator array_range::begin() noexcept {
-  return array_range_iterator(begin_);
-}
-
-simdjson_inline array_range_iterator array_range::end() noexcept {
-  return array_range_iterator(end_);
-}
-
-//
-// object_range_iterator
-//
-
-simdjson_inline object_range_iterator::object_range_iterator(object_iterator iter) noexcept
-  : iter_{iter} {}
-
-simdjson_inline simdjson_result<field> object_range_iterator::operator*() const noexcept {
-  return *iter_;
-}
-
-simdjson_inline object_range_iterator& object_range_iterator::operator++() noexcept {
-  ++iter_;
-  return *this;
-}
-
-SIMDJSON_PUSH_DISABLE_ALL_WARNINGS
-simdjson_inline void object_range_iterator::operator++(int) noexcept {
-  ++*this;
-}
-SIMDJSON_POP_DISABLE_WARNINGS
-
-
-//
-// object_range
-//
-
-simdjson_inline object_range::object_range(object& obj) noexcept {
-  auto b = obj.begin();
-  if (b.error()) { error_ = b.error(); return; }
-  begin_ = b.value_unsafe();
-  end_ = obj.end().value_unsafe();
-}
-
-simdjson_inline object_range_iterator object_range::begin() noexcept {
-  return object_range_iterator(begin_);
-}
-
-simdjson_inline object_range_iterator object_range::end() noexcept {
-  return object_range_iterator(end_);
-}
-
-//
-// Free functions
-//
-
-simdjson_inline array_range get_range(array& arr) noexcept {
-  return array_range(arr);
-}
-
-simdjson_inline object_range get_key_value_range(object& obj) noexcept {
-  return object_range(obj);
-}
-
-#if SIMDJSON_EXCEPTIONS
-simdjson_inline array_range get_range(simdjson_result<array> result) {
-  return array_range(result.value());
-}
-
-simdjson_inline object_range get_key_value_range(simdjson_result<object> result) {
-  return object_range(result.value());
-}
-#endif // SIMDJSON_EXCEPTIONS
-
-} // namespace ondemand
-} // namespace SIMDJSON_IMPLEMENTATION
-} // namespace simdjson
-
-// Verify the range wrapper types satisfy the expected C++20 concepts.
-static_assert(std::input_iterator<simdjson::SIMDJSON_IMPLEMENTATION::ondemand::array_range_iterator>);
-static_assert(std::input_iterator<simdjson::SIMDJSON_IMPLEMENTATION::ondemand::object_range_iterator>);
-static_assert(std::ranges::input_range<simdjson::SIMDJSON_IMPLEMENTATION::ondemand::array_range>);
-static_assert(std::ranges::input_range<simdjson::SIMDJSON_IMPLEMENTATION::ondemand::object_range>);
-static_assert(std::ranges::view<simdjson::SIMDJSON_IMPLEMENTATION::ondemand::array_range>);
-static_assert(std::ranges::view<simdjson::SIMDJSON_IMPLEMENTATION::ondemand::object_range>);
-
-#endif // SIMDJSON_SUPPORTS_RANGES
-
-#endif // SIMDJSON_GENERIC_ONDEMAND_RANGES_INL_H

include/simdjson/generic/ondemand/ranges.h

@@ -1,182 +0,0 @@
-#ifndef SIMDJSON_GENERIC_ONDEMAND_RANGES_H
-
-#ifndef SIMDJSON_CONDITIONAL_INCLUDE
-#define SIMDJSON_GENERIC_ONDEMAND_RANGES_H
-#include "simdjson/generic/ondemand/base.h"
-#include "simdjson/generic/ondemand/array.h"
-#include "simdjson/generic/ondemand/array_iterator.h"
-#include "simdjson/generic/ondemand/object.h"
-#include "simdjson/generic/ondemand/object_iterator.h"
-#include "simdjson/generic/ondemand/field.h"
-#include "simdjson/generic/ondemand/value.h"
-#endif // SIMDJSON_CONDITIONAL_INCLUDE
-
-#if SIMDJSON_SUPPORTS_RANGES
-
-namespace simdjson {
-namespace SIMDJSON_IMPLEMENTATION {
-namespace ondemand {
-
-/**
- * A ranges-compatible iterator adapter for JSON arrays.
- *
- * Wraps array_iterator to satisfy std::input_iterator by providing:
- * - const operator* (via mutable internal state)
- * - post-increment operator
- * - iterator_concept tag
- *
- * The mutable approach is standard for single-pass input iterators that
- * read from external sources (similar to std::istream_iterator).
- */
-class array_range_iterator {
-public:
-  using iterator_concept = std::input_iterator_tag;
-  using value_type = simdjson_result<value>;
-  using reference = simdjson_result<value>;
-  using difference_type = std::ptrdiff_t;
-
-  simdjson_inline array_range_iterator() noexcept = default;
-  simdjson_inline explicit array_range_iterator(array_iterator iter) noexcept;
-
-  /**
-   * Get the current element. Const-qualified for std::indirectly_readable;
-   * internally delegates to the mutable wrapped iterator.
-   */
-  simdjson_inline simdjson_result<value> operator*() const noexcept;
-  simdjson_inline array_range_iterator& operator++() noexcept;
-SIMDJSON_PUSH_DISABLE_ALL_WARNINGS
-  simdjson_inline void operator++(int) noexcept;
-SIMDJSON_POP_DISABLE_WARNINGS
-  /**
-   * Comparison delegates to array_iterator::operator==, which checks
-   * whether the underlying parser has finished the array (depth-based).
-   */
-  simdjson_inline friend bool operator==(const array_range_iterator& a,
-                                         const array_range_iterator& b) noexcept {
-    return a.iter_ == b.iter_;
-  }
-
-private:
-  mutable array_iterator iter_{};
-};
-
-/**
- * A std::ranges::view over a JSON array.
- *
- * Wraps an ondemand::array and exposes begin()/end() that return
- * array_range_iterator (satisfying std::input_iterator), enabling
- * use with std::views::transform and other range adaptors.
- *
- * If the array's begin() returns an error (only possible under
- * SIMDJSON_DEVELOPMENT_CHECKS), the range will be empty and error()
- * will return the error code.
- *
- * Usage:
- *   ondemand::parser parser;
- *   auto doc = parser.iterate(json);
- *   auto arr = doc.get_array().value();
- *   for (auto elem : ondemand::get_range(arr)) { ... }
- */
-class array_range {
-public:
-  simdjson_inline array_range() noexcept = default;
-  simdjson_inline explicit array_range(array& arr) noexcept;
-
-  simdjson_inline array_range_iterator begin() noexcept;
-  simdjson_inline array_range_iterator end() noexcept;
-
-  /** Returns SUCCESS if the range was created successfully, or the error code otherwise. */
-  simdjson_inline error_code error() const noexcept { return error_; }
-
-private:
-  array_iterator begin_{};
-  array_iterator end_{};
-  error_code error_{SUCCESS};
-};
-
-/**
- * A ranges-compatible iterator adapter for JSON objects.
- *
- * Wraps object_iterator to satisfy std::input_iterator, yielding
- * simdjson_result<field> elements (key-value pairs).
- */
-class object_range_iterator {
-public:
-  using iterator_concept = std::input_iterator_tag;
-  using value_type = simdjson_result<field>;
-  using reference = simdjson_result<field>;
-  using difference_type = std::ptrdiff_t;
-
-  simdjson_inline object_range_iterator() noexcept = default;
-  simdjson_inline explicit object_range_iterator(object_iterator iter) noexcept;
-
-  simdjson_inline simdjson_result<field> operator*() const noexcept;
-  simdjson_inline object_range_iterator& operator++() noexcept;
-SIMDJSON_PUSH_DISABLE_ALL_WARNINGS
-  simdjson_inline void operator++(int) noexcept;
-SIMDJSON_POP_DISABLE_WARNINGS
-  simdjson_inline friend bool operator==(const object_range_iterator& a,
-                                         const object_range_iterator& b) noexcept {
-    return a.iter_ == b.iter_;
-  }
-
-private:
-  mutable object_iterator iter_{};
-};
-
-/**
- * A std::ranges::view over a JSON object.
- *
- * Wraps an ondemand::object and exposes begin()/end() that return
- * object_range_iterator, enabling use with range adaptors.
- *
- * If the object's begin() returns an error, the range will be empty
- * and error() will return the error code.
- */
-class object_range {
-public:
-  simdjson_inline object_range() noexcept = default;
-  simdjson_inline explicit object_range(object& obj) noexcept;
-
-  simdjson_inline object_range_iterator begin() noexcept;
-  simdjson_inline object_range_iterator end() noexcept;
-
-  /** Returns SUCCESS if the range was created successfully, or the error code otherwise. */
-  simdjson_inline error_code error() const noexcept { return error_; }
-
-private:
-  object_iterator begin_{};
-  object_iterator end_{};
-  error_code error_{SUCCESS};
-};
-
-/** Get a std::ranges compatible view over a JSON array. */
-simdjson_inline array_range get_range(array& arr) noexcept;
-
-/** Get a std::ranges compatible view over a JSON object (key-value pairs). */
-simdjson_inline object_range get_key_value_range(object& obj) noexcept;
-
-#if SIMDJSON_EXCEPTIONS
-/** Get a std::ranges compatible view, unwrapping the simdjson_result (throws on error). */
-simdjson_inline array_range get_range(simdjson_result<array> result);
-
-/** Get a std::ranges compatible view, unwrapping the simdjson_result (throws on error). */
-simdjson_inline object_range get_key_value_range(simdjson_result<object> result);
-#endif // SIMDJSON_EXCEPTIONS
-
-} // namespace ondemand
-} // namespace SIMDJSON_IMPLEMENTATION
-} // namespace simdjson
-
-namespace std {
-namespace ranges {
-template<>
-inline constexpr bool enable_view<simdjson::SIMDJSON_IMPLEMENTATION::ondemand::array_range> = true;
-template<>
-inline constexpr bool enable_view<simdjson::SIMDJSON_IMPLEMENTATION::ondemand::object_range> = true;
-} // namespace ranges
-} // namespace std
-
-#endif // SIMDJSON_SUPPORTS_RANGES
-
-#endif // SIMDJSON_GENERIC_ONDEMAND_RANGES_H

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));
-  static constexpr auto enumerators = std::define_static_array(std::meta::enumerators_of(^^T));
+  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/generic/ondemand/value-inl.h

@@ -314,14 +314,20 @@ simdjson_inline simdjson_result<value> value::at_path(std::string_view json_path
   }
 }
 
-inline simdjson_result<std::vector<value>> value::at_path_with_wildcard(std::string_view json_path) noexcept {
+#if SIMDJSON_SUPPORTS_CONCEPTS
+template <typename Func>
+  requires std::invocable<Func, value>
+#else
+template <typename Func>
+#endif
+inline error_code value::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept {
   json_type t;
   SIMDJSON_TRY(type().get(t));
   switch (t) {
   case json_type::array:
-      return (*this).get_array().at_path_with_wildcard(json_path);
+      return (*this).get_array().for_each_at_path_with_wildcard(json_path, std::forward<Func>(callback));
   case json_type::object:
-      return (*this).get_object().at_path_with_wildcard(json_path);
+      return (*this).get_object().for_each_at_path_with_wildcard(json_path, std::forward<Func>(callback));
   default:
       return INVALID_JSON_POINTER;
   }
@@ -585,12 +591,18 @@ simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> simdjs
   return first.at_path(json_path);
 }
 
-inline simdjson_result<std::vector<SIMDJSON_IMPLEMENTATION::ondemand::value>> simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value>::at_path_with_wildcard(
-      std::string_view json_path) noexcept {
+#if SIMDJSON_SUPPORTS_CONCEPTS
+template <typename Func>
+  requires std::invocable<Func, SIMDJSON_IMPLEMENTATION::ondemand::value>
+#else
+template <typename Func>
+#endif
+inline error_code simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value>::for_each_at_path_with_wildcard(
+      std::string_view json_path, Func&& callback) noexcept {
   if (error()) {
     return error();
   }
-  return first.at_path_with_wildcard(json_path);
+  return first.for_each_at_path_with_wildcard(json_path, std::forward<Func>(callback));
 }
 
 } // namespace simdjson

include/simdjson/generic/ondemand/value.h

@@ -698,13 +698,21 @@ public:
   simdjson_inline simdjson_result<value> at_path(std::string_view at_path) noexcept;
 
   /**
-   * Get all values matching the given JSONPath expression with wildcard support.
+   * Call the provided callback for each value matching the given JSONPath
+   * expression with wildcard support.
    * Supports wildcard character (*) for arrays or ".*" for objects.
    *
    * @param json_path JSONPath expression with wildcards
-   * @return Vector of values matching the wildcard pattern
+   * @param callback Function called for each matching value
+   * @return error_code indicating success or failure
    */
-  simdjson_inline simdjson_result<std::vector<value>> at_path_with_wildcard(std::string_view json_path) noexcept;
+#if SIMDJSON_SUPPORTS_CONCEPTS
+  template <typename Func>
+    requires std::invocable<Func, value>
+#else
+  template <typename Func>
+#endif
+  simdjson_inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept;
 
 protected:
   /**
@@ -897,9 +905,23 @@ public:
   simdjson_inline simdjson_result<int32_t> current_depth() const noexcept;
   simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> at_pointer(std::string_view json_pointer) noexcept;
   simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> at_path(std::string_view json_path) noexcept;
-  simdjson_inline simdjson_result<std::vector<SIMDJSON_IMPLEMENTATION::ondemand::value>> at_path_with_wildcard(std::string_view json_path) noexcept;
+#if SIMDJSON_SUPPORTS_CONCEPTS
+  template <typename Func>
+    requires std::invocable<Func, SIMDJSON_IMPLEMENTATION::ondemand::value>
+#else
+  template <typename Func>
+#endif
+  simdjson_inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept;
 };
 
+// Forward-declare explicit specializations so MSVC /permissive- sees them before
+// any template instantiation that would resolve element.get(val) to the primary.
+template<> simdjson_inline error_code
+simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value>::get<SIMDJSON_IMPLEMENTATION::ondemand::value>(
+    SIMDJSON_IMPLEMENTATION::ondemand::value &out) noexcept;
+template<> simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value>
+simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value>::get<SIMDJSON_IMPLEMENTATION::ondemand::value>() noexcept;
+
 } // namespace simdjson
 
 #endif // SIMDJSON_GENERIC_ONDEMAND_VALUE_H

include/simdjson/internal/dom_parser_implementation.h

@@ -19,12 +19,7 @@ class document;
 * 3) The stream_final mode allows us to truncate final
 * unterminated strings. It is useful in conjunction with streaming_partial.
 */
-enum class stage1_mode {
-  regular,
-  streaming_partial, streaming_final,
-  json_sequence_partial, json_sequence_final,
-  comma_delimited_partial, comma_delimited_final
-};
+enum class stage1_mode { regular, streaming_partial, streaming_final};
 
 /**
  * Returns true if mode == streaming_partial or mode == streaming_final
@@ -36,6 +31,7 @@ inline bool is_streaming(stage1_mode mode) {
   // return (mode == stage1_mode::streaming_partial || mode == stage1_mode::streaming_final);
 }
 
+
 namespace internal {
 
 

include/simdjson/padded_string_view-inl.h

@@ -6,15 +6,6 @@
 
 #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
@@ -104,83 +95,7 @@ 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,9 +9,6 @@
 #include <memory>
 #include <string>
 #include <ostream>
-#if SIMDJSON_CPLUSPLUS17
-#include <variant>
-#endif
 
 namespace simdjson {
 
@@ -76,68 +73,6 @@ 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.
@@ -170,7 +105,6 @@ 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

include/simdjson/simdjson_version.h

@@ -4,7 +4,7 @@
 #define SIMDJSON_SIMDJSON_VERSION_H
 
 /** The version of simdjson being used (major.minor.revision) */
-#define SIMDJSON_VERSION "4.6.1"
+#define SIMDJSON_VERSION "4.6.3"
 
 namespace simdjson {
 enum {
@@ -19,7 +19,7 @@ enum {
   /**
    * The revision (major.minor.REVISION) of simdjson being used.
    */
-  SIMDJSON_VERSION_REVISION = 1
+  SIMDJSON_VERSION_REVISION = 3
 };
 } // namespace simdjson
 

jsonexamples/example_config.json

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

singleheader/amalgamate.py

@@ -268,21 +268,7 @@ 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.
-            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}"
-                )
+            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}"
             # 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."
@@ -439,10 +425,8 @@ 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_number, line in enumerate(fid2, 1):
+            for line in fid2:
                 line = line.rstrip('\n')
 
                 # Ignore #pragma once, it causes warnings if it ends up in a .cpp file
@@ -455,7 +439,6 @@ 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)
@@ -470,12 +453,6 @@ 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}"
@@ -524,35 +501,7 @@ class Amalgamator:
 
                 self.write(line)
 
-            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)
+            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}"
 
         self.write(f"/* end file {self.file_to_str(file)} */")
 

singleheader/simdjson.cpp

@@ -1,4 +1,4 @@
-/* auto-generated on 2026-04-02 19:14:16 -0400. version 4.6.1 Do not edit! */
+/* auto-generated on 2026-04-17 17:22:06 -0400. version 4.6.3 Do not edit! */
 /* including simdjson.cpp:  */
 /* begin file simdjson.cpp */
 #define SIMDJSON_SRC_SIMDJSON_CPP
@@ -3168,11 +3168,6 @@ 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 ; }

src/fallback.cpp

@@ -226,15 +226,9 @@ simdjson_warn_unused simdjson_inline error_code scan() {
       add_structural();
     // Primitive or invalid character (invalid characters will be checked in stage 2)
     } else {
-      // Anything else, add the structural and go until we find the next one.
-      // We also stop on RS (0x1E) so that RFC 7464 json_sequence inputs
-      // like `\x1e"a"\x1e"b"` produce a separate structural for each RS
-      // rather than being absorbed into a single primitive run. RS is a
-      // control character that is invalid in normal JSON, so breaking
-      // the run here has no effect on well-formed non-json_sequence
-      // inputs.
+      // Anything else, add the structural and go until we find the next one
       add_structural();
-      while (idx+1<len && !char_is_space_or_operator(buf[idx+1]) && buf[idx+1] != 0x1e) {
+      while (idx+1<len && !char_is_space_or_operator(buf[idx+1])) {
         idx++;
       };
     }
@@ -289,56 +283,6 @@ simdjson_warn_unused simdjson_inline error_code scan() {
     // doing.
     parser.structural_indexes[parser.n_structural_indexes] = uint32_t(len);
     if (parser.n_structural_indexes == 0) { return EMPTY; }
-  } else if (partial == stage1_mode::json_sequence_partial) {
-    // RFC 7464: use RS positions for batch boundaries
-    if(unclosed_string) {
-      parser.n_structural_indexes--;
-      if (simdjson_unlikely(parser.n_structural_indexes == 0)) { return CAPACITY; }
-    }
-    uint32_t next_batch_start = uint32_t(len);
-    auto new_structural_indexes = find_next_document_index_json_sequence(parser, len, false, next_batch_start);
-    if (new_structural_indexes == DOCUMENT_TOO_LARGE) {
-      return CAPACITY;
-    }
-    if (new_structural_indexes == 0) {
-      parser.n_structural_indexes = 0;
-      return EMPTY;
-    }
-    parser.n_structural_indexes = new_structural_indexes;
-    parser.structural_indexes[parser.n_structural_indexes] = next_batch_start;
-  } else if (partial == stage1_mode::json_sequence_final) {
-    // RFC 7464: final batch, last document extends to EOF
-    if(unclosed_string) { parser.n_structural_indexes--; }
-    uint32_t next_batch_start = uint32_t(len);
-    parser.n_structural_indexes = find_next_document_index_json_sequence(parser, len, true, next_batch_start);
-    parser.structural_indexes[parser.n_structural_indexes + 1] = parser.structural_indexes[parser.n_structural_indexes];
-    parser.structural_indexes[parser.n_structural_indexes] = uint32_t(len);
-    if (simdjson_unlikely(parser.n_structural_indexes == 0)) { return EMPTY; }
-  } else if (partial == stage1_mode::comma_delimited_partial) {
-    // Comma-delimited: filter root-level commas, use comma positions for batch boundaries
-    if(unclosed_string) {
-      parser.n_structural_indexes--;
-      if (simdjson_unlikely(parser.n_structural_indexes == 0)) { return CAPACITY; }
-    }
-    uint32_t next_batch_start = uint32_t(len);
-    auto new_structural_indexes = filter_comma_delimited(parser, len, false, next_batch_start);
-    if (new_structural_indexes == DOCUMENT_TOO_LARGE) {
-      return CAPACITY;
-    }
-    if (new_structural_indexes == 0) {
-      parser.n_structural_indexes = 0;
-      return EMPTY;
-    }
-    parser.n_structural_indexes = new_structural_indexes;
-    parser.structural_indexes[parser.n_structural_indexes] = next_batch_start;
-  } else if (partial == stage1_mode::comma_delimited_final) {
-    // Comma-delimited: final batch, last document extends to EOF
-    if(unclosed_string) { parser.n_structural_indexes--; }
-    uint32_t next_batch_start = uint32_t(len);
-    parser.n_structural_indexes = filter_comma_delimited(parser, len, true, next_batch_start);
-    parser.structural_indexes[parser.n_structural_indexes + 1] = parser.structural_indexes[parser.n_structural_indexes];
-    parser.structural_indexes[parser.n_structural_indexes] = uint32_t(len);
-    if (simdjson_unlikely(parser.n_structural_indexes == 0)) { return EMPTY; }
   } else if(unclosed_string) { error = UNCLOSED_STRING; }
   return error;
 }

src/generic/stage1/find_next_document_index.h

@@ -97,280 +97,9 @@ simdjson_inline uint32_t find_next_document_index(dom_parser_implementation &par
   return 0;
 }
 
-/**
- * Sentinel value returned to indicate a document started but didn't fit
- * (CAPACITY error), as opposed to 0 which means no document content found
- * (EMPTY).
- */
-constexpr uint32_t DOCUMENT_TOO_LARGE = UINT32_MAX;
-
-/**
- * For RFC 7464 JSON text sequences, filter RS from structural indexes and
- * find batch boundaries.
- *
- * In JSON sequence mode, RS (0x1E) marks the start of each JSON text.
- * RS bytes appear in structural_indexes as they are classified as scalars.
- * This function:
- * 1. Scans structural_indexes to find and count RS positions
- * 2. Filters RS out of structural_indexes in-place
- * 3. Determines batch boundaries based on RS positions
- *
- * @param parser The parser with structural_indexes and buf.
- * @param len The length of the current batch buffer.
- * @param is_final True if this is the final batch (no more data coming).
- * @param next_batch_start Output: offset where the next batch should start.
- * @return The number of structural indexes to keep (after RS filtering),
- *         0 if no document content found (EMPTY),
- *         or DOCUMENT_TOO_LARGE if a document started but didn't fit (CAPACITY).
- */
-simdjson_inline uint32_t find_next_document_index_json_sequence(
-    dom_parser_implementation &parser,
-    size_t len,
-    bool is_final,
-    uint32_t &next_batch_start) {
-  // Default: next batch starts at end of buffer
-  next_batch_start = uint32_t(len);
-
-  if (parser.n_structural_indexes == 0) { return 0; }
-
-  // Phase 1: Scan structural_indexes to find RS positions and handle them.
-  // RS marks the start of a JSON text. For objects/arrays, the '{' or '[' after RS
-  // is already in structural_indexes (it's an operator). For scalars like numbers,
-  // the digit following RS is NOT in structural_indexes because the scanner sees
-  // RS as a scalar, making the digit a scalar continuation, not a start.
-  // We must: (1) remove RS from structural_indexes, and (2) for scalars, add the
-  // actual value start position.
-  uint32_t write_idx = 0;
-  uint32_t last_rs_pos = 0;
-  uint32_t rs_count = 0;
-
-  for (uint32_t read_idx = 0; read_idx < parser.n_structural_indexes; read_idx++) {
-    const uint32_t pos = parser.structural_indexes[read_idx];
-    if (parser.buf[pos] == 0x1E) {
-      // This is an RS character - find the actual JSON value start.
-      last_rs_pos = pos;
-      rs_count++;
-      // Skip past this RS and any whitespace *and any additional RSes*
-      // to locate the real value. Consecutive RSes are degenerate
-      // "empty records" per RFC 7464; we collapse them here. They do
-      // not always appear as separate entries in structural_indexes
-      // because the scanner groups runs of adjacent non-whitespace
-      // scalar bytes (including RS) into a single scalar start.
-      uint32_t value_start = pos + 1;
-      while (value_start < len) {
-        const uint8_t c = parser.buf[value_start];
-        if (c == ' ' || c == '\t' || c == '\n' || c == '\r') {
-          value_start++;
-        } else if (c == 0x1E) {
-          // Collapsed empty record. Still count it so rs_count reflects
-          // the true number of record markers and last_rs_pos tracks
-          // the final one.
-          last_rs_pos = value_start;
-          rs_count++;
-          value_start++;
-        } else {
-          break;
-        }
-      }
-      // If the scanner emitted additional structurals inside the
-      // whitespace+RS run we just walked over (i.e., isolated RSes
-      // separated by whitespace), skip past them so we do not
-      // double-count or double-emit.
-      while (read_idx + 1 < parser.n_structural_indexes &&
-             parser.structural_indexes[read_idx + 1] < value_start) {
-        read_idx++;
-      }
-      // Check if the value start is an operator (always present in
-      // scanner structural_indexes) or a scalar-like start (which may
-      // be missing from structural_indexes and must be added here).
-      // Note: '"' is NOT always in structural_indexes. The scanner
-      // classifies '"' as a scalar character and emits it as a
-      // structural only when it is a *scalar start* (preceded by
-      // whitespace or an operator). When '"' immediately follows an
-      // RS (which the scanner also classifies as scalar), it is
-      // treated as a scalar continuation and not emitted - so we
-      // must add it here just like any other scalar value.
-      if (value_start < len) {
-        const uint8_t c = parser.buf[value_start];
-        const bool is_operator =
-            (c == '{' || c == '}' || c == '[' || c == ']' ||
-             c == ':' || c == ',');
-        // If the next scanner structural is exactly at value_start,
-        // the scanner already emitted it (it followed whitespace) and
-        // we must not add a duplicate - a subsequent iteration will
-        // copy it into write_idx.
-        const bool already_emitted =
-            (read_idx + 1 < parser.n_structural_indexes &&
-             parser.structural_indexes[read_idx + 1] == value_start);
-        if (!is_operator && !already_emitted) {
-          // Scalar value (number/true/false/null/string) - add its
-          // position since scanner missed it.
-          parser.structural_indexes[write_idx++] = value_start;
-        }
-      }
-    } else {
-      // Not RS, copy to output
-      parser.structural_indexes[write_idx++] = pos;
-    }
-  }
-
-  // Update structural index count
-  parser.n_structural_indexes = write_idx;
-
-  if (parser.n_structural_indexes == 0) { return 0; }
-  if (rs_count == 0) {
-    // No RS found; for final batch, try generic boundary detection
-    return is_final ? find_next_document_index(parser) : 0;
-  }
-
-  // Phase 2: Determine batch boundaries based on RS positions
-
-  if (is_final) {
-    // Final batch: all documents are complete (last one ends at EOF).
-    // In json_sequence mode, RS markers define document boundaries, so all
-    // remaining structurals form complete documents. Return them all directly.
-    // (Calling find_next_document_index() would fail for scalar documents.)
-    return parser.n_structural_indexes;
-  }
-
-  // Partial batch: need to find complete documents only.
-  // A document starting at an RS is complete if there is another RS after it.
-  next_batch_start = last_rs_pos;
-
-  if (rs_count < 2) {
-    // Only one RS, so we have at most one document that may be incomplete.
-    // We cannot confirm it is complete without another RS.
-    // Return DOCUMENT_TOO_LARGE if content was found (write_idx > 0), 0 if only separators.
-    return (parser.n_structural_indexes > 0) ? DOCUMENT_TOO_LARGE : 0;
-  }
-
-  // We have at least 2 RS markers. The last complete document ends before last_rs_pos.
-
-  // Find the structural index cutoff: keep only structurals < last_rs_pos.
-  // Since we already filtered RS, all remaining structurals are valid.
-  // We iterate backward to find the last structural before last_rs_pos.
-  uint32_t keep_count = 0;
-  for (uint32_t i = parser.n_structural_indexes; i > 0; i--) {
-    if (parser.structural_indexes[i - 1] < last_rs_pos) {
-      keep_count = i;
-      break;
-    }
-  }
-
-  // No structurals before the last RS - no complete documents
-  if (keep_count == 0) { return 0; }
-
-  // All documents before the last RS are complete by definition (the next RS
-  // confirms their end). No need to call find_next_document_index() which
-  // would fail for scalar documents like `1` or `"hello"`.
-  return keep_count;
-}
-
-/**
- * Filter comma-delimited documents by removing root-level commas from
- * structural indexes.
- *
- * For comma-delimited format like `{...},{...},{...}`, we need to remove
- * the commas that separate documents (depth 0) while preserving commas
- * inside arrays and objects (depth > 0).
- *
- * After filtering, the structural indexes look like whitespace-delimited
- * documents, so find_next_document_index() works unchanged.
- *
- * @param parser The parser with structural_indexes and buf.
- * @param len The length of the current batch buffer.
- * @param is_final True if this is the final batch (no more data coming).
- * @param next_batch_start Output: offset where the next batch should start.
- * @return The number of structural indexes to keep,
- *         0 if no document content found (EMPTY),
- *         or DOCUMENT_TOO_LARGE if a document started but didn't fit (CAPACITY).
- */
-simdjson_inline uint32_t filter_comma_delimited(
-    dom_parser_implementation &parser,
-    size_t len,
-    bool is_final,
-    uint32_t &next_batch_start) {
-  // Default: next batch starts at end of buffer
-  next_batch_start = uint32_t(len);
-
-  if (parser.n_structural_indexes == 0) { return 0; }
-
-  // Track depth to identify root-level commas (depth 0)
-  int depth = 0;
-  uint32_t write_idx = 0;
-  uint32_t last_root_comma_pos = 0;
-  uint32_t root_comma_count = 0;
-
-  for (uint32_t i = 0; i < parser.n_structural_indexes; i++) {
-    uint32_t idx = parser.structural_indexes[i];
-    uint8_t c = parser.buf[idx];
-
-    switch (c) {
-      case '{': case '[':
-        depth++;
-        parser.structural_indexes[write_idx++] = idx;
-        break;
-      case '}': case ']':
-        depth--;
-        parser.structural_indexes[write_idx++] = idx;
-        break;
-      case ',':
-        if (depth == 0) {
-          // Root-level comma = document boundary, skip it
-          last_root_comma_pos = idx;
-          root_comma_count++;
-          continue;
-        }
-        parser.structural_indexes[write_idx++] = idx;
-        break;
-      default:
-        // Colons, scalars, etc.
-        parser.structural_indexes[write_idx++] = idx;
-        break;
-    }
-  }
-
-  // Update structural index count
-  parser.n_structural_indexes = write_idx;
-
-  if (parser.n_structural_indexes == 0) { return 0; }
-
-  if (is_final) {
-    // Final batch: use standard boundary detection on filtered indexes
-    return find_next_document_index(parser);
-  }
-
-  // Partial batch: need to find complete documents only.
-  // A document ending with a root comma is complete.
-  if (root_comma_count == 0) {
-    // No root commas found; we cannot confirm any document is complete.
-    // The whole batch might be one incomplete document.
-    // Return DOCUMENT_TOO_LARGE if content was found (write_idx > 0), 0 if only commas.
-    return (parser.n_structural_indexes > 0) ? DOCUMENT_TOO_LARGE : 0;
-  }
-
-  // We have at least one root comma. Documents before the last comma are complete.
-  next_batch_start = last_root_comma_pos + 1;
-
-  // Find the structural index cutoff: keep only structurals < last_root_comma_pos
-  uint32_t keep_count = 0;
-  for (uint32_t i = parser.n_structural_indexes; i > 0; i--) {
-    if (parser.structural_indexes[i - 1] < last_root_comma_pos) {
-      keep_count = i;
-      break;
-    }
-  }
-
-  if (keep_count == 0) { return 0; }
-
-  // Use standard boundary detection on the complete portion
-  parser.n_structural_indexes = keep_count;
-  return find_next_document_index(parser);
-}
-
 } // namespace stage1
 } // unnamed namespace
 } // namespace SIMDJSON_IMPLEMENTATION
 } // namespace simdjson
 
-#endif // SIMDJSON_SRC_GENERIC_STAGE1_FIND_NEXT_DOCUMENT_INDEX_H
+#endif // SIMDJSON_SRC_GENERIC_STAGE1_FIND_NEXT_DOCUMENT_INDEX_H

src/generic/stage1/json_structural_indexer.h

@@ -314,6 +314,7 @@ simdjson_inline error_code json_structural_indexer::finish(dom_parser_implementa
         return EMPTY;
       }
     }
+
     parser.n_structural_indexes = new_structural_indexes;
   } else if (partial == stage1_mode::streaming_final) {
     if(have_unclosed_string) { parser.n_structural_indexes--; }
@@ -341,56 +342,6 @@ simdjson_inline error_code json_structural_indexer::finish(dom_parser_implementa
         // the trailing garbage.
         return EMPTY;
     }
-  } else if (partial == stage1_mode::json_sequence_partial) {
-    // RFC 7464: use RS positions for batch boundaries
-    if(have_unclosed_string) {
-      parser.n_structural_indexes--;
-      if (simdjson_unlikely(parser.n_structural_indexes == 0u)) { return CAPACITY; }
-    }
-    uint32_t next_batch_start = uint32_t(len);
-    auto new_structural_indexes = find_next_document_index_json_sequence(parser, len, false, next_batch_start);
-    if (new_structural_indexes == DOCUMENT_TOO_LARGE) {
-      return CAPACITY;
-    }
-    if (new_structural_indexes == 0) {
-      parser.n_structural_indexes = 0;
-      return EMPTY;
-    }
-    parser.n_structural_indexes = new_structural_indexes;
-    parser.structural_indexes[parser.n_structural_indexes] = next_batch_start;
-  } else if (partial == stage1_mode::json_sequence_final) {
-    // RFC 7464: final batch, last document extends to EOF
-    if(have_unclosed_string) { parser.n_structural_indexes--; }
-    uint32_t next_batch_start = uint32_t(len);
-    parser.n_structural_indexes = find_next_document_index_json_sequence(parser, len, true, next_batch_start);
-    parser.structural_indexes[parser.n_structural_indexes + 1] = parser.structural_indexes[parser.n_structural_indexes];
-    parser.structural_indexes[parser.n_structural_indexes] = uint32_t(len);
-    if (simdjson_unlikely(parser.n_structural_indexes == 0u)) { return EMPTY; }
-  } else if (partial == stage1_mode::comma_delimited_partial) {
-    // Comma-delimited: filter root-level commas, use comma positions for batch boundaries
-    if(have_unclosed_string) {
-      parser.n_structural_indexes--;
-      if (simdjson_unlikely(parser.n_structural_indexes == 0u)) { return CAPACITY; }
-    }
-    uint32_t next_batch_start = uint32_t(len);
-    auto new_structural_indexes = filter_comma_delimited(parser, len, false, next_batch_start);
-    if (new_structural_indexes == DOCUMENT_TOO_LARGE) {
-      return CAPACITY;
-    }
-    if (new_structural_indexes == 0) {
-      parser.n_structural_indexes = 0;
-      return EMPTY;
-    }
-    parser.n_structural_indexes = new_structural_indexes;
-    parser.structural_indexes[parser.n_structural_indexes] = next_batch_start;
-  } else if (partial == stage1_mode::comma_delimited_final) {
-    // Comma-delimited: final batch, last document extends to EOF
-    if(have_unclosed_string) { parser.n_structural_indexes--; }
-    uint32_t next_batch_start = uint32_t(len);
-    parser.n_structural_indexes = filter_comma_delimited(parser, len, true, next_batch_start);
-    parser.structural_indexes[parser.n_structural_indexes + 1] = parser.structural_indexes[parser.n_structural_indexes];
-    parser.structural_indexes[parser.n_structural_indexes] = uint32_t(len);
-    if (simdjson_unlikely(parser.n_structural_indexes == 0u)) { return EMPTY; }
   }
   checker.check_eof();
   return checker.errors();

src/internal/isadetection.h

@@ -52,17 +52,13 @@ POSSIBILITY OF SUCH DAMAGE.
 #include <cstdlib>
 #if defined(_MSC_VER)
 #include <intrin.h>
-#elif (defined(HAVE_GCC_GET_CPUID) && defined(USE_GCC_GET_CPUID)) || defined(__FILC__)
+#elif defined(HAVE_GCC_GET_CPUID) && defined(USE_GCC_GET_CPUID)
 #include <cpuid.h>
 #endif
 #if defined(__loongarch__) && defined(__linux__)
   #include <sys/auxv.h>
 #endif
 
-#ifdef __FILC__
-#include <stdfil.h>
-#endif
-
 namespace simdjson {
 namespace internal {
 
@@ -113,7 +109,7 @@ static inline void cpuid(uint32_t *eax, uint32_t *ebx, uint32_t *ecx,
   *ebx = cpu_info[1];
   *ecx = cpu_info[2];
   *edx = cpu_info[3];
-#elif (defined(HAVE_GCC_GET_CPUID) && defined(USE_GCC_GET_CPUID)) || defined(__FILC__)
+#elif defined(HAVE_GCC_GET_CPUID) && defined(USE_GCC_GET_CPUID)
   uint32_t level = *eax;
   __get_cpuid(level, eax, ebx, ecx, edx);
 #else
@@ -130,8 +126,6 @@ static inline void cpuid(uint32_t *eax, uint32_t *ebx, uint32_t *ecx,
 static inline uint64_t xgetbv() {
 #if defined(_MSC_VER)
   return _xgetbv(0);
-#elif defined(__FILC__)
-  return zxgetbv();
 #else
   uint32_t xcr0_lo, xcr0_hi;
   asm volatile("xgetbv\n\t" : "=a" (xcr0_lo), "=d" (xcr0_hi) : "c" (0));

tests/CMakeLists.txt

@@ -4,10 +4,6 @@ include(${PROJECT_SOURCE_DIR}/cmake/add_cpp_test.cmake)
 add_subdirectory(dom)
 add_subdirectory(ondemand)
 
-# compilation_failure_tests is added before the global link_libraries(simdjson) so that
-# multiple_include/myexe does not receive a duplicate simdjson entry alongside the one
-# already propagated by mylib PUBLIC simdjson::simdjson.
-add_subdirectory(compilation_failure_tests)
 
 # All remaining tests link with simdjson proper
 link_libraries(simdjson)
@@ -31,5 +27,6 @@ endif()
 # SIMDJSON_FORCE_IMPLEMENTATION, so we know we're testing what we think we're testing
 add_cpp_test(checkimplementation LABELS other per_implementation)
 
+add_subdirectory(compilation_failure_tests)
 add_subdirectory(builder)
 add_subdirectory(compile_time)

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,37 +46,17 @@ 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,
@@ -109,13 +89,6 @@ 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() {
@@ -159,8 +132,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"};
@@ -186,10 +159,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;
@@ -227,11 +200,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;
@@ -272,9 +245,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;
@@ -305,8 +278,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;
@@ -346,7 +319,13 @@ 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;
 
@@ -362,7 +341,7 @@ namespace builder_tests {
         "transmission": "Automatic"
       })"_padded;
 
-      CarOpt car{};
+      Car car{};
       ondemand::document doc;
       ASSERT_SUCCESS( parser.iterate(padded).get(doc) );
 
@@ -398,7 +377,7 @@ namespace builder_tests {
         "color": "Red"
       })"_padded;
 
-      CarOpt car{};
+      Car car{};
       ondemand::document doc;
       ASSERT_SUCCESS(parser.iterate(padded).get(doc));
 
@@ -423,7 +402,7 @@ namespace builder_tests {
         "price": 35999.99
       })"_padded;
 
-      CarOpt car{};
+      Car car{};
       ondemand::document doc;
       ASSERT_SUCCESS(parser.iterate(padded).get(doc));
 
@@ -516,6 +495,13 @@ 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};
 
@@ -547,7 +533,13 @@ 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};
 
@@ -574,6 +566,13 @@ 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
@@ -595,6 +594,13 @@ 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
@@ -623,21 +629,21 @@ namespace builder_tests {
 
     // Test 5: Round-trip test - serialize with extract_from, deserialize with extract_into
     {
-      struct MyProduct {
-        std::string id{};
-        std::string name{};
-        double price{};
-        int stock{};
+      struct Product {
+        std::string id;
+        std::string name;
+        double price;
+        int stock;
       };
 
-      MyProduct original{"P123", "Widget", 19.99, 100};
+      Product 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
-      MyProduct restored{"", "", 0.0, 0};
+      Product 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\xc3\xa9 r\xc3\xa9sum\xc3\xa9";
+    test.unicode = "Café résumé";
     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/compilation_failure_tests/CMakeLists.txt

@@ -14,17 +14,6 @@ function(add_dual_compile_test TEST_NAME)
 endfunction(add_dual_compile_test)
 
 
-if(NOT BUILD_SHARED_LIBS)
-  # Add multiple_include BEFORE link_libraries(simdjson) so that myexe only receives
-  # simdjson once (through mylib PUBLIC simdjson::simdjson) and not a second time from
-  # a directory-wide link entry.
-  add_subdirectory(multiple_include)
-endif()
-
-# Dual-compile tests build executables that reference simdjson symbols, so they need
-# the library linked in.
-link_libraries(simdjson)
-
 add_dual_compile_test(example_compiletest)
 # These don't compile with exceptions off
 if (SIMDJSON_EXCEPTIONS)
@@ -35,4 +24,9 @@ if (SIMDJSON_EXCEPTIONS)
   add_dual_compile_test(dangling_parser_parse_stdstring)
   add_dual_compile_test(dangling_parser_parse_padstring)
   add_dual_compile_test(unsafe_parse_many)
+endif()
+
+if(NOT BUILD_SHARED_LIBS)
+  # We only check that it builds
+  add_subdirectory(multiple_include)
 endif()

tests/compile_time/compile_time_json_tests.cpp

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

tests/document_stream_fuzz_test_common.h

@@ -1,230 +0,0 @@
-#ifndef SIMDJSON_TESTS_DOCUMENT_STREAM_FUZZ_TEST_COMMON_H
-#define SIMDJSON_TESTS_DOCUMENT_STREAM_FUZZ_TEST_COMMON_H
-
-#include <cstdint>
-#include <random>
-#include <string>
-#include <vector>
-
-#include "simdjson.h"
-
-namespace document_stream_fuzz {
-
-constexpr uint64_t fixed_seed = 0x5eed1234ULL;
-constexpr size_t batch_size = 512;
-constexpr size_t minimum_total_bytes = 4096;
-constexpr size_t minimum_document_count = 128;
-
-struct stream_case {
-  const char *name;
-  simdjson::stream_format format;
-  std::string input;
-  std::vector<std::string> expected_documents;
-};
-
-inline char random_char(std::mt19937_64 &rng) {
-  static constexpr char alphabet[] =
-      "abcdefghijklmnopqrstuvwxyz"
-      "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
-      "0123456789 _-/.";
-  std::uniform_int_distribution<size_t> dist(0, sizeof(alphabet) - 2);
-  return alphabet[dist(rng)];
-}
-
-inline std::string make_ascii_text(std::mt19937_64 &rng, size_t min_length, size_t max_length) {
-  std::uniform_int_distribution<size_t> length_dist(min_length, max_length);
-  const size_t length = length_dist(rng);
-  std::string text;
-  text.reserve(length);
-  for (size_t i = 0; i < length; i++) {
-    text.push_back(random_char(rng));
-  }
-  return text;
-}
-
-inline std::string quote_json_string(const std::string &text) {
-  std::string quoted;
-  quoted.reserve(text.size() + 2);
-  quoted.push_back('"');
-  for (char ch : text) {
-    if (ch == '\\' || ch == '"') {
-      quoted.push_back('\\');
-    }
-    quoted.push_back(ch);
-  }
-  quoted.push_back('"');
-  return quoted;
-}
-
-inline std::string make_integer_literal(std::mt19937_64 &rng) {
-  std::uniform_int_distribution<int64_t> dist(-1000000, 1000000);
-  return std::to_string(dist(rng));
-}
-
-inline std::string make_float_literal(std::mt19937_64 &rng) {
-  std::uniform_int_distribution<int64_t> whole_dist(-250000, 250000);
-  std::uniform_int_distribution<int64_t> fraction_dist(1, 9999);
-  return std::to_string(whole_dist(rng)) + "." + std::to_string(fraction_dist(rng));
-}
-
-inline std::string make_scalar(std::mt19937_64 &rng) {
-  std::uniform_int_distribution<int> type_dist(0, 4);
-  switch (type_dist(rng)) {
-    case 0: return quote_json_string(make_ascii_text(rng, 0, 20));
-    case 1: return make_integer_literal(rng);
-    case 2: return make_float_literal(rng);
-    case 3: return (rng() & 1) ? "true" : "false";
-    default: return "null";
-  }
-}
-
-inline std::string make_value(std::mt19937_64 &rng, int depth);
-
-inline std::string make_array(std::mt19937_64 &rng, int depth) {
-  std::uniform_int_distribution<int> count_dist(0, depth == 0 ? 5 : 3);
-  const int count = count_dist(rng);
-  std::string out = "[";
-  for (int i = 0; i < count; i++) {
-    if (i > 0) {
-      out.push_back(',');
-    }
-    out += make_value(rng, depth + 1);
-  }
-  out.push_back(']');
-  return out;
-}
-
-inline std::string make_object(std::mt19937_64 &rng, int depth) {
-  std::uniform_int_distribution<int> count_dist(0, depth == 0 ? 5 : 3);
-  const int count = count_dist(rng);
-  std::string out = "{";
-  for (int i = 0; i < count; i++) {
-    if (i > 0) {
-      out.push_back(',');
-    }
-    std::string key = "k";
-    key += std::to_string(depth);
-    key += '_';
-    key += std::to_string(i);
-    key += '_';
-    key += make_ascii_text(rng, 1, 6);
-    out += quote_json_string(key);
-    out.push_back(':');
-    out += make_value(rng, depth + 1);
-  }
-  out.push_back('}');
-  return out;
-}
-
-inline std::string make_value(std::mt19937_64 &rng, int depth) {
-  if (depth >= 3) {
-    return make_scalar(rng);
-  }
-  std::uniform_int_distribution<int> type_dist(0, 6);
-  switch (type_dist(rng)) {
-    case 0: return quote_json_string(make_ascii_text(rng, 0, 20));
-    case 1: return make_integer_literal(rng);
-    case 2: return make_float_literal(rng);
-    case 3: return (rng() & 1) ? "true" : "false";
-    case 4: return "null";
-    case 5: return make_array(rng, depth);
-    default: return make_object(rng, depth);
-  }
-}
-
-inline std::vector<std::string> make_documents() {
-  std::vector<std::string> docs = {
-    "0",
-    "-17",
-    "3.125",
-    "true",
-    "false",
-    "null",
-    "\"alpha beta\"",
-    "[]",
-    "[1,true,\"x\"]",
-    "{}",
-    "{\"a\":1,\"b\":[2,3],\"c\":{\"d\":false}}"
-  };
-
-  size_t total_bytes = 0;
-  for (const auto &doc : docs) {
-    total_bytes += doc.size();
-  }
-
-  std::mt19937_64 rng(fixed_seed);
-  while (docs.size() < minimum_document_count || total_bytes < minimum_total_bytes) {
-    docs.push_back(make_value(rng, 0));
-    total_bytes += docs.back().size();
-  }
-  return docs;
-}
-
-inline std::vector<std::string> make_wrapped_documents(const std::vector<std::string> &docs) {
-  std::vector<std::string> wrapped;
-  wrapped.reserve(docs.size());
-  for (size_t i = 0; i < docs.size(); i++) {
-    wrapped.push_back("{\"id\":" + std::to_string(i) + ",\"value\":" + docs[i] + "}");
-  }
-  return wrapped;
-}
-
-inline std::string build_whitespace_input(const std::vector<std::string> &docs) {
-  static const char *separators[] = {" ", "\n", "\r\n", "\t", " \n\t", "\r\t "};
-  std::string out = " \n\t";
-  for (size_t i = 0; i < docs.size(); i++) {
-    out += docs[i];
-    if (i + 1 < docs.size()) {
-      out += separators[i % (sizeof(separators) / sizeof(separators[0]))];
-    }
-  }
-  out += "\n\t ";
-  return out;
-}
-
-inline std::string build_json_sequence_input(const std::vector<std::string> &docs) {
-  std::string out;
-  for (size_t i = 0; i < docs.size(); i++) {
-    out.push_back('\x1e');
-    out += docs[i];
-    out.push_back('\n');
-  }
-  return out;
-}
-
-inline std::string build_comma_delimited_input(const std::vector<std::string> &docs) {
-  std::string out;
-  for (size_t i = 0; i < docs.size(); i++) {
-    if (i > 0) {
-      out += (i % 3 == 0) ? ",\n" : ", ";
-    }
-    out += docs[i];
-  }
-  return out;
-}
-
-inline std::string build_comma_delimited_array_input(const std::vector<std::string> &docs) {
-  std::string out = " \t\n[";
-  for (size_t i = 0; i < docs.size(); i++) {
-    if (i > 0) {
-      out += (i % 4 == 0) ? ",\n" : ", ";
-    }
-    out += docs[i];
-  }
-  out += "]\r\n";
-  return out;
-}
-
-inline std::vector<stream_case> make_stream_cases(const std::vector<std::string> &docs) {
-  std::vector<std::string> whitespace_docs = make_wrapped_documents(docs);
-  return {
-    {"whitespace_delimited", simdjson::stream_format::whitespace_delimited, build_whitespace_input(whitespace_docs), whitespace_docs},
-    {"json_sequence", simdjson::stream_format::json_sequence, build_json_sequence_input(whitespace_docs), whitespace_docs},
-    {"comma_delimited", simdjson::stream_format::comma_delimited, build_comma_delimited_input(whitespace_docs), whitespace_docs},
-    {"comma_delimited_array", simdjson::stream_format::comma_delimited_array, build_comma_delimited_array_input(whitespace_docs), whitespace_docs}
-  };
-}
-
-} // namespace document_stream_fuzz
-
-#endif

tests/dom/CMakeLists.txt

@@ -7,7 +7,6 @@ if(NOT SIMDJSON_LEGACY_VISUAL_STUDIO AND NOT SIMDJSON_WINDOWS_DLL)
 endif()
 add_cpp_test(basictests                 LABELS dom acceptance per_implementation)
 add_cpp_test(document_stream_tests      LABELS dom acceptance per_implementation)
-add_cpp_test(document_stream_fuzz_tests LABELS dom acceptance per_implementation)
 add_cpp_test(document_tests             LABELS dom acceptance per_implementation)
 add_cpp_test(errortests                 LABELS dom acceptance per_implementation)
 add_cpp_test(extracting_values_example  LABELS dom acceptance per_implementation)
@@ -127,16 +126,14 @@ endif()
 #   1. Visual Studio 2022 v17.6 or later
 #   2. GCC v14.0.0 or later (GCC v13.0.0 cannot handle pipe operator of lambda)
 #   3. Clang v15.0.0 or later (certain version C++ headers occur error when compiling)
-#   4. or if we are targeting C++20 or better
 if(
-  (MSVC AND MSVC_VERSION GREATER_EQUAL 1930) OR
+  (MSVC AND MSVC_VERSION LESS 1930) OR
   (CMAKE_CXX_COMPILER_ID STREQUAL "GNU" AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL "14.0.0") OR
-  (CMAKE_CXX_COMPILER_ID MATCHES "Clang" AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL "15.0.0") OR
-  (CMAKE_CXX_STANDARD GREATER_EQUAL 20)
+  (CMAKE_CXX_COMPILER_ID MATCHES "Clang" AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL "15.0.0")
   )
   message(STATUS "compiler id: ${CMAKE_CXX_COMPILER_ID} version: ${CMAKE_CXX_COMPILER_VERSION}")
   add_cpp_test(ranges_test LABELS dom acceptance per_implementation)
-  if(NOT SIMDJSON_STATIC_REFLECTION AND NOT CMAKE_CXX_STANDARD GREATER_EQUAL 20)
+  if(NOT SIMDJSON_STATIC_REFLECTION)
      set_target_properties(ranges_test PROPERTIES CXX_STANDARD 20 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF)
   endif()
 endif()

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/document_stream_fuzz_tests.cpp

@@ -1,97 +0,0 @@
-#include <string>
-#include <vector>
-
-#include "simdjson.h"
-#include "test_macros.h"
-#include "test_main.h"
-#include "document_stream_fuzz_test_common.h"
-
-namespace document_stream_fuzz_tests {
-
-std::string strip_stream_artifacts(simdjson::stream_format format, std::string_view text) {
-  size_t start = 0;
-  size_t end = text.size();
-  while (start < end && (text[start] == ' ' || text[start] == '\t' || text[start] == '\n' || text[start] == '\r' || text[start] == '\x1e')) {
-    start++;
-  }
-  while (end > start && (text[end - 1] == ' ' || text[end - 1] == '\t' || text[end - 1] == '\n' || text[end - 1] == '\r' || text[end - 1] == '\x1e')) {
-    end--;
-  }
-  std::string cleaned(text.substr(start, end - start));
-  if (format == simdjson::stream_format::comma_delimited || format == simdjson::stream_format::comma_delimited_array) {
-    while (!cleaned.empty() && cleaned.back() == ',') {
-      cleaned.pop_back();
-      while (!cleaned.empty() && (cleaned.back() == ' ' || cleaned.back() == '\t' || cleaned.back() == '\n' || cleaned.back() == '\r')) {
-        cleaned.pop_back();
-      }
-    }
-  }
-  return cleaned;
-}
-
-std::string canonicalize_document(simdjson::stream_format format, std::string_view text) {
-  std::string cleaned = strip_stream_artifacts(format, text);
-  simdjson::dom::parser parser;
-  simdjson::dom::element doc;
-  if (parser.parse(cleaned).get(doc)) {
-    return std::string("PARSE_ERROR:") + cleaned;
-  }
-  return simdjson::minify(doc);
-}
-
-const std::vector<std::string> &expected_documents() {
-  static const std::vector<std::string> docs = document_stream_fuzz::make_documents();
-  return docs;
-}
-
-const std::vector<document_stream_fuzz::stream_case> &stream_cases() {
-  static const std::vector<document_stream_fuzz::stream_case> cases =
-      document_stream_fuzz::make_stream_cases(expected_documents());
-  return cases;
-}
-
-bool verify_case(const document_stream_fuzz::stream_case &test_case) {
-  TEST_START();
-  const auto &expected = test_case.expected_documents;
-  ASSERT_TRUE(test_case.input.size() > document_stream_fuzz::batch_size * 4);
-
-  simdjson::padded_string input(test_case.input);
-  simdjson::dom::parser parser;
-
-  for (int pass = 0; pass < 2; pass++) {
-    simdjson::dom::document_stream stream;
-    ASSERT_SUCCESS(parser.parse_many(input, document_stream_fuzz::batch_size, test_case.format).get(stream));
-
-    size_t index = 0;
-    for (auto doc : stream) {
-      ASSERT_SUCCESS(doc.error());
-      ASSERT_TRUE(index < expected.size());
-      simdjson::dom::element el;
-      ASSERT_SUCCESS(doc.get(el));
-      ASSERT_EQUAL(
-          canonicalize_document(test_case.format, simdjson::minify(el)),
-          canonicalize_document(test_case.format, expected[index])
-      );
-      index++;
-    }
-    ASSERT_EQUAL(index, expected.size());
-  }
-
-  TEST_SUCCEED();
-}
-
-bool run() {
-  for (const auto &test_case : stream_cases()) {
-    std::cout << "Running fuzz corpus against stream format: " << test_case.name << std::endl;
-    if (!verify_case(test_case)) {
-      return false;
-    }
-  }
-  return true;
-}
-
-} // namespace document_stream_fuzz_tests
-
-int main(int argc, char *argv[]) {
-  return test_main(argc, argv, document_stream_fuzz_tests::run);
-}

tests/dom/readme_examples.cpp

@@ -1,6 +1,5 @@
 #include <iostream>
 #include "simdjson.h"
-#include "simdjson/padded_string_view.h"
 
 using namespace std;
 using namespace simdjson;
@@ -532,35 +531,6 @@ 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/fractured_json_tests.cpp

@@ -475,11 +475,11 @@ bool unicode_test() {
   std::cout << "Running " << __func__ << std::endl;
 
   const char* json = R"({
-    "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"
+    "greeting": "Hello, 世界!",
+    "emoji": "🎉🚀✨",
+    "arabic": "مرحبا",
+    "russian": "Привет",
+    "mixed": "café résumé naïve"
   })";
 
   simdjson::dom::parser parser;

tests/ondemand/CMakeLists.txt

@@ -12,7 +12,6 @@ add_cpp_test(ondemand_array_tests                    LABELS ondemand acceptance
 add_cpp_test(ondemand_array_error_tests              LABELS ondemand acceptance per_implementation)
 add_cpp_test(ondemand_compilation_tests              LABELS ondemand acceptance per_implementation)
 add_cpp_test(ondemand_document_stream_tests          LABELS ondemand acceptance per_implementation)
-add_cpp_test(ondemand_document_stream_fuzz_tests     LABELS ondemand acceptance per_implementation)
 add_cpp_test(ondemand_error_tests                    LABELS ondemand acceptance per_implementation)
 add_cpp_test(ondemand_error_location_tests           LABELS ondemand acceptance per_implementation)
 add_cpp_test(ondemand_json_pointer_tests             LABELS ondemand acceptance per_implementation)
@@ -41,29 +40,9 @@ 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()
 
-# Add the tests if we're on:
-#   1. Visual Studio 2022 v17.6 or later
-#   2. GCC v14.0.0 or later (GCC v13.0.0 cannot handle pipe operator of lambda)
-#   3. Clang v15.0.0 or later (certain version C++ headers occur error when compiling)
-#   4. or if we are targeting C++20 or better
-if(
-  (MSVC AND MSVC_VERSION GREATER_EQUAL 1930) OR
-  (CMAKE_CXX_COMPILER_ID STREQUAL "GNU" AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL "14.0.0") OR
-  (CMAKE_CXX_COMPILER_ID MATCHES "Clang" AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL "15.0.0") OR
-  (CMAKE_CXX_STANDARD GREATER_EQUAL 20)
-  )
-  message(STATUS "compiler id: ${CMAKE_CXX_COMPILER_ID} version: ${CMAKE_CXX_COMPILER_VERSION}")
-  add_cpp_test(ondemand_ranges_tests LABELS ondemand acceptance per_implementation)
-  if(NOT SIMDJSON_STATIC_REFLECTION AND NOT  CMAKE_CXX_STANDARD GREATER_EQUAL 20)
-     set_target_properties(ondemand_ranges_tests PROPERTIES CXX_STANDARD 20 CXX_STANDARD_REQUIRED ON CXX_EXTENSIONS OFF)
-  endif()
-endif()
-
-
 if(HAVE_POSIX_FORK AND HAVE_POSIX_WAIT) # assert tests use fork and wait, which aren't on MSVC
   add_cpp_test(ondemand_assert_out_of_order_values LABELS assert per_implementation explicitonly ondemand)
 endif()

tests/ondemand/ondemand_cacheline.cpp

@@ -1,12 +1,3 @@
-#ifdef __FILC__
-#include <stdio.h>
-#include <stdlib.h>
-int main() {
-  printf("This test is not relevant for FILC.\n");
-  return EXIT_SUCCESS;
-}
-#else // This test is not relevant for FILC
-
 #ifdef _WIN32
 #include <windows.h>
 #include <sysinfoapi.h>
@@ -29,7 +20,7 @@ long page_size() {
 }
 
 // Returns true if the buffer + len + simdjson::SIMDJSON_PADDING crosses the
-// page boundary. Assumes len != 0.
+// page boundary.
 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()));
@@ -95,6 +86,4 @@ int main() {
     return EXIT_FAILURE;
   }
   return EXIT_SUCCESS;
-}
-
-#endif // This test is not relevant for FILC
+}

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_document_stream_fuzz_tests.cpp

@@ -1,101 +0,0 @@
-#include <string>
-#include <vector>
-
-#include "simdjson.h"
-#include "test_ondemand.h"
-#include "document_stream_fuzz_test_common.h"
-
-namespace document_stream_fuzz_tests {
-
-std::string strip_stream_artifacts(simdjson::stream_format format, std::string_view text) {
-  size_t start = 0;
-  size_t end = text.size();
-  while (start < end && (text[start] == ' ' || text[start] == '\t' || text[start] == '\n' || text[start] == '\r' || text[start] == '\x1e')) {
-    start++;
-  }
-  while (end > start && (text[end - 1] == ' ' || text[end - 1] == '\t' || text[end - 1] == '\n' || text[end - 1] == '\r' || text[end - 1] == '\x1e')) {
-    end--;
-  }
-  std::string cleaned(text.substr(start, end - start));
-  if (format == simdjson::stream_format::comma_delimited || format == simdjson::stream_format::comma_delimited_array) {
-    while (!cleaned.empty() && cleaned.back() == ',') {
-      cleaned.pop_back();
-      while (!cleaned.empty() && (cleaned.back() == ' ' || cleaned.back() == '\t' || cleaned.back() == '\n' || cleaned.back() == '\r')) {
-        cleaned.pop_back();
-      }
-    }
-  }
-  return cleaned;
-}
-
-std::string canonicalize_document(simdjson::stream_format format, std::string_view text) {
-  std::string cleaned = strip_stream_artifacts(format, text);
-  simdjson::dom::parser parser;
-  simdjson::dom::element doc;
-  if (parser.parse(cleaned).get(doc)) {
-    return std::string("PARSE_ERROR:") + cleaned;
-  }
-  return simdjson::minify(doc);
-}
-
-const std::vector<std::string> &expected_documents() {
-  static const std::vector<std::string> docs = document_stream_fuzz::make_documents();
-  return docs;
-}
-
-const std::vector<document_stream_fuzz::stream_case> &stream_cases() {
-  static const std::vector<document_stream_fuzz::stream_case> cases =
-      document_stream_fuzz::make_stream_cases(expected_documents());
-  return cases;
-}
-
-bool verify_case(const document_stream_fuzz::stream_case &test_case) {
-  TEST_START();
-  const auto &expected = test_case.expected_documents;
-  ASSERT_TRUE(test_case.input.size() > document_stream_fuzz::batch_size * 4);
-
-  simdjson::padded_string input(test_case.input);
-  simdjson::ondemand::parser parser;
-
-  for (int pass = 0; pass < 2; pass++) {
-    simdjson::ondemand::document_stream stream;
-    ASSERT_SUCCESS(parser.iterate_many(input, document_stream_fuzz::batch_size, test_case.format).get(stream));
-
-    size_t index = 0;
-    for (auto it = stream.begin(); it != stream.end(); ++it) {
-      auto doc_result = *it;
-      ASSERT_SUCCESS(doc_result.error());
-      ASSERT_TRUE(index < expected.size());
-
-      simdjson::ondemand::document_reference doc;
-      ASSERT_SUCCESS(doc_result.get(doc));
-
-      std::string_view actual;
-      ASSERT_SUCCESS(simdjson::to_json_string(doc).get(actual));
-      ASSERT_EQUAL(
-          canonicalize_document(test_case.format, actual),
-          canonicalize_document(test_case.format, expected[index])
-      );
-      index++;
-    }
-    ASSERT_EQUAL(index, expected.size());
-  }
-
-  TEST_SUCCEED();
-}
-
-bool run() {
-  for (const auto &test_case : stream_cases()) {
-    std::cout << "Running fuzz corpus against stream format: " << test_case.name << std::endl;
-    if (!verify_case(test_case)) {
-      return false;
-    }
-  }
-  return true;
-}
-
-} // namespace document_stream_fuzz_tests
-
-int main(int argc, char *argv[]) {
-  return test_main(argc, argv, document_stream_fuzz_tests::run);
-}

tests/ondemand/ondemand_iterate_many_csv.cpp

@@ -13,7 +13,7 @@ bool normal() {
   auto json = R"( 1, 2, 3, 4, "a", "b", "c", {"hello": "world"} , [1, 2, 3])"_padded;
   ondemand::parser parser;
   ondemand::document_stream doc_stream;
-  ASSERT_SUCCESS(parser.iterate_many(json, json.size(), stream_format::comma_delimited).get(doc_stream));
+  ASSERT_SUCCESS(parser.iterate_many(json, json.size(), true).get(doc_stream));
 
   for (auto doc : doc_stream)
   {
@@ -28,7 +28,7 @@ bool small_batch_size() {
   auto json = R"( 1, 2, 3, 4, "a", "b", "c", {"hello": "world"} , [1, 2, 3])"_padded;
   ondemand::parser parser;
   ondemand::document_stream doc_stream;
-  ASSERT_SUCCESS(parser.iterate_many(json, 32, stream_format::comma_delimited).get(doc_stream));
+  ASSERT_SUCCESS(parser.iterate_many(json, 32, true).get(doc_stream));
 
   for (auto doc : doc_stream)
   {
@@ -43,7 +43,7 @@ bool trailing_comma() {
   auto json = R"(1,)"_padded;
   ondemand::parser parser;
   ondemand::document_stream doc_stream;
-  ASSERT_SUCCESS(parser.iterate_many(json, json.size(), stream_format::comma_delimited).get(doc_stream));
+  ASSERT_SUCCESS(parser.iterate_many(json, json.size(), true).get(doc_stream));
 
   for (auto doc : doc_stream)
   {
@@ -59,7 +59,7 @@ bool check_parsed_values() {
   auto json = R"(  1  , "a" , [100, 1]  , {"hello"  :    "world"}  , )"_padded;
   ondemand::parser parser;
   ondemand::document_stream doc_stream;
-  ASSERT_SUCCESS(parser.iterate_many(json, json.size(), stream_format::comma_delimited).get(doc_stream));
+  ASSERT_SUCCESS(parser.iterate_many(json, json.size(), true).get(doc_stream));
 
   auto begin = doc_stream.begin();
   auto end = doc_stream.end();
@@ -127,7 +127,7 @@ bool leading_comma() {
   auto json = R"(,1)"_padded;
   ondemand::parser parser;
   ondemand::document_stream doc_stream;
-  ASSERT_SUCCESS(parser.iterate_many(json, json.size(), stream_format::comma_delimited).get(doc_stream));
+  ASSERT_SUCCESS(parser.iterate_many(json, json.size(), true).get(doc_stream));
 
   try {
     auto begin = doc_stream.begin();

tests/ondemand/ondemand_padded_input.cpp

@@ -1,208 +0,0 @@
-#ifdef __FILC__
-#include <stdio.h>
-#include <stdlib.h>
-int main() {
-  printf("This test is not relevant for FILC.\n");
-  return EXIT_SUCCESS;
-}
-#else // This test is not relevant for FILC
-
-#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
-
-#endif // This test is not relevant for FILC

tests/ondemand/ondemand_ranges_tests.cpp

@@ -1,319 +0,0 @@
-#include <iostream>
-#include "simdjson.h"
-#include "test_macros.h"
-#include "test_main.h"
-
-#if SIMDJSON_SUPPORTS_RANGES
-
-#include <algorithm>
-#include <ranges>
-#include <string>
-#include <vector>
-
-using namespace simdjson;
-
-namespace ondemand_ranges_tests {
-
-#if SIMDJSON_EXCEPTIONS
-
-bool array_get_range_basic() {
-  TEST_START();
-  auto json = R"([10, 20, 30])"_padded;
-  ondemand::parser parser;
-  auto doc = parser.iterate(json);
-  auto arr = doc.get_array();
-  auto range = ondemand::get_range(arr);
-
-  std::vector<int64_t> values;
-  for (auto elem : range) {
-    values.push_back(int64_t(elem));
-  }
-  ASSERT_EQUAL(values.size(), size_t(3));
-  ASSERT_EQUAL(values[0], int64_t(10));
-  ASSERT_EQUAL(values[1], int64_t(20));
-  ASSERT_EQUAL(values[2], int64_t(30));
-  TEST_SUCCEED();
-}
-
-bool array_range_with_transform() {
-  TEST_START();
-  auto json = R"([1, 2, 3, 4, 5])"_padded;
-  ondemand::parser parser;
-  auto doc = parser.iterate(json);
-  auto arr = doc.get_array();
-
-  auto doubled = ondemand::get_range(arr)
-    | std::views::transform([](auto v) -> int64_t { return int64_t(v) * 2; });
-
-  std::vector<int64_t> values;
-  for (auto val : doubled) {
-    values.push_back(val);
-  }
-  ASSERT_EQUAL(values.size(), size_t(5));
-  ASSERT_EQUAL(values[0], int64_t(2));
-  ASSERT_EQUAL(values[1], int64_t(4));
-  ASSERT_EQUAL(values[2], int64_t(6));
-  ASSERT_EQUAL(values[3], int64_t(8));
-  ASSERT_EQUAL(values[4], int64_t(10));
-  TEST_SUCCEED();
-}
-
-bool array_range_strings() {
-  TEST_START();
-  auto json = R"(["alpha", "beta", "gamma"])"_padded;
-  ondemand::parser parser;
-  auto doc = parser.iterate(json);
-  auto arr = doc.get_array();
-
-  auto to_string = [](auto v) -> std::string {
-    return std::string(std::string_view(v));
-  };
-  auto strings = ondemand::get_range(arr) | std::views::transform(to_string);
-
-  std::vector<std::string> values;
-  for (auto s : strings) {
-    values.push_back(s);
-  }
-  ASSERT_EQUAL(values.size(), size_t(3));
-  ASSERT_TRUE(values[0] == "alpha");
-  ASSERT_TRUE(values[1] == "beta");
-  ASSERT_TRUE(values[2] == "gamma");
-  TEST_SUCCEED();
-}
-
-bool array_range_empty() {
-  TEST_START();
-  auto json = R"([])"_padded;
-  ondemand::parser parser;
-  auto doc = parser.iterate(json);
-  auto arr = doc.get_array();
-  auto range = ondemand::get_range(arr);
-
-  int count = 0;
-  for (simdjson_unused auto elem : range) {
-    count++;
-  }
-  ASSERT_EQUAL(count, 0);
-  TEST_SUCCEED();
-}
-
-bool array_range_nested() {
-  TEST_START();
-  auto json = R"([{"name": "Alice", "age": 30}, {"name": "Bob", "age": 25}])"_padded;
-  ondemand::parser parser;
-  auto doc = parser.iterate(json);
-  auto arr = doc.get_array();
-
-  auto get_name = [](auto v) -> std::string {
-    return std::string(std::string_view(v["name"]));
-  };
-  auto names = ondemand::get_range(arr) | std::views::transform(get_name);
-
-  std::vector<std::string> values;
-  for (auto name : names) {
-    values.push_back(name);
-  }
-  ASSERT_EQUAL(values.size(), size_t(2));
-  ASSERT_TRUE(values[0] == "Alice");
-  ASSERT_TRUE(values[1] == "Bob");
-  TEST_SUCCEED();
-}
-
-bool object_get_range_basic() {
-  TEST_START();
-  auto json = R"({"a": 1, "b": 2, "c": 3})"_padded;
-  ondemand::parser parser;
-  auto doc = parser.iterate(json);
-  auto obj = doc.get_object();
-  auto range = ondemand::get_key_value_range(obj);
-
-  std::vector<std::string> keys;
-  std::vector<int64_t> vals;
-  for (auto field_result : range) {
-    keys.push_back(std::string(std::string_view(field_result.escaped_key())));
-    vals.push_back(int64_t(field_result.value()));
-  }
-  ASSERT_EQUAL(keys.size(), size_t(3));
-  ASSERT_TRUE(keys[0] == "a");
-  ASSERT_TRUE(keys[1] == "b");
-  ASSERT_TRUE(keys[2] == "c");
-  ASSERT_EQUAL(vals[0], int64_t(1));
-  ASSERT_EQUAL(vals[1], int64_t(2));
-  ASSERT_EQUAL(vals[2], int64_t(3));
-  TEST_SUCCEED();
-}
-
-bool object_range_with_transform() {
-  TEST_START();
-  auto json = R"({"x": 10, "y": 20, "z": 30})"_padded;
-  ondemand::parser parser;
-  auto doc = parser.iterate(json);
-  auto obj = doc.get_object();
-
-  auto get_key = [](auto field_result) -> std::string {
-    return std::string(std::string_view(field_result.escaped_key()));
-  };
-  auto keys = ondemand::get_key_value_range(obj) | std::views::transform(get_key);
-
-  std::vector<std::string> values;
-  for (auto k : keys) {
-    values.push_back(k);
-  }
-  ASSERT_EQUAL(values.size(), size_t(3));
-  ASSERT_TRUE(values[0] == "x");
-  ASSERT_TRUE(values[1] == "y");
-  ASSERT_TRUE(values[2] == "z");
-  TEST_SUCCEED();
-}
-
-bool object_range_empty() {
-  TEST_START();
-  auto json = R"({})"_padded;
-  ondemand::parser parser;
-  auto doc = parser.iterate(json);
-  auto obj = doc.get_object();
-  auto range = ondemand::get_key_value_range(obj);
-
-  int count = 0;
-  for (simdjson_unused auto elem : range) {
-    count++;
-  }
-  ASSERT_EQUAL(count, 0);
-  TEST_SUCCEED();
-}
-
-bool get_range_from_result() {
-  TEST_START();
-  auto json = R"([100, 200, 300])"_padded;
-  ondemand::parser parser;
-  auto doc = parser.iterate(json);
-
-  // get_range with simdjson_result<array> - unwraps automatically
-  auto range = ondemand::get_range(doc.get_array());
-
-  std::vector<int64_t> values;
-  for (auto elem : range) {
-    values.push_back(int64_t(elem));
-  }
-  ASSERT_EQUAL(values.size(), size_t(3));
-  ASSERT_EQUAL(values[0], int64_t(100));
-  ASSERT_EQUAL(values[1], int64_t(200));
-  ASSERT_EQUAL(values[2], int64_t(300));
-  TEST_SUCCEED();
-}
-
-bool object_range_key_iteration() {
-  TEST_START();
-  auto json = R"({"name": "Alice", "age": 30, "city": "New York"})"_padded;
-  ondemand::parser parser;
-  auto doc = parser.iterate(json);
-  auto obj = doc.get_object();
-
-  // Test the specific pattern: iterating over field_result.key()
-  std::vector<std::string> keys;
-  for (auto field_result : ondemand::get_key_value_range(obj)) {
-    keys.push_back(std::string(field_result.escaped_key().value()));
-  }
-
-  ASSERT_EQUAL(keys.size(), size_t(3));
-  bool has_name = false, has_age = false, has_city = false;
-  for (const auto& key : keys) {
-    if (key == "name") has_name = true;
-    else if (key == "age") has_age = true;
-    else if (key == "city") has_city = true;
-  }
-  ASSERT_TRUE(has_name);
-  ASSERT_TRUE(has_age);
-  ASSERT_TRUE(has_city);
-  TEST_SUCCEED();
-}
-
-// Verify that the types satisfy the expected C++20 concepts.
-bool concept_checks() {
-  TEST_START();
-  static_assert(std::input_iterator<ondemand::array_range_iterator>);
-  static_assert(std::input_iterator<ondemand::object_range_iterator>);
-  static_assert(std::ranges::input_range<ondemand::array_range>);
-  static_assert(std::ranges::input_range<ondemand::object_range>);
-  static_assert(std::ranges::view<ondemand::array_range>);
-  static_assert(std::ranges::view<ondemand::object_range>);
-  TEST_SUCCEED();
-}
-
-#endif // SIMDJSON_EXCEPTIONS
-
-// These tests work without exceptions.
-bool array_range_noexcept_basic() {
-  TEST_START();
-  auto json = R"([1, 2, 3])"_padded;
-  ondemand::parser parser;
-  auto doc = parser.iterate(json);
-  ondemand::array arr;
-  ASSERT_SUCCESS(doc.get_array().get(arr));
-  auto range = ondemand::get_range(arr);
-  ASSERT_SUCCESS(range.error());
-
-  int count = 0;
-  for (auto elem : range) {
-    int64_t val;
-    ASSERT_SUCCESS(elem.get_int64().get(val));
-    count++;
-  }
-  ASSERT_EQUAL(count, 3);
-  TEST_SUCCEED();
-}
-
-bool object_range_noexcept_basic() {
-  TEST_START();
-  auto json = R"({"a": 1, "b": 2})"_padded;
-  ondemand::parser parser;
-  auto doc = parser.iterate(json);
-  ondemand::object obj;
-  ASSERT_SUCCESS(doc.get_object().get(obj));
-  auto range = ondemand::get_key_value_range(obj);
-  ASSERT_SUCCESS(range.error());
-
-  int count = 0;
-  for (auto field_result : range) {
-    simdjson_unused ondemand::field f;
-    ASSERT_SUCCESS(std::move(field_result).get(f));
-    count++;
-  }
-  ASSERT_EQUAL(count, 2);
-  TEST_SUCCEED();
-}
-
-bool run() {
-  return
-    array_range_noexcept_basic() &&
-    object_range_noexcept_basic() &&
-#if SIMDJSON_EXCEPTIONS
-    concept_checks() &&
-    array_get_range_basic() &&
-    array_range_with_transform() &&
-    array_range_strings() &&
-    array_range_empty() &&
-    array_range_nested() &&
-    object_get_range_basic() &&
-    object_range_with_transform() &&
-    object_range_empty() &&
-    get_range_from_result() &&
-    object_range_key_iteration() &&
-#endif // SIMDJSON_EXCEPTIONS
-    true;
-}
-
-} // namespace ondemand_ranges_tests
-
-int main(int argc, char *argv[]) {
-  return test_main(argc, argv, ondemand_ranges_tests::run);
-}
-
-#else // !SIMDJSON_SUPPORTS_RANGES
-
-int main() {
-  std::cout << "Ranges tests require C++20 ranges support, skipping." << std::endl;
-  return 0;
-}
-
-#endif // SIMDJSON_SUPPORTS_RANGES

tests/ondemand/ondemand_readme_examples.cpp

@@ -1,5 +1,4 @@
 #include "simdjson.h"
-#include "simdjson/padded_string_view.h"
 #include "test_ondemand.h"
 #if __cpp_lib_optional >= 201606L
 #include <optional>
@@ -50,33 +49,6 @@ 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
@@ -205,6 +177,68 @@ simdjson_inline simdjson_result<Car> simdjson::ondemand::document::get() & noexc
 
 #if SIMDJSON_EXCEPTIONS
 
+// Test matching the doc example in doc/basics.md
+// "Using for_each_at_path_with_wildcard for JSONPath Queries (On-Demand)"
+bool wildcard_basics_example() {
+  TEST_START();
+  simdjson::padded_string json_string = R"(
+{
+  "firstName": "John",
+  "lastName": "doe",
+  "age": 26,
+  "address": {
+    "streetAddress": "naist street",
+    "city": "Nara",
+    "postalCode": "630-0192"
+  },
+  "phoneNumbers": [
+    {
+      "type": "iPhone",
+      "numbers": ["0123-4567-8888", "0123-4567-8788"]
+    },
+    {
+      "type": "home",
+      "numbers": ["0123-4567-8910"]
+    }
+  ]
+})"_padded;
+
+  ondemand::parser parser;
+  ondemand::document doc = parser.iterate(json_string);
+
+  // Fetch all fields in the address object
+  std::vector<std::string_view> fields;
+  auto error = doc.for_each_at_path_with_wildcard("$.address.*",
+      [&](ondemand::value value) {
+        std::string_view field;
+        if (value.get(field) == SUCCESS) {
+          fields.push_back(field);
+        }
+      });
+  ASSERT_SUCCESS(error);
+  ASSERT_EQUAL(fields.size(), 3);
+  ASSERT_EQUAL(fields[0], "naist street");
+  ASSERT_EQUAL(fields[1], "Nara");
+  ASSERT_EQUAL(fields[2], "630-0192");
+
+  // Fetch all phone numbers
+  std::vector<std::string_view> numbers;
+  error = doc.for_each_at_path_with_wildcard("$.phoneNumbers[*].numbers[*]",
+      [&](ondemand::value value) {
+        std::string_view number;
+        if (value.get(number) == SUCCESS) {
+          numbers.push_back(number);
+        }
+      });
+  ASSERT_SUCCESS(error);
+  ASSERT_EQUAL(numbers.size(), 3);
+  ASSERT_EQUAL(numbers[0], "0123-4567-8888");
+  ASSERT_EQUAL(numbers[1], "0123-4567-8788");
+  ASSERT_EQUAL(numbers[2], "0123-4567-8910");
+
+  TEST_SUCCEED();
+}
+
 void main_capture() {
   padded_string json_padded = "{\"a\":[1,2,3], \"b\": 2, \"c\": \"hello\"}"_padded;
   std::vector<std::string_view> fields;
@@ -1706,7 +1740,10 @@ bool allow_comma_separated_example() {
   auto json = R"( 1, 2, 3, 4, "a", "b", "c", {"hello": "world"} , [1, 2, 3])"_padded;
   ondemand::parser parser;
   ondemand::document_stream doc_stream;
-  auto error = parser.iterate_many(json, 32, simdjson::stream_format::comma_delimited).get(doc_stream);
+  // We pass '32' as the batch size, but it is a bogus parameter because, since
+  // we pass 'true' to the allow_comma parameter, the batch size will be set to at least
+  // the document size.
+  auto error = parser.iterate_many(json, 32, true).get(doc_stream);
   if(error) { std::cerr << error << std::endl; return false; }
   for (auto doc : doc_stream) {
     std::cout << doc.type() << std::endl;
@@ -2041,6 +2078,7 @@ bool value_raw_json_object() {
 }
 
 #endif
+
 bool run() {
   return true
     && fatal_error()
@@ -2100,6 +2138,7 @@ bool run() {
     && current_location_no_error()
     && to_string_example_no_except()
   #if SIMDJSON_EXCEPTIONS
+    && wildcard_basics_example()
     && issue2215()
     && to_string_example()
     && raw_string()

tests/ondemand/ondemand_wildcard_tests.cpp

@@ -21,18 +21,16 @@ namespace wildcard_tests {
     ondemand::parser parser;
     auto doc = parser.iterate(json);
 
-    std::vector<ondemand::value> titles;
-    ASSERT_SUCCESS(doc.at_path_with_wildcard("$.books[*].title").get(titles));
+    std::vector<std::string_view> titles;
+    ASSERT_SUCCESS(doc.for_each_at_path_with_wildcard("$.books[*].title", [&](ondemand::value v) {
+      std::string_view sv;
+      if (v.get_string().get(sv) == SUCCESS) { titles.push_back(sv); }
+    }));
 
     ASSERT_EQUAL(titles.size(), 3);
-
-    std::string_view title;
-    ASSERT_SUCCESS(titles[0].get_string().get(title));
-    ASSERT_EQUAL(title, "Book A");
-    ASSERT_SUCCESS(titles[1].get_string().get(title));
-    ASSERT_EQUAL(title, "Book B");
-    ASSERT_SUCCESS(titles[2].get_string().get(title));
-    ASSERT_EQUAL(title, "Book C");
+    ASSERT_EQUAL(titles[0], "Book A");
+    ASSERT_EQUAL(titles[1], "Book B");
+    ASSERT_EQUAL(titles[2], "Book C");
 
     TEST_SUCCEED();
   }
@@ -46,18 +44,16 @@ namespace wildcard_tests {
     ondemand::parser parser;
     auto doc = parser.iterate(json);
 
-    std::vector<ondemand::value> prices;
-    ASSERT_SUCCESS(doc.at_path_with_wildcard("$.prices[*]").get(prices));
+    std::vector<uint64_t> prices;
+    ASSERT_SUCCESS(doc.for_each_at_path_with_wildcard("$.prices[*]", [&](ondemand::value v) {
+      uint64_t p;
+      if (v.get_uint64().get(p) == SUCCESS) { prices.push_back(p); }
+    }));
 
     ASSERT_EQUAL(prices.size(), 5);
-
-    uint64_t price;
-    ASSERT_SUCCESS(prices[0].get_uint64().get(price));
-    ASSERT_EQUAL(price, 10);
-    ASSERT_SUCCESS(prices[2].get_uint64().get(price));
-    ASSERT_EQUAL(price, 30);
-    ASSERT_SUCCESS(prices[4].get_uint64().get(price));
-    ASSERT_EQUAL(price, 50);
+    ASSERT_EQUAL(prices[0], 10);
+    ASSERT_EQUAL(prices[2], 30);
+    ASSERT_EQUAL(prices[4], 50);
 
     TEST_SUCCEED();
   }
@@ -75,19 +71,14 @@ namespace wildcard_tests {
     ondemand::parser parser;
     auto doc = parser.iterate(json);
 
-    std::vector<ondemand::value> names;
-    auto error = doc.at_path_with_wildcard("$.users.*.name").get(names);
+    std::set<std::string_view> name_set;
+    auto error = doc.for_each_at_path_with_wildcard("$.users.*.name", [&](ondemand::value v) {
+      std::string_view sv;
+      if (v.get_string().get(sv) == SUCCESS) { name_set.insert(sv); }
+    });
     ASSERT_SUCCESS(error);
 
-    ASSERT_EQUAL(names.size(), 3);
-
-    // Verify we got all three names (order may vary)
-    std::set<std::string_view> name_set;
-    for (auto& name : names) {
-      std::string_view view;
-      ASSERT_SUCCESS(name.get_string().get(view));
-      name_set.insert(view);
-    }
+    ASSERT_EQUAL(name_set.size(), 3);
     ASSERT_TRUE(name_set.count("Alice") > 0);
     ASSERT_TRUE(name_set.count("Bob") > 0);
     ASSERT_TRUE(name_set.count("Charlie") > 0);
@@ -117,19 +108,15 @@ namespace wildcard_tests {
     ondemand::parser parser;
     auto doc = parser.iterate(json);
 
-    std::vector<ondemand::value> salaries;
-    auto error = doc.at_path_with_wildcard("$.departments.*.employees[*].salary").get(salaries);
+    uint64_t total = 0;
+    size_t count = 0;
+    auto error = doc.for_each_at_path_with_wildcard("$.departments.*.employees[*].salary", [&](ondemand::value v) {
+      uint64_t s;
+      if (v.get_uint64().get(s) == SUCCESS) { total += s; count++; }
+    });
     ASSERT_SUCCESS(error);
 
-    ASSERT_EQUAL(salaries.size(), 4);
-
-    // Check sum of all salaries
-    uint64_t total = 0;
-    for (auto& salary : salaries) {
-      uint64_t value;
-      ASSERT_SUCCESS(salary.get_uint64().get(value));
-      total += value;
-    }
+    ASSERT_EQUAL(count, 4);
     ASSERT_EQUAL(total, 360000);
 
     TEST_SUCCEED();
@@ -142,11 +129,12 @@ namespace wildcard_tests {
     ondemand::parser parser;
     auto doc = parser.iterate(json);
 
-    std::vector<ondemand::value> items;
-    auto error = doc.at_path_with_wildcard("$.items[*].name").get(items);
+    size_t count = 0;
+    auto error = doc.for_each_at_path_with_wildcard("$.items[*].name", [&](ondemand::value) {
+      count++;
+    });
     ASSERT_SUCCESS(error);
-
-    ASSERT_EQUAL(items.size(), 0);
+    ASSERT_EQUAL(count, 0);
 
     TEST_SUCCEED();
   }
@@ -158,11 +146,12 @@ namespace wildcard_tests {
     ondemand::parser parser;
     auto doc = parser.iterate(json);
 
-    std::vector<ondemand::value> names;
-    auto error = doc.at_path_with_wildcard("$.users.*.name").get(names);
+    size_t count = 0;
+    auto error = doc.for_each_at_path_with_wildcard("$.users.*.name", [&](ondemand::value) {
+      count++;
+    });
     ASSERT_SUCCESS(error);
-
-    ASSERT_EQUAL(names.size(), 0);
+    ASSERT_EQUAL(count, 0);
 
     TEST_SUCCEED();
   }
@@ -175,8 +164,7 @@ namespace wildcard_tests {
     auto doc = parser.iterate(json);
 
     // Can't use array wildcard on scalar
-    std::vector<ondemand::value> values;
-    auto error = doc.at_path_with_wildcard("$.data[*]").get(values);
+    auto error = doc.for_each_at_path_with_wildcard("$.data[*]", [](ondemand::value) {});
     ASSERT_ERROR(error, INVALID_JSON_POINTER);
 
     TEST_SUCCEED();
@@ -195,12 +183,12 @@ namespace wildcard_tests {
     ondemand::parser parser;
     auto doc = parser.iterate(json);
 
-    // Get all nested arrays
-    std::vector<ondemand::value> arrays;
-    ASSERT_SUCCESS(doc.at_path_with_wildcard("$.matrix[*]").get(arrays));
+    size_t count = 0;
+    ASSERT_SUCCESS(doc.for_each_at_path_with_wildcard("$.matrix[*]", [&](ondemand::value) {
+      count++;
+    }));
 
-    // Verify we got 3 arrays
-    ASSERT_EQUAL(arrays.size(), 3);
+    ASSERT_EQUAL(count, 3);
 
     TEST_SUCCEED();
   }
@@ -218,18 +206,16 @@ namespace wildcard_tests {
     ondemand::parser parser;
     auto doc = parser.iterate(json);
 
-    std::vector<ondemand::value> statuses;
-    ASSERT_SUCCESS(doc.at_path_with_wildcard("$.data[*].info.status").get(statuses));
+    std::vector<std::string_view> statuses;
+    ASSERT_SUCCESS(doc.for_each_at_path_with_wildcard("$.data[*].info.status", [&](ondemand::value v) {
+      std::string_view sv;
+      if (v.get_string().get(sv) == SUCCESS) { statuses.push_back(sv); }
+    }));
 
     ASSERT_EQUAL(statuses.size(), 3);
-
-    std::string_view status;
-    ASSERT_SUCCESS(statuses[0].get_string().get(status));
-    ASSERT_EQUAL(status, "active");
-    ASSERT_SUCCESS(statuses[1].get_string().get(status));
-    ASSERT_EQUAL(status, "inactive");
-    ASSERT_SUCCESS(statuses[2].get_string().get(status));
-    ASSERT_EQUAL(status, "active");
+    ASSERT_EQUAL(statuses[0], "active");
+    ASSERT_EQUAL(statuses[1], "inactive");
+    ASSERT_EQUAL(statuses[2], "active");
 
     TEST_SUCCEED();
   }
@@ -250,13 +236,12 @@ namespace wildcard_tests {
     ondemand::parser parser;
     auto doc = parser.iterate(json);
 
-    std::vector<ondemand::value> values;
-    ASSERT_SUCCESS(doc.at_path_with_wildcard("$.mixed[*]").get(values));
+    size_t count = 0;
+    ASSERT_SUCCESS(doc.for_each_at_path_with_wildcard("$.mixed[*]", [&](ondemand::value) {
+      count++;
+    }));
 
-    // Just verify we got all 6 elements
-    ASSERT_EQUAL(values.size(), 6);
-
-    // Don't try to access the values - they've been consumed by the OnDemand API
+    ASSERT_EQUAL(count, 6);
 
     TEST_SUCCEED();
   }
@@ -275,8 +260,11 @@ namespace wildcard_tests {
     auto doc = parser.iterate(json);
 
     // Third element doesn't have "name" field
-    std::vector<ondemand::value> names;
-    auto error = doc.at_path_with_wildcard("$.data[*].name").get(names);
+    std::vector<std::string_view> names;
+    auto error = doc.for_each_at_path_with_wildcard("$.data[*].name", [&](ondemand::value v) {
+      std::string_view sv;
+      if (v.get_string().get(sv) == SUCCESS) { names.push_back(sv); }
+    });
 
     // This might error or return partial results
     if (error) {
@@ -301,18 +289,47 @@ namespace wildcard_tests {
     ondemand::parser parser;
     auto doc = parser.iterate(json);
 
-    std::vector<ondemand::value> names;
-    ASSERT_SUCCESS(doc.at_path_with_wildcard("$[*].name").get(names));
+    std::vector<std::string_view> names;
+    ASSERT_SUCCESS(doc.for_each_at_path_with_wildcard("$[*].name", [&](ondemand::value v) {
+      std::string_view sv;
+      if (v.get_string().get(sv) == SUCCESS) { names.push_back(sv); }
+    }));
 
     ASSERT_EQUAL(names.size(), 3);
+    ASSERT_EQUAL(names[0], "Item 1");
+    ASSERT_EQUAL(names[1], "Item 2");
+    ASSERT_EQUAL(names[2], "Item 3");
 
-    std::string_view name;
-    ASSERT_SUCCESS(names[0].get_string().get(name));
-    ASSERT_EQUAL(name, "Item 1");
-    ASSERT_SUCCESS(names[1].get_string().get(name));
-    ASSERT_EQUAL(name, "Item 2");
-    ASSERT_SUCCESS(names[2].get_string().get(name));
-    ASSERT_EQUAL(name, "Item 3");
+    TEST_SUCCEED();
+  }
+
+  // https://github.com/simdjson/simdjson/issues/2684
+  bool wildcard_raw_json_issue_2684() {
+    TEST_START();
+    auto json = R"([{"tag_meta":{"meta_code":2000211,"meta_value":""},"tag_value":""}])"_padded;
+
+    ondemand::parser parser;
+    auto doc = parser.iterate(json);
+
+    size_t count = 0;
+    bool raw_json_ok = true;
+    ASSERT_SUCCESS(doc.for_each_at_path_with_wildcard("$[*].tag_meta", [&](ondemand::value v) {
+      count++;
+      std::string_view raw;
+      if (v.raw_json().get(raw) != SUCCESS) {
+        raw_json_ok = false;
+        return;
+      }
+      // raw_json() must not leak sibling fields or outer array delimiters
+      std::string_view expected = R"({"meta_code":2000211,"meta_value":""})";
+      if (raw != expected || raw.find("tag_value") != std::string_view::npos) {
+        std::cerr << "  raw_json() returned: " << raw << std::endl;
+        raw_json_ok = false;
+      }
+    }));
+
+    ASSERT_EQUAL(count, 1);
+    ASSERT_TRUE(raw_json_ok);
 
     TEST_SUCCEED();
   }
@@ -329,10 +346,11 @@ namespace wildcard_tests {
            wildcard_with_nested_objects() &&
            mixed_types_in_array() &&
            wildcard_nonexistent_field() &&
-           root_array_wildcard();
+           root_array_wildcard() &&
+           wildcard_raw_json_issue_2684();
   }
 }
 
 int main(int argc, char *argv[]) {
   return test_main(argc, argv, wildcard_tests::run);
-}
+}

tests/ondemand/ondemand_wrong_type_error_tests.cpp

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