version bump.

.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

.github/workflows/vs17-ci.yml

@@ -13,20 +13,18 @@ jobs:
       fail-fast: false
       matrix:
         include:
-          - {gen: Visual Studio 17 2022, arch: Win32, shared: ON, build_type: Release, memory_map: OFF}
-          - {gen: Visual Studio 17 2022, arch: Win32, shared: OFF, build_type: Release, memory_map: OFF}
-          - {gen: Visual Studio 17 2022, arch: x64, shared: ON, build_type: Release, memory_map: OFF}
-          - {gen: Visual Studio 17 2022, arch: x64, shared: OFF, build_type: Debug, memory_map: OFF}
-          - {gen: Visual Studio 17 2022, arch: x64, shared: OFF, build_type: Release, memory_map: OFF}
-          - {gen: Visual Studio 17 2022, arch: x64, shared: OFF, build_type: RelWithDebInfo, memory_map: OFF}
-          # Exercise the opt-in Windows memory-file mapping path at least once in CI.
-          - {gen: Visual Studio 17 2022, arch: x64, shared: OFF, build_type: Release, memory_map: ON}
+          - {gen: Visual Studio 17 2022, arch: Win32, shared: ON, build_type: Release}
+          - {gen: Visual Studio 17 2022, arch: Win32, shared: OFF, build_type: Release}
+          - {gen: Visual Studio 17 2022, arch: x64, shared: ON, build_type: Release}
+          - {gen: Visual Studio 17 2022, arch: x64, shared: OFF, build_type: Debug}
+          - {gen: Visual Studio 17 2022, arch: x64, shared: OFF, build_type: Release}
+          - {gen: Visual Studio 17 2022, arch: x64, shared: OFF, build_type: RelWithDebInfo}
     steps:
     - name: checkout
       uses: actions/checkout@v4
     - name: Configure
       run: |
-        cmake -G "${{matrix.gen}}" -A ${{matrix.arch}} -DSIMDJSON_DEVELOPER_MODE=ON -DSIMDJSON_COMPETITION=OFF -DBUILD_SHARED_LIBS=${{matrix.shared}} -DSIMDJSON_ENABLE_MEMORY_FILE_MAPPING_ON_WINDOWS=${{matrix.memory_map}} -B build
+        cmake -G "${{matrix.gen}}" -A ${{matrix.arch}} -DSIMDJSON_DEVELOPER_MODE=ON -DSIMDJSON_COMPETITION=OFF -DBUILD_SHARED_LIBS=${{matrix.shared}} -B build
     - name: Build Debug
       run: cmake --build build --config ${{matrix.build_type}} --verbose
     - name: Run tests

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.2
     DESCRIPTION "Parsing gigabytes of JSON per second"
     HOMEPAGE_URL "https://simdjson.org/"
     LANGUAGES CXX C
@@ -75,41 +75,6 @@ if(SIMDJSON_DEVELOPMENT_CHECKS)
   )
 endif()
 
-# padded_memory_map is always available on POSIX. On Windows it is disabled
-# by default because it depends on the `CreateFileMapping2` / `MapViewOfFile3`
-# APIs, which require Windows 10 version 1803 or later and are exported via
-# onecore.lib rather than the default kernel32.lib. Turn this option ON to
-# opt into the feature on Windows; simdjson will then set the appropriate
-# Windows version macros and link onecore, so everything that links
-# simdjson picks up both the compile-time declarations and the import
-# library automatically. The option is a no-op on POSIX (where the feature
-# is unconditionally enabled).
-option(SIMDJSON_ENABLE_MEMORY_FILE_MAPPING_ON_WINDOWS
-  "Enable simdjson::padded_memory_map on Windows (requires Windows 10 \
-version 1803 or later). Always enabled on POSIX." OFF)
-if(SIMDJSON_ENABLE_MEMORY_FILE_MAPPING_ON_WINDOWS)
-  simdjson_add_props(
-      target_compile_definitions PUBLIC
-      SIMDJSON_ENABLE_MEMORY_FILE_MAPPING_ON_WINDOWS=1
-  )
-  if(WIN32)
-    # Raise the Windows version floor so that <windows.h> declares the
-    # modern memory-mapping APIs, and link the import library that
-    # actually exports them. _WIN32_WINNT / WINVER / NTDDI_VERSION together
-    # tell <sdkddkver.h> which APIs to light up.
-    simdjson_add_props(
-        target_compile_definitions PUBLIC
-        _WIN32_WINNT=0x0A00
-        WINVER=0x0A00
-        NTDDI_VERSION=0x0A000006 # NTDDI_WIN10_RS5, Windows 10 version 1809
-    )
-    simdjson_add_props(
-        target_link_libraries PUBLIC
-        onecore
-    )
-  endif()
-endif()
-
 if(is_top_project)
   option(SIMDJSON_INSTALL "Enable target install" ON)
   option(SIMDJSON_DEVELOPER_MODE "Enable targets for developing simdjson" OFF)
@@ -202,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()
@@ -446,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.2"
 
 # 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

@@ -1,10 +1,9 @@
 add_subdirectory(dom)
 
 
-include_directories( . )
+include_directories( . linux )
 link_libraries(simdjson-windows-headers test-data)
 link_libraries(simdjson)
-link_libraries(counters)
 if(SIMDJSON_STATIC_REFLECTION)
   add_compile_definitions(SIMDJSON_STATIC_REFLECTION=1)
 endif(SIMDJSON_STATIC_REFLECTION)
@@ -16,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

@@ -40,7 +40,6 @@ SIMDJSON_POP_DISABLE_WARNINGS
 #include "json2msgpack/boostjson.h"
 
 #include "partial_tweets/simdjson_ondemand.h"
-#include "partial_tweets/simdjson_ondemand_key_selector.h"
 #include "partial_tweets/simdjson_dom.h"
 #include "partial_tweets/yyjson.h"
 #if SIMDJSON_COMPETITION_ONDEMAND_SAJSON

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

@@ -1,5 +1,4 @@
-#include <counters/event_counter.h>
-using namespace counters;
+#include "event_counter.h"
 
 #include <cassert>
 #include <cctype>
@@ -26,6 +25,7 @@ using namespace counters;
 #include <string>
 #include <vector>
 
+#include "linux-perf-events.h"
 #ifdef __linux__
 #include <libgen.h>
 #endif
@@ -204,8 +204,12 @@ struct feature_benchmarker {
   }
   // Rate of 1-7-structural misses per 8-structural flip
   double struct1_7_miss_rate(BenchmarkStage stage) const {
+#if SIMDJSON_SIMPLE_PERFORMANCE_COUNTERS
+    return 1;
+#else
     if (!has_events()) { return 1; }
     return struct7_miss[stage].best.branch_misses() - struct7[stage].best.branch_misses() / double(struct7_miss.stats->blocks_with_1_structural_flipped);
+#endif
   }
   // Extra cost of an 8-15 structural block over a 1-7 structural block
   double struct8_15_cost(BenchmarkStage stage) const {
@@ -217,8 +221,12 @@ struct feature_benchmarker {
   }
   // Rate of 8-15-structural misses per 8-structural flip
   double struct8_15_miss_rate(BenchmarkStage stage) const {
+#if SIMDJSON_SIMPLE_PERFORMANCE_COUNTERS
+    return 1;
+#else
     if (!has_events()) { return 1; }
     return double(struct15_miss[stage].best.branch_misses() - struct15[stage].best.branch_misses()) / double(struct15_miss.stats->blocks_with_8_structurals_flipped);
+#endif
   }
 
   // Extra cost of a 16+-structural block over an 8-15 structural block (actual varies based on # of structurals!)
@@ -231,8 +239,12 @@ struct feature_benchmarker {
   }
   // Rate of 16-structural misses per 16-structural flip
   double struct16_miss_rate(BenchmarkStage stage) const {
+#if SIMDJSON_SIMPLE_PERFORMANCE_COUNTERS
+    return 1;
+#else
     if (!has_events()) { return 1; }
     return double(struct23_miss[stage].best.branch_misses() - struct23[stage].best.branch_misses()) / double(struct23_miss.stats->blocks_with_16_structurals_flipped);
+#endif
   }
 
 
@@ -246,8 +258,12 @@ struct feature_benchmarker {
   }
   // Rate of UTF-8 misses per UTF-8 flip
   double utf8_miss_rate(BenchmarkStage stage) const {
+#if SIMDJSON_SIMPLE_PERFORMANCE_COUNTERS
+    return 1;
+#else
     if (!has_events()) { return 1; }
     return double(utf8_miss[stage].best.branch_misses() - utf8[stage].best.branch_misses()) / double(utf8_miss.stats->blocks_with_utf8_flipped);
+#endif
   }
   // Extra cost of having escapes in a block
   double escape_cost(BenchmarkStage stage) const {
@@ -259,8 +275,12 @@ struct feature_benchmarker {
   }
   // Rate of escape misses per escape flip
   double escape_miss_rate(BenchmarkStage stage) const {
+#if SIMDJSON_SIMPLE_PERFORMANCE_COUNTERS
+    return 1;
+#else
     if (!has_events()) { return 1; }
     return double(escape_miss[stage].best.branch_misses() - escape[stage].best.branch_misses()) / double(escape_miss.stats->blocks_with_escapes_flipped);
+#endif
   }
 
 
@@ -358,6 +378,22 @@ struct feature_benchmarker {
   }
 };
 
+#if SIMDJSON_SIMPLE_PERFORMANCE_COUNTERS
+void print_file_effectiveness(BenchmarkStage stage, const char* filename, const benchmarker& results, const feature_benchmarker& features) {
+  double actual = results[stage].best.elapsed_ns() / double(results.stats->blocks);
+  double calc = features.calc_expected(stage, results);
+  double calc_misses = features.calc_expected_misses(stage, results);
+  double calc_miss_cost = features.calc_expected_miss_cost(stage, results);
+  printf("        | %-8s ", benchmark_stage_name(stage));
+  printf("| %-15s ",   filename);
+  printf("|    %8.3g ", features.calc_expected_feature_cost(stage, results));
+  printf("|    %8.3g ", calc_miss_cost);
+  printf("| %8.3g ",  calc);
+  printf("| %8.3g ",  actual);
+  printf("| %+8.3g ", actual - calc);
+  printf("| %13llu ", (long long unsigned)(calc_misses));
+}
+#else
 void print_file_effectiveness(BenchmarkStage stage, const char* filename, const benchmarker& results, const feature_benchmarker& features) {
   double actual = results[stage].best.elapsed_ns() / double(results.stats->blocks);
   double calc = features.calc_expected(stage, results);
@@ -381,6 +417,7 @@ void print_file_effectiveness(BenchmarkStage stage, const char* filename, const
   }
   printf("|\n");
 }
+#endif
 
 int main(int argc, char *argv[]) {
   // Read options

benchmark/benchmark.h

@@ -1,8 +1,7 @@
 #ifndef _BENCHMARK_H_
 #define _BENCHMARK_H_
 
-#include <counters/event_counter.h>
-using namespace counters;
+#include "event_counter.h"
 
 /*
  * Prints the best number of operations per cycle where

benchmark/benchmarker.h

@@ -1,8 +1,7 @@
 #ifndef __BENCHMARKER_H
 #define __BENCHMARKER_H
 
-#include <counters/event_counter.h>
-using namespace counters;
+#include "event_counter.h"
 #include "simdjson.h"
 
 #include <cassert>
@@ -29,9 +28,11 @@ using namespace counters;
 #include <string>
 #include <vector>
 
+#include "linux-perf-events.h"
 #ifdef __linux__
 #include <libgen.h>
 #endif
+#include "simdjson.h"
 
 #include <functional>
 
@@ -422,12 +423,18 @@ struct benchmarker {
         stage.instructions() / static_cast<double>(stats->structurals),
         stage.instructions() / static_cast<double>(stage.cycles())
       );
-      printf("%s%-13s: %7.0f branch misses (%6.2f%%)\n",
+#if !SIMDJSON_SIMPLE_PERFORMANCE_COUNTERS
+      // NOTE: removed cycles/miss because it is a somewhat misleading stat
+      printf("%s%-13s: %7.0f branch misses (%6.2f%%) - %.0f cache misses (%6.2f%%) - %.2f cache references\n",
         prefix,
         "Misses",
         stage.branch_misses(),
-        percent(stage.branch_misses(), all_stages_without_allocation.branch_misses())
+        percent(stage.branch_misses(), all_stages_without_allocation.branch_misses()),
+        stage.cache_misses(),
+        percent(stage.cache_misses(), all_stages_without_allocation.cache_misses()),
+        stage.cache_references()
       );
+#endif
     }
   }
 

benchmark/car_builder/benchmark_car_builder.cpp

@@ -1,5 +1,4 @@
-#include <counters/event_counter.h>
-using namespace counters;
+#include "event_counter.h"
 #include <random>
 #include <vector>
 

benchmark/dom/CMakeLists.txt

@@ -1,12 +1,11 @@
-include_directories( .. )
+include_directories( .. ../linux )
 link_libraries(simdjson-windows-headers test-data)
 link_libraries(simdjson)
-link_libraries(counters)
 
 add_executable(perfdiff perfdiff.cpp)
 add_executable(parse parse.cpp)
 add_executable(parse_stream parse_stream.cpp)
-
+add_executable(statisticalmodel statisticalmodel.cpp)
 
 add_executable(parse_noutf8validation parse.cpp)
 target_compile_definitions(parse_noutf8validation PRIVATE SIMDJSON_SKIPUTF8VALIDATION)

benchmark/dom/parse.cpp

@@ -1,5 +1,4 @@
-#include <counters/event_counter.h>
-using namespace counters;
+#include "event_counter.h"
 
 #include <cassert>
 #include <cctype>
@@ -25,6 +24,7 @@ using namespace counters;
 #include <string>
 #include <vector>
 
+#include "linux-perf-events.h"
 #ifdef __linux__
 #include <libgen.h>
 #endif

benchmark/dom/statisticalmodel.cpp

@@ -0,0 +1,207 @@
+#include <iostream>
+#include <unistd.h>
+#include "simdjson.h"
+#ifdef __linux__
+#include "linux-perf-events.h"
+#endif
+
+size_t count_nonasciibytes(const uint8_t *input, size_t length) {
+  size_t count = 0;
+  for (size_t i = 0; i < length; i++) {
+    count += input[i] >> 7;
+  }
+  return count;
+}
+
+size_t count_backslash(const uint8_t *input, size_t length) {
+  size_t count = 0;
+  for (size_t i = 0; i < length; i++) {
+    count += (input[i] == '\\') ? 1 : 0;
+  }
+  return count;
+}
+
+struct stat_s {
+  size_t integer_count;
+  size_t float_count;
+  size_t string_count;
+  size_t backslash_count;
+  size_t non_ascii_byte_count;
+  size_t object_count;
+  size_t array_count;
+  size_t null_count;
+  size_t true_count;
+  size_t false_count;
+  size_t byte_count;
+  size_t structural_indexes_count;
+  bool valid;
+};
+
+using stat_t = struct stat_s;
+
+
+
+simdjson_inline void simdjson_process_atom(stat_t &s,
+                                         simdjson::dom::element element) {
+  if (element.is<int64_t>()) {
+    s.integer_count++;
+  } else if(element.is<std::string_view>()) {
+    s.string_count++;
+  } else if(element.is<double>()) {
+    s.float_count++;
+  } else if (element.is<bool>()) {
+    bool v;
+    simdjson::error_code error;
+    if ((error = element.get(v))) { std::cerr << error << std::endl; abort(); }
+    if (v) {
+      s.true_count++;
+    } else {
+      s.false_count++;
+    }
+  } else if (element.is_null()) {
+    s.null_count++;
+  }
+}
+
+void simdjson_recurse(stat_t &s, simdjson::dom::element element) {
+  simdjson::error_code error;
+  if (element.is<simdjson::dom::array>()) {
+    s.array_count++;
+    simdjson::dom::array array;
+    if ((error = element.get(array))) { std::cerr << error << std::endl; abort(); }
+    for (auto child : array) {
+      if (child.is<simdjson::dom::array>() || child.is<simdjson::dom::object>()) {
+        simdjson_recurse(s, child);
+      } else {
+        simdjson_process_atom(s, child);
+      }
+    }
+  } else if (element.is<simdjson::dom::object>()) {
+    s.object_count++;
+    simdjson::dom::object object;
+    if ((error = element.get(object))) { std::cerr << error << std::endl; abort(); }
+    for (auto field : object) {
+      s.string_count++; // for key
+      if (field.value.is<simdjson::dom::array>() || field.value.is<simdjson::dom::object>()) {
+        simdjson_recurse(s, field.value);
+      } else {
+        simdjson_process_atom(s, field.value);
+      }
+    }
+  } else {
+    simdjson_process_atom(s, element);
+  }
+}
+
+stat_t simdjson_compute_stats(const simdjson::padded_string &p) {
+  stat_t answer{};
+  simdjson::dom::parser parser;
+  simdjson::dom::element doc;
+  auto error = parser.parse(p).get(doc);
+  if (error) {
+    answer.valid = false;
+    return answer;
+  }
+  answer.valid = true;
+  answer.backslash_count =
+      count_backslash(reinterpret_cast<const uint8_t *>(p.data()), p.size());
+  answer.non_ascii_byte_count = count_nonasciibytes(
+      reinterpret_cast<const uint8_t *>(p.data()), p.size());
+  answer.byte_count = p.size();
+  answer.structural_indexes_count = parser.implementation->n_structural_indexes;
+  simdjson_recurse(answer, doc);
+  return answer;
+}
+
+int main(int argc, char *argv[]) {
+#ifndef _MSC_VER
+  int c;
+  while ((c = getopt(argc, argv, "")) != -1) {
+    switch (c) {
+
+    default:
+      abort();
+    }
+  }
+#else
+  int optind = 1;
+#endif
+  if (optind >= argc) {
+    std::cerr << "Reads json, prints stats. " << std::endl;
+    std::cerr << "Usage: " << argv[0] << " <jsonfile>" << std::endl;
+
+    exit(1);
+  }
+  const char *filename = argv[optind];
+  if (optind + 1 < argc) {
+    std::cerr << "warning: ignoring everything after " << argv[optind + 1]
+              << std::endl;
+  }
+  simdjson::padded_string p;
+  auto error = simdjson::padded_string::load(filename).get(p);
+  if (error) {
+    std::cerr << "Could not load the file " << filename << std::endl;
+    return EXIT_FAILURE;
+  }
+  stat_t s = simdjson_compute_stats(p);
+  if (!s.valid) {
+    std::cerr << "not a valid JSON" << std::endl;
+    return EXIT_FAILURE;
+  }
+
+  printf("# integer_count float_count string_count backslash_count "
+         "non_ascii_byte_count object_count array_count null_count true_count "
+         "false_count byte_count structural_indexes_count ");
+#ifdef __linux__
+  printf("  stage1_cycle_count stage1_instruction_count  stage2_cycle_count "
+         " stage2_instruction_count  stage3_cycle_count "
+         "stage3_instruction_count  ");
+#else
+  printf("(you are not under linux, so perf counters are disaabled)");
+#endif
+  printf("\n");
+  printf("%zu %zu %zu %zu %zu %zu %zu %zu %zu %zu %zu %zu ", s.integer_count,
+         s.float_count, s.string_count, s.backslash_count,
+         s.non_ascii_byte_count, s.object_count, s.array_count, s.null_count,
+         s.true_count, s.false_count, s.byte_count, s.structural_indexes_count);
+#ifdef __linux__
+  simdjson::dom::parser parser;
+  simdjson::error_code alloc_error = parser.allocate(p.size());
+  if (alloc_error) {
+    std::cerr << alloc_error << std::endl;
+    return EXIT_FAILURE;
+  }
+  const uint32_t iterations = p.size() < 1 * 1000 * 1000 ? 1000 : 50;
+  std::vector<int> evts;
+  evts.push_back(PERF_COUNT_HW_CPU_CYCLES);
+  evts.push_back(PERF_COUNT_HW_INSTRUCTIONS);
+  LinuxEvents<PERF_TYPE_HARDWARE> unified(evts);
+  unsigned long cy1 = 0, cy2 = 0;
+  unsigned long cl1 = 0, cl2 = 0;
+  std::vector<unsigned long long> results;
+  results.resize(evts.size());
+  for (uint32_t i = 0; i < iterations; i++) {
+    unified.start();
+    // The default template is simdjson::architecture::NATIVE.
+    bool isok = (parser.implementation->stage1((const uint8_t *)p.data(), p.size(), simdjson::stage1_mode::regular) == simdjson::SUCCESS);
+    unified.end(results);
+
+    cy1 += results[0];
+    cl1 += results[1];
+
+    unified.start();
+    isok = isok && (parser.implementation->stage2(parser.doc) == simdjson::SUCCESS);
+    unified.end(results);
+
+    cy2 += results[0];
+    cl2 += results[1];
+    if (!isok) {
+      std::cerr << "failure?" << std::endl;
+    }
+  }
+  printf("%f %f %f %f ", static_cast<double>(cy1) / static_cast<double>(iterations), static_cast<double>(cl1) / static_cast<double>(iterations),
+         static_cast<double>(cy2) / static_cast<double>(iterations), static_cast<double>(cl2) / static_cast<double>(iterations));
+#endif // __linux__
+  printf("\n");
+  return EXIT_SUCCESS;
+}

benchmark/event_counter.h

@@ -0,0 +1,201 @@
+#ifndef __EVENT_COUNTER_H
+#define __EVENT_COUNTER_H
+
+#ifndef SIMDJSON_SIMPLE_PERFORMANCE_COUNTERS
+#ifdef __aarch64__
+// on ARM, we use just cycles and instructions
+#define SIMDJSON_SIMPLE_PERFORMANCE_COUNTERS 1
+#else
+// elsewhere, we try to use four counters.
+#define SIMDJSON_SIMPLE_PERFORMANCE_COUNTERS 0
+#endif
+#endif
+#include <cassert>
+#include <cctype>
+#ifndef _MSC_VER
+#include <dirent.h>
+#endif
+#include <unistd.h>
+#include <cinttypes>
+
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+
+#include <algorithm>
+#include <chrono>
+#include <cstring>
+#include <fstream>
+#include <iomanip>
+#include <iostream>
+#include <map>
+#include <set>
+#include <sstream>
+#include <string>
+#include <vector>
+
+#ifdef __linux__
+#include "linux-perf-events.h"
+#include <libgen.h>
+#endif
+
+#if __APPLE__ &&  __aarch64__
+#include "apple/apple_arm_events.h"
+#endif
+
+#include "simdjson.h"
+
+using std::string;
+using std::vector;
+using std::chrono::steady_clock;
+using std::chrono::time_point;
+using std::chrono::duration;
+
+struct event_count {
+  duration<double> elapsed;
+  vector<unsigned long long> event_counts;
+  event_count() : elapsed(0), event_counts{0,0,0,0,0} {}
+  event_count(const duration<double> _elapsed, const vector<unsigned long long> _event_counts) : elapsed(_elapsed), event_counts(_event_counts) {}
+  event_count(const event_count& other): elapsed(other.elapsed), event_counts(other.event_counts) { }
+
+  // The types of counters (so we can read the getter more easily)
+  #if SIMDJSON_SIMPLE_PERFORMANCE_COUNTERS
+  enum event_counter_types {
+    CPU_CYCLES,
+    INSTRUCTIONS
+  };
+  #else
+  enum event_counter_types {
+    CPU_CYCLES,
+    INSTRUCTIONS,
+    BRANCH_MISSES,
+    CACHE_REFERENCES,
+    CACHE_MISSES
+  };
+  #endif
+  double elapsed_sec() const { return duration<double>(elapsed).count(); }
+  double elapsed_ns() const { return duration<double, std::nano>(elapsed).count(); }
+  double cycles() const { return static_cast<double>(event_counts[CPU_CYCLES]); }
+  double instructions() const { return static_cast<double>(event_counts[INSTRUCTIONS]); }
+#if !SIMDJSON_SIMPLE_PERFORMANCE_COUNTERS
+  double branch_misses() const { return static_cast<double>(event_counts[BRANCH_MISSES]); }
+  double cache_references() const { return static_cast<double>(event_counts[CACHE_REFERENCES]); }
+  double cache_misses() const { return static_cast<double>(event_counts[CACHE_MISSES]); }
+#endif
+  event_count& operator=(const event_count& other) {
+    this->elapsed = other.elapsed;
+    this->event_counts = other.event_counts;
+    return *this;
+  }
+  event_count operator+(const event_count& other) const {
+    return event_count(elapsed+other.elapsed, {
+      event_counts[0]+other.event_counts[0],
+      event_counts[1]+other.event_counts[1],
+      event_counts[2]+other.event_counts[2],
+      event_counts[3]+other.event_counts[3],
+      event_counts[4]+other.event_counts[4],
+    });
+  }
+
+  void operator+=(const event_count& other) {
+    *this = *this + other;
+  }
+};
+
+struct event_aggregate {
+  int iterations = 0;
+  event_count total{};
+  event_count best{};
+  event_count worst{};
+
+  event_aggregate() {}
+
+  void operator<<(const event_count& other) {
+    if (iterations == 0 || other.elapsed < best.elapsed) {
+      best = other;
+    }
+    if (iterations == 0 || other.elapsed > worst.elapsed) {
+      worst = other;
+    }
+    iterations++;
+    total += other;
+  }
+
+  double elapsed_sec() const { return total.elapsed_sec() / iterations; }
+  double total_elapsed_ns() const { return total.elapsed_ns(); }
+  double elapsed_ns() const { return total.elapsed_ns() / iterations; }
+  double cycles() const { return total.cycles() / iterations; }
+  double instructions() const { return total.instructions() / iterations; }
+#if !SIMDJSON_SIMPLE_PERFORMANCE_COUNTERS
+  double branch_misses() const { return total.branch_misses() / iterations; }
+  double cache_references() const { return total.cache_references() / iterations; }
+  double cache_misses() const { return total.cache_misses() / iterations; }
+#endif
+};
+
+struct event_collector {
+  event_count count{};
+  time_point<steady_clock> start_clock{};
+
+#if defined(__linux__)
+  LinuxEvents<PERF_TYPE_HARDWARE> linux_events;
+  event_collector() : linux_events(vector<int>{
+  #if SIMDJSON_SIMPLE_PERFORMANCE_COUNTERS
+    PERF_COUNT_HW_CPU_CYCLES,
+    PERF_COUNT_HW_INSTRUCTIONS,
+  #else
+    PERF_COUNT_HW_CPU_CYCLES,
+    PERF_COUNT_HW_INSTRUCTIONS,
+    PERF_COUNT_HW_BRANCH_MISSES,
+    PERF_COUNT_HW_CACHE_REFERENCES,
+    PERF_COUNT_HW_CACHE_MISSES
+  #endif
+  }) {}
+  bool has_events() {
+    return linux_events.is_working();
+  }
+#elif __APPLE__ &&  __aarch64__
+  AppleEvents apple_events;
+  performance_counters diff;
+  event_collector() : diff(0) {
+    apple_events.setup_performance_counters();
+  }
+  bool has_events() {
+    return apple_events.setup_performance_counters();
+  }
+#else
+  event_collector() {}
+  bool has_events() {
+    return false;
+  }
+#endif
+
+  simdjson_inline void start() {
+#if defined(__linux)
+    linux_events.start();
+#elif __APPLE__ &&  __aarch64__
+    if(has_events()) { diff = apple_events.get_counters(); }
+#endif
+    start_clock = steady_clock::now();
+  }
+  simdjson_inline event_count& end() {
+    time_point<steady_clock> end_clock = steady_clock::now();
+#if defined(__linux)
+    linux_events.end(count.event_counts);
+#elif __APPLE__ &&  __aarch64__
+    if(has_events()) {
+      performance_counters end = apple_events.get_counters();
+      diff = end - diff;
+    }
+    count.event_counts[0] = diff.cycles;
+    count.event_counts[1] = diff.instructions;
+    count.event_counts[2] = diff.missed_branches;
+    count.event_counts[3] = 0;
+    count.event_counts[4] = 0;
+#endif
+    count.elapsed = end_clock - start_clock;
+    return count;
+  }
+};
+
+#endif

benchmark/from/benchmark_helpers.h

@@ -1,8 +1,7 @@
 #ifndef BENCHMARK_HELPERS_H
 #define BENCHMARK_HELPERS_H
 
-#include <counters/event_counter.h>
-using namespace counters;
+#include "event_counter.h"
 #include <atomic>
 
 event_collector collector;

benchmark/json_benchmark/run_json_benchmark.h

@@ -1,8 +1,7 @@
 #pragma once
 
 #include "simdjson.h"
-#include <counters/event_counter.h>
-using namespace counters;
+#include "event_counter.h"
 #include <iostream>
 
 namespace json_benchmark {
@@ -59,7 +58,11 @@ template<typename B, typename R> static void run_json_benchmark(benchmark::State
   if (collector.has_events()) {
     state.counters["instructions"] = events.instructions();
     state.counters["cycles"]       = events.cycles();
+#if !SIMDJSON_SIMPLE_PERFORMANCE_COUNTERS
     state.counters["branch_miss"]  = events.branch_misses();
+    state.counters["cache_miss"]   = events.cache_misses();
+    state.counters["cache_ref"]    = events.cache_references();
+#endif
     state.counters["instructions_per_byte"]  = events.instructions() / double(bench.bytes_per_iteration());
     state.counters["instructions_per_cycle"] = events.instructions() / events.cycles();
     state.counters["cycles_per_byte"]        = events.cycles()       / double(bench.bytes_per_iteration());
@@ -67,7 +70,11 @@ template<typename B, typename R> static void run_json_benchmark(benchmark::State
 
     state.counters["best_instructions"] = events.best.instructions();
     state.counters["best_cycles"]       = events.best.cycles();
+#if !SIMDJSON_SIMPLE_PERFORMANCE_COUNTERS
     state.counters["best_branch_miss"]  = events.best.branch_misses();
+    state.counters["best_cache_miss"]   = events.best.cache_misses();
+    state.counters["best_cache_ref"]    = events.best.cache_references();
+#endif
 
     state.counters["best_instructions_per_byte"]  = events.best.instructions() / double(bench.bytes_per_iteration());
     state.counters["best_instructions_per_cycle"] = events.best.instructions() / events.best.cycles();
@@ -88,7 +95,11 @@ template<typename B, typename R> static void run_json_benchmark(benchmark::State
   if (collector.has_events()) {
     label << " instructions=" << setw(12) << uint64_t(events.best.instructions())     << setw(0);
     label << " cycles="       << setw(12) << uint64_t(events.best.cycles())           << setw(0);
+#if !SIMDJSON_SIMPLE_PERFORMANCE_COUNTERS
     label << " branch_miss="  << setw(8)  << uint64_t(events.best.branch_misses())    << setw(0);
+    label << " cache_miss="   << setw(8)  << uint64_t(events.best.cache_misses())     << setw(0);
+    label << " cache_ref="    << setw(10) << uint64_t(events.best.cache_references()) << setw(0);
+#endif
   }
 
   label << " items=" << setw(10) << bench.items_per_iteration() << setw(0);

benchmark/large_amazon_cellphones/large_amazon_cellphones.h

@@ -1,7 +1,6 @@
 #pragma once
 
 #include "json_benchmark/string_runner.h"
-#include <fstream>
 #include <map>
 #include <string>
 

benchmark/linux/linux-perf-events.h

@@ -0,0 +1,105 @@
+#pragma once
+#ifdef __linux__
+
+#include <asm/unistd.h>       // for __NR_perf_event_open
+#include <linux/perf_event.h> // for perf event constants
+#include <sys/ioctl.h>        // for ioctl
+#include <unistd.h>           // for syscall
+
+#include <cerrno>  // for errno
+#include <cstring> // for memset
+#include <stdexcept>
+
+#include <iostream>
+#include <vector>
+
+template <int TYPE = PERF_TYPE_HARDWARE> class LinuxEvents {
+  int fd;
+  bool working;
+  perf_event_attr attribs{};
+  size_t num_events{};
+  std::vector<uint64_t> temp_result_vec{};
+  std::vector<uint64_t> ids{};
+
+public:
+  explicit LinuxEvents(std::vector<int> config_vec) : fd(0), working(true) {
+    memset(&attribs, 0, sizeof(attribs));
+    attribs.type = TYPE;
+    attribs.size = sizeof(attribs);
+    attribs.disabled = 1;
+    attribs.exclude_kernel = 1;
+    attribs.exclude_hv = 1;
+
+    attribs.sample_period = 0;
+    attribs.read_format = PERF_FORMAT_GROUP | PERF_FORMAT_ID;
+    const int pid = 0;  // the current process
+    const int cpu = -1; // all CPUs
+    const unsigned long flags = 0;
+
+    int group = -1; // no group
+    num_events = config_vec.size();
+    ids.resize(config_vec.size());
+    uint32_t i = 0;
+    for (auto config : config_vec) {
+      attribs.config = config;
+      int _fd = static_cast<int>(syscall(__NR_perf_event_open, &attribs, pid, cpu, group, flags));
+      if (_fd == -1) {
+        report_error("perf_event_open");
+      }
+      ioctl(_fd, PERF_EVENT_IOC_ID, &ids[i++]);
+      if (group == -1) {
+        group = _fd;
+        fd = _fd;
+      }
+    }
+
+    temp_result_vec.resize(num_events * 2 + 1);
+  }
+
+  ~LinuxEvents() { if (fd != -1) { close(fd); } }
+
+  inline void start() {
+    if (fd != -1) {
+      if (ioctl(fd, PERF_EVENT_IOC_RESET, PERF_IOC_FLAG_GROUP) == -1) {
+        report_error("ioctl(PERF_EVENT_IOC_RESET)");
+      }
+
+      if (ioctl(fd, PERF_EVENT_IOC_ENABLE, PERF_IOC_FLAG_GROUP) == -1) {
+        report_error("ioctl(PERF_EVENT_IOC_ENABLE)");
+      }
+    }
+  }
+
+  inline void end(std::vector<unsigned long long> &results) {
+    if (fd != -1) {
+      if (ioctl(fd, PERF_EVENT_IOC_DISABLE, PERF_IOC_FLAG_GROUP) == -1) {
+        report_error("ioctl(PERF_EVENT_IOC_DISABLE)");
+      }
+
+      if (read(fd, temp_result_vec.data(), temp_result_vec.size() * 8) == -1) {
+        report_error("read");
+      }
+    }
+    // our actual results are in slots 1,3,5, ... of this structure
+    for (uint32_t i = 1; i < temp_result_vec.size(); i += 2) {
+      results[i / 2] = temp_result_vec[i];
+    }
+    for (uint32_t i = 2; i < temp_result_vec.size(); i += 2) {
+      if(ids[i/2-1] != temp_result_vec[i]) {
+        report_error("event mismatch");
+      }
+    }
+
+
+  }
+
+  bool is_working() {
+    return working;
+  }
+
+private:
+  void report_error(const std::string &) {
+    working = false;
+  }
+};
+#endif

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,

benchmark/static_reflect/benchmark_utils/benchmark_helper.h

@@ -1,7 +1,6 @@
 #ifndef BENCHMARK_HELPER_HPP
 #define BENCHMARK_HELPER_HPP
-#include <counters/event_counter.h>
-using namespace counters;
+#include "event_counter.h"
 #include <atomic>
 
 inline event_collector &get_collector() {

dependencies/CMakeLists.txt

@@ -20,14 +20,6 @@ if(SIMDJSON_GOOGLE_BENCHMARKS)
   )
 endif()
 
-CPMAddPackage(
-        NAME counters
-        URL https://github.com/lemire/counters/archive/refs/tags/v3.1.0.zip
-        OPTIONS
-        "COUNTERS_BUILD_TESTS OFF"
-        "COUNTERS_INSTALL OFF"
-)
-
 CPMAddPackage(
         NAME simdjson-data
         URL https://github.com/simdjson/simdjson-data/archive/351949906abde446f0314bf79606fb5d884f5be7.zip

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,97 +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.** You can use `simdjson::padded_memory_map` to create a
-`simdjson::padded_string_view` from a file on disk. On POSIX systems (Linux,
-macOS, BSD, ...) it uses `mmap` for true zero-copy access and is always
-available. On Windows it is an **opt-in** feature because it relies on the
-`CreateFileMapping2` / `MapViewOfFile3` APIs (Windows 10, version 1803 or
-later) which are exported from `onecore.lib` rather than the default
-`kernel32.lib`. To enable it, you must satisfy **all** of the following:
+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.
 
-1. Building simdjson with `-DSIMDJSON_ENABLE_MEMORY_FILE_MAPPING_ON_WINDOWS=ON`, or
-   defining `SIMDJSON_ENABLE_MEMORY_FILE_MAPPING_ON_WINDOWS=1` and raising
-   `NTDDI_VERSION` to at least `NTDDI_WIN10_RS4` (Windows 10, version 1803)
-   and linking `onecore.lib` manually if you are consuming simdjson as a
-   pre-built library.
-2. `#include <windows.h>` before including simdjson, in every translation
-   unit that uses `padded_memory_map`.
+Some users may want to browse code along with the compiled assembly. You want to check out the following lists of examples:
 
-The Windows implementation then uses `CreateFileMapping2` / `MapViewOfFile3`
-for true zero-copy access whenever possible, with a transparent
-buffered-read fallback for files that end too close to a page boundary.
+* [simdjson examples with errors handled through exceptions](https://godbolt.org/z/98Kx9Kqjn)
+* [simdjson examples with errors without exceptions](https://godbolt.org/z/PKG7GdbPo)
 
-The availability of the class can be tested with the preprocessor macro
-`SIMDJSON_HAS_PADDED_MEMORY_MAP`.
-
-```cpp
-#ifdef _WIN32
-#include <windows.h> // Must come BEFORE <simdjson.h> on Windows
-#endif
-#include "simdjson.h"
-// ...
-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);
-```
-
-**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
+*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 / padded read                                                 | Creates view with sufficient padding                                                   | Non-owning (tied to map lifetime)            | Always available on POSIX (zero-copy `mmap`). On Windows, opt-in via `-DSIMDJSON_ENABLE_MEMORY_FILE_MAPPING_ON_WINDOWS=ON` (requires Windows 10 1803+ and links `onecore.lib`) and `#include <windows.h>` before simdjson; uses `CreateFileMapping2` + `MapViewOfFile3`. |
+```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
@@ -1347,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;
   }
@@ -1440,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)
@@ -1518,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
@@ -1839,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"(
@@ -1876,27 +1829,22 @@ 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.

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

@@ -127,31 +127,11 @@ codepage, and they may call SetFileApisToOEM accordingly.
 
 
 **Advanced feature:**
-You can use `simdjson::padded_memory_map` to create a `simdjson::padded_string_view`
-from a file on disk without copying the file contents into your own buffer.
-On POSIX systems (Linux, macOS, BSD, ...) it uses `mmap` for true zero-copy
-access. On Windows it is available as an **opt-in** feature and requires:
-
-1. Building simdjson with `-DSIMDJSON_ENABLE_MEMORY_FILE_MAPPING_ON_WINDOWS=ON`, or
-   defining `SIMDJSON_ENABLE_MEMORY_FILE_MAPPING_ON_WINDOWS=1` and raising
-   `NTDDI_VERSION` to at least `NTDDI_WIN10_RS4` (Windows 10, version 1803)
-   and linking `onecore.lib` manually if you are consuming simdjson as a
-   pre-built library.
-2. `#include <windows.h>` before `#include "simdjson.h"` in every
-   translation unit where you want to use `padded_memory_map`.
-
-When enabled on Windows, the implementation uses `CreateFileMapping2` and
-`MapViewOfFile3` for true zero-copy mapping whenever the file does not end
-within `SIMDJSON_PADDING` bytes of a page boundary; otherwise it falls back
-to reading the file into a padded heap buffer. If those requirements are
-not met, the class is not declared and the code below will fail to compile.
+On non-Windows systems, you can use memory-file mapping to create a `simdjson::padded_string_view`
+from a file on disk.
 
 ```cpp
-#ifdef _WIN32
-#include <windows.h> // Must come BEFORE <simdjson.h> on Windows
-#endif
-#include "simdjson.h"
-// ...
+// if the macro _WIN32 is defined, this will not work since we do not support Windows
 simdjson::padded_memory_map map(TWITTER_JSON);
 if (!map.is_valid()) { /* handle error */ }
 simdjson::padded_string_view view = map.view(); // view is usable while padded_memory_map is in scope
@@ -790,9 +770,6 @@ void basics_treewalk_1() {
 }
 ```
 
-Notice that we do not include `dom::element_type::BIGINT` in this example
-as `dom::element_type::BIGINT` type is only generated if the parser was
-set to support big integers (`parser.number_as_string(true)`).
 
 
 Reusing the parser for maximum efficiency
@@ -905,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

@@ -22,12 +22,10 @@ Contents
   - [Threads](#threads)
 - [Support](#support)
 - [API](#api)
-- [Streaming directly from a memory-mapped file](#streaming-directly-from-a-memory-mapped-file)
 - [Use cases](#use-cases)
 - [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
 -----------
@@ -134,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
@@ -157,79 +155,13 @@ for (auto doc : docs) {
 See [basics.md](basics.md#newline-delimited-json-ndjson-and-json-lines) for an overview of the API.
 
 
-Streaming directly from a memory-mapped file
---------------------------------------------
-
-When your input is a large NDJSON / JSON-lines file on disk, the most efficient
-way to feed `iterate_many` is to use `simdjson::padded_memory_map`. It returns
-a `padded_string_view` with the right amount of trailing padding, so you can
-hand it straight to `iterate_many` without ever copying the file contents into
-your own buffer.
-
-`padded_memory_map` is available on POSIX systems (Linux, macOS, BSD, ...) by
-default. On Windows it is an **opt-in** feature with the following
-requirements:
-
-1. Build simdjson with `-DSIMDJSON_ENABLE_MEMORY_FILE_MAPPING_ON_WINDOWS=ON`, or — if
-   you consume simdjson as a pre-built library — define
-   `SIMDJSON_ENABLE_MEMORY_FILE_MAPPING_ON_WINDOWS=1`, raise `NTDDI_VERSION` to at
-   least `NTDDI_WIN10_RS4` (`0x0A000005`, Windows 10 version 1803), and
-   add `onecore.lib` to your link line yourself. The Windows
-   implementation uses the modern memory APIs `CreateFileMapping2` /
-   `MapViewOfFile3`, which are available starting with that version of
-   Windows and are exported by `onecore.lib`.
-2. `#include <windows.h>` before `#include "simdjson.h"` in every
-   translation unit where you want to use `padded_memory_map`. simdjson
-   deliberately does not pull in `<windows.h>` itself, so the class is
-   only declared when the Win32 types are already visible.
-
-If either requirement is not met on Windows, the `padded_memory_map` class is
-not declared at all and any code that references it fails to compile with an
-"unknown identifier" error. The availability of the class can be tested with
-the macro `SIMDJSON_HAS_PADDED_MEMORY_MAP`.
-
-On POSIX, `padded_memory_map` uses `mmap` to map the file directly into
-memory with zero copies. On Windows (when enabled), it uses
-`CreateFileMapping2` + `MapViewOfFile3` for true zero-copy mapping
-whenever the file does not end within `SIMDJSON_PADDING` bytes of a page
-boundary; for those rare cases, it transparently falls back to reading
-the file into a heap-allocated padded buffer so that the returned view
-always has `SIMDJSON_PADDING` accessible zero bytes after the file content.
-
-```cpp
-#ifdef _WIN32
-#include <windows.h> // Must come BEFORE <simdjson.h> on Windows
-#endif
-#include "simdjson.h"
-
-// ...
-
-simdjson::padded_memory_map map("huge_stream.ndjson");
-if (!map.is_valid()) { /* file missing, unreadable, too large, ... */ return; }
-
-simdjson::ondemand::parser parser;
-simdjson::ondemand::document_stream stream;
-auto error = parser.iterate_many(map.view()).get(stream);
-if (error) { std::cerr << error << std::endl; return; }
-
-for (auto doc : stream) {
-  // process each JSON document in the stream
-  std::cout << doc << std::endl;
-}
-```
-
-Important lifetime rule: the `padded_string_view` returned by `map.view()` is
-only valid while the `padded_memory_map` instance is alive, so keep `map`
-alive for as long as you are iterating the stream.
-
-The file must not be modified while the memory map is in use. If you need a
-fully independent copy of the data, use `simdjson::padded_string::load(...)`
-instead.
-
-If you prefer single-document parsing on a memory-mapped file, the same
-pattern applies to `parser.iterate(...)`:
+**Advanced feature:**
+On non-Windows systems, you can use memory-file mapping to create a `simdjson::padded_string_view`
+from a file on disk.
 
 ```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
@@ -346,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
 --------------------
@@ -578,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

@@ -18,7 +18,6 @@ Contents
 - [How it works](#how-it-works)
 - [Support](#support)
 - [API](#api)
-- [Streaming directly from a memory-mapped file](#streaming-directly-from-a-memory-mapped-file)
 - [Use cases](#use-cases)
 - [Tracking your position](#tracking-your-position)
 - [Incomplete streams](#incomplete-streams)
@@ -133,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
@@ -219,83 +218,17 @@ got full document at 29
 
 
 
-Streaming directly from a memory-mapped file
---------------------------------------------
-
-When your input is a large NDJSON / JSON-lines file on disk, the most
-efficient way to feed `parse_many` is to use `simdjson::padded_memory_map`.
-It returns a `padded_string_view` with the right amount of trailing padding,
-so you can pass it directly to `parse_many` without copying the file content
-into your own buffer first.
-
-`padded_memory_map` is available on POSIX systems (Linux, macOS, BSD, ...) by
-default. On Windows it is an **opt-in** feature with the following
-requirements:
-
-1. Build simdjson with `-DSIMDJSON_ENABLE_MEMORY_FILE_MAPPING_ON_WINDOWS=ON`, or — if
-   you consume simdjson as a pre-built library — define
-   `SIMDJSON_ENABLE_MEMORY_FILE_MAPPING_ON_WINDOWS=1`, raise `NTDDI_VERSION` to at
-   least `NTDDI_WIN10_RS4` (`0x0A000005`, Windows 10 version 1803), and
-   add `onecore.lib` to your link line yourself. The Windows
-   implementation uses the modern memory APIs `CreateFileMapping2` /
-   `MapViewOfFile3`, which are available starting with that version of
-   Windows and are exported by `onecore.lib`.
-2. `#include <windows.h>` before `#include "simdjson.h"` in every
-   translation unit where you want to use `padded_memory_map`. simdjson
-   deliberately does not pull in `<windows.h>` itself, so the class is
-   only declared when the Win32 types are already visible.
-
-If either requirement is not met on Windows, the `padded_memory_map` class is
-not declared at all and any code that references it fails to compile with an
-"unknown identifier" error. The availability of the class can be tested with
-the macro `SIMDJSON_HAS_PADDED_MEMORY_MAP`.
-
-On POSIX, `padded_memory_map` uses `mmap` to map the file directly into
-memory with zero copies. On Windows (when enabled), it uses
-`CreateFileMapping2` + `MapViewOfFile3` for true zero-copy mapping
-whenever the file does not end within `SIMDJSON_PADDING` bytes of a page
-boundary; for those rare cases, it transparently falls back to reading
-the file into a heap-allocated padded buffer so that the returned view
-always has `SIMDJSON_PADDING` accessible zero bytes after the file content.
-
-```cpp
-#ifdef _WIN32
-#include <windows.h> // Must come BEFORE <simdjson.h> on Windows
-#endif
-#include "simdjson.h"
-
-// ...
-
-simdjson::padded_memory_map map("huge_stream.ndjson");
-if (!map.is_valid()) { /* file missing, unreadable, too large, ... */ return; }
-
-simdjson::dom::parser parser;
-simdjson::dom::document_stream stream;
-auto error = parser.parse_many(map.view()).get(stream);
-if (error) { std::cerr << error << std::endl; return; }
-
-for (auto doc : stream) {
-  // process each JSON document in the stream
-  std::cout << doc << std::endl;
-}
-```
-
-Important lifetime rule: the `padded_string_view` returned by `map.view()` is
-only valid while the `padded_memory_map` instance is alive, so keep `map`
-alive for as long as you are iterating the stream.
-
-The file must not be modified while the memory map is in use. If you need a
-fully independent copy of the data, use `simdjson::padded_string::load(...)`
-instead.
-
-If you prefer single-document parsing on a memory-mapped file, the same
-pattern applies to `parser.parse(...)`:
+**Advanced feature:**
+On non-Windows systems, you can use memory-file mapping to create a `simdjson::padded_string_view`
+from a file on disk.
 
 ```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
-simdjson::dom::element doc = parser.parse(view); // parse the JSON
+ondemand::document doc = parser.iterate(view); // parse the JSON
 ```
 
 Incomplete streams
@@ -320,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/concepts.h

@@ -59,14 +59,6 @@ concept appendable_containers =
     details::supports_add<T> || details::supports_append<T> ||
     details::supports_insert<T>) && !string_view_keyed_map<T>;
 
-/// Check if T is a key_selector type for efficient JSON field lookup
-template <typename T>
-concept key_selector_type = requires(T selector) {
-    { selector.size() } -> std::same_as<std::size_t>;
-    { selector.index_of(std::string_view{}) } -> std::same_as<std::size_t>;
-    { selector.get_key(std::size_t{}) } -> std::same_as<std::string_view>;
-};
-
 /// Insert into the container however possible
 template <appendable_containers T, typename... Args>
 constexpr decltype(auto) emplace_one(T &vec, Args &&...args) {

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/element.h

@@ -22,8 +22,6 @@ enum class element_type {
   STRING = '"',    ///< std::string_view
   BOOL = 't',      ///< bool
   NULL_VALUE = 'n', ///< null
-  /// The BIGINT type is for integers that do not fit in 64 bits. It is only present
-  // if you set parser.number_as_string(true).
   BIGINT = 'Z'     ///< std::string_view: big integer stored as raw digit string
 };
 

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);
@@ -181,48 +186,6 @@ inline simdjson_result<document_stream> parser::parse_many(const std::string &s,
 inline simdjson_result<document_stream> parser::parse_many(const padded_string &s, size_t batch_size) noexcept {
   return parse_many(s.data(), s.length(), batch_size);
 }
-inline simdjson_result<document_stream> parser::parse_many(const padded_string_view &v, size_t batch_size) noexcept {
-  return parse_many(v.data(), v.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);
-}
-inline simdjson_result<document_stream> parser::parse_many(const padded_string_view &v, size_t batch_size, stream_format format) noexcept {
-  return parse_many(v.data(), v.length(), batch_size, format);
-}
 
 simdjson_inline size_t parser::capacity() const noexcept {
   return implementation ? implementation->capacity() : 0;

include/simdjson/dom/parser.h

@@ -490,39 +490,10 @@ public:
   /** @overload parse_many(const uint8_t *buf, size_t len, size_t batch_size) */
   inline simdjson_result<document_stream> parse_many(const padded_string &s, size_t batch_size = dom::DEFAULT_BATCH_SIZE) noexcept;
   inline simdjson_result<document_stream> parse_many(const padded_string &&s, size_t batch_size) = delete;// unsafe
-  /** @overload parse_many(const uint8_t *buf, size_t len, size_t batch_size)
-   *
-   * Because padded_string_view guarantees SIMDJSON_PADDING trailing bytes, this
-   * overload is safe to use with buffers that the caller owns elsewhere (for
-   * example, a padded_memory_map), with no extra copy. Without this overload,
-   * passing a padded_string_view would silently bind to the padded_string
-   * overload via an implicit conversion, allocating and copying the input, and
-   * — because that temporary is destroyed at the end of the full-expression —
-   * leaving the returned document_stream pointing at freed memory. */
-  inline simdjson_result<document_stream> parse_many(const padded_string_view &v, size_t batch_size = dom::DEFAULT_BATCH_SIZE) noexcept;
 
   /** @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;
-  /** @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_view &v, 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

@@ -20,7 +20,6 @@
 #include "simdjson/generic/ondemand/document.h"
 #include "simdjson/generic/ondemand/document_stream.h"
 #include "simdjson/generic/ondemand/field.h"
-#include "simdjson/generic/ondemand/key_selector.h"
 #include "simdjson/generic/ondemand/object.h"
 #include "simdjson/generic/ondemand/object_iterator.h"
 #include "simdjson/generic/ondemand/serialization.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/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/key_selector.h

@@ -1,339 +0,0 @@
-#ifndef SIMDJSON_GENERIC_ONDEMAND_KEY_SELECTOR_H
-#define SIMDJSON_GENERIC_ONDEMAND_KEY_SELECTOR_H
-
-#include "simdjson/base.h"
-#include "simdjson/common_defs.h"
-#include <array>
-#include <string_view>
-#include <cstddef>
-#include <cstdint>
-#include <cstring>
-
-#if SIMDJSON_SUPPORTS_CONCEPTS
-
-namespace simdjson {
-namespace SIMDJSON_IMPLEMENTATION {
-namespace ondemand {
-
-
-
-// Forward declaration
-class object;
-
-/**
- * A compile-time key selector for efficient JSON object field lookup.
- * Uses perfect hashing (gperf-style) to map keys to identifiers.
- */
-template <std::size_t N>
-class key_selector {
-    static_assert(N > 0, "key_selector requires at least one key");
-    static_assert(N <= 100, "key_selector supports at most 100 keys");
-
-    // Perfect hash table data (gperf-style)
-    static constexpr std::size_t MAX_POSITIONS = 16;
-    static constexpr std::size_t POS_LAST_CHAR = std::size_t(-1);
-    static constexpr std::size_t MAX_TABLE_SIZE = 256; // Power of 2, fits in uint8_t
-
-    std::array<std::array<std::uint8_t, 256>, MAX_POSITIONS> asso_values_{};
-    std::uint8_t num_positions_{};
-    std::array<std::size_t, MAX_POSITIONS> positions_{};
-    std::array<std::uint8_t, MAX_TABLE_SIZE> slot_to_key_{};
-    std::array<std::uint8_t, N> key_to_slot_{};
-    std::array<std::array<char, 64>, N> key_data_{};
-    std::array<std::uint8_t, N> key_lengths_{};
-    std::size_t table_size_{};
-
-public:
-    // Validate keys at compile time
-    constexpr void validate_keys(const std::array<std::string_view, N>& keys) {
-        for (std::size_t i = 0; i < N; ++i) {
-            auto key = keys[i];
-            if (key.empty()) {
-                throw "Empty keys are not allowed in key_selector";
-            }
-            if (key.size() > SIMDJSON_PADDING) {
-                throw "Key length exceeds SIMDJSON_PADDING (64 bytes)";
-            }
-            for (char c : key) {
-                if (c == '\\') {
-                    throw "Escape characters (\\) are not allowed in key_selector keys";
-                }
-                if (c == '\0') {
-                    throw "Null characters are not allowed in key_selector keys";
-                }
-            }
-        }
-    }
-
-    // Gperf-style perfect hash generation using partition-based algorithm
-    constexpr void generate_hash_table(const std::array<std::string_view, N>& keys) {
-        // Try power-of-two table sizes starting from next_power_of_2(N)
-        constexpr std::size_t START_M = next_power_of_2(N);
-        if constexpr (START_M <= MAX_TABLE_SIZE) {
-            if (try_compute_phf<START_M>(keys)) return;
-            if constexpr (START_M * 2 <= MAX_TABLE_SIZE) {
-                if (try_compute_phf<START_M * 2>(keys)) return;
-                if constexpr (START_M * 4 <= MAX_TABLE_SIZE) {
-                    if (try_compute_phf<START_M * 4>(keys)) return;
-                    if constexpr (START_M * 8 <= MAX_TABLE_SIZE) {
-                        if (try_compute_phf<START_M * 8>(keys)) return;
-                    }
-                }
-            }
-        }
-
-        // Fallback: linear table
-        table_size_ = N;
-        num_positions_ = 0;
-        std::fill(slot_to_key_.begin(), slot_to_key_.begin() + MAX_TABLE_SIZE, static_cast<std::uint8_t>(N));
-        for (std::size_t i = 0; i < N; ++i) {
-            slot_to_key_[i] = static_cast<std::uint8_t>(i);
-            key_to_slot_[i] = static_cast<std::uint8_t>(i);
-        }
-    }
-
-private:
-    // Helper functions for gperf algorithm
-    static constexpr std::size_t next_power_of_2(std::size_t n) {
-        if (n == 0) return 1;
-        std::size_t p = 1;
-        while (p < n) p <<= 1;
-        return p;
-    }
-
-    static constexpr std::size_t char_at(std::string_view key, std::size_t pos) {
-        if (pos == POS_LAST_CHAR) {
-            return key.empty() ? 256 : static_cast<unsigned char>(key.back());
-        }
-        return (pos < key.size()) ? static_cast<unsigned char>(key[pos]) : 256;
-    }
-
-    template <std::size_t M>
-    constexpr bool try_compute_phf(const std::array<std::string_view, N>& keys) {
-        // Initialize
-        std::array<std::array<std::size_t, 256>, MAX_POSITIONS> asso{};
-        std::size_t npos = 0;
-        std::array<std::size_t, MAX_POSITIONS> pos{};
-        std::array<std::size_t, M> s2k{};
-
-        // Try to generate gperf
-        if (try_generate_gperf<M>(keys, asso, npos, pos, s2k)) {
-            table_size_ = M;
-            num_positions_ = static_cast<std::uint8_t>(npos);
-            for (std::size_t p = 0; p < MAX_POSITIONS; ++p) {
-                positions_[p] = pos[p];
-                for (std::size_t c = 0; c < 256; ++c) {
-                    asso_values_[p][c] = static_cast<std::uint8_t>(asso[p][c]);
-                }
-            }
-            for (std::size_t i = 0; i < M; ++i) {
-                slot_to_key_[i] = static_cast<std::uint8_t>(s2k[i]);
-            }
-            // Fill remaining slots with sentinel
-            for (std::size_t i = M; i < MAX_TABLE_SIZE; ++i) {
-                slot_to_key_[i] = static_cast<std::uint8_t>(N);
-            }
-
-            // Build key_to_slot mapping
-            for (std::size_t i = 0; i < N; ++i) {
-                key_to_slot_[i] = static_cast<std::uint8_t>(N); // Initialize
-            }
-            for (std::size_t slot = 0; slot < M; ++slot) {
-                std::size_t key_idx = s2k[slot];
-                if (key_idx < N) {
-                    key_to_slot_[key_idx] = static_cast<std::uint8_t>(slot);
-                }
-            }
-            return true;
-        }
-        return false;
-    }
-
-    template <std::size_t M>
-    static constexpr bool try_generate_gperf(
-        const std::array<std::string_view, N>& keys,
-        std::array<std::array<std::size_t, 256>, MAX_POSITIONS>& asso_values,
-        std::size_t& num_positions,
-        std::array<std::size_t, MAX_POSITIONS>& positions,
-        std::array<std::size_t, M>& slot_to_key)
-    {
-        // Initialize
-        for (std::size_t p = 0; p < MAX_POSITIONS; ++p) {
-            for (std::size_t c = 0; c < 256; ++c) {
-                asso_values[p][c] = 0;
-            }
-        }
-        for (std::size_t i = 0; i < M; ++i) {
-            slot_to_key[i] = N;
-        }
-
-        // Try length-only hashing first
-        bool success = true;
-        for (std::size_t i = 0; i < N && success; ++i) {
-            std::size_t slot = keys[i].size() % M;
-            if (slot_to_key[slot] != N) {
-                success = false;
-            } else {
-                slot_to_key[slot] = i;
-            }
-        }
-
-        if (success) {
-            num_positions = 0;
-            return true;
-        }
-
-        // Try with position 0
-        positions[0] = 0;
-        num_positions = 1;
-
-        // Find a working assignment of asso_values for position 0
-        // Use a simple approach: try different offsets
-        for (std::size_t offset = 0; offset < M; ++offset) {
-            // Reset
-            for (std::size_t i = 0; i < M; ++i) {
-                slot_to_key[i] = N;
-            }
-
-            // Assign asso_values based on offset
-            for (std::size_t c = 0; c < 256; ++c) {
-                asso_values[0][c] = (c + offset) % M;
-            }
-
-            success = true;
-            for (std::size_t i = 0; i < N && success; ++i) {
-                std::size_t h = keys[i].size();
-                std::size_t ch = char_at(keys[i], 0);
-                if (ch < 256) h += asso_values[0][ch];
-                std::size_t slot = h % M;
-
-                if (slot_to_key[slot] != N) {
-                    success = false;
-                } else {
-                    slot_to_key[slot] = i;
-                }
-            }
-
-            if (success) {
-                return true;
-            }
-        }
-
-        // Try with positions {0, last_char}
-        if (N <= 50) { // Only for smaller N to avoid complexity
-            positions[0] = 0;
-            positions[1] = POS_LAST_CHAR;
-            num_positions = 2;
-
-            for (std::size_t offset1 = 0; offset1 < 4 && !success; ++offset1) {
-                for (std::size_t offset2 = 0; offset2 < 4 && !success; ++offset2) {
-                    // Reset
-                    for (std::size_t i = 0; i < M; ++i) {
-                        slot_to_key[i] = N;
-                    }
-
-                    // Assign asso_values
-                    for (std::size_t c = 0; c < 256; ++c) {
-                        asso_values[0][c] = (c + offset1) % M;
-                        asso_values[1][c] = (c + offset2) % M;
-                    }
-
-                    success = true;
-                    for (std::size_t i = 0; i < N && success; ++i) {
-                        std::size_t h = keys[i].size();
-                        std::size_t ch1 = char_at(keys[i], 0);
-                        if (ch1 < 256) h += asso_values[0][ch1];
-                        std::size_t ch2 = char_at(keys[i], POS_LAST_CHAR);
-                        if (ch2 < 256) h += asso_values[1][ch2];
-                        std::size_t slot = h % M;
-
-                        if (slot_to_key[slot] != N) {
-                            success = false;
-                        } else {
-                            slot_to_key[slot] = i;
-                        }
-                    }
-
-                    if (success) {
-                        return true;
-                    }
-                }
-            }
-        }
-
-        return false;
-    }
-
-
-
-public:
-    constexpr key_selector(const std::array<std::string_view, N>& keys) {
-        validate_keys(keys);
-
-        // Store key data
-        for (std::size_t i = 0; i < N; ++i) {
-            key_lengths_[i] = static_cast<std::uint8_t>(keys[i].size());
-            std::copy(keys[i].begin(), keys[i].end(), key_data_[i].begin());
-        }
-
-        generate_hash_table(keys);
-    }
-
-    [[nodiscard]] constexpr std::size_t size() const noexcept { return N; }
-
-    [[nodiscard]] constexpr simdjson_really_inline std::size_t compute_hash(std::string_view key) const noexcept {
-        std::size_t h = key.size();
-        const char* kp = key.data();
-        for (std::uint8_t i = 0; i < num_positions_; ++i) {
-            std::size_t pos = positions_[i];
-            std::size_t ch;
-            if (pos == POS_LAST_CHAR) {
-                ch = static_cast<unsigned char>(key.back());
-            } else {
-                ch = static_cast<unsigned char>(kp[pos]);
-            }
-            h += asso_values_[i][ch];
-        }
-        return h & (table_size_ - 1);
-    }
-
-    [[nodiscard]] constexpr simdjson_really_inline  bool contains(std::string_view key) const noexcept {
-        std::size_t slot = compute_hash(key);
-        if (slot >= table_size_) return false;
-
-        std::uint8_t key_idx = slot_to_key_[slot];
-        if (key_idx >= N) return false;
-
-        // Compare key
-        if (key_lengths_[key_idx] != key.size()) return false;
-        return std::equal(key.begin(), key.end(), key_data_[key_idx].begin());
-    }
-
-    [[nodiscard]] constexpr simdjson_really_inline std::size_t index_of(std::string_view key) const noexcept {
-        std::size_t slot = compute_hash(key);
-        if (slot >= table_size_) return N; // Invalid index
-
-        std::uint8_t key_idx = slot_to_key_[slot];
-        if (key_idx >= N) return N;
-
-        // Compare key
-        if (key_lengths_[key_idx] != key.size()) return N;
-        if (!std::equal(key.begin(), key.end(), key_data_[key_idx].begin())) return N;
-
-        return key_idx;
-    }
-
-    // Accessors for key data (used by object::find_field)
-    [[nodiscard]] constexpr std::string_view get_key(std::size_t index) const noexcept {
-        if (index >= N) return {};
-        return std::string_view(key_data_[index].data(), key_lengths_[index]);
-    }
-};
-
-} // namespace ondemand
-} // namespace SIMDJSON_IMPLEMENTATION
-} // namespace simdjson
-
-#endif // SIMDJSON_SUPPORTS_CONCEPTS
-
-#endif // SIMDJSON_GENERIC_ONDEMAND_KEY_SELECTOR_H

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

@@ -63,42 +63,6 @@ simdjson_inline simdjson_result<value> object::find_field(const std::string_view
   return value(iter.child());
 }
 
-#if SIMDJSON_SUPPORTS_CONCEPTS
-template <concepts::key_selector_type Selector>
-simdjson_inline std::pair<std::size_t, simdjson_result<value>> object::find_field(const Selector& selector) & noexcept {
-  // Try to find any of the keys in the selector
-  for (std::size_t i = 0; i < selector.size(); ++i) {
-    std::string_view key = selector.get_key(i);
-    auto result = iter.find_field_unordered_raw(key);
-    if (result.error()) {
-      return {selector.size(), result.error()};
-    }
-    bool has_value = result.value();
-    if (has_value) {
-      return {i, value(iter.child())};
-    }
-  }
-  return {selector.size(), NO_SUCH_FIELD}; // Return size() as invalid index
-}
-
-template <concepts::key_selector_type Selector>
-simdjson_inline std::pair<std::size_t, simdjson_result<value>> object::find_field(const Selector& selector) && noexcept {
-  // Try to find any of the keys in the selector
-  for (std::size_t i = 0; i < selector.size(); ++i) {
-    std::string_view key = selector.get_key(i);
-    auto result = iter.find_field_unordered_raw(key);
-    if (result.error()) {
-      return {selector.size(), result.error()};
-    }
-    bool has_value = result.value();
-    if (has_value) {
-      return {i, value(iter.child())};
-    }
-  }
-  return {selector.size(), NO_SUCH_FIELD}; // Return size() as invalid index
-}
-#endif
-
 simdjson_inline simdjson_result<object> object::start(value_iterator &iter) noexcept {
   SIMDJSON_TRY( iter.start_object().error() );
   return object(iter);
@@ -213,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;
@@ -225,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);
     }
   }
 }
@@ -370,20 +326,6 @@ simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> simdjs
   return std::forward<SIMDJSON_IMPLEMENTATION::ondemand::object>(first).find_field(key);
 }
 
-#if SIMDJSON_SUPPORTS_CONCEPTS
-template <concepts::key_selector_type Selector>
-simdjson_inline std::pair<std::size_t, simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value>> simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::object>::find_field(const Selector& selector) & noexcept {
-  if (error()) { return {0, error()}; }
-  return first.find_field(selector);
-}
-
-template <concepts::key_selector_type Selector>
-simdjson_inline std::pair<std::size_t, simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value>> simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::object>::find_field(const Selector& selector) && noexcept {
-  if (error()) { return {0, error()}; }
-  return std::forward<SIMDJSON_IMPLEMENTATION::ondemand::object>(first).find_field(selector);
-}
-#endif
-
 simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::object>::at_pointer(std::string_view json_pointer) noexcept {
   if (error()) { return error(); }
   return first.at_pointer(json_pointer);
@@ -397,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

@@ -5,7 +5,6 @@
 #include "simdjson/generic/ondemand/base.h"
 #include "simdjson/generic/implementation_simdjson_result_base.h"
 #include "simdjson/generic/ondemand/value_iterator.h"
-#include "simdjson/generic/ondemand/key_selector.h"
 #include <vector>
 #if SIMDJSON_STATIC_REFLECTION && SIMDJSON_SUPPORTS_CONCEPTS
 #include "simdjson/generic/ondemand/json_string_builder.h"  // for constevalutil::fixed_string
@@ -123,23 +122,6 @@ public:
   /** @overload simdjson_inline simdjson_result<value> find_field_unordered(std::string_view key) & noexcept; */
   simdjson_inline simdjson_result<value> operator[](std::string_view key) && noexcept;
 
-#if SIMDJSON_SUPPORTS_CONCEPTS
-  /**
-   * Look up a field by name using a key_selector. This method is similar to find_field_unordered()
-   * but uses a compile-time generated perfect hash table for efficient lookup.
-   *
-   * @tparam Selector The key_selector type
-   * @param selector The key selector instance
-   * @returns A pair containing the key identifier (index in the selector) and the value,
-   *          or NO_SUCH_FIELD if the field is not in the object.
-   */
-  template <concepts::key_selector_type Selector>
-  simdjson_inline std::pair<std::size_t, simdjson_result<value>> find_field(const Selector& selector) & noexcept;
-  /** @overload template <concepts::key_selector_type Selector> simdjson_inline std::pair<std::size_t, simdjson_result<value>> find_field(const Selector& selector) & noexcept; */
-  template <concepts::key_selector_type Selector>
-  simdjson_inline std::pair<std::size_t, simdjson_result<value>> find_field(const Selector& selector) && noexcept;
-#endif
-
   /**
    * Get the value associated with the given JSON pointer. We use the RFC 6901
    * https://tools.ietf.org/html/rfc6901 standard, interpreting the current node
@@ -190,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
@@ -342,17 +332,17 @@ public:
   simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> find_field(std::string_view key) && noexcept;
   simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> find_field_unordered(std::string_view key) & noexcept;
   simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> find_field_unordered(std::string_view key) && noexcept;
-#if SIMDJSON_SUPPORTS_CONCEPTS
-  template <concepts::key_selector_type Selector>
-  simdjson_inline std::pair<std::size_t, simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value>> find_field(const Selector& selector) & noexcept;
-  template <concepts::key_selector_type Selector>
-  simdjson_inline std::pair<std::size_t, simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value>> find_field(const Selector& selector) && noexcept;
-#endif
   simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> operator[](std::string_view key) & noexcept;
   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;
 }

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). */
@@ -459,4 +425,4 @@ public:
 
 } // namespace simdjson
 
-#endif // SIMDJSON_GENERIC_ONDEMAND_PARSER_H
+#endif // SIMDJSON_GENERIC_ONDEMAND_PARSER_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-inl.h

@@ -10,18 +10,13 @@
 #include <climits>
 #include <cwchar>
 
-#if SIMDJSON_HAS_UNISTD_H
+#ifndef _WIN32
 #include <fcntl.h>
 #include <stdio.h>
 #include <sys/mman.h>
 #include <sys/stat.h>
 #include <unistd.h>
 #endif
-// On Windows, `padded_memory_map` (when it is enabled) depends on types and
-// functions declared in <windows.h>. We deliberately do NOT include that
-// header here: users of simdjson who want `padded_memory_map` on Windows
-// must include <windows.h> themselves *before* including this header. See
-// padded_string.h for the detection logic.
 
 namespace simdjson {
 namespace internal {
@@ -390,9 +385,7 @@ inline bool padded_string_builder::reserve(size_t additional) noexcept {
 }
 
 
-#if SIMDJSON_HAS_PADDED_MEMORY_MAP
-
-#if SIMDJSON_HAS_UNISTD_H
+#ifndef _WIN32
 simdjson_inline padded_memory_map::padded_memory_map(const char *filename) noexcept {
 
     int fd = open(filename, O_RDONLY);
@@ -428,132 +421,7 @@ simdjson_inline padded_memory_map::~padded_memory_map() noexcept {
     munmap(const_cast<char *>(data), size + simdjson::SIMDJSON_PADDING);
   }
 }
-#elif defined(_WIN32)
-// Windows zero-copy implementation using placeholder virtual memory.
-//
-// We use the modern Windows memory APIs (VirtualAlloc2, CreateFileMapping2,
-// MapViewOfFile3 — available since Windows 10 1803) to map the file into a
-// contiguous virtual address range that includes at least SIMDJSON_PADDING
-// zero bytes after the file content, with no data copies.
-//
-// Strategy:
-//   1. If rounding the file size up to the allocation granularity already
-//      exceeds file_size + SIMDJSON_PADDING, the OS page zero-fill provides
-//      the padding and we use a simple MapViewOfFile3 call.
-//   2. Otherwise we reserve a contiguous placeholder region via VirtualAlloc2,
-//      split it at the granularity-aligned file boundary, map the file into
-//      the first part, and commit zero pages for the second part (padding).
-simdjson_inline padded_memory_map::padded_memory_map(const char *filename) noexcept {
-  HANDLE file_handle = ::CreateFileA(
-      filename, GENERIC_READ,
-      FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
-      NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
-  if (file_handle == INVALID_HANDLE_VALUE) {
-    return;
-  }
-  LARGE_INTEGER file_size_li;
-  if (!::GetFileSizeEx(file_handle, &file_size_li) || file_size_li.QuadPart < 0) {
-    ::CloseHandle(file_handle);
-    return;
-  }
-#if SIMDJSON_IS_32BITS
-  if (static_cast<unsigned long long>(file_size_li.QuadPart) >
-      static_cast<unsigned long long>(SIZE_MAX - simdjson::SIMDJSON_PADDING)) {
-    ::CloseHandle(file_handle);
-    return;
-  }
-#endif
-  size = static_cast<size_t>(file_size_li.QuadPart);
-  if (size == 0) {
-    ::CloseHandle(file_handle);
-    return;
-  }
 
-  HANDLE section = ::CreateFileMapping2(
-      file_handle, NULL, FILE_MAP_READ, PAGE_READONLY,
-      0, 0, NULL, NULL, 0);
-  ::CloseHandle(file_handle);
-  if (section == NULL) {
-    return;
-  }
-
-  SYSTEM_INFO si;
-  ::GetSystemInfo(&si);
-  const size_t granularity = static_cast<size_t>(si.dwAllocationGranularity);
-  const size_t file_region = (size + granularity - 1) & ~(granularity - 1);
-  const size_t total_needed = size + simdjson::SIMDJSON_PADDING;
-
-  if (file_region >= total_needed) {
-    // The zero-fill in the last page already covers the padding.
-    PVOID view = ::MapViewOfFile3(
-        section, ::GetCurrentProcess(), NULL, 0, 0,
-        0, PAGE_READONLY, NULL, 0);
-    ::CloseHandle(section);
-    if (view != NULL) {
-      data = static_cast<const char *>(view);
-    }
-    return;
-  }
-
-  // We need extra zero pages beyond the file region. Use the placeholder API
-  // to get a contiguous virtual address range spanning both the file mapping
-  // and the zero-filled padding.
-  const size_t padding_region =
-      ((total_needed - file_region) + granularity - 1) & ~(granularity - 1);
-  const size_t reserve_size = file_region + padding_region;
-
-  // Reserve a contiguous placeholder.
-  PVOID placeholder = ::VirtualAlloc2(
-      ::GetCurrentProcess(), NULL, reserve_size,
-      MEM_RESERVE | MEM_RESERVE_PLACEHOLDER, PAGE_NOACCESS, NULL, 0);
-  if (placeholder == NULL) {
-    ::CloseHandle(section);
-    return;
-  }
-
-  // Split into two placeholders at the file_region boundary.
-  if (!::VirtualFree(placeholder, file_region,
-                     MEM_RELEASE | MEM_PRESERVE_PLACEHOLDER)) {
-    ::VirtualFree(placeholder, 0, MEM_RELEASE);
-    ::CloseHandle(section);
-    return;
-  }
-
-  // Map the file into the first placeholder.
-  PVOID file_view = ::MapViewOfFile3(
-      section, ::GetCurrentProcess(), placeholder, 0, file_region,
-      MEM_REPLACE_PLACEHOLDER, PAGE_READONLY, NULL, 0);
-  ::CloseHandle(section);
-  if (file_view == NULL) {
-    ::VirtualFree(placeholder, 0, MEM_RELEASE);
-    ::VirtualFree(static_cast<char *>(placeholder) + file_region,
-                  0, MEM_RELEASE);
-    return;
-  }
-
-  // Commit zero pages in the second placeholder (the padding).
-  void *pad = static_cast<char *>(placeholder) + file_region;
-  PVOID padding_ptr = ::VirtualAlloc2(
-      ::GetCurrentProcess(), pad, padding_region,
-      MEM_REPLACE_PLACEHOLDER | MEM_COMMIT, PAGE_READONLY, NULL, 0);
-  if (padding_ptr == NULL) {
-    ::UnmapViewOfFile(file_view);
-    ::VirtualFree(pad, 0, MEM_RELEASE);
-    return;
-  }
-
-  data = static_cast<const char *>(file_view);
-  padding_view_ = padding_ptr;
-}
-
-simdjson_inline padded_memory_map::~padded_memory_map() noexcept {
-  if (data == nullptr) { return; }
-  ::UnmapViewOfFile(data);
-  if (padding_view_ != nullptr) {
-    ::VirtualFree(padding_view_, 0, MEM_RELEASE);
-  }
-}
-#endif // POSIX or _WIN32
 
 simdjson_inline simdjson::padded_string_view padded_memory_map::view() const noexcept simdjson_lifetime_bound {
   if(!is_valid()) {
@@ -565,8 +433,7 @@ simdjson_inline simdjson::padded_string_view padded_memory_map::view() const noe
 simdjson_inline bool padded_memory_map::is_valid() const noexcept {
   return data != nullptr;
 }
-
-#endif // SIMDJSON_HAS_PADDED_MEMORY_MAP
+#endif // _WIN32
 
 } // namespace simdjson
 

include/simdjson/padded_string.h

@@ -277,26 +277,11 @@ inline std::ostream& operator<<(std::ostream& out, const padded_string& s) { ret
 inline std::ostream& operator<<(std::ostream& out, simdjson_result<padded_string> &s) noexcept(false) { return out << s.value(); }
 #endif
 
-#if SIMDJSON_HAS_PADDED_MEMORY_MAP
+
+#ifndef _WIN32
 /**
  * A class representing a memory-mapped file with padding.
- *
- * On POSIX systems (Linux, macOS, BSD, ...), this uses `mmap` to map the file
- * contents directly into memory, which is efficient for large files (no copy).
- *
- * On Windows, this class is disabled by default and must be opted into at
- * build time by defining `SIMDJSON_ENABLE_MEMORY_FILE_MAPPING_ON_WINDOWS=1`. When
- * enabled, `<windows.h>` must also be included before `<simdjson.h>` and
- * the compilation must target Windows 10, version 1803 or later. The
- * Windows implementation uses the modern memory APIs (`VirtualAlloc2`,
- * `CreateFileMapping2`, `MapViewOfFile3`) with the placeholder virtual
- * memory mechanism to always achieve true zero-copy mapping with
- * contiguous zero-filled padding.
- *
- * Either way, the resulting `padded_string_view` carries at least
- * `SIMDJSON_PADDING` bytes of accessible zero-filled padding after the file
- * content, so it can be consumed directly by the simdjson parsers (including
- * `parse_many` / `iterate_many`).
+ * It is only available on non-Windows platforms, as Windows has different APIs for memory mapping.
  */
 class padded_memory_map {
 public:
@@ -304,11 +289,9 @@ public:
    * Create a new padded memory map for the given file.
    * After creating the memory map, you can call view() to get a padded_string_view of the file content.
    * The memory map will be automatically released when the padded_memory_map instance is destroyed.
-   * On POSIX systems, the file content is not copied, so this is efficient for large files.
-   * On Windows, the file is mapped into memory via `MapViewOfFile3` (zero-copy).
-   * In all cases, the file must remain unchanged while the memory map is in use.
-   * In case of error (e.g., file not found, permission denied, etc.), the memory map will be
-   * invalid and view() will return an empty view.
+   * Note that the file content is not copied, so this is efficient for large files. However,
+   * the file must remain unchanged while the memory map is in use. In case of error (e.g., file not found,
+   * permission denied, etc.), the memory map will be invalid and view() will return an empty view.
    * You can check if the memory map is valid by calling is_valid() before using view().
    *
    * @param filename the path to the file to memory-map.
@@ -345,14 +328,8 @@ private:
   padded_memory_map &operator=(const padded_memory_map &) = delete;
   const char *data{nullptr};
   size_t size{0};
-#ifdef _WIN32
-  // When the file ends near an allocation-granularity boundary, we use the
-  // placeholder API to append zero-filled padding pages. This pointer tracks
-  // that region so the destructor can release it with VirtualFree.
-  void *padding_view_{nullptr};
-#endif
 };
-#endif // SIMDJSON_HAS_PADDED_MEMORY_MAP
+#endif // _WIN32
 
 
 

include/simdjson/padded_string_view-inl.h

@@ -6,15 +6,6 @@
 
 #include <cstring> /* memcmp */
 
-// for page size computation.
-#if SIMDJSON_HAS_UNISTD_H
-  #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 SIMDJSON_HAS_UNISTD_H
-    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/portability.h

@@ -285,53 +285,5 @@ using std::size_t;
 #endif
 #endif
 
-#ifndef SIMDJSON_HAS_UNISTD_H
-#if defined(__unix__) || defined(__APPLE__) || defined(__linux__)
-#define SIMDJSON_HAS_UNISTD_H 1
-#else
-#define SIMDJSON_HAS_UNISTD_H 0
-#endif
-#endif
-
-// padded_memory_map availability.
-//
-// On POSIX platforms the class is always available: the implementation uses
-// `mmap` (and a trailing anonymous page for padding) from <sys/mman.h>.
-//
-// On Windows the class is disabled by default and must be explicitly
-// opted into by defining `SIMDJSON_ENABLE_MEMORY_FILE_MAPPING_ON_WINDOWS=1`. Enabling
-// it requires:
-//   1. `<windows.h>` has been included *before* `<simdjson.h>` (so that
-//      this header can see the Win32 types and the `_WINDOWS_` include
-//      guard),
-//   2. the compilation targets Windows 10, version 1803 or later
-//      (i.e. `NTDDI_VERSION >= NTDDI_WIN10_RS4`, `0x0A000005`). This is
-//      required because the implementation relies on the modern memory
-//      APIs introduced with that version (`CreateFileMapping2` /
-//      `MapViewOfFile3`),
-//   3. the link step pulls in an import library that exports those APIs,
-//      typically `onecore.lib` (or `mincore.lib`).
-//
-// The `SIMDJSON_ENABLE_MEMORY_FILE_MAPPING_ON_WINDOWS` CMake option arranges (1)-(3)
-// automatically when building simdjson with its own CMake. Consumers using
-// simdjson as a pre-built library are responsible for setting the macro,
-// the Windows version macros, and the link library themselves.
-//
-// If the opt-in conditions are not met on Windows, `padded_memory_map`
-// simply does not exist — any attempt to use it fails at compile time
-// with an "unknown identifier" diagnostic rather than silently degrading.
-//
-// The SIMDJSON_HAS_PADDED_MEMORY_MAP macro reflects whether the class is
-// available in the current translation unit. Users may test this macro to
-// conditionally compile code that depends on padded_memory_map.
-#ifndef SIMDJSON_HAS_PADDED_MEMORY_MAP
-  #if defined(__unix__) || defined(__APPLE__) || defined(__linux__)
-    #define SIMDJSON_HAS_PADDED_MEMORY_MAP 1
-  #elif defined(_WINDOWS_) && defined(SIMDJSON_ENABLE_MEMORY_FILE_MAPPING_ON_WINDOWS) && SIMDJSON_ENABLE_MEMORY_FILE_MAPPING_ON_WINDOWS
-    #define SIMDJSON_HAS_PADDED_MEMORY_MAP 1
-  #else
-    #define SIMDJSON_HAS_PADDED_MEMORY_MAP 0
-  #endif
-#endif
 
 #endif // SIMDJSON_PORTABILITY_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.2"
 
 namespace simdjson {
 enum {
@@ -19,7 +19,7 @@ enum {
   /**
    * The revision (major.minor.REVISION) of simdjson being used.
    */
-  SIMDJSON_VERSION_REVISION = 1
+  SIMDJSON_VERSION_REVISION = 2
 };
 } // 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 11:03:09 -0400. version 4.6.2 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();

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)

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

@@ -1,29 +1,13 @@
-// On Windows, padded_memory_map is an opt-in feature gated on the
-// SIMDJSON_ENABLE_MEMORY_FILE_MAPPING_ON_WINDOWS macro. When that macro is set, the
-// consumer must also include <windows.h> before <simdjson.h>. We include
-// the Win32 header here so that -- in configurations that turned the
-// feature on -- the test actually exercises the Windows path.
 #ifdef _WIN32
-#ifndef WIN32_LEAN_AND_MEAN
-#define WIN32_LEAN_AND_MEAN
-#endif
-#ifndef NOMINMAX
-#define NOMINMAX
-#endif
-#include <windows.h>
-#endif
+#include <cstdlib>
+// This test is not supported on Windows because it relies on POSIX APIs like
+// mmap. Please run it on a POSIX-compliant system.
+int main() { return EXIT_SUCCESS; }
+#else
 
 #include "simdjson.h"
 #include "test_macros.h"
 
-// When SIMDJSON_HAS_PADDED_MEMORY_MAP is 0 (e.g. Windows builds without
-// SIMDJSON_ENABLE_MEMORY_FILE_MAPPING_ON_WINDOWS, or MinGW configurations that lack
-// the required SDK gating), compile the test body out and make main()
-// report success so the test suite still runs as a no-op. This is not a
-// silent downgrade: users who want the Windows path must explicitly
-// enable the CMake option `SIMDJSON_ENABLE_MEMORY_FILE_MAPPING_ON_WINDOWS`.
-#if SIMDJSON_HAS_PADDED_MEMORY_MAP
-
 #if SIMDJSON_EXCEPTIONS
 bool test_memory_map_exception() {
   TEST_START();
@@ -53,89 +37,11 @@ bool test_memory_map_noexception() {
     TEST_SUCCEED();
 }
 
-// Verifies that padded_memory_map can feed a streaming parser (iterate_many)
-// with JSON documents read from a file. This exercises the API that parse_many
-// / iterate_many users typically want: no extra copy on POSIX, portable fallback
-// on Windows. The AMAZON_CELLPHONES_NDJSON resource is an NDJSON file so it is
-// a realistic stress-test for streaming from a memory-mapped file.
-bool test_memory_map_iterate_many() {
-    TEST_START();
-    simdjson::padded_memory_map map(AMAZON_CELLPHONES_NDJSON);
-    if (!map.is_valid()) {
-        std::cerr << "Failed to memory-map the file " << AMAZON_CELLPHONES_NDJSON << std::endl;
-        return false;
-    }
-    simdjson::padded_string_view view = map.view();
-    simdjson::ondemand::parser parser;
-    simdjson::ondemand::document_stream stream;
-    ASSERT_SUCCESS( parser.iterate_many(view).get(stream) );
-    size_t count = 0;
-    for (auto doc : stream) {
-        ASSERT_SUCCESS( doc.error() );
-        count++;
-    }
-    if (count == 0) {
-        std::cerr << "Expected at least one document in " << AMAZON_CELLPHONES_NDJSON << std::endl;
-        return false;
-    }
-    TEST_SUCCEED();
-}
-
-// Verifies that padded_memory_map also works with the DOM streaming parser
-// (parse_many). Same rationale as the ondemand variant above.
-bool test_memory_map_parse_many() {
-    TEST_START();
-    simdjson::padded_memory_map map(AMAZON_CELLPHONES_NDJSON);
-    if (!map.is_valid()) {
-        std::cerr << "Failed to memory-map the file " << AMAZON_CELLPHONES_NDJSON << std::endl;
-        return false;
-    }
-    simdjson::padded_string_view view = map.view();
-    simdjson::dom::parser parser;
-    simdjson::dom::document_stream stream;
-    ASSERT_SUCCESS( parser.parse_many(view).get(stream) );
-    size_t count = 0;
-    for (auto doc : stream) {
-        ASSERT_SUCCESS( doc.error() );
-        count++;
-    }
-    if (count == 0) {
-        std::cerr << "Expected at least one document in " << AMAZON_CELLPHONES_NDJSON << std::endl;
-        return false;
-    }
-    TEST_SUCCEED();
-}
-
-// Ensures that trying to memory-map a file that does not exist leaves the map
-// in the "invalid" state rather than crashing. This is important on Windows
-// where the underlying implementation path differs from POSIX.
-bool test_memory_map_missing_file() {
-    TEST_START();
-    simdjson::padded_memory_map map("this_file_definitely_does_not_exist_123456789.json");
-    if (map.is_valid()) {
-        std::cerr << "Expected is_valid() == false for missing file" << std::endl;
-        return false;
-    }
-    TEST_SUCCEED();
-}
-
-#endif // SIMDJSON_HAS_PADDED_MEMORY_MAP
-
 int main() {
-#if SIMDJSON_HAS_PADDED_MEMORY_MAP
-    bool ok = true;
 #if SIMDJSON_EXCEPTIONS
-    ok = ok && test_memory_map_exception();
-#endif
-    ok = ok && test_memory_map_noexception();
-    ok = ok && test_memory_map_iterate_many();
-    ok = ok && test_memory_map_parse_many();
-    ok = ok && test_memory_map_missing_file();
-    return ok ? EXIT_SUCCESS : EXIT_FAILURE;
+    return (test_memory_map_exception() && test_memory_map_noexception()) ? EXIT_SUCCESS : EXIT_FAILURE;
 #else
-    std::cout << "padded_memory_map is disabled in this configuration; "
-                 "set SIMDJSON_ENABLE_MEMORY_FILE_MAPPING_ON_WINDOWS=ON in CMake to "
-                 "enable it on Windows. Test skipped." << std::endl;
-    return EXIT_SUCCESS;
+    return test_memory_map_noexception() ? EXIT_SUCCESS : EXIT_FAILURE;
 #endif
 }
+#endif

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)
@@ -25,7 +24,6 @@ add_cpp_test(ondemand_misc_tests                     LABELS ondemand acceptance
 add_cpp_test(ondemand_number_tests                   LABELS ondemand acceptance per_implementation)
 add_cpp_test(ondemand_number_in_string_tests         LABELS ondemand acceptance per_implementation)
 add_cpp_test(ondemand_object_tests                   LABELS ondemand acceptance per_implementation)
-add_cpp_test(ondemand_object_find_field_tests        LABELS ondemand acceptance per_implementation)
 add_cpp_test(ondemand_object_error_tests             LABELS ondemand acceptance per_implementation)
 add_cpp_test(ondemand_ordering_tests                 LABELS ondemand acceptance per_implementation)
 add_cpp_test(ondemand_parse_api_tests                LABELS ondemand acceptance per_implementation)
@@ -42,7 +40,6 @@ add_cpp_test(ondemand_convert_tests                  LABELS ondemand acceptance
 add_cpp_test(ondemand_unknown_tests                  LABELS ondemand acceptance per_implementation)
 add_cpp_test(ondemand_wildcard_tests                 LABELS ondemand acceptance per_implementation)
 if(NOT SIMDJSON_SANITIZE)
-  add_cpp_test(ondemand_padded_input              LABELS ondemand acceptance per_implementation)
   add_cpp_test(ondemand_cacheline              LABELS ondemand acceptance per_implementation)
 endif()
 

tests/ondemand/ondemand_cacheline.cpp

@@ -20,7 +20,7 @@ long page_size() {
 }
 
 // Returns true if the buffer + len + simdjson::SIMDJSON_PADDING crosses the
-// page boundary. 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()));

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

@@ -173,36 +173,6 @@ namespace object_tests {
     TEST_SUCCEED();
   }
 
-#if SIMDJSON_SUPPORTS_CONCEPTS
-  bool object_find_field_key_selector() {
-    TEST_START();
-    auto json = R"({ "name": "John", "age": 30, "city": "New York" })"_padded;
-    constexpr std::array<std::string_view, 3> keys = {"name", "age", "city"};
-    constexpr auto selector = ondemand::key_selector<3>(keys);
-
-    SUBTEST("ondemand::object with key_selector", test_ondemand_doc(json, [&](auto doc_result) {
-      ondemand::object object;
-      ASSERT_SUCCESS( doc_result.get(object) );
-
-      auto [index, value_result] = object.find_field(selector);
-      ASSERT_TRUE(index < 3);
-      ASSERT_SUCCESS(value_result);
-      std::string_view str_val;
-      ASSERT_SUCCESS(value_result.get(str_val));
-      ASSERT_EQUAL(str_val, "John");
-
-      // Test that we can find different keys
-      ASSERT_EQUAL(selector.index_of("name"), 0);
-      ASSERT_EQUAL(selector.index_of("age"), 1);
-      ASSERT_EQUAL(selector.index_of("city"), 2);
-      ASSERT_EQUAL(selector.index_of("invalid"), 3); // Not found
-
-      return true;
-    }));
-    TEST_SUCCEED();
-  }
-#endif
-
   bool run() {
     return
            object_find_field_unordered() &&
@@ -211,9 +181,6 @@ namespace object_tests {
            object_find_field() &&
            document_object_find_field() &&
            value_object_find_field() &&
-#if SIMDJSON_SUPPORTS_CONCEPTS
-           object_find_field_key_selector() &&
-#endif
            true;
   }
 

tests/ondemand/ondemand_padded_input.cpp

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

tests/ondemand/ondemand_readme_examples.cpp

@@ -1,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()