deserialize: single-pass dispatch for structs with optional fields

The reflection deserializer used `obj[key].get(out.member)` per struct field, which delegates to find_field_unordered. For *absent* optional fields this scans the entire JSON object before returning NO_SUCH_FIELD — O(K) per absent optional, where K is the JSON object's field count. A struct with N optionals where most are absent pays O(N*K) per record. CITM hits this hard: CITMEvent has 7 optional fields; most events leave several of them null/missing, so we re-scan each event many times. Switch to single-pass dispatch when the struct has any std::optional member: walk the JSON object exactly once, dispatch each visited key to the matching struct member via a compile-time-generated key comparison (with length pre-filter), let object_iterator::operator++ auto-skip values for unknown keys. For structs with all-required fields (Twitter Status, User), keep the existing per-field obj[key] path. It's O(1) per field on in-order JSON and faster than the unrolled compare chain for dense, in-order objects. Measured (TRUE A/B, 7 alternating rounds, single docker invocation): CITM static_reflection: 2084 -> 2387 MB/s +14.5% CITM from: 2053 -> 2358 MB/s +14.9% Twitter static_reflection: 3416 -> 3419 MB/s break-even Twitter from: 3416 -> 3417 MB/s break-even All static_reflection_comprehensive_tests pass.
avoid unnecessary pointer member (#2715 )
2026-06-08 17:27:07 +00:00 · 2026-05-09 04:55:37 -07:00 · 2026-05-08 00:26:57 -04:00 · 2026-05-07 23:13:40 -04:00 · 2026-05-07 21:46:52 -04:00 · 2026-05-07 19:07:39 -04:00
142 changed files with 12238 additions and 3446 deletions
@@ -0,0 +1,26 @@
+name: gcc 16
+
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    branches:
+      - master
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    container:
+      image: 'gcc:16'
+    steps:
+      - uses: actions/checkout@v6
+      - name: Install dependencies
+        run: |
+          apt -y update
+          apt -y --no-install-recommends install cmake ninja-build
+      - name: Build and test
+        run: |
+          cmake -B build -D SIMDJSON_STATIC_REFLECTION=ON -DSIMDJSON_DEVELOPER_MODE=ON -GNinja
+          cmake --build build
+          ctest --test-dir build --parallel $(nproc)
@@ -42,3 +42,14 @@ jobs:
          echo -e '#include <simdjson.h>\nint main(int argc,char**argv) {simdjson::dom::parser parser;simdjson::dom::element tweets = parser.load(argv[1]); }' > tmp.cpp && c++ -Idestination/include -Ldestination/lib -std=c++17 -Wl,-rpath,destination/lib -o linkandrun tmp.cpp -lsimdjson && ./linkandrun jsonexamples/twitter.json &&
          cd ../tests/installation_tests/find &&
          mkdir buildshared && cd buildshared && cmake -DCMAKE_INSTALL_PREFIX:PATH=../../../buildshared/destination .. &&  cmake --build .
+      - name: Use cmake (parsing for NaN/Infinity enabled)
+        run: |
+          mkdir build_nan_inf &&
+          cd build_nan_inf &&
+          cmake  -DSIMDJSON_ENABLE_NAN_INF=ON -DSIMDJSON_GOOGLE_BENCHMARKS=ON -DSIMDJSON_DEVELOPER_MODE=ON -DBUILD_SHARED_LIBS=ON -DCMAKE_INSTALL_PREFIX:PATH=destination ..  &&
+          cmake --build .   &&
+          ctest --output-on-failure -LE explicitonly -j   &&
+          cmake --install . &&
+          echo -e '#include <simdjson.h>\nint main(int argc,char**argv) {simdjson::dom::parser parser;simdjson::dom::element tweets = parser.load(argv[1]); }' > tmp.cpp && c++ -Idestination/include -Ldestination/lib -std=c++17 -Wl,-rpath,destination/lib -o linkandrun tmp.cpp -lsimdjson && ./linkandrun jsonexamples/twitter.json &&
+          cd ../tests/installation_tests/find &&
+          mkdir build_nan_inf && cd build_nan_inf && cmake -DCMAKE_INSTALL_PREFIX:PATH=../../../build_nan_inf/destination .. &&  cmake --build .
@@ -21,6 +21,13 @@ jobs:
          cmake -DSIMDJSON_SANITIZE=ON -DCMAKE_BUILD_TYPE=Debug -DSIMDJSON_GOOGLE_BENCHMARKS=OFF -DSIMDJSON_DEVELOPER_MODE=ON -DBUILD_SHARED_LIBS=OFF ..  &&
          cmake --build .   &&
          ctest --output-on-failure -LE explicitonly -j
+      - name: Use cmake with address sanitizer (Parsing of NaN/Infinity enabled)
+        run: |
+          mkdir builddebug_nan_inf &&
+          cd builddebug_nan_inf &&
+          cmake -DSIMDJSON_SANITIZE=ON -DCMAKE_BUILD_TYPE=Debug -DSIMDJSON_GOOGLE_BENCHMARKS=OFF -DSIMDJSON_DEVELOPER_MODE=ON -DBUILD_SHARED_LIBS=OFF -DSIMDJSON_ENABLE_NAN_INF=ON ..  &&
+          cmake --build .   &&
+          ctest --output-on-failure -LE explicitonly -j
  ubuntu-build-undefined-sanitizer:
    if: >-
      ! contains(toJSON(github.event.commits.*.message), '[skip ci]') &&
@@ -39,3 +46,10 @@ jobs:
          cmake -DSIMDJSON_SANITIZE_UNDEFINED=ON -DCMAKE_BUILD_TYPE=Debug -DSIMDJSON_GOOGLE_BENCHMARKS=OFF -DSIMDJSON_DEVELOPER_MODE=ON -DBUILD_SHARED_LIBS=OFF ..  &&
          cmake --build .   &&
          ctest --output-on-failure -LE explicitonly -j
+      - name: Use cmake with undefined sanitizer (Parsing of NaN/Infinity enabled)
+        run: |
+          mkdir builddebugundefsani_nan_inf &&
+          cd builddebugundefsani_nan_inf &&
+          cmake -DSIMDJSON_SANITIZE_UNDEFINED=ON -DCMAKE_BUILD_TYPE=Debug -DSIMDJSON_GOOGLE_BENCHMARKS=OFF -DSIMDJSON_DEVELOPER_MODE=ON -DBUILD_SHARED_LIBS=OFF -DSIMDJSON_ENABLE_NAN_INF=ON ..  &&
+          cmake --build .   &&
+          ctest --output-on-failure -LE explicitonly -j
@@ -12,14 +12,15 @@ jobs:
        shared: [ON, OFF]
        cxx: [g++-13, clang++-16]
        sanitizer: [ON, OFF]
+        nan_inf: [ON, OFF]
        build_type: [RelWithDebInfo, Debug, Release]
    steps:
      - uses: actions/checkout@a5ac7e51b41094c92402da3b24376905380afc29 # v4.1.6
      - name: Prepare
-        run: cmake -DCMAKE_BUILD_TYPE=${{matrix.build_type}} -DSIMDJSON_DEVELOPER_MODE=ON -DSIMDJSON_SANITIZE=${{matrix.sanitizer}} -DBUILD_SHARED_LIBS=${{matrix.shared}}  -B build
+        run: cmake -DCMAKE_BUILD_TYPE=${{matrix.build_type}} -DSIMDJSON_DEVELOPER_MODE=ON -DSIMDJSON_SANITIZE=${{matrix.sanitizer}} -DBUILD_SHARED_LIBS=${{matrix.shared}} -DSIMDJSON_ENABLE_NAN_INF=${{matrix.nan_inf}} -B build
        env:
          CXX: ${{matrix.cxx}}
      - 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
@@ -13,18 +13,22 @@ jobs:
      fail-fast: false
      matrix:
        include:
-          - {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}
+          - {gen: Visual Studio 17 2022, arch: Win32, shared: ON, build_type: Release, memory_map: OFF, nan_inf: OFF}
+          - {gen: Visual Studio 17 2022, arch: Win32, shared: OFF, build_type: Release, memory_map: OFF, nan_inf: OFF}
+          - {gen: Visual Studio 17 2022, arch: x64, shared: ON, build_type: Release, memory_map: OFF, nan_inf: OFF}
+          - {gen: Visual Studio 17 2022, arch: x64, shared: OFF, build_type: Debug, memory_map: OFF, nan_inf: OFF}
+          - {gen: Visual Studio 17 2022, arch: x64, shared: OFF, build_type: Release, memory_map: OFF, nan_inf: OFF}
+          - {gen: Visual Studio 17 2022, arch: x64, shared: OFF, build_type: RelWithDebInfo, memory_map: OFF, nan_inf: OFF}
+          - {gen: Visual Studio 17 2022, arch: x64, shared: OFF, build_type: Debug, memory_map: OFF, nan_inf: ON}
+          - {gen: Visual Studio 17 2022, arch: x64, shared: OFF, build_type: Release, memory_map: OFF, nan_inf: ON}
+          # 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, nan_inf: OFF}
    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}} -B build
+        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}} -DSIMDJSON_ENABLE_NAN_INF=${{matrix.nan_inf}} -B build
    - name: Build Debug
      run: cmake --build build --config ${{matrix.build_type}} --verbose
    - name: Run tests
@@ -37,4 +41,4 @@ jobs:
    - name: Test Installation
      run: |
        cmake -G "${{matrix.gen}}" -A ${{matrix.arch}}  -B build_install_test tests/installation_tests/find
-        cmake --build build_install_test --config ${{matrix.build_type}}
+        cmake --build build_install_test --config ${{matrix.build_type}}
@@ -12,7 +12,7 @@ endif()
 project(
    simdjson
    # The version number is modified by tools/release.py
-    VERSION 4.4.1
+    VERSION 4.6.1
    DESCRIPTION "Parsing gigabytes of JSON per second"
    HOMEPAGE_URL "https://simdjson.org/"
    LANGUAGES CXX C
@@ -29,8 +29,8 @@ string(
 # ---- Options, variables ----

 # These version numbers are modified by tools/release.py
-set(SIMDJSON_LIB_VERSION "31.0.0" CACHE STRING "simdjson library version")
-set(SIMDJSON_LIB_SOVERSION "31" CACHE STRING "simdjson library soversion")
+set(SIMDJSON_LIB_VERSION "33.0.0" CACHE STRING "simdjson library version")
+set(SIMDJSON_LIB_SOVERSION "33" CACHE STRING "simdjson library soversion")

 option(SIMDJSON_BUILD_STATIC_LIB "Build simdjson_static library along with simdjson (only makes sense if BUILD_SHARED_LIBS=ON)" OFF)
 if(SIMDJSON_BUILD_STATIC_LIB AND NOT BUILD_SHARED_LIBS)
@@ -75,10 +75,48 @@ 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)
  option(BUILD_SHARED_LIBS "Build simdjson as a shared library" OFF)
  option(SIMDJSON_SINGLEHEADER "Disable singleheader generation" ON)
+else()
+  option(SIMDJSON_INSTALL "Enable target install" ${BUILD_SHARED_LIBS})
 endif()

 include(cmake/handle-deprecations.cmake)
@@ -92,13 +130,16 @@ add_library(simdjson ${SIMDJSON_SOURCES})
 add_library(simdjson::simdjson ALIAS simdjson)
 set(SIMDJSON_LIBRARIES simdjson)

+# Check for <bit> header compatibility
+include(CheckIncludeFileCXX)
+check_include_file_cxx(bit SIMDJSON_HAS_BIT_HEADER)
+
 # Enable precompiled headers for faster builds
 if(CMAKE_VERSION VERSION_GREATER_EQUAL "3.16")
-  target_precompile_headers(simdjson PRIVATE
+  set(SIMDJSON_PRECOMPILE_HEADERS
    <algorithm>
    <array>
    <atomic>
-    <bit>
    <cassert>
    <cctype>
    <cerrno>
@@ -111,6 +152,12 @@ if(CMAKE_VERSION VERSION_GREATER_EQUAL "3.16")
    <utility>
    <vector>
  )
+
+  if(SIMDJSON_HAS_BIT_HEADER)
+    list(APPEND SIMDJSON_PRECOMPILE_HEADERS <bit>)
+  endif()
+
+  target_precompile_headers(simdjson PRIVATE ${SIMDJSON_PRECOMPILE_HEADERS})
 endif()

 if(SIMDJSON_BUILD_STATIC_LIB)
@@ -155,13 +202,37 @@ if(MSVC)
  endif()
 endif()

+
+
 if(SIMDJSON_STATIC_REFLECTION)
+
+
+  if(CMAKE_CXX_COMPILER_ID STREQUAL "Clang" AND CMAKE_CXX_COMPILER_VERSION MATCHES "^21")
+    execute_process(
+        COMMAND ${CMAKE_CXX_COMPILER} --version
+        OUTPUT_VARIABLE CLANG_VERSION_OUTPUT
+        ERROR_VARIABLE CLANG_VERSION_ERROR
+        RESULT_VARIABLE CLANG_VERSION_RESULT
+    )
+    if(CLANG_VERSION_RESULT EQUAL 0 AND CLANG_VERSION_OUTPUT MATCHES "https://github.com/bloomberg/clang-p2996.git")
+        set(IS_BLOOMBERG_P2996_CLANG ON)
+        message(STATUS "Using Bloomberg P2996 Clang fork")
+    endif()
+  endif()
+
  # We would like to require C++26, but no compiler supports that!
  # This is a hack:
+  if(IS_BLOOMBERG_P2996_CLANG)
  simdjson_add_props(
      target_compile_options PUBLIC
      -freflection -fexpansion-statements -stdlib=libc++ -std=c++26
  )
+  else()
+  simdjson_add_props(
+      target_compile_options PUBLIC
+      -freflection -std=c++26
+  )
+  endif()
 else()
  simdjson_add_props(target_compile_features PUBLIC cxx_std_11)
 endif()
@@ -183,6 +254,12 @@ if(SIMDJSON_MINUS_ZERO_AS_FLOAT)
  simdjson_add_props(target_compile_definitions PRIVATE SIMDJSON_MINUS_ZERO_AS_FLOAT=1)
 endif(SIMDJSON_MINUS_ZERO_AS_FLOAT)

+option(SIMDJSON_ENABLE_NAN_INF "Allow parsing of NaN and Infinity JSON values" OFF)
+if(SIMDJSON_ENABLE_NAN_INF)
+  message(STATUS "simdjson NaN and Infinity parsing is enabled.")
+  simdjson_add_props(target_compile_definitions PUBLIC SIMDJSON_ENABLE_NAN_INF=1)
+endif()
+
 # GCC and Clang have horrendous Debug builds when using SIMD.
 # A common fix is to use '-Og' instead.
 # bug https://gcc.gnu.org/bugzilla/show_bug.cgi?id=54412
@@ -216,87 +293,89 @@ endif()

 # ---- Install rules ----

-include(CMakePackageConfigHelpers)
-include(GNUInstallDirs)
+if(SIMDJSON_INSTALL)
+    include(CMakePackageConfigHelpers)
+    include(GNUInstallDirs)

-if(SIMDJSON_SINGLEHEADER)
-  install(
-      FILES singleheader/simdjson.h
-      DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}"
-      COMPONENT simdjson_Development
-  )
+    if(SIMDJSON_SINGLEHEADER)
+      install(
+          FILES singleheader/simdjson.h
+          DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}"
+          COMPONENT simdjson_Development
+      )
+    endif()
+
+    install(
+        TARGETS simdjson
+        EXPORT simdjsonTargets
+        RUNTIME COMPONENT simdjson_Runtime
+        LIBRARY COMPONENT simdjson_Runtime
+        NAMELINK_COMPONENT simdjson_Development
+        ARCHIVE COMPONENT simdjson_Development
+        INCLUDES DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}"
+    )
+    configure_file(cmake/simdjson-config.cmake.in simdjson-config.cmake @ONLY)
+
+    write_basic_package_version_file(
+        simdjson-config-version.cmake
+        COMPATIBILITY SameMinorVersion
+    )
+
+    set(
+        SIMDJSON_INSTALL_CMAKEDIR "${CMAKE_INSTALL_LIBDIR}/cmake/simdjson"
+        CACHE STRING "CMake package config location relative to the install prefix"
+    )
+    mark_as_advanced(SIMDJSON_INSTALL_CMAKEDIR)
+
+    install(
+        FILES
+        "${PROJECT_BINARY_DIR}/simdjson-config.cmake"
+        "${PROJECT_BINARY_DIR}/simdjson-config-version.cmake"
+        DESTINATION "${SIMDJSON_INSTALL_CMAKEDIR}"
+        COMPONENT simdjson_Development
+    )
+
+    install(
+        EXPORT simdjsonTargets
+        NAMESPACE simdjson::
+        DESTINATION "${SIMDJSON_INSTALL_CMAKEDIR}"
+        COMPONENT simdjson_Development
+    )
+
+    if(SIMDJSON_BUILD_STATIC_LIB)
+      install(
+          TARGETS simdjson_static
+          EXPORT simdjson_staticTargets
+          ARCHIVE COMPONENT simdjson_Development
+          INCLUDES DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}"
+      )
+      install(
+          EXPORT simdjson_staticTargets
+          NAMESPACE simdjson::
+          DESTINATION "${SIMDJSON_INSTALL_CMAKEDIR}"
+          COMPONENT simdjson_Development
+      )
+    endif()
+
+    # pkg-config
+    include(cmake/JoinPaths.cmake)
+    join_paths(PKGCONFIG_INCLUDEDIR "\${prefix}" "${CMAKE_INSTALL_INCLUDEDIR}")
+    join_paths(PKGCONFIG_LIBDIR "\${prefix}" "${CMAKE_INSTALL_LIBDIR}")
+
+    if(SIMDJSON_ENABLE_THREADS)
+      set(PKGCONFIG_CFLAGS "-DSIMDJSON_THREADS_ENABLED=1")
+      if(CMAKE_THREAD_LIBS_INIT)
+        set(PKGCONFIG_LIBS_PRIVATE "Libs.private: ${CMAKE_THREAD_LIBS_INIT}")
+      endif()
+    endif()
+
+    configure_file("simdjson.pc.in" "simdjson.pc" @ONLY)
+    install(
+        FILES "${CMAKE_CURRENT_BINARY_DIR}/simdjson.pc"
+        DESTINATION "${CMAKE_INSTALL_LIBDIR}/pkgconfig"
+    )
 endif()

-install(
-    TARGETS simdjson
-    EXPORT simdjsonTargets
-    RUNTIME COMPONENT simdjson_Runtime
-    LIBRARY COMPONENT simdjson_Runtime
-    NAMELINK_COMPONENT simdjson_Development
-    ARCHIVE COMPONENT simdjson_Development
-    INCLUDES DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}"
-)
-configure_file(cmake/simdjson-config.cmake.in simdjson-config.cmake @ONLY)
-
-write_basic_package_version_file(
-    simdjson-config-version.cmake
-    COMPATIBILITY SameMinorVersion
-)
-
-set(
-    SIMDJSON_INSTALL_CMAKEDIR "${CMAKE_INSTALL_LIBDIR}/cmake/simdjson"
-    CACHE STRING "CMake package config location relative to the install prefix"
-)
-mark_as_advanced(SIMDJSON_INSTALL_CMAKEDIR)
-
-install(
-    FILES
-    "${PROJECT_BINARY_DIR}/simdjson-config.cmake"
-    "${PROJECT_BINARY_DIR}/simdjson-config-version.cmake"
-    DESTINATION "${SIMDJSON_INSTALL_CMAKEDIR}"
-    COMPONENT simdjson_Development
-)
-
-install(
-    EXPORT simdjsonTargets
-    NAMESPACE simdjson::
-    DESTINATION "${SIMDJSON_INSTALL_CMAKEDIR}"
-    COMPONENT simdjson_Development
-)
-
-if(SIMDJSON_BUILD_STATIC_LIB)
-  install(
-      TARGETS simdjson_static
-      EXPORT simdjson_staticTargets
-      ARCHIVE COMPONENT simdjson_Development
-      INCLUDES DESTINATION "${CMAKE_INSTALL_INCLUDEDIR}"
-  )
-  install(
-      EXPORT simdjson_staticTargets
-      NAMESPACE simdjson::
-      DESTINATION "${SIMDJSON_INSTALL_CMAKEDIR}"
-      COMPONENT simdjson_Development
-  )
-endif()
-
-# pkg-config
-include(cmake/JoinPaths.cmake)
-join_paths(PKGCONFIG_INCLUDEDIR "\${prefix}" "${CMAKE_INSTALL_INCLUDEDIR}")
-join_paths(PKGCONFIG_LIBDIR "\${prefix}" "${CMAKE_INSTALL_LIBDIR}")
-
-if(SIMDJSON_ENABLE_THREADS)
-  set(PKGCONFIG_CFLAGS "-DSIMDJSON_THREADS_ENABLED=1")
-  if(CMAKE_THREAD_LIBS_INIT)
-    set(PKGCONFIG_LIBS_PRIVATE "Libs.private: ${CMAKE_THREAD_LIBS_INIT}")
-  endif()
-endif()
-
-configure_file("simdjson.pc.in" "simdjson.pc" @ONLY)
-install(
-    FILES "${CMAKE_CURRENT_BINARY_DIR}/simdjson.pc"
-    DESTINATION "${CMAKE_INSTALL_LIBDIR}/pkgconfig"
-)
-
 #
 # CPack
 #
@@ -373,18 +452,25 @@ add_subdirectory(fuzz)
 #
 # Source files should be just ASCII
 #
-find_program(FIND find)
-find_program(FILE file)
-find_program(GREP grep)
-if(FIND AND FILE AND GREP)
+find_program(FIND_CMD find)
+find_program(FILE_CMD file)
+find_program(GREP_CMD grep)
+if(FIND_CMD AND FILE_CMD AND GREP_CMD)
  add_test(
      NAME just_ascii
      COMMAND sh -c "\
-${FIND} include src windows tools singleheader tests examples benchmark \
-path benchmark/checkperf-reference -prune -name '*.h' -o -name '*.cpp' \
-type f -exec ${FILE} '{}' \; | ${GREP} -qv ASCII || exit 0  && exit 1"
+non_ascii=$(${FIND_CMD} include src windows tools singleheader tests examples benchmark \
+  -path benchmark/checkperf-reference -prune -name '*.h' -o -name '*.cpp' \
+  -type f -exec ${FILE_CMD} '{}' \; | ${GREP_CMD} -v ASCII); \
+if [ -n \"$non_ascii\" ]; then \
+  echo 'The following files contain non-ASCII characters:'; \
+  echo \"$non_ascii\"; \
+  exit 1; \
+fi"
      WORKING_DIRECTORY "${PROJECT_SOURCE_DIR}"
  )
+else()
+  message(WARNING "just_ascii test disabled because required tools were not found: find='${FIND_CMD}', file='${FILE_CMD}', grep='${GREP_CMD}'")
 endif()

 ##
@@ -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.4.1"
+PROJECT_NUMBER         = "4.6.1"

 # 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
@@ -65,6 +65,7 @@ Real-world usage
 - [GreptimeDB](https://github.com/GreptimeTeam/greptimedb)
 - [mamba](https://github.com/mamba-org/mamba)
 - [Ladybird Browser](https://ladybird.org)
+- [SereneDB](https://github.com/serenedb/serenedb)


 If you are planning to use simdjson in a product, please work from one of our releases.
@@ -211,10 +212,16 @@ We have an in-depth paper focused on the UTF-8 validation:

 We also have an informal [blog post providing some background and context](https://branchfree.org/2019/02/25/paper-parsing-gigabytes-of-json-per-second/).

-For the video inclined, <br />
+For the video inclined, we had a talk at QCon San Francisco 2019<br />
 [![simdjson at QCon San Francisco 2019](http://img.youtube.com/vi/wlvKAT7SZIQ/0.jpg)](http://www.youtube.com/watch?v=wlvKAT7SZIQ)<br />
 (It was the best voted talk, we're kinda proud of it.)

+We also had a CppCon 2025 talk. We show how C++26 reflection allows for one-line serialization (to_json(player)) or deserialization—without invasive macros or manual mapping—using nothing but the C++ standard library. Whether you’re a performance junkie or simply interested in the roadmap for the next decade of C++ development, watch our full talk!
+
+[![simdjson at CppCon 2025](http://img.youtube.com/vi/Mcgk3CxHYMs/0.jpg)](http://www.youtube.com/watch?v=Mcgk3CxHYMs)<br />
+
+
+
 Citing this work
 -----------------

@@ -1,9 +1,10 @@
 add_subdirectory(dom)


-include_directories( . linux )
+include_directories( . )
 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)
@@ -15,6 +16,7 @@ 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)
@@ -124,6 +124,7 @@ SIMDJSON_POP_DISABLE_WARNINGS
 #include "kostya/boostjson.h"

 #include "large_random/simdjson_ondemand.h"
+#include "large_random/simdjson_ondemand_ranges.h"
 #if SIMDJSON_COMPETITION_ONDEMAND_UNORDERED
 #include "large_random/simdjson_ondemand_unordered.h"
 #endif // SIMDJSON_COMPETITION_ONDEMAND_UNORDERED
@@ -0,0 +1,216 @@
+#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();
@@ -1,4 +1,5 @@
-#include "event_counter.h"
+#include <counters/event_counter.h>
+using namespace counters;

 #include <cassert>
 #include <cctype>
@@ -25,7 +26,6 @@
 #include <string>
 #include <vector>

-#include "linux-perf-events.h"
 #ifdef __linux__
 #include <libgen.h>
 #endif
@@ -204,12 +204,8 @@ 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 {
@@ -221,12 +217,8 @@ 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!)
@@ -239,12 +231,8 @@ 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
  }


@@ -258,12 +246,8 @@ 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 {
@@ -275,12 +259,8 @@ 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
  }


@@ -378,22 +358,6 @@ 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);
@@ -417,7 +381,6 @@ void print_file_effectiveness(BenchmarkStage stage, const char* filename, const
  }
  printf("|\n");
 }
-#endif

 int main(int argc, char *argv[]) {
  // Read options
@@ -1,7 +1,8 @@
 #ifndef _BENCHMARK_H_
 #define _BENCHMARK_H_

-#include "event_counter.h"
+#include <counters/event_counter.h>
+using namespace counters;

 /*
 * Prints the best number of operations per cycle where
@@ -1,7 +1,8 @@
 #ifndef __BENCHMARKER_H
 #define __BENCHMARKER_H

-#include "event_counter.h"
+#include <counters/event_counter.h>
+using namespace counters;
 #include "simdjson.h"

 #include <cassert>
@@ -28,11 +29,9 @@
 #include <string>
 #include <vector>

-#include "linux-perf-events.h"
 #ifdef __linux__
 #include <libgen.h>
 #endif
-#include "simdjson.h"

 #include <functional>

@@ -423,18 +422,12 @@ struct benchmarker {
        stage.instructions() / static_cast<double>(stats->structurals),
        stage.instructions() / static_cast<double>(stage.cycles())
      );
-#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",
+      printf("%s%-13s: %7.0f branch misses (%6.2f%%)\n",
        prefix,
        "Misses",
        stage.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()
+        percent(stage.branch_misses(), all_stages_without_allocation.branch_misses())
      );
-#endif
    }
  }

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

@@ -1,11 +1,12 @@
-include_directories( .. ../linux )
+include_directories( .. )
 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)
@@ -1,4 +1,5 @@
-#include "event_counter.h"
+#include <counters/event_counter.h>
+using namespace counters;

 #include <cassert>
 #include <cctype>
@@ -24,7 +25,6 @@
 #include <string>
 #include <vector>

-#include "linux-perf-events.h"
 #ifdef __linux__
 #include <libgen.h>
 #endif
@@ -1,207 +0,0 @@
-#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;
-}
@@ -1,201 +0,0 @@
-#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
@@ -1,7 +1,8 @@
 #ifndef BENCHMARK_HELPERS_H
 #define BENCHMARK_HELPERS_H

-#include "event_counter.h"
+#include <counters/event_counter.h>
+using namespace counters;
 #include <atomic>

 event_collector collector;
@@ -1,7 +1,8 @@
 #pragma once

 #include "simdjson.h"
-#include "event_counter.h"
+#include <counters/event_counter.h>
+using namespace counters;
 #include <iostream>

 namespace json_benchmark {
@@ -58,11 +59,7 @@ 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());
@@ -70,11 +67,7 @@ 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();
@@ -95,11 +88,7 @@ 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);
@@ -1,6 +1,7 @@
 #pragma once

 #include "json_benchmark/string_runner.h"
+#include <fstream>
 #include <map>
 #include <string>

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

 error_code Sax::Allocate(size_t new_capacity) {
  // string_capacity copied from document::allocate
-  size_t string_capacity = SIMDJSON_ROUNDUP_N(5 * new_capacity / 3 + SIMDJSON_PADDING, 64);
+  // a document with only zero-length strings... could have capacity/3 string
+  // and we would need capacity/3 * 5 bytes on the string buffer
+  if(5 * (new_capacity / 3) + SIMDJSON_PADDING < SIMDJSON_PADDING) {
+    return CAPACITY; // overflow, only happen on legacy 32-bit systems with very large capacity
+  }
+  size_t string_capacity = SIMDJSON_ROUNDUP_N(5 * (new_capacity / 3) + SIMDJSON_PADDING, 64);
  string_buf.reset(new (std::nothrow) uint8_t[string_capacity]);
  if (auto error = dom_parser.set_capacity(new_capacity)) { return error; }
  if (capacity == 0) { // set max depth the first time only
@@ -1,105 +0,0 @@
-#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
@@ -10,7 +10,7 @@ namespace partial_tweets {
 //     {
 //       "created_at": "Sun Aug 31 00:29:15 +0000 2014",
 //       "id": 505874924095815700,
-//       "text": "@aym0566x \n\n名前:前田あゆみ\n第一印象:なんか怖っ！\n今の印象:とりあえずキモい。噛み合わない\n好きなところ:ぶすでキモいとこ😋✨✨\n思い出:んーーー、ありすぎ😊❤️\nLINE交換できる？:あぁ……ごめん✋\nトプ画をみて:照れますがな😘✨\n一言:お前は一生もんのダチ💖",
+//       "text": "@aym0566x ...",
 //       "in_reply_to_status_id": null,
 //       "user": {
 //         "id": 1186275104,
@@ -1,6 +1,7 @@
 #ifndef BENCHMARK_HELPER_HPP
 #define BENCHMARK_HELPER_HPP
-#include "event_counter.h"
+#include <counters/event_counter.h>
+using namespace counters;
 #include <atomic>

 inline event_collector &get_collector() {
@@ -0,0 +1,88 @@
+#ifndef GLAZE_CITM_CATALOG_DATA_H
+#define GLAZE_CITM_CATALOG_DATA_H
+
+#include <cstdint>
+#include <map>
+#include <optional>
+#include <stdexcept>
+#include <string>
+#include <vector>
+
+#include <glaze/glaze.hpp>
+
+// Glaze-specific shadow types. We mirror the Rust serde struct here (rather
+// than the C++ CitmCatalog) so that fields the source JSON encodes as `null`
+// (e.g. CITMEvent.name) parse cleanly into std::optional. This matches what
+// the Rust benchmark does, and the resulting JSON output volume is therefore
+// directly comparable to the Rust numbers.
+
+struct GlazeCITMPrice {
+    uint64_t amount;
+    uint64_t audienceSubCategoryId;
+    uint64_t seatCategoryId;
+};
+
+struct GlazeCITMArea {
+    uint64_t areaId;
+    std::vector<uint64_t> blockIds;
+};
+
+struct GlazeCITMSeatCategory {
+    std::vector<GlazeCITMArea> areas;
+    uint64_t seatCategoryId;
+};
+
+struct GlazeCITMPerformance {
+    uint64_t id;
+    uint64_t eventId;
+    std::optional<std::string> logo;
+    std::optional<std::string> name;
+    std::vector<GlazeCITMPrice> prices;
+    std::vector<GlazeCITMSeatCategory> seatCategories;
+    std::optional<std::string> seatMapImage;
+    uint64_t start;
+    std::string venueCode;
+};
+
+struct GlazeCITMEvent {
+    uint64_t id;
+    std::optional<std::string> name;
+    std::optional<std::string> description;
+    std::optional<std::string> logo;
+    std::vector<uint64_t> subTopicIds;
+    std::optional<std::string> subjectCode;
+    std::optional<std::string> subtitle;
+    std::vector<uint64_t> topicIds;
+};
+
+struct GlazeCitmCatalog {
+    std::map<std::string, GlazeCITMEvent> events;
+    std::vector<GlazeCITMPerformance> performances;
+};
+
+inline GlazeCitmCatalog glaze_deserialize_citm(const std::string &json_str) {
+    GlazeCitmCatalog data;
+    constexpr glz::opts opts{.error_on_unknown_keys = false};
+    auto err = glz::read<opts>(data, json_str);
+    if (err) {
+        throw std::runtime_error("glaze citm parse error: " +
+                                 glz::format_error(err, json_str));
+    }
+    return data;
+}
+
+inline std::string glaze_serialize_citm(const GlazeCitmCatalog &data) {
+    std::string out;
+    // skip_null_members = false: emit `"field":null` for unset optionals so the
+    // output has the same field count as simdjson's (which writes `"field":""`).
+    // Glaze still produces 4-char `null` vs simdjson's 2-char `""`, so it's not
+    // byte-identical, but the work-per-field is comparable.
+    constexpr glz::opts opts{.skip_null_members = false};
+    auto err = glz::write<opts>(data, out);
+    if (err) {
+        throw std::runtime_error("glaze citm write error");
+    }
+    return out;
+}
+
+#endif // GLAZE_CITM_CATALOG_DATA_H
@@ -0,0 +1,95 @@
+// Standalone Glaze benchmark for CITM Catalog (see glaze_twitter_bench.cpp
+// header comment for context).
+
+#include <cstdio>
+#include <cstdlib>
+#include <fstream>
+#include <iostream>
+#include <stdexcept>
+#include <string>
+
+#include "../citm_catalog_benchmark/glaze_citm_catalog_data.h"
+#include "../benchmark_utils/benchmark_helper.h"
+
+namespace {
+
+std::string read_file(const std::string &filename) {
+    printf("# Reading file %s\n", filename.c_str());
+    constexpr size_t read_size = 65536;
+    std::ifstream stream(filename, std::ios::binary);
+    if (!stream) {
+        std::cerr << "Could not open file: " << filename << std::endl;
+        std::exit(EXIT_FAILURE);
+    }
+    stream.exceptions(std::ios_base::badbit);
+    std::string out;
+    std::string buf(read_size, '\0');
+    while (stream.read(&buf[0], read_size)) {
+        out.append(buf, 0, size_t(stream.gcount()));
+    }
+    out.append(buf, 0, size_t(stream.gcount()));
+    return out;
+}
+
+void bench_glaze_serialization(GlazeCitmCatalog &data) {
+    std::string output = glaze_serialize_citm(data);
+    size_t output_volume = output.size();
+    printf("# output volume: %zu bytes\n", output_volume);
+
+    volatile size_t measured_volume = 0;
+    pretty_print(1, output_volume, "bench_glaze",
+                 bench([&data, &measured_volume, &output_volume]() {
+                     std::string output = glaze_serialize_citm(data);
+                     measured_volume = output.size();
+                     if (measured_volume != output_volume) {
+                         printf("mismatch\n");
+                     }
+                 }));
+}
+
+void bench_glaze_parsing(const std::string &json_str) {
+    size_t input_volume = json_str.size();
+    printf("# input volume: %zu bytes\n", input_volume);
+
+    volatile bool result = true;
+    pretty_print(1, input_volume, "bench_glaze_parsing",
+                 bench([&json_str, &result]() {
+                     try {
+                         GlazeCitmCatalog data = glaze_deserialize_citm(json_str);
+                         result = true;
+                     } catch (...) {
+                         result = false;
+                         printf("parse error\n");
+                     }
+                 }));
+}
+
+}  // namespace
+
+int main(int argc, char *argv[]) {
+    const char *json_file = std::getenv("CITM_JSON");
+    if (!json_file) {
+        json_file = "buildreflect/jsonexamples/citm_catalog.json";
+    }
+    if (argc > 1) {
+        json_file = argv[1];
+    }
+
+    std::string json_str = read_file(json_file);
+
+    const char *mode = std::getenv("BENCH_MODE");
+    if (!mode) mode = "all";
+
+    GlazeCitmCatalog data = glaze_deserialize_citm(json_str);
+
+    if (std::string(mode) == "all" || std::string(mode) == "parse") {
+        printf("\n=== Glaze CITM Parsing ===\n");
+        bench_glaze_parsing(json_str);
+    }
+    if (std::string(mode) == "all" || std::string(mode) == "serialize") {
+        printf("\n=== Glaze CITM Serialization ===\n");
+        bench_glaze_serialization(data);
+    }
+
+    return EXIT_SUCCESS;
+}
@@ -0,0 +1,99 @@
+// Standalone Glaze benchmark for Twitter, built with g++ instead of the
+// p2996 clang fork (which crashes on Glaze's heavy template metaprogramming).
+// Reuses the same data structs and bench() helper as the in-tree benchmarks
+// so the throughput numbers are directly comparable.
+
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <fstream>
+#include <iostream>
+#include <stdexcept>
+#include <string>
+#include <vector>
+
+#include "../twitter_benchmark/twitter_data.h"
+#include "../twitter_benchmark/glaze_twitter_data.h"
+#include "../benchmark_utils/benchmark_helper.h"
+
+namespace {
+
+std::string read_file(const std::string &filename) {
+    printf("# Reading file %s\n", filename.c_str());
+    constexpr size_t read_size = 4096;
+    std::ifstream stream(filename);
+    if (!stream) {
+        std::cerr << "Could not open file: " << filename << std::endl;
+        std::exit(EXIT_FAILURE);
+    }
+    stream.exceptions(std::ios_base::badbit);
+    std::string out;
+    std::string buf(read_size, '\0');
+    while (stream.read(&buf[0], read_size)) {
+        out.append(buf, 0, size_t(stream.gcount()));
+    }
+    out.append(buf, 0, size_t(stream.gcount()));
+    return out;
+}
+
+void bench_glaze_serialization(TwitterData &data) {
+    std::string output = glaze_serialize(data);
+    size_t output_volume = output.size();
+    printf("# output volume: %zu bytes\n", output_volume);
+
+    volatile size_t measured_volume = 0;
+    pretty_print(1, output_volume, "bench_glaze",
+                 bench([&data, &measured_volume, &output_volume]() {
+                     std::string output = glaze_serialize(data);
+                     measured_volume = output.size();
+                     if (measured_volume != output_volume) {
+                         printf("mismatch\n");
+                     }
+                 }));
+}
+
+void bench_glaze_parsing(const std::string &json_str) {
+    size_t input_volume = json_str.size();
+    printf("# input volume: %zu bytes\n", input_volume);
+
+    volatile bool result = true;
+    pretty_print(1, input_volume, "bench_glaze_parsing",
+                 bench([&json_str, &result]() {
+                     try {
+                         TwitterData data = glaze_deserialize(json_str);
+                         result = true;
+                     } catch (...) {
+                         result = false;
+                         printf("parse error\n");
+                     }
+                 }));
+}
+
+}  // namespace
+
+int main(int argc, char *argv[]) {
+    const char *json_file = std::getenv("TWITTER_JSON");
+    if (!json_file) {
+        json_file = "buildreflect/jsonexamples/twitter.json";
+    }
+    if (argc > 1) {
+        json_file = argv[1];
+    }
+
+    std::string json_str = read_file(json_file);
+
+    const char *mode = std::getenv("BENCH_MODE");
+    if (!mode) mode = "all";
+    TwitterData data = glaze_deserialize(json_str);
+
+    if (std::string(mode) == "all" || std::string(mode) == "parse") {
+        printf("\n=== Glaze Twitter Parsing ===\n");
+        bench_glaze_parsing(json_str);
+    }
+    if (std::string(mode) == "all" || std::string(mode) == "serialize") {
+        printf("\n=== Glaze Twitter Serialization ===\n");
+        bench_glaze_serialization(data);
+    }
+
+    return EXIT_SUCCESS;
+}
@@ -0,0 +1,31 @@
+#ifndef GLAZE_TWITTER_DATA_H
+#define GLAZE_TWITTER_DATA_H
+
+#include "twitter_data.h"
+#include <glaze/glaze.hpp>
+#include <stdexcept>
+#include <string>
+
+// Glaze auto-reflects aggregate types whose field names already match JSON
+// keys (snake_case here matches the JSON), so no glz::meta is required.
+
+inline TwitterData glaze_deserialize(const std::string &json_str) {
+    TwitterData data;
+    constexpr glz::opts opts{.error_on_unknown_keys = false};
+    auto err = glz::read<opts>(data, json_str);
+    if (err) {
+        throw std::runtime_error("glaze parse error: " + glz::format_error(err, json_str));
+    }
+    return data;
+}
+
+inline std::string glaze_serialize(const TwitterData &data) {
+    std::string out;
+    auto err = glz::write_json(data, out);
+    if (err) {
+        throw std::runtime_error("glaze write error");
+    }
+    return out;
+}
+
+#endif // GLAZE_TWITTER_DATA_H
@@ -12,7 +12,7 @@ cmake_dependent_option(SIMDJSON_GOOGLE_BENCHMARKS "compile the Google Benchmark
 if(SIMDJSON_GOOGLE_BENCHMARKS)
  CPMAddPackage(
        NAME google_benchmarks
-        URL https://github.com/google/benchmark/archive/refs/tags/v1.9.4.zip
+        URL https://github.com/google/benchmark/archive/refs/tags/v1.9.5.zip
        OPTIONS
        "BENCHMARK_ENABLE_TESTING OFF"
        "BENCHMARK_ENABLE_INSTALL OFF"
@@ -20,6 +20,14 @@ 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
@@ -28,6 +28,9 @@ 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)
+- [C++20 Ranges Support](#c20-ranges-support)
 - [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)
@@ -56,7 +59,7 @@ Requirements
 The simdjson library is widely deployed in popular systems such as the Node.js runtime
 environment.

- A recent compiler (LLVM clang 6 or better, GNU GCC 7.4 or better, Xcode 11 or better) on POSIX systems such as macOS, FreeBSD or Linux. We require that the compiler supports the C++11 standard or better. We test the library on a big-endian system (IBM s390x with Linux).
+- A recent compiler (LLVM clang 6 or better, GNU GCC 7.4 or better, Xcode 11 or better) on POSIX systems such as macOS, FreeBSD or Linux. We require that the compiler supports the C++11 standard or better. We test the library on a big-endian system (IBM s390x with Linux). We support [Fil-C, the memory-safe C/C++ compiler](https://fil-c.org).
 - Visual Studio 2017 or better. We support the LLVM clang compiler under Visual Studio (clang-cl) as well as the regular Visual Studio compiler. For better release performance (both compile time and execution time), we recommend Visual Studio users adopt LLVM (clang-cl). We discourage using GCC under Windows: there [is a long-running bug with GCC under Windows](https://gcc.gnu.org/bugzilla/show_bug.cgi?id=54412).

 Support for AVX-512 require a processor with AVX512-VBMI2 support (Ice Lake or better, AMD Zen 4 or better) under a 64-bit system and a recent compiler (LLVM clang 6 or better, GCC 8 or better, Visual Studio 2019 or better). You need a correspondingly recent assembler such as gas (2.30+) or nasm (2.14+): recent compilers usually come with recent assemblers. If you mix a recent compiler with an incompatible/old assembler (e.g., when using a recent compiler with an old Linux distribution), you may get errors at build time because the compiler produces instructions that the assembler does not recognize: you should update your assembler to match your compiler (e.g., upgrade binutils to version 2.30 or better under Linux) or use an older compiler matching the capabilities of your assembler.
@@ -161,54 +164,77 @@ The basics: loading and parsing JSON documents
 ----------------------------------------------

 The simdjson library allows you to navigate and validate JSON documents ([RFC 8259](https://www.tbray.org/ongoing/When/201x/2017/12/14/rfc8259.html)).
-As required by the standard, your JSON document should be in a Unicode (UTF-8) string. The whole
-string, from the beginning to the end, needs to be valid: we do not attempt to tolerate bad
-inputs before or after a document.
+Your JSON document should be a valid Unicode (UTF-8) string.

-For efficiency reasons, simdjson requires a string with a few bytes (`simdjson::SIMDJSON_PADDING`)
-at the end, these bytes may be read but their content does not affect the parsing. In practice,
-it means that the JSON inputs should be stored in a memory region with `simdjson::SIMDJSON_PADDING`
-extra bytes at the end. You do not have to set these bytes to specific values though you may
-want to if you want to avoid runtime warnings with some sanitizers. We expect the user
-of the library to load the data (from disk or from the network) into a padded buffer. To make
-this easy, we provide the `padded_string::load` function which loads files from disk in a padded buffer.
-[You can similarly fetch a file from a URL to a padded string](https://github.com/simdjson/curltostring) using our `simdjson::padded_string_builder`. Advanced users may want to read the section Free Padding in [our performance notes](performance.md).
-
-The simdjson library offers a tree-like [API](https://en.wikipedia.org/wiki/API), which you can
-access by creating a `ondemand::parser` and calling the `iterate()` method. The iterate method
-quickly indexes the input string and may detect some errors. The following example illustrates
-how to get started with an input JSON file (`"twitter.json"`):
+To parse JSON, create a `ondemand::parser` and call its `iterate()` method on a padded input.
+The simplest way to load a JSON file is with `padded_string::load`:

 ```cpp
 ondemand::parser parser;
-auto json = padded_string::load("twitter.json"); // load JSON file 'twitter.json'.
-ondemand::document doc = parser.iterate(json); // position a pointer at the beginning of the JSON data
+auto json = padded_string::load("twitter.json");
+ondemand::document doc = parser.iterate(json);
 ```

-(Windows users compiling with C++17 or better may use `wchar_t` strings to support non-ASCII
-filenames: `padded_string::load(L"twitter.json")`.)
+For inline JSON strings, use the `_padded` suffix:

-If you prefer not to create your own `ondemand::parser` instance, you can access
-a thread-local version by calling `ondemand::parser.get_parser()`.
+```cpp
+ondemand::parser parser;
+auto json = "[1,2,3]"_padded;
+ondemand::document doc = parser.iterate(json);
+```

+If you are compiling with C++17 or better, you can use `simdjson::padded_input`
+which accepts any string-like input and handles padding automatically:
+
+```cpp
+ondemand::parser parser;
+std::string_view json = "[1,2,3]";
+simdjson::padded_input input(json);
+ondemand::document doc = parser.iterate(input);
+
+// Also works with std::string, considering reserved capacity
+std::string json_str = "[1,2,3]";
+json_str.reserve(100);  // Reserve extra space
+simdjson::padded_input input2(json_str);  // May avoid copying
+ondemand::document doc2 = parser.iterate(input2);
+```
+
+The simdjson library also accepts `std::string` instances directly---if the provided
+reference is non-const, it will allocate padding as needed:
+
+```cpp
+ondemand::parser parser;
+std::string json = "[1,2,3]";
+ondemand::document doc = parser.iterate(json);
+```
+
+By default, the simdjson library throws exceptions (`simdjson_error`) on errors. We omit `try`-`catch` clauses from our illustrating examples: if you omit `try`-`catch` in your code, an uncaught exception will halt your program. It is also possible to use simdjson without generating exceptions, and you may even build the library without exception support at all. See [Error handling](#error-handling) for details.
+
+
+### Advanced input options
+
+This section covers additional ways to provide JSON input to simdjson, including
+options for fine-grained control over padding and memory.
+
+**Thread-local parser.** If you prefer not to create your own `ondemand::parser` instance, you can access
+a thread-local version by calling `ondemand::parser.get_parser()`:

 ```cpp
 ondemand::document doc = ondemand::parser.get_parser().iterate(json);
 ```

-However, you should be careful because a parser instance can only be used for one
-document at a time, thus it is only applicable when you are only parsing one
+A parser instance can only be used for one document at a time, so
+the thread-local parser is only applicable when you parse one
 document per thread at any one time.

-You can also create a padded string---and call `iterate()`:
+**`padded_input` details (C++17+).** The actual padding only occurs when the JSON string ends near the boundary of a memory page, which is
+uncommon. Using a `simdjson::padded_input` is safe although sanitizers and tools like valgrind
+might report illegal reads (which are safe in our case because they remain in the mapped page). You should avoid `simdjson::padded_input`
+on systems without a page size of at least 4096: virtually all systems qualify except for
+some niche embedded systems running custom operating systems. Standard Linux, Windows, macOS, Android, iOS, etc., are all fine. Note that, most times, a `simdjson::padded_input` instance will not copy the data and will only act
+as a view (it does not own the memory).

-```cpp
-ondemand::parser parser;
-auto json = "[1,2,3]"_padded; // The _padded suffix creates a simdjson::padded_string instance
-ondemand::document doc = parser.iterate(json); // parse a string
-```
-
-If you have a buffer of your own with enough padding already (SIMDJSON_PADDING extra bytes allocated), you can use `padded_string_view` to pass it in:
+**User-managed buffers.** If you have a buffer of your own with enough padding already (`SIMDJSON_PADDING` extra bytes allocated), you can use `padded_string_view` to pass it in:

 ```cpp
 ondemand::parser parser;
@@ -217,73 +243,97 @@ strcpy(json, "[1]");
 ondemand::document doc = parser.iterate(json, strlen(json), sizeof(json));
 ```

-The simdjson library will also accept `std::string` instances. If the provided
-reference is non-const, it will allocate padding as needed.
-
-You can copy your data directly on a `simdjson::padded_string` as follows:
+**Copying into a `padded_string`.** You can copy your data directly into a `simdjson::padded_string`:

 ```cpp
 const char * data = "my data"; // 7 bytes
 simdjson::padded_string my_padded_data(data, 7); // copies to a padded buffer
 ```

-Or as follows...
+Or from a `std::string`:

 ```cpp
 std::string data = "my data";
 simdjson::padded_string my_padded_data(data); // copies to a padded buffer
 ```

-You can then parse the JSON data from the `simdjson::padded_string` instance:
-
-
-```cpp
-ondemand::document doc = parser.iterate(my_padded_data);
-```
-
-Whenever you pass an `std::string` reference to `parser::iterate`,
-the parser will access the bytes beyond the end of
+**`std::string` and sanitizer warnings.** Whenever you pass an `std::string` reference to `parser::iterate`,
+the parser may access bytes beyond the end of
 the string but before the end of the allocated memory (`std::string::capacity()`).
-If you are using a sanitizer that checks for reading uninitialized bytes or `std::string`'s
-container-overflow checks, you may encounter sanitizer warnings.
-You can safely ignore these warnings. Or you can call `simdjson::pad(std::string&)` to pad the
-string with `SIMDJSON_PADDING` spaces: this function returns a `simdjson::padding_string_view` which can be be passed to the parser's iterator function:
+Sanitizers that check for reading uninitialized bytes may produce warnings.
+You can safely ignore these warnings, or call `simdjson::pad(std::string&)` to pad the
+string explicitly:

 ```cpp
 std::string json = "[1]";
 ondemand::document doc = parser.iterate(simdjson::pad(json));
 ```

-We recommend against creating many `std::string` or many `std::padding_string` instances in your application to store your JSON data.
+We recommend against creating many `std::string` or many `std::padded_string` instances in your application to store your JSON data.
 Consider reusing the same buffers and limiting memory allocations.

-By default, the simdjson library throws exceptions (`simdjson_error`) on errors. We omit `try`-`catch` clauses from our illustrating examples: if you omit `try`-`catch` in your code, an uncaught exception will halt your program. It is also possible to use simdjson without generating exceptions, and you may even build the library without exception support at all. See [Error handling](#error-handling) for details.
+**Memory-file mapping.** 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:

-Some users may want to browse code along with the compiled assembly. You want to check out the following lists of examples:
+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`.

-* [simdjson examples with errors handled through exceptions](https://godbolt.org/z/98Kx9Kqjn)
-* [simdjson examples with errors without exceptions](https://godbolt.org/z/PKG7GdbPo)
+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.

-*Windows-specific*:  Windows users who need to read files with
+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
 non-ANSI characters in the name should set their code page to
 UTF-8 (65001). This should be the default with Windows 11 and better.
 Further, they may use the AreFileApisANSI function to determine whether
 the filename is interpreted using the ANSI or the system default OEM
 codepage, and they may call SetFileApisToOEM accordingly.

+Some users may want to browse code along with the compiled assembly:

-**Advanced feature:**
-On non-Windows systems, you can use memory-file mapping to create a `simdjson::padded_string_view`
-from a file on disk.
+* [simdjson examples with errors handled through exceptions](https://godbolt.org/z/98Kx9Kqjn)
+* [simdjson examples with errors without exceptions](https://godbolt.org/z/PKG7GdbPo)

-```cpp
-// If the macro _WIN32 is defined, this will not work since we do not support memory-file mapping
-// under Windows at this time.
-simdjson::padded_memory_map map(myfilename);
-if (!map.is_valid()) { /* handle error */ }
-simdjson::padded_string_view view = map.view(); // view is usable while padded_memory_map is in scope
-ondemand::document doc = parser.iterate(view); // parse the JSON
-```
+**Summary of input types:**
+
+
+| Input Type / Method                          | Padding Requirement                                                                 | How Padding is Handled                                                                 | Ownership / Copying                          | Notes / Warnings                                                                 |
+|----------------------------------------------|-------------------------------------------------------------------------------------|----------------------------------------------------------------------------------------|----------------------------------------------|----------------------------------------------------------------------------------|
+| `padded_string::load("file.json")`           | Automatic (SIMDJSON_PADDING extra bytes)                                           | Library allocates padded buffer and loads file into it                                 | Owned by `padded_string`                     | Recommended for files; safest and simplest.                                      |
+| `"...json..."_padded` literal                | Automatic (built-in padding)                                                        | Creates `padded_string` with padding                                                   | Owned by `padded_string`                     | Convenient for small hardcoded JSON.                                             |
+| `simdjson::padded_input` (C++17+)            | Automatic when needed                                                               | Adds padding **only** if the string ends near a memory page boundary. For `std::string`, considers `capacity()` | Usually a non-owning view (no copy most times) | Safe on standard OS (page size ≥ 4096). May trigger sanitizer/valgrind warnings (harmless). Avoid on niche embedded systems. |
+| User buffer with explicit padding            | Must have at least `SIMDJSON_PADDING` extra allocated bytes after JSON content     | Pass via `iterate(ptr, json_length, total_allocated_size)` or `padded_string_view`     | User-owned (no copy)                         | Use `char buf[len + SIMDJSON_PADDING]`. Library reads (but never writes) into padding. |
+| `std::string` (non-const)                    | Library checks `capacity()`                                                         | If insufficient, library may allocate a padded copy                                    | May copy (depends on capacity)               | Can trigger sanitizer warnings on uninitialized bytes. Use `simdjson::pad(json)` to avoid. |
+| `simdjson::pad(std::string&)`                | Adds padding if needed                                                              | Returns `padded_string_view` pointing to the (possibly resized) string                 | References original string                   | Recommended to silence sanitizers when using `std::string`.                      |
+| `padded_string(data, length)` or `padded_string(std::string)` | Automatic (copies into padded buffer)                                              | Explicit copy into owned padded buffer                                                 | Owned by `padded_string`                     | Safe when you want full ownership and padding guaranteed.                        |
+| `padded_string_view` (manual)                | User guarantees `SIMDJSON_PADDING` extra bytes after the viewed length             | User provides pointer + length + capacity                                              | Non-owning view                              | Low-level; requires careful buffer management.                                   |
+| Memory-mapped file (`padded_memory_map`)     | Automatic via mapping / 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`. |


 Documents are iterators
@@ -436,7 +486,7 @@ support for users who avoid exceptions. See [the simdjson error handling documen
 * **Extracting Values:** You can cast a JSON element to a native type:
  `double(element)`. This works for `std::string_view`, double, uint64_t, int64_t, bool,
  ondemand::object and ondemand::array. We also have explicit methods such as `get_string()`, `get_double()`,
-  `get_uint64()`, `get_int64()`, `get_bool()`, `get_object()` and `get_array()`. After a cast or an explicit method,
+  `get_uint64()`, `get_int64()`, `get_uint32()`, `get_int32()`, `get_bool()`, `get_object()` and `get_array()`. After a cast or an explicit method,
  the number, string or boolean will be parsed, or the initial `{` or `[` will be verified for `ondemand::object` and `ondemand::array`. An exception may be thrown if
  the cast is not possible: the error code is `simdjson::INCORRECT_TYPE` (see [Error handling](#error-handling)). Importantly, when getting an ondemand::object or ondemand::array instance, its content is
  not validated: you are only guaranteed that the corresponding initial character (`{` or `[`) is present. Thus,
@@ -446,8 +496,8 @@ support for users who avoid exceptions. See [the simdjson error handling documen
  pass `true` (`get_string(true)`) as a parameter to get replacement characters where errors
  occur. If you somehow need to access non-UTF-8 strings in a lossless manner
  (e.g., if you strings contain unpaired surrogates), you may use the `get_wobbly_string()` function to get a string in the [WTF-8 format](https://simonsapin.github.io/wtf-8).
-  When calling `get_uint64()` and `get_int64()`, if the number does not fit in a corresponding
-  64-bit integer type, it is also considered an error. When parsing numbers or other scalar values, the library checks
+  When calling `get_uint64()`, `get_int64()`, `get_uint32()` or `get_int32()`, if the number does not fit in the
+  corresponding integer type, it is also considered an error (`NUMBER_OUT_OF_RANGE`). When parsing numbers or other scalar values, the library checks
  that the value is followed by an expected character, thus you *may* get a number parsing error when accessing the digits
  as an integer in the following strings: `{"number":12332a`, `{"number":12332\0`, `{"number":12332` (the digits appear at the end). We always abide by the [RFC 8259](https://www.tbray.org/ongoing/When/201x/2017/12/14/rfc8259.html) JSON specification so that, for example, numbers prefixed by the `+` sign are in error.

@@ -1300,10 +1350,6 @@ You can also use the custom `Car` type as part of a template such as `std::vecto
  simdjson::ondemand::parser parser;
  simdjson::ondemand::document doc = parser.iterate(json);
  std::vector<Car> cars(doc);
-  // visual studio users need an explicit call:
-  //   std::vector<Car> cars = doc.get<std::vector<Car>>();
-  // because the compiler does not know whether to convert
-  // doc to an unsigned int or to a vector.
  for(Car& c : cars) {
    std::cout << c.year << std::endl;
  }
@@ -1397,6 +1443,8 @@ 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)
@@ -1473,6 +1521,10 @@ 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
@@ -1550,6 +1602,10 @@ type without a document instance like so:
 Car car = simdjson::from(json);
 ```

+The string must be a `simdjson::padded_string_view`, which can be created from an std::string
+instance with `simdjson::pad()` function, from a `simdjson::padded_string` instance, or string literal using the `_padded`  user-defined literal.
+
+
 You can also use the `simdjson::from` syntax without exceptions, like so:
 ```cpp
 Car car;
@@ -1790,15 +1846,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"(
@@ -1827,31 +1883,86 @@ ondemand::parser parser;
 ondemand::document doc = parser.iterate(json_string);

 // Fetch all fields in the address object
-std::vector<ondemand::value> values;
-auto error = doc.at_path_with_wildcard("$.address.*").get(values);
-if (!error) {
-  for (auto value : values) {
-    std::string_view field;
-    if (value.get(field) == SUCCESS) {
-      std::cout << field << std::endl;
-    }
-  }
-}
+auto error = doc.for_each_at_path_with_wildcard("$.address.*",
+    [](ondemand::value value) {
+      std::string_view field;
+      if (value.get(field) == SUCCESS) {
+        std::cout << field << std::endl;
+      }
+    });

 // Fetch all phone numbers
-error = doc.at_path_with_wildcard("$.phoneNumbers[*].numbers[*]").get(values);
-if (!error) {
-  for (auto value : values) {
-    std::string_view number;
-    if (value.get(number) == SUCCESS) {
-      std::cout << number << std::endl;
-    }
-  }
-}
+doc.for_each_at_path_with_wildcard("$.phoneNumbers[*].numbers[*]",
+    [](ondemand::value value) {
+      std::string_view number;
+      if (value.get(number) == SUCCESS) {
+        std::cout << number << std::endl;
+      }
+    });
 ```

 This function is particularly useful for extracting data from complex JSON structures with nested arrays and objects. By leveraging wildcards, you can simplify your queries and reduce the need for multiple iterations.

+## C++20 Ranges Support
+
+When compiling with C++20 (or later), you can use `std::ranges` with the On-Demand API
+via the `get_range()` helper. This enables use of range adaptors such as `std::views::transform`.
+
+```cpp
+#include "simdjson.h"
+#include <ranges>
+#include <string>
+#include <vector>
+
+auto json = R"([
+  { "name": "Alice", "age": 30 },
+  { "name": "Bob",   "age": 25 },
+  { "name": "Carol", "age": 35 }
+])"_padded;
+
+ondemand::parser parser;
+auto doc = parser.iterate(json);
+auto arr = doc.get_array();
+
+// Use std::views::transform to extract names
+auto names = ondemand::get_range(arr)
+  | std::views::transform([](auto elem) -> std::string {
+      return std::string(std::string_view(elem["name"]));
+    });
+
+for (auto name : names) {
+  std::cout << name << std::endl;  // Alice, Bob, Carol
+}
+```
+
+The `get_range()` and `get_key_value_range()` functions wrap an `ondemand::array`
+or `ondemand::object` in a `std::ranges::view` that satisfies `std::ranges::input_range`.
+They work with both exception and non-exception code:
+
+```cpp
+// With exceptions:
+auto range = ondemand::get_range(doc.get_array());
+
+// Without exceptions:
+ondemand::array arr;
+if (doc.get_array().get(arr) == SUCCESS) {
+  auto range = ondemand::get_range(arr);
+  for (auto elem : range) { /* ... */ }
+}
+```
+
+Object iteration uses `get_key_value_range()` and yields `simdjson_result<ondemand::field>` elements:
+
+```cpp
+auto obj = doc.get_object();
+for (auto field_result : ondemand::get_key_value_range(obj)) {
+  std::cout << field_result.key() << std::endl;
+}
+```
+
+The range wrappers are zero-cost: they forward directly to the underlying
+On-Demand iterators with no value buffering or extra per-element overhead.
+
 ## Compile-Time JSONPath and JSON Pointer (C++26 Reflection)

 The simdjson library provides **compile-time validated** JSONPath and JSON Pointer accessors when using C++26 Static Reflection. These accessors validate paths against struct definitions at compile time and generate optimized code with zero runtime overhead. In some cases, we find that it is much faster. Furthermore, it is safer in the sense that the expression
@@ -32,6 +32,21 @@ your code with the `SIMDJSON_STATIC_REFLECTION` macro set:
 The `simdjson::compile_time::parse_json` function parses a JSON document at **compile time** and returns a `constexpr` structure reflecting its content. We support the full range of JSON values, which are mapped to C++ types as in
 the following table.

+For convenience, you can also use the `""_json` user-defined literal operator, which is available in the `simdjson::literals` namespace:
+
+```cpp
+using namespace simdjson::literals;
+
+constexpr auto cfg = R"(
+{
+    "port": 8080,
+    "host": "localhost"
+}
+)"_json;
+```
+
+Alternatively, you can use the qualified name `simdjson::literals::operator""_json`.
+

 | JSON type      | C++ type                         |
 |----------------|----------------------------------|
@@ -61,6 +76,8 @@ You can do so, at compile-time, as follows:


 ```cpp
+using namespace simdjson::literals;
+
 constexpr auto cfg = R"(

 {
@@ -79,6 +96,8 @@ constexpr auto cfg = R"(
 You can nest objects and arrays:

 ```cpp
+using namespace simdjson::literals;
+
 constexpr auto data = R"(

 {
@@ -98,6 +117,8 @@ constexpr auto data = R"(
 Top-level arrays are allowed:

 ```cpp
+using namespace simdjson::literals;
+
 constexpr auto arr = R"(

 [1, 2, 3]
@@ -116,6 +137,8 @@ want to check that it conforms to your expectation. You can do so with concepts.
 Let us consider this example:

 ```cpp
+    using namespace simdjson::literals;
+
    constexpr auto config = R"(

    [
@@ -127,11 +127,31 @@ codepage, and they may call SetFileApisToOEM accordingly.


 **Advanced feature:**
-On non-Windows systems, you can use memory-file mapping to create a `simdjson::padded_string_view`
-from a file on disk.
+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.

 ```cpp
-// if the macro _WIN32 is defined, this will not work since we do not support Windows
+#ifdef _WIN32
+#include <windows.h> // Must come BEFORE <simdjson.h> on Windows
+#endif
+#include "simdjson.h"
+// ...
 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
@@ -168,6 +188,23 @@ Once you have an element, you can navigate it with idiomatic C++ iterators, oper
  `SIMDJSON_MINUS_ZERO_AS_FLOAT` to `1` when building simdjson, you can get that `-0` is mapped to `-0.0`
  as in JavaScript. You can get the desired effect by building simdjson with cmake setting the
  `SIMDJSON_MINUS_ZERO_AS_FLOAT` to on: `cmake -B build -D SIMDJSON_MINUS_ZERO_AS_FLOAT=ON`.
+* **Big Integer Support (opt-in):** By default, integers that exceed the 64-bit range cause parsing to fail with `BIGINT_ERROR`. You can opt in to big integer support so that these numbers are stored as raw digit strings on the tape instead:
+  ```cpp
+  simdjson::dom::parser parser;
+  parser.number_as_string(true); // opt-in, default false
+  simdjson::dom::element doc;
+  auto error = parser.parse("[1, 123456789012345678901]"_padded).get(doc);
+  if (error) { std::cerr << error << std::endl; return EXIT_FAILURE; }
+  for (simdjson::dom::element elem : doc) {
+    if (elem.is_bigint()) {
+      std::string_view digits;
+      error = elem.get_bigint().get(digits);
+      if (error) { std::cerr << error << std::endl; return EXIT_FAILURE; }
+      std::cout << "big integer: " << digits << std::endl;
+    }
+  }
+  ```
+  When enabled, big integers have type `element_type::BIGINT`. Calling `get_int64()`, `get_uint64()`, or `get_double()` on a big integer returns `INCORRECT_TYPE`. Normal numbers (int64, uint64, double) are unaffected.
 * **Field Access:** To get the value of the "foo" field in an object, use `object["foo"]`.
 * **Array Iteration:** To iterate through an array, use `for (auto value : array) { ... }`. If you
  know the type of the value, you can cast it right there, too! `for (double value : array) { ... }`
@@ -180,7 +217,7 @@ Once you have an element, you can navigate it with idiomatic C++ iterators, oper
 * **Array and Object size** Given an array or an object, you can get its size (number of elements or keys)
  with the `size()` method.
 * **Checking an Element Type:** You can check an element's type with `element.type()`. It
-  returns an `element_type` with values such as `simdjson::dom::element_type::ARRAY`, `simdjson::dom::element_type::OBJECT`, `simdjson::dom::element_type::INT64`,  `simdjson::dom::element_type::UINT64`,`simdjson::dom::element_type::DOUBLE`, `simdjson::dom::element_type::STRING`, `simdjson::dom::element_type::BOOL` or, `simdjson::dom::element_type::NULL_VALUE`.
+  returns an `element_type` with values such as `simdjson::dom::element_type::ARRAY`, `simdjson::dom::element_type::OBJECT`, `simdjson::dom::element_type::INT64`,  `simdjson::dom::element_type::UINT64`,`simdjson::dom::element_type::DOUBLE`, `simdjson::dom::element_type::STRING`, `simdjson::dom::element_type::BOOL`, `simdjson::dom::element_type::NULL_VALUE` or, `simdjson::dom::element_type::BIGINT` (when big integer support is enabled).
 * **Output to streams and strings:** Given a document or an element (or node) out of a JSON document, you can output a minified string version using the C++ stream idiom (`out << element`). You can also request the construction of a minified string version (`simdjson::minify(element)`) or a prettified string version (`simdjson::prettify(element)`). Numbers are serialized as 64-bit floating-point numbers (`double`).

 ### Examples
@@ -753,6 +790,9 @@ 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
@@ -865,6 +905,19 @@ simdjson::dom::element element = parser.parse(padded_json_copy.get(), json_len,

 Setting the `realloc_if_needed` parameter `false` in this manner may lead to better performance since copies are avoided, but it requires that the user takes more responsibilities: the simdjson library cannot verify that the input buffer was padded with SIMDJSON_PADDING extra bytes.

+If you are compiling your project with C++17 or better, you can use a `simdjson::padded_input`:
+
+```cpp
+simdjson::dom::parser parser;
+std::string_view json = "[1,2,3]";
+simdjson::padded_input input(json); // Automatically pads if needed
+simdjson::dom::element element = parser.parse(input);
+```
+
+The actual padding only occurs if the JSON string ends near the boundary of a memory page, which is uncommon. Using a `simdjson::padded_input` is safe although sanitizers and tools like valgrind might report illegal reads (which are safe in our case because they remain in the mapped page). You should avoid `simdjson::padded_input` on systems without a page size of at least 4096: virtually all systems qualify except for some niche embedded systems running custom operating systems. Standard Linux, Windows, macOS, Android, iOS, etc., are all fine.  Note that, most times, an `simdjson::padded_input` instance will not copy the data and will only act
+as a view (it does not own the memory).
+
+
 Performance Tips
 ---------------------

@@ -22,10 +22,12 @@ 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
 -----------
@@ -132,7 +134,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) <- Not supported by simdjson!
+- [Record separator-delimited JSON (RFC 7464)](https://tools.ietf.org/html/rfc7464)
 - [More on Wikipedia...](https://en.wikipedia.org/wiki/JSON_streaming)

 API
@@ -155,13 +157,79 @@ for (auto doc : docs) {
 See [basics.md](basics.md#newline-delimited-json-ndjson-and-json-lines) for an overview of the API.


-**Advanced feature:**
-On non-Windows systems, you can use memory-file mapping to create a `simdjson::padded_string_view`
-from a file on disk.
+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(...)`:

 ```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
@@ -278,39 +346,131 @@ Importantly, you should only call `truncated_bytes()` after iterating through al
 Comma-separated documents
 -----------

-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:
+To parse comma-separated documents like `{"a":1},{"b":2},{"c":3}`, use the `stream_format::comma_delimited` parameter:

 ```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;
-    // 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:
-
+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}
 ```
-number
-number
-number
-number
-string
-string
-string
-object
-array
+
+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
+```
+
+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
 --------------------
@@ -418,3 +578,161 @@ 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.
@@ -18,6 +18,7 @@ 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)
@@ -132,7 +133,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) <- Not supported by simdjson!
+- [Record separator-delimited JSON (RFC 7464)](https://tools.ietf.org/html/rfc7464)
 - [More on Wikipedia...](https://en.wikipedia.org/wiki/JSON_streaming)

 API
@@ -218,17 +219,83 @@ got full document at 29



-**Advanced feature:**
-On non-Windows systems, you can use memory-file mapping to create a `simdjson::padded_string_view`
-from a file on disk.
+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(...)`:

 ```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
+simdjson::dom::element doc = parser.parse(view); // parse the JSON
 ```

 Incomplete streams
@@ -253,3 +320,115 @@ 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.
@@ -204,9 +204,31 @@ but can be significantly larger. E.g., Apple systems favour pages spanning 16 ki

 In effect, it means that you can almost always read a few bytes beyond your current buffer---without
 allocating extra memory. However, tools such as valgrind or memory sanitizers will flag such behavior as unsafe.
-Nevertheless, you can still make sure of this capability in your code if you are an expert
-programmer and you are willing to silence sanitizer warnings. The following code provides
-a portable example.
+You can still make sure of this capability in your code if you are an expert
+programmer and you are willing to silence sanitizer warnings.
+
+If you are building simdjson with C++17 or better, you can use `simdjson::padded_input`.
+The `padded_input` struct automatically manages padding for you. It can be constructed from a `std::string_view`, 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.
+


 The conditional compilation checks for the `_MSC_VER` macro (indicating Microsoft Visual Studio)
@@ -250,7 +272,7 @@ long page_size() {
 }

 // Returns true if the buffer + len + simdjson::SIMDJSON_PADDING crosses the
-// page boundary.
+// page boundary. Assumes len != 0.
 bool need_allocation(const char *buf, size_t len) {
  return ((reinterpret_cast<uintptr_t>(buf + len - 1) % page_size())
    + simdjson::SIMDJSON_PADDING >= static_cast<uintptr_t>(page_size()));
@@ -93,6 +93,14 @@ Float values are represented as two 64-bit tape elements:

 Performance consideration: We store numbers of the main tape because we believe that locality of reference is helpful for performance.

+## Big Integers
+
+When a JSON integer exceeds the 64-bit range (both signed and unsigned), it is classified as a big integer. By default, parsing returns `BIGINT_ERROR`. When `parser.number_as_string(true)` is set, the raw digits are stored on the string tape using the same format as strings (4-byte little-endian length prefix, followed by the UTF-8 digit bytes, followed by a null terminator).
+
+A big integer is represented on the main tape as the 64-bit tape element `('Z' << 56) + x` where the payload `x` is the location on the string tape of the null-terminated digit string.
+
+For example, the JSON value `99999999999999999999` would be stored as the string `"99999999999999999999"` on the string tape, with a `'Z'` tag on the main tape. Negative big integers include the leading minus sign.
+
 ## Root node

 Each JSON document will have two special 64-bit tape elements representing a root node, one at the beginning and one at the end.
@@ -54,6 +54,9 @@ static void print_json(std::ostream& os, simdjson::dom::element element) noexcep
  case simdjson::dom::element_type::NULL_VALUE:
    os << "null" << endl;
    break;
+  case simdjson::dom::element_type::BIGINT:
+    os << element.get_bigint().value_unsafe() << endl;
+    break;
  }
 }
 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *Data, size_t Size) {
@@ -21,6 +21,10 @@ 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.
@@ -46,6 +50,21 @@ 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>
@@ -30,6 +30,10 @@ double from_chars(const char *first, const char* end) noexcept;
 #endif
 #endif

+#ifndef SIMDJSON_ENABLE_NAN_INF
+#define SIMDJSON_ENABLE_NAN_INF 0
+#endif
+
 } // namespace simdjson

 #if defined(__GNUC__)
@@ -45,9 +49,6 @@ double from_chars(const char *first, const char* end) noexcept;

 // Align to N-byte boundary
 #define SIMDJSON_ROUNDUP_N(a, n) (((a) + ((n)-1)) & ~((n)-1))
-#define SIMDJSON_ROUNDDOWN_N(a, n) ((a) & ~((n)-1))
-
-#define SIMDJSON_ISALIGNED_N(ptr, n) (((uintptr_t)(ptr) & ((n)-1)) == 0)

 #if SIMDJSON_REGULAR_VISUAL_STUDIO
  // We could use [[deprecated]] but it requires C++14
@@ -55,6 +56,7 @@ double from_chars(const char *first, const char* end) noexcept;

  #define simdjson_really_inline __forceinline
  #define simdjson_never_inline __declspec(noinline)
+  #define simdjson_really_flatten [[msvc::flatten]]

  #define simdjson_unused
  #define simdjson_warn_unused
@@ -95,6 +97,7 @@ double from_chars(const char *first, const char* end) noexcept;

  #define simdjson_really_inline inline __attribute__((always_inline))
  #define simdjson_never_inline inline __attribute__((noinline))
+  #define simdjson_really_flatten [[gnu::flatten]]

  #define simdjson_unused __attribute__((unused))
  #define simdjson_warn_unused __attribute__((warn_unused_result))
@@ -171,6 +174,15 @@ double from_chars(const char *first, const char* end) noexcept;
  #define simdjson_inline simdjson_really_inline
 #endif

+#if defined(simdjson_flatten)
+  // Prefer the user's definition of simdjson_flatten; don't define it ourselves.
+#elif (defined(__GNUC__) && !defined(__OPTIMIZE__)) || (defined(_DEBUG) && _MSC_VER )
+  // Flattening can lead to significant code bloat and high compile times. Don't use it for unoptimized builds.
+  #define simdjson_flatten
+#else
+  #define simdjson_flatten simdjson_really_flatten
+#endif
+
 #if SIMDJSON_VISUAL_STUDIO
    /**
     * Windows users need to do some extra work when building
@@ -266,6 +266,12 @@ consteval std::pair<double, size_t> parse_double(const char *src,
 }
 } // namespace number_parsing

+consteval auto make_data_member_options(auto&& name_str) {
+  std::meta::data_member_options options{};
+  options.name = std::forward<decltype(name_str)>(name_str);
+  return options;
+}
+
 // JSON string may contain embedded nulls, and C++26 reflection does not yet
 // support std::string_view as a data member type. As a workaround, we define
 // a custom type that holds a const char* and a size.
@@ -320,7 +326,8 @@ using class_type = type_builder<meta_info...>::constructed_type;
 /**
 * @brief Variable template for constructing instances with values
 */
-template <typename T, auto... Vs> constexpr auto construct_from = T{Vs...};
+template <typename T, auto... Vs> constexpr T construct_from = T{Vs...};
+

 // in JSON, there are only a few whitespace characters that are allowed
 // outside of objects, arrays, strings, and numbers.
@@ -410,7 +417,7 @@ parse_number(std::string_view json,
        std::from_chars(json.data(), json.data() + json.size(), int_value);
    if (res.ec == std::errc()) {
      out = int_value;
-      if ((res.ptr - json.data()) != scope) {
+      if (static_cast<std::size_t>(res.ptr - json.data()) != scope) {
        simdjson_consteval_error(
            "Internal error: cannot agree on the character range of the float");
      }
@@ -424,7 +431,7 @@ parse_number(std::string_view json,
        std::from_chars(json.data(), json.data() + json.size(), uint_value);
    if (res.ec == std::errc()) {
      out = uint_value;
-      if ((res.ptr - json.data()) != scope) {
+      if (static_cast<std::size_t>(res.ptr - json.data()) != scope) {
        simdjson_consteval_error(
            "Internal error: cannot agree on the character range of the float");
      }
@@ -533,7 +540,7 @@ parse_string(std::string_view json) {
      // present, we have an error (isolated high surrogate), which we
      // tolerate by substituting the substitution_code_point.
      if (end - cursor < 6 || *cursor != '\\' ||
-          *(cursor + 1) != 'u' > 0xFFFF) {
+          *(cursor + 1) != 'u') {
        code_point = substitution_code_point;
      } else {       // we have \u following the high surrogate
        cursor += 2; // skip \u
@@ -887,10 +894,19 @@ parse_json_array_impl(const std::string_view json) {
  std::size_t count = values.size() - 1;
  // We assume all elements have the same type as the first element.
  // However, if the array is heterogeneous, we should use std::variant.
+  auto elem_type = std::meta::type_of(values[1]);
+  // String literals reflected via reflect_constant_string have type const
+  // char[N], but when passed as template auto parameters they decay to
+  // const char*.  Use const char* as the element type so that
+  // construct_from can aggregate-initialize the array.
+  if (std::meta::is_array_type(elem_type) &&
+      std::meta::remove_all_extents(elem_type) == ^^const char) {
+    elem_type = ^^const char *;
+  }
  auto array_type = std::meta::substitute(
      ^^std::array,
      {
-          std::meta::type_of(values[1]), std::meta::reflect_constant(count)});
+          elem_type, std::meta::reflect_constant(count)});

  // Create array instance with values
  values[0] = array_type;
@@ -957,8 +973,7 @@ parse_json_object_impl(std::string_view json) {
        simdjson_consteval_error("Expected '}'");
      }
      cursor += object_size;
-      auto dms = std::meta::data_member_spec(std::meta::type_of(parsed),
-                                             {.name = field_name});
+      auto dms = std::meta::data_member_spec(std::meta::type_of(parsed), make_data_member_options(field_name));
      members.push_back(std::meta::reflect_constant(dms));
      values.push_back(parsed);

@@ -967,8 +982,7 @@ parse_json_object_impl(std::string_view json) {
    case '[': {
      std::string_view value(cursor, end);
      auto [parsed, array_size] = parse_json_array_impl(value);
-      auto dms = std::meta::data_member_spec(std::meta::type_of(parsed),
-                                             {.name = field_name});
+      auto dms = std::meta::data_member_spec(std::meta::type_of(parsed), make_data_member_options(field_name));
      members.push_back(std::meta::reflect_constant(dms));
      values.push_back(parsed);
      if (*(cursor + array_size - 1) != ']') {
@@ -989,8 +1003,7 @@ parse_json_object_impl(std::string_view json) {
        }
      }
      auto dms =
-          std::meta::data_member_spec(^^const char *, {
-                                                          .name = field_name});
+          std::meta::data_member_spec(^^const char *, make_data_member_options(field_name));
      members.push_back(std::meta::reflect_constant(dms));
      values.push_back(std::meta::reflect_constant_string(value));
      break;
@@ -1001,8 +1014,7 @@ parse_json_object_impl(std::string_view json) {
      }
      cursor += 4;

-      auto dms = std::meta::data_member_spec(^^bool, {
-                                                         .name = field_name});
+      auto dms = std::meta::data_member_spec(^^bool, make_data_member_options(field_name));
      members.push_back(std::meta::reflect_constant(dms));
      values.push_back(std::meta::reflect_constant(true));
      break;
@@ -1013,8 +1025,7 @@ parse_json_object_impl(std::string_view json) {
      }
      cursor += 5;

-      auto dms = std::meta::data_member_spec(^^bool, {
-                                                         .name = field_name});
+      auto dms = std::meta::data_member_spec(^^bool, make_data_member_options(field_name));
      members.push_back(std::meta::reflect_constant(dms));
      values.push_back(std::meta::reflect_constant(false));
      break;
@@ -1025,9 +1036,7 @@ parse_json_object_impl(std::string_view json) {
      }
      cursor += 4;

-      auto dms = std::meta::data_member_spec(^^std::nullptr_t,
-                                             {
-                                                 .name = field_name});
+      auto dms = std::meta::data_member_spec(^^std::nullptr_t, make_data_member_options(field_name));
      members.push_back(std::meta::reflect_constant(dms));
      values.push_back(std::meta::reflect_constant(nullptr));
      break;
@@ -1051,22 +1060,19 @@ parse_json_object_impl(std::string_view json) {
      if (std::holds_alternative<int64_t>(out)) {
        int64_t int_value = std::get<int64_t>(out);
        auto dms =
-            std::meta::data_member_spec(^^int64_t, {
-                                                       .name = field_name});
+            std::meta::data_member_spec(^^int64_t, make_data_member_options(field_name));
        members.push_back(std::meta::reflect_constant(dms));
        values.push_back(std::meta::reflect_constant(int_value));
      } else if (std::holds_alternative<uint64_t>(out)) {
        uint64_t uint_value = std::get<uint64_t>(out);
        auto dms =
-            std::meta::data_member_spec(^^uint64_t, {
-                                                        .name = field_name});
+            std::meta::data_member_spec(^^uint64_t, make_data_member_options(field_name));
        members.push_back(std::meta::reflect_constant(dms));
        values.push_back(std::meta::reflect_constant(uint_value));
      } else {
        double float_value = std::get<double>(out);
        auto dms =
-            std::meta::data_member_spec(^^double, {
-                                                      .name = field_name});
+            std::meta::data_member_spec(^^double, make_data_member_options(field_name));
        members.push_back(std::meta::reflect_constant(dms));
        values.push_back(std::meta::reflect_constant(float_value));
      }
@@ -1111,16 +1117,11 @@ template <constevalutil::fixed_string json_str> consteval auto parse_json() {
                "Only JSON objects and arrays are supported at the top level, this "
                "limitation will be lifted in the future.");*/

-  constexpr auto result = json.front() == '['
-                              ? parse_json_array_impl(json)
-                              : parse_json_object_impl(json);
-  return [: result.first :];
-  /*
-  if(json.front() == '[') {
-      return [:parse_json_array_impl(json).first:];
-  } else if(json.front() == '{') {
-   //   return [:parse_json_object_impl(json).first:];
-  }*/
+  if constexpr (json.front() == '[') {
+    return [: parse_json_array_impl(json).first :];
+  } else {
+    return [: parse_json_object_impl(json).first :];
+  }
 }

 } // namespace compile_time
@@ -63,13 +63,16 @@ namespace compile_time {
 template <constevalutil::fixed_string json_str> consteval auto parse_json();

 } // namespace compile_time
-} // namespace simdjson

+inline namespace literals {

 template <simdjson::constevalutil::fixed_string str>
 consteval auto operator ""_json() {
  return simdjson::compile_time::parse_json<str>();
 }

+} // namespace literals
+} // namespace simdjson
+
 #endif // SIMDJSON_STATIC_REFLECTION
 #endif // SIMDJSON_GENERIC_COMPILE_TIME_JSON_H
@@ -58,6 +58,11 @@ struct fixed_string {
            data[i] = str[i];
        }
    }
+    constexpr fixed_string(const unsigned char (&str)[N])  {
+        for (std::size_t i = 0; i < N; ++i) {
+            data[i] = static_cast<char>(str[i]);
+        }
+    }
    char data[N];
    constexpr std::string_view view() const { return {data, N - 1}; }
    constexpr size_t size() const { return N ; }
@@ -37,9 +37,6 @@ inline auto_parser<parser_type>::auto_parser(parser_type parser, ondemand::docum
  : auto_parser{*parser, std::move(doc)} {}


-
-
-
 template <typename parser_type>
 inline std::remove_pointer_t<parser_type> &auto_parser<parser_type>::parser() noexcept {
  if constexpr (std::is_pointer_v<parser_type>) {
@@ -118,16 +115,6 @@ template <typename T>
 inline auto to_adaptor<T>::operator()(ondemand::parser &parser, padded_string_view const str) const noexcept {
  return auto_parser<ondemand::parser *>{parser, str};
 }
-
-template <typename T>
-inline auto to_adaptor<T>::operator()(std::string str) const noexcept {
-  return auto_parser<ondemand::parser *>{pad_with_reserve(str)};
-}
-
-template <typename T>
-inline auto to_adaptor<T>::operator()(ondemand::parser &parser, std::string str) const noexcept {
-  return auto_parser<ondemand::parser *>{parser, pad_with_reserve(str)};
-}
 } // namespace internal
 } // namespace convert
 } // namespace simdjson
@@ -36,12 +36,12 @@ public:
 	explicit auto_parser(std::remove_pointer_t<parser_type> &parser, padded_string_view const str) noexcept requires(std::is_pointer_v<parser_type>);
 	explicit auto_parser(padded_string_view const str) noexcept requires(std::is_pointer_v<parser_type>);
 	explicit auto_parser(parser_type parser, ondemand::document &&doc) noexcept requires(std::is_pointer_v<parser_type>);
-		auto_parser(auto_parser const &) = delete;
-		auto_parser &operator=(auto_parser const &) = delete;
-		auto_parser(auto_parser &&) noexcept = default;
-		auto_parser &operator=(auto_parser &&) noexcept = default;
-		~auto_parser() = default;
-
+	auto_parser(auto_parser const &) = delete;
+	auto_parser &operator=(auto_parser const &) = delete;
+	~auto_parser() = default;
+    // Prevent moving
+    auto_parser(auto_parser&&) = delete;
+	auto_parser &operator=(auto_parser &&) noexcept = delete;
 	simdjson_warn_unused std::remove_pointer_t<parser_type> &parser() noexcept;

 	template <typename T>
@@ -75,11 +75,6 @@ struct to_adaptor {
 	T operator()(simdjson_result<ondemand::value> &val) const noexcept;
 	auto operator()(padded_string_view const str) const noexcept;
 	auto operator()(ondemand::parser &parser, padded_string_view const str) const noexcept;
-	// The std::string is padded with reserve to ensure there is enough space for padding.
-	// Some sanitizers may not like this, so you can use simdjson::pad instead.
-	// simdjson::from(simdjson::pad(str))
-	auto operator()(std::string str) const noexcept;
-	auto operator()(ondemand::parser &parser, std::string str) const noexcept;
 };
 // deduction guide
 auto_parser(padded_string_view const str) -> auto_parser<ondemand::parser*>;
@@ -90,7 +85,12 @@ auto_parser(padded_string_view const str) -> auto_parser<ondemand::parser*>;
 * The simdjson::from instance is EXPERIMENTAL AND SUBJECT TO CHANGES.
 *
 * The `from` instance is a utility adaptor for parsing JSON strings into objects.
- * It provides a convenient way to convert JSON data into C++ objects using the `auto_parser`.
+ *
+ * The string must be a simdjson::padded_string_view, which can be created from a std::string
+ * with simdjson::pad(), from a simdjson::padded_string, or string literal using the `_padded`
+ * user-defined literal.
+ *
+ * The `from` instance provides a convenient way to convert JSON data into C++ objects using the `auto_parser`.
 *
 * Example usage:
 *
@@ -103,21 +103,9 @@ inline simdjson_result<element> array::at_pointer(std::string_view json_pointer)
  // We don't support this, because we're returning a real element, not a position.
  if (json_pointer == "-") { return INDEX_OUT_OF_BOUNDS; }

-  // Read the array index
  size_t array_index = 0;
  size_t i;
-  for (i = 0; i < json_pointer.length() && json_pointer[i] != '/'; i++) {
-    uint8_t digit = uint8_t(json_pointer[i] - '0');
-    // Check for non-digit in array index. If it's there, we're trying to get a field in an object
-    if (digit > 9) { return INCORRECT_TYPE; }
-    array_index = array_index*10 + digit;
-  }
-
-  // 0 followed by other digits is invalid
-  if (i > 1 && json_pointer[0] == '0') { return INVALID_JSON_POINTER; } // "JSON pointer array index has other characters after 0"
-
-  // Empty string is invalid; so is a "/" with no digits before it
-  if (i == 0) { return INVALID_JSON_POINTER; } // "Empty string in JSON pointer array index"
+  SIMDJSON_TRY(internal::parse_json_pointer_array_index(json_pointer, array_index, i));

  // Get the child
  auto child = array(tape).at(array_index);
@@ -33,16 +33,25 @@ 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
  // worse with "[7,7,7,7,6,7,7,7,6,7,7,6,[7,7,7,7,6,7,7,7,6,7,7,6,7,7,7,7,7,7,6"
  //where capacity + 1 tape elements are
  // generated, see issue https://github.com/simdjson/simdjson/issues/345
+  if(capacity + 3 < capacity) {
+    return CAPACITY; // overflow, only happen on legacy 32-bit systems with very large capacity
+  }
  size_t tape_capacity = SIMDJSON_ROUNDUP_N(capacity + 3, 64);
  // a document with only zero-length strings... could have capacity/3 string
  // and we would need capacity/3 * 5 bytes on the string buffer
-  size_t string_capacity = SIMDJSON_ROUNDUP_N(5 * capacity / 3 + SIMDJSON_PADDING, 64);
+  if(5 * (capacity / 3) + SIMDJSON_PADDING < SIMDJSON_PADDING) {
+    return CAPACITY; // overflow, only happen on legacy 32-bit systems with very large capacity
+  }
+  size_t string_capacity = SIMDJSON_ROUNDUP_N(5 * (capacity / 3) + SIMDJSON_PADDING, 64);
  string_buf.reset( new (std::nothrow) uint8_t[string_capacity]);
  tape.reset(new (std::nothrow) uint64_t[tape_capacity]);
  if(!(string_buf && tape)) {
@@ -141,6 +150,15 @@ inline bool document::dump_raw_tape(std::ostream &os) const noexcept {
    case 'r': // we start and end with the root node
      // should we be hitting the root node?
      return false;
+    case 'Z': // we have a big integer
+      os << "bigint ";
+      std::memcpy(&string_length, string_buf.get() + payload, sizeof(uint32_t));
+      os << std::string_view(
+        reinterpret_cast<const char *>(string_buf.get() + payload + sizeof(uint32_t)),
+        string_length
+      );
+      os << '\n';
+      break;
    default:
      return false;
    }
@@ -89,12 +89,14 @@ simdjson_inline document_stream::document_stream(
  dom::parser &_parser,
  const uint8_t *_buf,
  size_t _len,
-  size_t _batch_size
+  size_t _batch_size,
+  stream_format _format
 ) 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
@@ -112,6 +114,7 @@ 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)
@@ -224,7 +227,14 @@ 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();
-    while(svlen > 1 && (std::isspace(start[svlen-1]) || start[svlen-1] == '\0')) {
+    // 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(static_cast<unsigned char>(start[svlen-1])) || start[svlen-1] == '\0' || static_cast<uint8_t>(start[svlen-1]) == 0x1E || (stream->format == stream_format::comma_delimited && start[svlen-1] == ','))) {
      svlen--;
    }
    return std::string_view(start, svlen);
@@ -274,10 +284,35 @@ 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) {
-    return p.implementation->stage1(&buf[_batch_start], remaining, stage1_mode::streaming_final);
+    // 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);
  } else {
-    return p.implementation->stage1(&buf[_batch_start], batch_size, stage1_mode::streaming_partial);
+    // 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);
  }
 }

@@ -206,12 +206,14 @@ 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
+    size_t batch_size,
+    stream_format format = stream_format::whitespace_delimited
  ) noexcept;

  /**
@@ -261,6 +263,8 @@ 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};
@@ -81,6 +81,10 @@ simdjson_inline simdjson_result<bool> simdjson_result<dom::element>::get_bool()
  if (error()) { return error(); }
  return first.get_bool();
 }
+simdjson_inline simdjson_result<std::string_view> simdjson_result<dom::element>::get_bigint() const noexcept {
+  if (error()) { return error(); }
+  return first.get_bigint();
+}

 simdjson_inline bool simdjson_result<dom::element>::is_array() const noexcept {
  return !error() && first.is_array();
@@ -110,6 +114,9 @@ simdjson_inline bool simdjson_result<dom::element>::is_bool() const noexcept {
 simdjson_inline bool simdjson_result<dom::element>::is_null() const noexcept {
  return !error() && first.is_null();
 }
+simdjson_inline bool simdjson_result<dom::element>::is_bigint() const noexcept {
+  return !error() && first.is_bigint();
+}

 simdjson_inline simdjson_result<dom::element> simdjson_result<dom::element>::operator[](std::string_view key) const noexcept {
  if (error()) { return error(); }
@@ -218,6 +225,15 @@ inline simdjson_result<bool> element::get_bool() const noexcept {
  }
  return INCORRECT_TYPE;
 }
+inline simdjson_result<std::string_view> element::get_bigint() const noexcept {
+  SIMDJSON_DEVELOPMENT_ASSERT(tape.usable());
+  switch (tape.tape_ref_type()) {
+    case internal::tape_type::BIGINT:
+      return tape.get_string_view();
+    default:
+      return INCORRECT_TYPE;
+  }
+}
 inline simdjson_result<const char *> element::get_c_str() const noexcept {
  SIMDJSON_DEVELOPMENT_ASSERT(tape.usable()); // https://github.com/simdjson/simdjson/issues/1914
  switch (tape.tape_ref_type()) {
@@ -360,6 +376,10 @@ inline bool element::is_null() const noexcept {
  return tape.is_null_on_tape();
 }

+inline bool element::is_bigint() const noexcept {
+  return tape.tape_ref_type() == internal::tape_type::BIGINT;
+}
+
 #if SIMDJSON_EXCEPTIONS

 inline element::operator bool() const noexcept(false) { return get<bool>(); }
@@ -492,6 +512,8 @@ inline std::ostream& operator<<(std::ostream& out, element_type type) {
      return out << "bool";
    case element_type::NULL_VALUE:
      return out << "null";
+    case element_type::BIGINT:
+      return out << "bigint";
    default:
      return out << "unexpected content!!!"; // abort() usage is forbidden in the library
  }
@@ -21,7 +21,10 @@ enum class element_type {
  DOUBLE = 'd',    ///< double: Any number with a "." or "e" that fits in double.
  STRING = '"',    ///< std::string_view
  BOOL = 't',      ///< bool
-  NULL_VALUE = 'n' ///< null
+  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
 };

 /**
@@ -120,6 +123,14 @@ public:
   */
  inline simdjson_result<bool> get_bool() const noexcept;

+  /**
+   * Read this element as a big integer (raw digit string).
+   *
+   * @returns A string_view of the raw digits, or:
+   *          INCORRECT_TYPE if the JSON element is not a big integer.
+   */
+  inline simdjson_result<std::string_view> get_bigint() const noexcept;
+
  /**
   * Whether this element is a json array.
   *
@@ -175,6 +186,11 @@ public:
   */
  inline bool is_null() const noexcept;

+  /**
+   * Whether this element is a big integer (number exceeding 64-bit range).
+   */
+  inline bool is_bigint() const noexcept;
+
  /**
   * Tell whether the value can be cast to provided type (T).
   *
@@ -533,6 +549,7 @@ public:
  simdjson_inline simdjson_result<uint64_t> get_uint64() const noexcept;
  simdjson_inline simdjson_result<double> get_double() const noexcept;
  simdjson_inline simdjson_result<bool> get_bool() const noexcept;
+  simdjson_inline simdjson_result<std::string_view> get_bigint() const noexcept;

  simdjson_inline bool is_array() const noexcept;
  simdjson_inline bool is_object() const noexcept;
@@ -543,6 +560,7 @@ public:
  simdjson_inline bool is_number() const noexcept;
  simdjson_inline bool is_bool() const noexcept;
  simdjson_inline bool is_null() const noexcept;
+  simdjson_inline bool is_bigint() const noexcept;

  simdjson_inline simdjson_result<dom::element> operator[](std::string_view key) const noexcept;
  simdjson_inline simdjson_result<dom::element> operator[](const char *key) const noexcept;
@@ -227,8 +227,18 @@ inline size_t structure_analyzer::estimate_string_length(std::string_view s) con
 }

 inline size_t structure_analyzer::estimate_number_length(double d) const {
-  if (std::isnan(d) || std::isinf(d)) {
+  if (!std::isfinite(d)) {
+#if SIMDJSON_ENABLE_NAN_INF
+    if (std::isnan(d)) {
+      return 3; // "NaN"
+    } else if (d < 0) {
+      return 9; // "-Infinity"
+    } else {
+      return 8; // "Infinity"
+    }
+#else
    return 4; // "null" for invalid numbers
+#endif
  }
  // Rough estimate: up to 17 significant digits + sign + decimal point + exponent
  char buf[32];
@@ -950,6 +960,14 @@ inline size_t fractured_string_builder::measure_value_length(const dom::element&
    case dom::element_type::DOUBLE: {
      double val;
      if (elem.get_double().get(val) == SUCCESS) {
+#if SIMDJSON_ENABLE_NAN_INF
+        if (!std::isfinite(val)) {
+          if (std::isnan(val))
+            return 3; // "NaN"
+          // "-Infinity" (9) or "Infinity" (8)
+          return val < 0 ? 9 : 8;
+        }
+#endif
        char buf[32];
        int len = snprintf(buf, sizeof(buf), "%.17g", val);
        return len > 0 ? static_cast<size_t>(len) : 1;
@@ -36,10 +36,11 @@ inline bool parser::dump_raw_tape(std::ostream &os) const noexcept {
 }

 inline simdjson_result<size_t> parser::read_file(std::string_view path) noexcept {
+  const std::string path_copy(path);
  // Open the file
  SIMDJSON_PUSH_DISABLE_WARNINGS
  SIMDJSON_DISABLE_DEPRECATED_WARNING // Disable CRT_SECURE warning on MSVC: manually verified this is safe
-  std::FILE *fp = std::fopen(path.data(), "rb");
+  std::FILE *fp = std::fopen(path_copy.c_str(), "rb");
  SIMDJSON_POP_DISABLE_WARNINGS

  if (fp == nullptr) {
@@ -132,6 +133,7 @@ inline simdjson_result<element> parser::parse_into_document(document& provided_d
    buf += 3;
    len -= 3;
  }
+  implementation->_number_as_string = _number_as_string;
  _error = implementation->parse(buf, len, provided_doc);

  if (_error) { return _error; }
@@ -168,12 +170,7 @@ 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 {
-  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);
+  return parse_many(buf, len, batch_size, stream_format::whitespace_delimited);
 }
 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);
@@ -184,6 +181,48 @@ 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;
@@ -490,10 +490,39 @@ 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.
@@ -610,6 +639,13 @@ public:
  inline bool dump_raw_tape(std::ostream &os) const noexcept;


+  /**
+   * When enabled, big integers (exceeding uint64 range) are stored as strings
+   * in the tape instead of returning BIGINT_ERROR. Default: false.
+   */
+  inline void number_as_string(bool enabled) noexcept { _number_as_string = enabled; }
+  inline bool number_as_string() const noexcept { return _number_as_string; }
+
 private:
  /**
   * The maximum document length this parser will automatically support.
@@ -618,6 +654,9 @@ private:
   */
  size_t _max_capacity;

+  /** Whether to store big integers as strings instead of returning BIGINT_ERROR */
+  bool _number_as_string{false};
+
  /**
   * The loaded buffer (reused each time load() is called)
   */
@@ -11,6 +11,7 @@
 #include "simdjson/dom/object-inl.h"
 #include "simdjson/internal/tape_ref-inl.h"

+#include <cmath>
 #include <cstring>

 namespace simdjson {
@@ -181,6 +182,22 @@ simdjson_inline void base_formatter<formatter>::number(int64_t x) {

 template <class formatter>
 simdjson_inline void base_formatter<formatter>::number(double x) {
+#if SIMDJSON_ENABLE_NAN_INF
+  if (simdjson_unlikely(!std::isfinite(x))) {
+    if (std::isnan(x)) {
+      char const *s = "NaN";
+      chars(s, s + 3);
+    } else {
+      if (x < 0) {
+        one_char('-');
+      }
+      char const *s = "Infinity";
+      chars(s, s + 8);
+    }
+    return;
+  }
+#endif
+
  char number_buffer[24];
  // Currently, passing the nullptr to the second argument is
  // safe because our implementation does not check the second
@@ -460,6 +477,12 @@ inline void string_builder<serializer>::append(simdjson::dom::element value) {
    case tape_type::STRING:
      format.string(iter.get_string_view());
      break;
+    case tape_type::BIGINT: {
+      // Big integer stored as string — output raw digits (no quotes)
+      auto sv = iter.get_string_view();
+      format.chars(sv.data(), sv.data() + sv.size());
+      break;
+    }
    case tape_type::INT64:
      format.number(iter.next_tape_value<int64_t>());
      iter.json_index++; // numbers take up 2 spots, so we need to increment
@@ -22,6 +22,9 @@ namespace atomparsing {
 // to the compile-time constant 1936482662.
 simdjson_inline uint32_t string_to_uint32(const char* str) { uint32_t val; std::memcpy(&val, str, sizeof(uint32_t)); return val; }

+// Acts on the same principle as string_to_uint32, but on an 8-byte block of memory
+simdjson_inline uint64_t string_to_uint64(const char* str) { uint64_t val; std::memcpy(&val, str, sizeof(uint64_t)); return val; }
+

 // Again in str4ncmp we use a memcpy to avoid undefined behavior. The memcpy may appear expensive.
 // Yet all decent optimizing compilers will compile memcpy to a single instruction, just about.
@@ -33,6 +36,28 @@ simdjson_inline uint32_t str4ncmp(const uint8_t *src, const char* atom) {
  return srcval ^ string_to_uint32(atom);
 }

+// Checks that the first 8 characters of the input string match the given atom in a case-insensitive manner.
+//
+// 'atom' must consist of only lowercase letters.
+simdjson_warn_unused
+simdjson_inline uint64_t str8ncmp_case_insensitive(const uint8_t *src, const char* atom) {
+  uint64_t srcval; // we want to avoid unaligned 32-bit loads (undefined in C/C++)
+  static_assert(sizeof(uint64_t) <= SIMDJSON_PADDING, "SIMDJSON_PADDING must be larger than 8 bytes");
+  std::memcpy(&srcval, src, sizeof(uint64_t));
+
+  return (srcval | 0x2020202020202020ull) ^ string_to_uint64(atom);
+}
+
+// Checks that the first 3 characters of 'src' match 'atom' in a case-insensitive way.
+//
+// 'atom' must consist of only lowercase letters.
+simdjson_warn_unused
+simdjson_inline uint32_t str3ncmp_case_insensitive(const uint8_t *src, const char* atom) {
+  return ((src[0] | 0x20) ^ atom[0]) //
+       | ((src[1] | 0x20) ^ atom[1]) //
+       | ((src[2] | 0x20) ^ atom[2]);
+}
+
 simdjson_warn_unused
 simdjson_inline bool is_valid_true_atom(const uint8_t *src) {
  return (str4ncmp(src, "true") | jsoncharutils::is_not_structural_or_whitespace(src[4])) == 0;
@@ -69,9 +94,74 @@ simdjson_inline bool is_valid_null_atom(const uint8_t *src, size_t len) {
  else { return false; }
 }

+#if SIMDJSON_ENABLE_NAN_INF
+// "nan" is 3 bytes; we check characters and then verify the next
+// character is structural or whitespace. We accept both "nan" and "NaN".
+simdjson_warn_unused
+simdjson_inline bool is_valid_nan_atom(const uint8_t *src) {
+  return (str3ncmp_case_insensitive(src, "nan")
+        | jsoncharutils::is_not_structural_or_whitespace(src[3])) == 0;
+}
+
+// checks that the next four characters of a string are 'nan"', where the 'nan'
+// is checked in a case-insensitive way.
+simdjson_warn_unused
+simdjson_inline bool is_valid_nan_in_string(const uint8_t *src) {
+  return (str3ncmp_case_insensitive(src, "nan") | (src[3] ^ '"')) == 0;
+}
+
+simdjson_warn_unused
+simdjson_inline bool is_valid_nan_atom(const uint8_t *src, size_t len) {
+  if (len > 3) { return is_valid_nan_atom(src); }
+  if (len == 3) { return str3ncmp_case_insensitive(src, "nan") == 0; }
+  return false;
+}
+
+// This function will accept any case-insensitive 3-character spelling of
+// infinity: 'inf', 'INF', and 'Inf' are all accepted.
+//
+// Any capitalization of 'infinity' is also accepted.
+simdjson_warn_unused
+simdjson_inline bool is_valid_inf_atom(const uint8_t *src) {
+  bool is_short_inf = (str3ncmp_case_insensitive(src, "inf")
+                     | jsoncharutils::is_not_structural_or_whitespace(src[3])) == 0;
+  if(is_short_inf) return true;
+
+  // Check for 'infinity' (any capitalization)
+  return (str8ncmp_case_insensitive(src, "infinity") | jsoncharutils::is_not_structural_or_whitespace(src[8])) == 0;
+}
+
+simdjson_warn_unused
+simdjson_inline bool is_valid_inf_in_string(const uint8_t *src) {
+  bool is_short_inf = (str3ncmp_case_insensitive(src, "inf") | (src[3] ^ '"')) == 0;
+  if(is_short_inf) return true;
+
+  return (str8ncmp_case_insensitive(src, "infinity") | (src[8] ^ '"')) == 0;
+}
+
+
+// This function will accept any case-insensitive 3-character spelling of
+// infinity: 'inf', 'INF', and 'Inf' are all accepted.
+//
+// Any capitalization of 'infinity' is also accepted.
+simdjson_warn_unused
+simdjson_inline bool is_valid_inf_atom(const uint8_t *src, size_t len) {
+  if (len > 8) { return is_valid_inf_atom(src); }
+  if (len == 8 && str8ncmp_case_insensitive(src, "infinity") == 0) {
+    return true;
+  }
+  if (len > 3) {
+    return (str3ncmp_case_insensitive(src, "inf")
+          | jsoncharutils::is_not_structural_or_whitespace(src[3])) == 0;
+  }
+  if (len == 3) { return str3ncmp_case_insensitive(src, "inf") == 0; }
+  return false;
+}
+#endif // SIMDJSON_ENABLE_NAN_INF
+
 } // namespace atomparsing
 } // unnamed namespace
 } // namespace SIMDJSON_IMPLEMENTATION
 } // namespace simdjson

-#endif // SIMDJSON_GENERIC_ATOMPARSING_H
+#endif // SIMDJSON_GENERIC_ATOMPARSING_H
@@ -21,23 +21,113 @@ namespace simdjson {
 namespace SIMDJSON_IMPLEMENTATION {
 namespace builder {

+// Forward-declare helpers defined in json_string_builder-inl.h so the
+// writer-based atom code below can call them (the -inl.h is not yet
+// included at the point this header is parsed; without these forwards,
+// name lookup falls back to the wrong outer namespace).
+namespace internal {
+simdjson_really_inline char *write_uint_jeaiii(char *p, uint64_t v) noexcept;
+} // namespace internal
+inline size_t write_string_escaped(const std::string_view input, char *out);
+
+// =============================================================
+// `writer`: position-as-local hot-path writer used by the reflection
+// atom code below. Holds the buffer pointer, write position and
+// capacity in three fields that, once `writer` itself is a stack-local
+// in the caller and all atom() functions are inlined, become true
+// register-resident locals after SROA. Glaze achieves the same effect
+// by passing `B&& b, auto&& ix` through every helper. Holding `pos`
+// in a register (rather than as a member of string_builder) is what
+// breaks the strict-aliasing penalty on every char* write through the
+// buffer, which forces a reload of `b.position` and `b.capacity`
+// after every byte.
+// =============================================================
+struct writer {
+  char *ptr;        // buffer pointer (refreshed after a grow)
+  size_t pos;       // write position (local)
+  size_t cap;       // capacity (refreshed after a grow)
+  string_builder &sb;  // back-ref for grow / sync
+
+  // Snapshot string_builder state into a writer for the duration of
+  // a write chain.
+  simdjson_really_inline writer(string_builder &builder) noexcept
+      : ptr(builder.unsafe_data())
+      , pos(builder.unsafe_position())
+      , cap(builder.unsafe_capacity())
+      , sb(builder) {}
+
+  // Write the local position back to the underlying string_builder.
+  // Caller is responsible for invoking before the writer is dropped
+  // (otherwise data is lost). Idempotent.
+  simdjson_really_inline void sync() noexcept {
+    sb.unsafe_set_position(pos);
+  }
+
+  // Ensure at least `n` more bytes of free capacity. Grows the
+  // underlying buffer if needed (rare path). Returns false on
+  // allocation failure.
+  simdjson_really_inline bool ensure(size_t n) noexcept {
+    // Use subtraction (relying on the pos <= cap invariant) so a huge n
+    // cannot wrap pos + n to a small value that spuriously passes the test.
+    // This is pedantic except maybe on 32-bit targets.
+    if (simdjson_likely(n <= cap - pos)) return true;
+    return grow_slow(n);
+  }
+
+  // Slow path of ensure(). Out-of-line via simdjson_inline (not
+  // simdjson_really_inline) to keep the hot path short.
+  simdjson_inline bool grow_slow(size_t n) noexcept {
+    // Detect overflow.
+    // This is pedantic except maybe on 32-bit targets.
+    if (simdjson_unlikely(pos + n < pos)) return false;
+    sb.unsafe_set_position(pos);
+    // even if 2*capacity overflows, the (std::max) below will pick the needed value,
+    // so we do not need a separate overflow check here.
+    if (!sb.unsafe_grow((std::max)(cap * 2, pos + n))) {
+      return false;
+    }
+    ptr = sb.unsafe_data();
+    cap = sb.unsafe_capacity();
+    return true;
+  }
+};
+
+// === Helper: invoke a string_builder member that writes variable-length
+// content (escape_and_append_with_quotes etc), syncing the writer's local
+// state before the call and reloading after. Used for string fields where
+// rewriting the entire SIMD escape path through the writer would be a much
+// bigger refactor.
+template <class F>
+simdjson_really_inline void call_through_string_builder(writer &w, F &&f) noexcept {
+  w.sync();
+  f(w.sb);
+  w.ptr = w.sb.unsafe_data();
+  w.pos = w.sb.unsafe_position();
+  w.cap = w.sb.unsafe_capacity();
+}
+
 template <class T>
-  requires(concepts::container_but_not_string<T> && !require_custom_serialization<T>)
-constexpr void atom(string_builder &b, const T &t) {
+  requires(concepts::container_but_not_string<T> && ! concepts::optional_type<T> && !require_custom_serialization<T>)
+simdjson_really_inline constexpr void atom(writer &w, const T &t) {
  auto it = t.begin();
  auto end = t.end();
  if (it == end) {
-    b.append_raw("[]");
+    if (!w.ensure(2)) return;
+    std::memcpy(w.ptr + w.pos, "[]", 2);
+    w.pos += 2;
    return;
  }
-  b.append('[');
-  atom(b, *it);
+  if (!w.ensure(1)) return;
+  w.ptr[w.pos++] = '[';
+  atom(w, *it);
  ++it;
  for (; it != end; ++it) {
-    b.append(',');
-    atom(b, *it);
+    if (!w.ensure(1)) return;
+    w.ptr[w.pos++] = ',';
+    atom(w, *it);
  }
-  b.append(']');
+  if (!w.ensure(1)) return;
+  w.ptr[w.pos++] = ']';
 }

 template <class T>
@@ -45,37 +135,100 @@ template <class T>
           std::is_same_v<T, std::string_view> ||
           std::is_same_v<T, const char *> ||
           std::is_same_v<T, char>)
-constexpr void atom(string_builder &b, const T &t) {
-  b.escape_and_append_with_quotes(t);
+simdjson_really_inline constexpr void atom(writer &w, const T &t) {
+  // Inline the escape path through the writer so we never round-trip
+  // pos through memory for string fields (Twitter is dominated by
+  // these — sync/reload around each string was a real cost).
+  std::string_view input;
+  if constexpr (std::is_same_v<T, char>) {
+    input = std::string_view(&t, 1);
+  } else {
+    input = std::string_view(t);
+  }
+  // Worst-case escape: every byte expands to \uXXXX (6 chars), plus 2 quotes.
+  // Guard against 2 + 6 * input.size() wrapping for huge inputs — if it
+  // wrapped to a small value, ensure() would spuriously succeed and the
+  // subsequent escape would overflow the buffer.
+  // Note that this is pedantic except maybe on 32-bit targets.
+  if (simdjson_unlikely(input.size() > ((std::numeric_limits<size_t>::max)() - 2) / 6)) { return; }
+  if (!w.ensure(2 + 6 * input.size())) { return; }
+  w.ptr[w.pos++] = '"';
+  w.pos += write_string_escaped(input, w.ptr + w.pos);
+  w.ptr[w.pos++] = '"';
 }

 template <concepts::string_view_keyed_map T>
  requires(!require_custom_serialization<T>)
-constexpr void atom(string_builder &b, const T &m) {
+simdjson_really_inline constexpr void atom(writer &w, const T &m) {
  if (m.empty()) {
-    b.append_raw("{}");
+    if (!w.ensure(2)) return;
+    std::memcpy(w.ptr + w.pos, "{}", 2);
+    w.pos += 2;
    return;
  }
-  b.append('{');
+  if (!w.ensure(1)) return;
+  w.ptr[w.pos++] = '{';
  bool first = true;
  for (const auto& [key, value] : m) {
    if (!first) {
-      b.append(',');
+      if (!w.ensure(1)) return;
+      w.ptr[w.pos++] = ',';
    }
    first = false;
-    // Keys must be convertible to string_view per the concept
-    b.escape_and_append_with_quotes(key);
-    b.append(':');
-    atom(b, value);
+    // Keys must be convertible to string_view per the concept.
+    std::string_view key_sv(key);
+    // Guard against 3 + 6 * key_sv.size() wrapping for huge keys, if it
+    // wrapped to a small value, ensure() would spuriously succeed and the
+    // subsequent escape would overflow the buffer.
+    // Note that this is pedantic except maybe on 32-bit targets.
+    if (simdjson_unlikely(key_sv.size() > ((std::numeric_limits<size_t>::max)() - 3) / 6)) { return; }
+    if (!w.ensure(2 + 6 * key_sv.size() + 1)) { return; }
+    w.ptr[w.pos++] = '"';
+    w.pos += write_string_escaped(key_sv, w.ptr + w.pos);
+    w.ptr[w.pos++] = '"';
+    w.ptr[w.pos++] = ':';
+    atom(w, value);
  }
-  b.append('}');
+  if (!w.ensure(1)) return;
+  w.ptr[w.pos++] = '}';
 }


 template<typename number_type,
         typename = typename std::enable_if<std::is_arithmetic<number_type>::value && !std::is_same_v<number_type, char>>::type>
-constexpr void atom(string_builder &b, const number_type t) {
-  b.append(t);
+simdjson_really_inline constexpr void atom(writer &w, const number_type t) {
+  // Booleans / floats: defer to string_builder (rare path; keeps writer hot
+  // path free of float-formatter machinery). For integers, write directly
+  // via jeaiii using local pos.
+  if constexpr (std::is_same_v<number_type, bool>) {
+    if (t) {
+      if (!w.ensure(4)) return;
+      std::memcpy(w.ptr + w.pos, "true", 4);
+      w.pos += 4;
+    } else {
+      if (!w.ensure(5)) return;
+      std::memcpy(w.ptr + w.pos, "false", 5);
+      w.pos += 5;
+    }
+  } else if constexpr (std::is_floating_point_v<number_type>) {
+    call_through_string_builder(w, [&](string_builder &b) { b.append(t); });
+  } else if constexpr (std::is_unsigned_v<number_type>) {
+    if (!w.ensure(20)) return;
+    char *end = internal::write_uint_jeaiii(
+        w.ptr + w.pos, static_cast<uint64_t>(t));
+    w.pos = static_cast<size_t>(end - w.ptr);
+  } else {
+    // signed integral
+    if (!w.ensure(20)) return;
+    using U = typename std::make_unsigned<number_type>::type;
+    bool negative = t < 0;
+    U pv = negative ? U(0) - static_cast<U>(t) : static_cast<U>(t);
+    w.ptr[w.pos] = '-';
+    w.pos += negative;
+    char *end = internal::write_uint_jeaiii(
+        w.ptr + w.pos, static_cast<uint64_t>(pv));
+    w.pos = static_cast<size_t>(end - w.ptr);
+  }
 }

 template <class T>
@@ -88,61 +241,83 @@ template <class T>
           !std::is_same_v<T, std::string_view> &&
           !std::is_same_v<T, const char*> &&
           !std::is_same_v<T, char> && !require_custom_serialization<T>)
-constexpr void atom(string_builder &b, const T &t) {
+simdjson_really_inline constexpr void atom(writer &w, const T &t) {
+  // Per-field block: ensure key+value worst case, then write key + value
+  // through the writer's local pos. For arithmetic fields, the integer
+  // write happens directly via write_uint_jeaiii on w.ptr+w.pos, so pos
+  // never round-trips through memory.
  int i = 0;
-  b.append('{');
+  if (!w.ensure(1)) return;
+  w.ptr[w.pos++] = '{';
  template for (constexpr auto dm : std::define_static_array(std::meta::nonstatic_data_members_of(^^T, std::meta::access_context::unchecked()))) {
-    if (i != 0)
-      b.append(',');
-    constexpr auto key = std::define_static_string(constevalutil::consteval_to_quoted_escaped(std::meta::identifier_of(dm)));
-    b.append_raw(key);
-    b.append(':');
-    atom(b, t.[:dm:]);
+    constexpr auto first_key = std::define_static_string(
+        constevalutil::consteval_to_quoted_escaped(std::meta::identifier_of(dm)) + ":");
+    constexpr auto rest_key = std::define_static_string(
+        std::string(",") + constevalutil::consteval_to_quoted_escaped(std::meta::identifier_of(dm)) + ":");
+    constexpr size_t first_key_len = std::char_traits<char>::length(first_key);
+    constexpr size_t rest_key_len = std::char_traits<char>::length(rest_key);
+    if (!w.ensure(rest_key_len)) return;
+    if (i == 0) {
+      std::memcpy(w.ptr + w.pos, first_key, first_key_len);
+      w.pos += first_key_len;
+    } else {
+      std::memcpy(w.ptr + w.pos, rest_key, rest_key_len);
+      w.pos += rest_key_len;
+    }
+    atom(w, t.[:dm:]);
    i++;
  };
-  b.append('}');
+  if (!w.ensure(1)) return;
+  w.ptr[w.pos++] = '}';
 }

 // Support for optional types (std::optional, etc.)
 template <concepts::optional_type T>
  requires(!require_custom_serialization<T>)
-constexpr void atom(string_builder &b, const T &opt) {
+simdjson_really_inline constexpr void atom(writer &w, const T &opt) {
  if (opt) {
-    atom(b, opt.value());
+    atom(w, opt.value());
  } else {
-    b.append_raw("null");
+    if (!w.ensure(4)) return;
+    std::memcpy(w.ptr + w.pos, "null", 4);
+    w.pos += 4;
  }
 }

 // Support for smart pointers (std::unique_ptr, std::shared_ptr, etc.)
 template <concepts::smart_pointer T>
  requires(!require_custom_serialization<T>)
-constexpr void atom(string_builder &b, const T &ptr) {
+simdjson_really_inline constexpr void atom(writer &w, const T &ptr) {
  if (ptr) {
-    atom(b, *ptr);
+    atom(w, *ptr);
  } else {
-    b.append_raw("null");
+    if (!w.ensure(4)) return;
+    std::memcpy(w.ptr + w.pos, "null", 4);
+    w.pos += 4;
  }
 }

 // Support for enums - serialize as string representation using expand approach from P2996R12
 template <typename T>
  requires(std::is_enum_v<T> && !require_custom_serialization<T>)
-void atom(string_builder &b, const T &e) {
+simdjson_really_inline void atom(writer &w, const T &e) {
 #if SIMDJSON_STATIC_REFLECTION
-  constexpr auto enumerators = std::define_static_array(std::meta::enumerators_of(^^T));
+  static constexpr auto enumerators = std::define_static_array(std::meta::enumerators_of(^^T));
  template for (constexpr auto enum_val : enumerators) {
    constexpr auto enum_str = std::define_static_string(constevalutil::consteval_to_quoted_escaped(std::meta::identifier_of(enum_val)));
+    constexpr size_t enum_str_len = std::char_traits<char>::length(enum_str);
    if (e == [:enum_val:]) {
-      b.append_raw(enum_str);
+      if (!w.ensure(enum_str_len)) return;
+      std::memcpy(w.ptr + w.pos, enum_str, enum_str_len);
+      w.pos += enum_str_len;
      return;
    }
  };
  // Fallback to integer if enum value not found
-  atom(b, static_cast<std::underlying_type_t<T>>(e));
+  atom(w, static_cast<std::underlying_type_t<T>>(e));
 #else
  // Fallback: serialize as integer if reflection not available
-  atom(b, static_cast<std::underlying_type_t<T>>(e));
+  atom(w, static_cast<std::underlying_type_t<T>>(e));
 #endif
 }

@@ -152,28 +327,37 @@ template <concepts::appendable_containers T>
           !concepts::optional_type<T> && !concepts::smart_pointer<T> &&
           !std::is_same_v<T, std::string> &&
           !std::is_same_v<T, std::string_view> && !std::is_same_v<T, const char*> && !require_custom_serialization<T>)
-constexpr void atom(string_builder &b, const T &container) {
+simdjson_really_inline constexpr void atom(writer &w, const T &container) {
  if (container.empty()) {
-    b.append_raw("[]");
+    if (!w.ensure(2)) return;
+    std::memcpy(w.ptr + w.pos, "[]", 2);
+    w.pos += 2;
    return;
  }
-  b.append('[');
+  if (!w.ensure(1)) return;
+  w.ptr[w.pos++] = '[';
  bool first = true;
  for (const auto& item : container) {
    if (!first) {
-      b.append(',');
+      if (!w.ensure(1)) return;
+      w.ptr[w.pos++] = ',';
    }
    first = false;
-    atom(b, item);
+    atom(w, item);
  }
-  b.append(']');
+  if (!w.ensure(1)) return;
+  w.ptr[w.pos++] = ']';
 }

-// append functions that delegate to atom functions for primitive types
+// append() — top-level entry. Each overload constructs a stack-local
+// writer, runs atom(w, t) through the inlined call chain, then syncs
+// the local position back into the string_builder.
 template <class T>
  requires(std::is_arithmetic_v<T> && !std::is_same_v<T, char>)
-void append(string_builder &b, const T &t) {
-  atom(b, t);
+simdjson_inline void append(string_builder &b, const T &t) {
+  writer w(b);
+  atom(w, t);
+  w.sync();
 }

 template <class T>
@@ -181,20 +365,26 @@ template <class T>
           std::is_same_v<T, std::string_view> ||
           std::is_same_v<T, const char *> ||
           std::is_same_v<T, char>)
-void append(string_builder &b, const T &t) {
-  atom(b, t);
+simdjson_inline void append(string_builder &b, const T &t) {
+  writer w(b);
+  atom(w, t);
+  w.sync();
 }

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

 template <concepts::smart_pointer T>
  requires(!require_custom_serialization<T>)
-void append(string_builder &b, const T &t) {
-  atom(b, t);
+simdjson_inline void append(string_builder &b, const T &t) {
+  writer w(b);
+  atom(w, t);
+  w.sync();
 }

 template <concepts::appendable_containers T>
@@ -202,14 +392,18 @@ template <concepts::appendable_containers T>
           !concepts::optional_type<T> && !concepts::smart_pointer<T> &&
           !std::is_same_v<T, std::string> &&
           !std::is_same_v<T, std::string_view> && !std::is_same_v<T, const char*> && !require_custom_serialization<T>)
-void append(string_builder &b, const T &t) {
-  atom(b, t);
+simdjson_inline void append(string_builder &b, const T &t) {
+  writer w(b);
+  atom(w, t);
+  w.sync();
 }

 template <concepts::string_view_keyed_map T>
  requires(!require_custom_serialization<T>)
-void append(string_builder &b, const T &t) {
-  atom(b, t);
+simdjson_inline void append(string_builder &b, const T &t) {
+  writer w(b);
+  atom(w, t);
+  w.sync();
 }

 // works for struct
@@ -223,39 +417,19 @@ template <class Z>
           !std::is_same_v<Z, std::string_view> &&
           !std::is_same_v<Z, const char*> &&
           !std::is_same_v<Z, char> && !require_custom_serialization<Z>)
-void append(string_builder &b, const Z &z) {
-  int i = 0;
-  b.append('{');
-  template for (constexpr auto dm : std::define_static_array(std::meta::nonstatic_data_members_of(^^Z, std::meta::access_context::unchecked()))) {
-    if (i != 0)
-      b.append(',');
-    constexpr auto key = std::define_static_string(constevalutil::consteval_to_quoted_escaped(std::meta::identifier_of(dm)));
-    b.append_raw(key);
-    b.append(':');
-    atom(b, z.[:dm:]);
-    i++;
-  };
-  b.append('}');
+simdjson_inline void append(string_builder &b, const Z &z) {
+  writer w(b);
+  atom(w, z);
+  w.sync();
 }

 // works for container that have begin() and end() iterators
 template <class Z>
  requires(concepts::container_but_not_string<Z> && !require_custom_serialization<Z>)
-void append(string_builder &b, const Z &z) {
-  auto it = z.begin();
-  auto end = z.end();
-  if (it == end) {
-    b.append_raw("[]");
-    return;
-  }
-  b.append('[');
-  atom(b, *it);
-  ++it;
-  for (; it != end; ++it) {
-    b.append(',');
-    atom(b, *it);
-  }
-  b.append(']');
+simdjson_inline void append(string_builder &b, const Z &z) {
+  writer w(b);
+  atom(w, z);
+  w.sync();
 }

 template <class Z>
@@ -294,40 +468,41 @@ 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('{');
+  writer w(b);
+  if (!w.ensure(1)) { w.sync(); return; }
+  w.ptr[w.pos++] = '{';
  bool first = true;
-
  // Iterate through all members of T using reflection
-  template for (constexpr auto mem : std::define_static_array(
-      std::meta::nonstatic_data_members_of(^^T, std::meta::access_context::unchecked()))) {
-
+  static constexpr auto members = std::define_static_array(std::meta::nonstatic_data_members_of(^^T, std::meta::access_context::unchecked()));
+  template for (constexpr auto mem : members) {
    if constexpr (std::meta::is_public(mem)) {
-      constexpr std::string_view key = std::define_static_string(std::meta::identifier_of(mem));
+      static constexpr std::string_view key = std::define_static_string(std::meta::identifier_of(mem));

      // Only serialize this field if it's in our list of requested fields
-      if constexpr (should_extract(key)) {
-        if (!first) {
-          b.append(',');
+      if constexpr (((FieldNames.view() == key) || ...)) {
+        static constexpr auto first_key = std::define_static_string(
+            constevalutil::consteval_to_quoted_escaped(std::meta::identifier_of(mem)) + ":");
+        static constexpr auto rest_key = std::define_static_string(
+            std::string(",") + constevalutil::consteval_to_quoted_escaped(std::meta::identifier_of(mem)) + ":");
+        constexpr size_t first_key_len = std::char_traits<char>::length(first_key);
+        constexpr size_t rest_key_len = std::char_traits<char>::length(rest_key);
+        if (!w.ensure(rest_key_len)) { w.sync(); return; }
+        if (first) {
+          std::memcpy(w.ptr + w.pos, first_key, first_key_len);
+          w.pos += first_key_len;
+        } else {
+          std::memcpy(w.ptr + w.pos, rest_key, rest_key_len);
+          w.pos += rest_key_len;
        }
        first = false;
-
-        // Serialize the key
-        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(':');
-
-        // Serialize the value
-        atom(b, obj.[:mem:]);
+        atom(w, obj.[:mem:]);
      }
    }
  };

-  b.append('}');
+  if (!w.ensure(1)) { w.sync(); return; }
+  w.ptr[w.pos++] = '}';
+  w.sync();
 }

 template<constevalutil::fixed_string... FieldNames, typename T>
@@ -1,5 +1,7 @@
 #include <array>
+#include <cmath>
 #include <cstring>
+#include <limits>
 #include <type_traits>
 #ifndef SIMDJSON_GENERIC_STRING_BUILDER_INL_H

@@ -32,7 +34,8 @@
 #define SIMDJSON_EXPERIMENTAL_HAS_LSX 1
 #endif
 #endif
-#if defined(__riscv_v_intrinsic) && __riscv_v_intrinsic >= 11000
+#if defined(__riscv_v_intrinsic) && __riscv_v_intrinsic >= 11000 &&            \
+    defined(__riscv_vector)
 #ifndef SIMDJSON_EXPERIMENTAL_HAS_RVV
 #define SIMDJSON_EXPERIMENTAL_HAS_RVV 1
 #endif
@@ -504,7 +507,7 @@ simdjson_inline bool string_builder::capacity_check(size_t upcoming_bytes) {
  return is_valid;
 }

-simdjson_inline void string_builder::grow_buffer(size_t desired_capacity) {
+inline void string_builder::grow_buffer(size_t desired_capacity) {
  if (!is_valid) {
    return;
  }
@@ -560,62 +563,6 @@ simdjson_inline void string_builder::clear() noexcept {

 namespace internal {

-template <typename number_type, typename = typename std::enable_if<
-                                    std::is_unsigned<number_type>::value>::type>
-simdjson_really_inline int int_log2(number_type x) {
-  return 63 - leading_zeroes(uint64_t(x) | 1);
-}
-
-simdjson_really_inline int fast_digit_count_32(uint32_t x) {
-  static uint64_t table[] = {
-      4294967296,  8589934582,  8589934582,  8589934582,  12884901788,
-      12884901788, 12884901788, 17179868184, 17179868184, 17179868184,
-      21474826480, 21474826480, 21474826480, 21474826480, 25769703776,
-      25769703776, 25769703776, 30063771072, 30063771072, 30063771072,
-      34349738368, 34349738368, 34349738368, 34349738368, 38554705664,
-      38554705664, 38554705664, 41949672960, 41949672960, 41949672960,
-      42949672960, 42949672960};
-  return uint32_t((x + table[int_log2(x)]) >> 32);
-}
-
-simdjson_really_inline int fast_digit_count_64(uint64_t x) {
-  static uint64_t table[] = {9,
-                             99,
-                             999,
-                             9999,
-                             99999,
-                             999999,
-                             9999999,
-                             99999999,
-                             999999999,
-                             9999999999,
-                             99999999999,
-                             999999999999,
-                             9999999999999,
-                             99999999999999,
-                             999999999999999ULL,
-                             9999999999999999ULL,
-                             99999999999999999ULL,
-                             999999999999999999ULL,
-                             9999999999999999999ULL};
-  int y = (19 * int_log2(x) >> 6);
-  y += x > table[y];
-  return y + 1;
-}
-
-template <typename number_type, typename = typename std::enable_if<
-                                    std::is_unsigned<number_type>::value>::type>
-simdjson_really_inline size_t digit_count(number_type v) noexcept {
-  static_assert(sizeof(number_type) == 8 || sizeof(number_type) == 4 ||
-                    sizeof(number_type) == 2 || sizeof(number_type) == 1,
-                "We only support 8-bit, 16-bit, 32-bit and 64-bit numbers");
-  SIMDJSON_IF_CONSTEXPR(sizeof(number_type) <= 4) {
-    return fast_digit_count_32(static_cast<uint32_t>(v));
-  }
-  else {
-    return fast_digit_count_64(static_cast<uint64_t>(v));
-  }
-}
 static const char decimal_table[200] = {
    0x30, 0x30, 0x30, 0x31, 0x30, 0x32, 0x30, 0x33, 0x30, 0x34, 0x30, 0x35,
    0x30, 0x36, 0x30, 0x37, 0x30, 0x38, 0x30, 0x39, 0x31, 0x30, 0x31, 0x31,
@@ -635,6 +582,78 @@ static const char decimal_table[200] = {
    0x39, 0x30, 0x39, 0x31, 0x39, 0x32, 0x39, 0x33, 0x39, 0x34, 0x39, 0x35,
    0x39, 0x36, 0x39, 0x37, 0x39, 0x38, 0x39, 0x39,
 };
+
+// Forward unsigned-int writer (cascade-on-magnitude, no upfront digit_count).
+// Built from a non-recursive DAG of always_inline helpers — gcc and MSVC
+// refuse to inline recursive `always_inline`/`__forceinline` functions.
+// Caller must guarantee at least 20 bytes available at p. All helpers
+// return pointer past the last digit written.
+
+// Caller guarantees v < 100. Writes 1-2 digits.
+simdjson_really_inline char* write_lt100(char* p, uint64_t v) noexcept {
+  if (v < 10) { *p++ = char('0' + v); return p; }
+  std::memcpy(p, &decimal_table[v * 2], 2);
+  return p + 2;
+}
+
+// Caller guarantees v < 10000. Writes 1-4 digits.
+simdjson_really_inline char* write_lt10000(char* p, uint64_t v) noexcept {
+  if (v < 100) return write_lt100(p, v);
+  uint64_t hi = v / 100, lo = v % 100;
+  if (v < 1000) {
+    *p++ = char('0' + hi);
+  } else {
+    std::memcpy(p, &decimal_table[hi * 2], 2);
+    p += 2;
+  }
+  std::memcpy(p, &decimal_table[lo * 2], 2);
+  return p + 2;
+}
+
+// Caller guarantees v < 10000. Always writes exactly 4 digits.
+simdjson_really_inline void write_4_digits(char* p, uint64_t v) noexcept {
+  uint64_t hi = v / 100, lo = v % 100;
+  std::memcpy(p,     &decimal_table[hi * 2], 2);
+  std::memcpy(p + 2, &decimal_table[lo * 2], 2);
+}
+
+// Caller guarantees v < 10^8. Writes 1-8 digits.
+simdjson_really_inline char* write_lt1e8(char* p, uint64_t v) noexcept {
+  if (v < 10000) return write_lt10000(p, v);
+  uint64_t hi = v / 10000, lo = v % 10000;
+  p = write_lt10000(p, hi);
+  write_4_digits(p, lo);
+  return p + 4;
+}
+
+simdjson_really_inline char* write_uint_jeaiii(char* p, uint64_t v) noexcept {
+  if (v < 10000ULL) return write_lt10000(p, v);
+  if (v < 100000000ULL) {                   // 5-8 digits
+    uint64_t hi = v / 10000, lo = v % 10000;
+    p = write_lt10000(p, hi);
+    write_4_digits(p, lo);
+    return p + 4;
+  }
+  if (v < 10000000000000000ULL) {           // 9-16 digits
+    uint64_t hi = v / 100000000ULL, lo = v % 100000000ULL;
+    p = write_lt1e8(p, hi);
+    uint64_t lo_hi = lo / 10000, lo_lo = lo % 10000;
+    write_4_digits(p,     lo_hi);
+    write_4_digits(p + 4, lo_lo);
+    return p + 8;
+  }
+  // 17-20 digits
+  uint64_t hi = v / 10000000000000000ULL, lo = v % 10000000000000000ULL;
+  p = write_lt10000(p, hi);
+  uint64_t lo_a = lo / 100000000ULL, lo_b = lo % 100000000ULL;
+  uint64_t lo_a_hi = lo_a / 10000, lo_a_lo = lo_a % 10000;
+  uint64_t lo_b_hi = lo_b / 10000, lo_b_lo = lo_b % 10000;
+  write_4_digits(p,      lo_a_hi);
+  write_4_digits(p + 4,  lo_a_lo);
+  write_4_digits(p + 8,  lo_b_hi);
+  write_4_digits(p + 12, lo_b_lo);
+  return p + 16;
+}
 } // namespace internal

 template <typename number_type, typename>
@@ -662,87 +681,59 @@ simdjson_inline void string_builder::append(number_type v) noexcept {
    }
  }
  else SIMDJSON_IF_CONSTEXPR(std::is_unsigned<number_type>::value) {
-    // Process 4 digits at a time instead of 2, reducing store operations
-    // and divisions by approximately half for large numbers.
    constexpr size_t max_number_size = 20;
    if (capacity_check(max_number_size)) {
      using unsigned_type = typename std::make_unsigned<number_type>::type;
-      unsigned_type pv = static_cast<unsigned_type>(v);
-      size_t dc = internal::digit_count(pv);
-      char *write_pointer = buffer.get() + position + dc - 1;
-
-      // Process 4 digits per iteration for large numbers
-      while (pv >= 10000) {
-        unsigned_type q = pv / 10000;
-        unsigned_type r = pv % 10000;
-        unsigned_type r_hi = r / 100;  // High 2 digits of remainder
-        unsigned_type r_lo = r % 100;  // Low 2 digits of remainder
-        // Write low 2 digits first (rightmost), then high 2 digits
-        memcpy(write_pointer - 1, &internal::decimal_table[r_lo * 2], 2);
-        memcpy(write_pointer - 3, &internal::decimal_table[r_hi * 2], 2);
-        write_pointer -= 4;
-        pv = q;
-      }
-
-      // Handle remaining 1-4 digits with original 2-digit loop
-      while (pv >= 100) {
-        memcpy(write_pointer - 1, &internal::decimal_table[(pv % 100) * 2], 2);
-        write_pointer -= 2;
-        pv /= 100;
-      }
-      if (pv >= 10) {
-        *write_pointer-- = char('0' + (pv % 10));
-        pv /= 10;
-      }
-      *write_pointer = char('0' + pv);
-      position += dc;
+      char* end = internal::write_uint_jeaiii(
+          buffer.get() + position,
+          static_cast<uint64_t>(static_cast<unsigned_type>(v)));
+      position = end - buffer.get();
    }
  }
  else SIMDJSON_IF_CONSTEXPR(std::is_integral<number_type>::value) {
-    // Same 4-digit batching as unsigned path for signed integers
+    // 19 digits (max abs value of int64_t) + optional minus sign.
    constexpr size_t max_number_size = 20;
    if (capacity_check(max_number_size)) {
      using unsigned_type = typename std::make_unsigned<number_type>::type;
      bool negative = v < 0;
-      unsigned_type pv = static_cast<unsigned_type>(v);
-      if (negative) {
-        pv = 0 - pv; // the 0 is for Microsoft
-      }
-      size_t dc = internal::digit_count(pv);
-      // by always writing the minus sign, we avoid the branch.
+      // 0 - pv (rather than -pv) avoids an MSVC unary-minus warning.
+      unsigned_type pv = negative
+          ? unsigned_type(0) - static_cast<unsigned_type>(v)
+          : static_cast<unsigned_type>(v);
+      // Branchless: always write '-', advance only if negative.
      buffer.get()[position] = '-';
-      position += negative ? 1 : 0;
-      char *write_pointer = buffer.get() + position + dc - 1;
-
-      // Process 4 digits per iteration for large numbers
-      while (pv >= 10000) {
-        unsigned_type q = pv / 10000;
-        unsigned_type r = pv % 10000;
-        unsigned_type r_hi = r / 100;
-        unsigned_type r_lo = r % 100;
-        memcpy(write_pointer - 1, &internal::decimal_table[r_lo * 2], 2);
-        memcpy(write_pointer - 3, &internal::decimal_table[r_hi * 2], 2);
-        write_pointer -= 4;
-        pv = q;
-      }
-
-      // Handle remaining 1-4 digits
-      while (pv >= 100) {
-        memcpy(write_pointer - 1, &internal::decimal_table[(pv % 100) * 2], 2);
-        write_pointer -= 2;
-        pv /= 100;
-      }
-      if (pv >= 10) {
-        *write_pointer-- = char('0' + (pv % 10));
-        pv /= 10;
-      }
-      *write_pointer = char('0' + pv);
-      position += dc;
+      position += negative;
+      char* end = internal::write_uint_jeaiii(
+          buffer.get() + position, static_cast<uint64_t>(pv));
+      position = end - buffer.get();
    }
  }
  else SIMDJSON_IF_CONSTEXPR(std::is_floating_point<number_type>::value) {
    constexpr size_t max_number_size = 24;
    if (capacity_check(max_number_size)) {
+#if SIMDJSON_ENABLE_NAN_INF
+      // Check if the input might be NaN or infinity
+      if (simdjson_unlikely(!std::isfinite(v))) {
+        if (std::isnan(v)) {
+          constexpr char nan_literal[] = "NaN";
+          constexpr size_t nan_len = sizeof(nan_literal) - 1;
+
+          std::memcpy(buffer.get() + position, nan_literal, nan_len);
+          position += nan_len;
+        } else {
+          constexpr char inf_literal[] = "Infinity";
+          constexpr size_t inf_len = sizeof(inf_literal) - 1;
+          if (v < 0) {
+            buffer.get()[position] = '-';
+            ++position;
+          }
+          std::memcpy(buffer.get() + position, inf_literal, inf_len);
+          position += inf_len;
+        }
+        return;
+      }
+#endif
+
      // We could specialize for float.
      char *end = simdjson::internal::to_chars(buffer.get() + position, nullptr,
                                               double(v));
@@ -754,6 +745,11 @@ simdjson_inline void string_builder::append(number_type v) noexcept {
 simdjson_inline void
 string_builder::escape_and_append(std::string_view input) noexcept {
  // escaping might turn a control character into \x00xx so 6 characters.
+  // Guard against size_t overflow in the multiplication below.
+  if (input.size() > (std::numeric_limits<size_t>::max)() / 6) {
+    set_valid(false);
+    return;
+  }
  if (capacity_check(6 * input.size())) {
    position += write_string_escaped(input, buffer.get() + position);
  }
@@ -762,6 +758,11 @@ string_builder::escape_and_append(std::string_view input) noexcept {
 simdjson_inline void
 string_builder::escape_and_append_with_quotes(std::string_view input) noexcept {
  // escaping might turn a control character into \x00xx so 6 characters.
+  // Guard against size_t overflow in the arithmetic below.
+  if (input.size() > ((std::numeric_limits<size_t>::max)() - 2) / 6) {
+    set_valid(false);
+    return;
+  }
  if (capacity_check(2 + 6 * input.size())) {
    buffer.get()[position++] = '"';
    position += write_string_escaped(input, buffer.get() + position);
@@ -793,7 +794,9 @@ simdjson_inline void string_builder::escape_and_append_with_quotes() noexcept {
 #endif

 simdjson_inline void string_builder::append_raw(const char *c) noexcept {
-  size_t len = std::strlen(c);
+  // char_traits::length is constexpr; lets the compiler fold the length
+  // when called with a pointer to a compile-time-constant string.
+  size_t len = std::char_traits<char>::length(c);
  append_raw(c, len);
 }

@@ -812,6 +815,14 @@ simdjson_inline void string_builder::append_raw(const char *str,
    position += len;
  }
 }
+
+template <size_t N>
+simdjson_inline void string_builder::append_raw_n(const char *str) noexcept {
+  if (capacity_check(N)) {
+    std::memcpy(buffer.get() + position, str, N);
+    position += N;
+  }
+}
 #if SIMDJSON_SUPPORTS_CONCEPTS
 // Support for optional types (std::optional, etc.)
 template <concepts::optional_type T>
@@ -841,7 +852,7 @@ simdjson_inline void string_builder::append(const T &value) {
 #if SIMDJSON_SUPPORTS_RANGES && SIMDJSON_SUPPORTS_CONCEPTS
 // Support for range-based appending (std::ranges::view, etc.)
 template <std::ranges::range R>
-  requires(!std::is_convertible<R, std::string_view>::value && !require_custom_serialization<R>)
+  requires(!std::is_convertible<R, std::string_view>::value && !concepts::optional_type<R> && !require_custom_serialization<R>)
 simdjson_inline void string_builder::append(const R &range) noexcept {
  auto it = std::ranges::begin(range);
  auto end = std::ranges::end(range);
@@ -171,7 +171,7 @@ public:
 #if SIMDJSON_SUPPORTS_RANGES && SIMDJSON_SUPPORTS_CONCEPTS
  // Support for range-based appending (std::ranges::view, etc.)
  template <std::ranges::range R>
-requires (!std::is_convertible<R, std::string_view>::value && !require_custom_serialization<R>)
+requires (!std::is_convertible<R, std::string_view>::value && !concepts::optional_type<R> && !require_custom_serialization<R>)
  simdjson_inline void append(const R &range) noexcept;
 #endif
  /**
@@ -185,6 +185,15 @@ requires (!std::is_convertible<R, std::string_view>::value && !require_custom_se
   * There is no UTF-8 validation.
   */
  simdjson_inline void append_raw(const char *str, size_t len) noexcept;
+
+  /**
+   * Append exactly N characters from str. The length is a template parameter
+   * so the compiler can fully inline the memcpy with a compile-time-constant
+   * size, avoiding the libc call. Used for compile-time-constant keys in the
+   * reflection struct atom.
+   */
+  template <size_t N>
+  simdjson_inline void append_raw_n(const char *str) noexcept;
 #if SIMDJSON_EXCEPTIONS
  /**
   * Creates an std::string from the written JSON buffer.
@@ -236,6 +245,26 @@ requires (!std::is_convertible<R, std::string_view>::value && !require_custom_se
   */
  simdjson_inline size_t size() const noexcept;

+  // ============================================================
+  // Internal hooks for the position-as-local writer in json_builder.h.
+  // These exist so the reflection atom code can hold buffer pointer,
+  // position and capacity in registers across long write chains rather
+  // than reloading them after every char* write (strict aliasing
+  // forces those reloads when accessed via members of *this). User
+  // code should NOT call these directly.
+  // ============================================================
+  simdjson_inline char *unsafe_data() noexcept { return buffer.get(); }
+  simdjson_inline size_t unsafe_position() const noexcept { return position; }
+  simdjson_inline size_t unsafe_capacity() const noexcept { return capacity; }
+  simdjson_inline void unsafe_set_position(size_t p) noexcept { position = p; }
+  /// Make capacity available for at least `n` more bytes after the current
+  /// position. Returns false if the allocation failed.
+  simdjson_inline bool unsafe_grow(size_t needed_total_capacity) noexcept {
+    grow_buffer(needed_total_capacity);
+    return is_valid;
+  }
+  simdjson_inline bool unsafe_is_valid() const noexcept { return is_valid; }
+
 private:
  /**
   * Returns true if we can write at least upcoming_bytes bytes.
@@ -249,7 +278,7 @@ private:
   * If the allocation fails, is_valid is set to false. We expect
   * that this function would not be repeatedly called.
   */
-  simdjson_inline void grow_buffer(size_t desired_capacity);
+  inline void grow_buffer(size_t desired_capacity);

  /**
   * We use this helper function to make sure that is_valid is kept consistent.
@@ -63,7 +63,11 @@ inline dom_parser_implementation &dom_parser_implementation::operator=(dom_parse
 inline simdjson_warn_unused error_code dom_parser_implementation::set_capacity(size_t capacity) noexcept {
  if(capacity > SIMDJSON_MAXSIZE_BYTES) { return CAPACITY; }
  // Stage 1 index output
-  size_t max_structures = SIMDJSON_ROUNDUP_N(capacity, 64) + 2 + 7;
+  size_t rounded_capacity = SIMDJSON_ROUNDUP_N(capacity, 64);
+  if(rounded_capacity + 9 < rounded_capacity) {
+    return CAPACITY; // overflow, only happen on legacy 32-bit systems with very large capacity
+  }
+  size_t max_structures = rounded_capacity + 9;
  structural_indexes.reset( new (std::nothrow) uint32_t[max_structures] );
  if (!structural_indexes) { _capacity = 0; return MEMALLOC; }
  structural_indexes[0] = 0;
@@ -74,6 +78,7 @@ 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]);
@@ -4,6 +4,7 @@
 #define SIMDJSON_GENERIC_NUMBERPARSING_H
 #include "simdjson/generic/base.h"
 #include "simdjson/generic/jsoncharutils.h"
+#include "simdjson/generic/atomparsing.h"
 #include "simdjson/internal/numberparsing_tables.h"
 #endif // SIMDJSON_CONDITIONAL_INCLUDE

@@ -299,6 +300,24 @@ simdjson_inline bool compute_float_64(int64_t power, uint64_t i, bool negative,
  return true;
 }

+#if SIMDJSON_ENABLE_NAN_INF
+// Parses a nan or infinity. Returns true on success, false on failure.
+simdjson_unused simdjson_inline bool compute_nan_inf(const uint8_t* src, bool negative, double& d) noexcept {
+  if (atomparsing::is_valid_inf_atom(src)) {
+    double inf = std::numeric_limits<double>::infinity();
+    d = negative ? -inf : inf;
+    return true;
+  }
+
+  if (atomparsing::is_valid_nan_atom(src)) {
+    d = std::numeric_limits<double>::quiet_NaN();
+    return true;
+  }
+
+  return false;
+}
+#endif
+
 // We call a fallback floating-point parser that might be slow. Note
 // it will accept JSON numbers, but the JSON spec. is more restrictive so
 // before you call parse_float_fallback, you need to have validated the input
@@ -478,7 +497,7 @@ simdjson_inline size_t significant_digits(const uint8_t * start_digits, size_t d
 } // unnamed namespace

 /** @private */
-static error_code slow_float_parsing(simdjson_unused const uint8_t * src, double* answer) {
+inline error_code slow_float_parsing(simdjson_unused const uint8_t * src, double* answer) {
  if (parse_float_fallback(src, answer)) {
    return SUCCESS;
  }
@@ -600,7 +619,21 @@ simdjson_warn_unused simdjson_inline error_code parse_number(const uint8_t *cons
  // If there were no digits, or if the integer starts with 0 and has more than one digit, it's an error.
  // Optimization note: size_t is expected to be unsigned.
  size_t digit_count = size_t(p - start_digits);
-  if (digit_count == 0 || ('0' == *start_digits && digit_count > 1)) { return INVALID_NUMBER(src); }
+  if (digit_count == 0 || ('0' == *start_digits && digit_count > 1)) {
+
+#if SIMDJSON_ENABLE_NAN_INF
+    // By this point, we know that our input does not begin with a digit. We will attempt
+    // to handle NaN/Infinity.
+
+    double d;
+    if (compute_nan_inf(p, negative, d)) {
+      writer.append_double(d);
+      return SUCCESS;
+    }
+#endif
+
+    return INVALID_NUMBER(src);
+  }

  //
  // Handle floats if there is a . or e (or both)
@@ -1031,7 +1064,17 @@ simdjson_unused simdjson_inline simdjson_result<double> parse_double(const uint8
  bool leading_zero = (i == 0);
  while (parse_digit(*p, i)) { p++; }
  // no integer digits, or 0123 (zero must be solo)
-  if ( p == src ) { return INCORRECT_TYPE; }
+  if ( p == src ) {
+
+#if SIMDJSON_ENABLE_NAN_INF
+    // If there are no loading digits, the number may be nan or infinity.
+    // Attempt to compute those, and return on success.
+    double d;
+    if (compute_nan_inf(p, negative, d)) { return d; }
+#endif
+
+    return INCORRECT_TYPE;
+  }
  if ( (leading_zero && p != src+1)) { return NUMBER_ERROR; }

  //
@@ -1249,7 +1292,22 @@ simdjson_unused simdjson_inline simdjson_result<double> parse_double_in_string(c
  bool leading_zero = (i == 0);
  while (parse_digit(*p, i)) { p++; }
  // no integer digits, or 0123 (zero must be solo)
-  if ( p == src ) { return INCORRECT_TYPE; }
+  if ( p == src ) {
+#if SIMDJSON_ENABLE_NAN_INF
+    // If there are no leading digits, attempt to parse numbers that are either
+    // NaN or Infinity
+    if (atomparsing::is_valid_inf_in_string(src)) {
+      double inf = std::numeric_limits<double>::infinity();
+      return negative ? -inf : inf;
+    }
+
+    if (atomparsing::is_valid_nan_in_string(src)) {
+      return std::numeric_limits<double>::quiet_NaN();
+    }
+#endif
+
+    return INCORRECT_TYPE;
+  }
  if ( (leading_zero && p != src+1)) { return NUMBER_ERROR; }

  //
@@ -22,6 +22,7 @@
 #include "simdjson/generic/ondemand/field.h"
 #include "simdjson/generic/ondemand/object.h"
 #include "simdjson/generic/ondemand/object_iterator.h"
+#include "simdjson/generic/ondemand/ranges.h"
 #include "simdjson/generic/ondemand/serialization.h"

 // Deserialization for standard types
@@ -39,6 +40,7 @@
 #include "simdjson/generic/ondemand/logger-inl.h"
 #include "simdjson/generic/ondemand/object-inl.h"
 #include "simdjson/generic/ondemand/object_iterator-inl.h"
+#include "simdjson/generic/ondemand/ranges-inl.h"
 #include "simdjson/generic/ondemand/parser-inl.h"
 #include "simdjson/generic/ondemand/raw_json_string-inl.h"
 #include "simdjson/generic/ondemand/token_iterator-inl.h"
@@ -135,21 +135,9 @@ inline simdjson_result<value> array::at_pointer(std::string_view json_pointer) n
  // We don't support this, because we're returning a real element, not a position.
  if (json_pointer == "-") { return INDEX_OUT_OF_BOUNDS; }

-  // Read the array index
  size_t array_index = 0;
  size_t i;
-  for (i = 0; i < json_pointer.length() && json_pointer[i] != '/'; i++) {
-    uint8_t digit = uint8_t(json_pointer[i] - '0');
-    // Check for non-digit in array index. If it's there, we're trying to get a field in an object
-    if (digit > 9) { return INCORRECT_TYPE; }
-    array_index = array_index*10 + digit;
-  }
-
-  // 0 followed by other digits is invalid
-  if (i > 1 && json_pointer[0] == '0') { return INVALID_JSON_POINTER; } // "JSON pointer array index has other characters after 0"
-
-  // Empty string is invalid; so is a "/" with no digits before it
-  if (i == 0) { return INVALID_JSON_POINTER; } // "Empty string in JSON pointer array index"
+  SIMDJSON_TRY(internal::parse_json_pointer_array_index(json_pointer, array_index, i));
  // Get the child
  auto child = at(array_index);
  // If there is an error, it ends here
@@ -170,46 +158,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 +193,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 +262,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(); }
@@ -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
@@ -40,6 +40,13 @@ class token_iterator;
 class value;
 class value_iterator;

+#if SIMDJSON_SUPPORTS_RANGES
+class array_range;
+class array_range_iterator;
+class object_range;
+class object_range_iterator;
+#endif // SIMDJSON_SUPPORTS_RANGES
+
 } // namespace ondemand
 } // namespace SIMDJSON_IMPLEMENTATION
 } // namespace simdjson
@@ -16,6 +16,8 @@
 #include "simdjson/generic/ondemand/deserialize.h"
 #endif // SIMDJSON_CONDITIONAL_INCLUDE

+#include <limits>
+
 namespace simdjson {
 namespace SIMDJSON_IMPLEMENTATION {
 namespace ondemand {
@@ -131,6 +133,18 @@ simdjson_inline simdjson_result<int64_t> document::get_int64() noexcept {
 simdjson_inline simdjson_result<int64_t> document::get_int64_in_string() noexcept {
  return get_root_value_iterator().get_root_int64_in_string(true);
 }
+simdjson_inline simdjson_result<uint32_t> document::get_uint32() noexcept {
+  uint64_t result;
+  SIMDJSON_TRY(get_uint64().get(result));
+  if (result > (std::numeric_limits<uint32_t>::max)()) { return NUMBER_OUT_OF_RANGE; }
+  return static_cast<uint32_t>(result);
+}
+simdjson_inline simdjson_result<int32_t> document::get_int32() noexcept {
+  int64_t result;
+  SIMDJSON_TRY(get_int64().get(result));
+  if (result > (std::numeric_limits<int32_t>::max)() || result < (std::numeric_limits<int32_t>::min)()) { return NUMBER_OUT_OF_RANGE; }
+  return static_cast<int32_t>(result);
+}
 simdjson_inline simdjson_result<double> document::get_double() noexcept {
  return get_root_value_iterator().get_root_double(true);
 }
@@ -164,6 +178,8 @@ template<> simdjson_inline simdjson_result<std::string_view> document::get() & n
 template<> simdjson_inline simdjson_result<double> document::get() & noexcept { return get_double(); }
 template<> simdjson_inline simdjson_result<uint64_t> document::get() & noexcept { return get_uint64(); }
 template<> simdjson_inline simdjson_result<int64_t> document::get() & noexcept { return get_int64(); }
+template<> simdjson_inline simdjson_result<uint32_t> document::get() & noexcept { return get_uint32(); }
+template<> simdjson_inline simdjson_result<int32_t> document::get() & noexcept { return get_int32(); }
 template<> simdjson_inline simdjson_result<bool> document::get() & noexcept { return get_bool(); }
 template<> simdjson_inline simdjson_result<value> document::get() & noexcept { return get_value(); }

@@ -174,6 +190,8 @@ template<> simdjson_warn_unused simdjson_inline error_code document::get(std::st
 template<> simdjson_warn_unused simdjson_inline error_code document::get(double& out) & noexcept { return get_double().get(out); }
 template<> simdjson_warn_unused simdjson_inline error_code document::get(uint64_t& out) & noexcept { return get_uint64().get(out); }
 template<> simdjson_warn_unused simdjson_inline error_code document::get(int64_t& out) & noexcept { return get_int64().get(out); }
+template<> simdjson_warn_unused simdjson_inline error_code document::get(uint32_t& out) & noexcept { return get_uint32().get(out); }
+template<> simdjson_warn_unused simdjson_inline error_code document::get(int32_t& out) & noexcept { return get_int32().get(out); }
 template<> simdjson_warn_unused simdjson_inline error_code document::get(bool& out) & noexcept { return get_bool().get(out); }
 template<> simdjson_warn_unused simdjson_inline error_code document::get(value& out) & noexcept { return get_value().get(out); }

@@ -347,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;
  }
@@ -356,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;
  }
@@ -504,6 +528,14 @@ simdjson_inline simdjson_result<int64_t> simdjson_result<SIMDJSON_IMPLEMENTATION
  if (error()) { return error(); }
  return first.get_int64_in_string();
 }
+simdjson_inline simdjson_result<uint32_t> simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document>::get_uint32() noexcept {
+  if (error()) { return error(); }
+  return first.get_uint32();
+}
+simdjson_inline simdjson_result<int32_t> simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document>::get_int32() noexcept {
+  if (error()) { return error(); }
+  return first.get_int32();
+}
 simdjson_inline simdjson_result<double> simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document>::get_double() noexcept {
  if (error()) { return error(); }
  return first.get_double();
@@ -627,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;
+  return first.get_uint64();
 }
 simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document>::operator int64_t() noexcept(false) {
  if (error()) { throw simdjson_error(error()); }
-  return first;
+  return first.get_int64();
 }
 simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document>::operator double() noexcept(false) {
  if (error()) { throw simdjson_error(error()); }
-  return first;
+  return first.get_double();
 }
 simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document>::operator std::string_view() noexcept(false) {
  if (error()) { throw simdjson_error(error()); }
-  return first;
+  return first.get_string();
 }
 simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document>::operator SIMDJSON_IMPLEMENTATION::ondemand::raw_json_string() noexcept(false) {
  if (error()) { throw simdjson_error(error()); }
-  return first;
+  return first.get_raw_json_string();
 }
 simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document>::operator bool() noexcept(false) {
  if (error()) { throw simdjson_error(error()); }
-  return first;
+  return first.get_bool();
 }
 simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document>::operator SIMDJSON_IMPLEMENTATION::ondemand::value() noexcept(false) {
  if (error()) { throw simdjson_error(error()); }
@@ -687,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
@@ -731,6 +769,18 @@ simdjson_inline simdjson_result<uint64_t> document_reference::get_uint64() noexc
 simdjson_inline simdjson_result<uint64_t> document_reference::get_uint64_in_string() noexcept { return doc->get_root_value_iterator().get_root_uint64_in_string(false); }
 simdjson_inline simdjson_result<int64_t> document_reference::get_int64() noexcept { return doc->get_root_value_iterator().get_root_int64(false); }
 simdjson_inline simdjson_result<int64_t> document_reference::get_int64_in_string() noexcept { return doc->get_root_value_iterator().get_root_int64_in_string(false); }
+simdjson_inline simdjson_result<uint32_t> document_reference::get_uint32() noexcept {
+  uint64_t result;
+  SIMDJSON_TRY(doc->get_root_value_iterator().get_root_uint64(false).get(result));
+  if (result > (std::numeric_limits<uint32_t>::max)()) { return NUMBER_OUT_OF_RANGE; }
+  return static_cast<uint32_t>(result);
+}
+simdjson_inline simdjson_result<int32_t> document_reference::get_int32() noexcept {
+  int64_t result;
+  SIMDJSON_TRY(doc->get_root_value_iterator().get_root_int64(false).get(result));
+  if (result > (std::numeric_limits<int32_t>::max)() || result < (std::numeric_limits<int32_t>::min)()) { return NUMBER_OUT_OF_RANGE; }
+  return static_cast<int32_t>(result);
+}
 simdjson_inline simdjson_result<double> document_reference::get_double() noexcept { return doc->get_root_value_iterator().get_root_double(false); }
 simdjson_inline simdjson_result<double> document_reference::get_double_in_string() noexcept { return doc->get_root_value_iterator().get_root_double(false); }
 simdjson_inline simdjson_result<std::string_view> document_reference::get_string(bool allow_replacement) noexcept { return doc->get_root_value_iterator().get_root_string(false, allow_replacement); }
@@ -748,6 +798,8 @@ template<> simdjson_inline simdjson_result<std::string_view> document_reference:
 template<> simdjson_inline simdjson_result<double> document_reference::get() & noexcept { return get_double(); }
 template<> simdjson_inline simdjson_result<uint64_t> document_reference::get() & noexcept { return get_uint64(); }
 template<> simdjson_inline simdjson_result<int64_t> document_reference::get() & noexcept { return get_int64(); }
+template<> simdjson_inline simdjson_result<uint32_t> document_reference::get() & noexcept { return get_uint32(); }
+template<> simdjson_inline simdjson_result<int32_t> document_reference::get() & noexcept { return get_int32(); }
 template<> simdjson_inline simdjson_result<bool> document_reference::get() & noexcept { return get_bool(); }
 template<> simdjson_inline simdjson_result<value> document_reference::get() & noexcept { return get_value(); }
 #if SIMDJSON_EXCEPTIONS
@@ -786,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
@@ -879,6 +937,14 @@ simdjson_inline simdjson_result<int64_t> simdjson_result<SIMDJSON_IMPLEMENTATION
  if (error()) { return error(); }
  return first.get_int64_in_string();
 }
+simdjson_inline simdjson_result<uint32_t> simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document_reference>::get_uint32() noexcept {
+  if (error()) { return error(); }
+  return first.get_uint32();
+}
+simdjson_inline simdjson_result<int32_t> simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document_reference>::get_int32() noexcept {
+  if (error()) { return error(); }
+  return first.get_int32();
+}
 simdjson_inline simdjson_result<double> simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document_reference>::get_double() noexcept {
  if (error()) { return error(); }
  return first.get_double();
@@ -994,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;
+  return first.get_uint64();
 }
 simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document_reference>::operator int64_t() noexcept(false) {
  if (error()) { throw simdjson_error(error()); }
-  return first;
+  return first.get_int64();
 }
 simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document_reference>::operator double() noexcept(false) {
  if (error()) { throw simdjson_error(error()); }
-  return first;
+  return first.get_double();
 }
 simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document_reference>::operator std::string_view() noexcept(false) {
  if (error()) { throw simdjson_error(error()); }
-  return first;
+  return first.get_string();
 }
 simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document_reference>::operator SIMDJSON_IMPLEMENTATION::ondemand::raw_json_string() noexcept(false) {
  if (error()) { throw simdjson_error(error()); }
-  return first;
+  return first.get_raw_json_string();
 }
 simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document_reference>::operator bool() noexcept(false) {
  if (error()) { throw simdjson_error(error()); }
-  return first;
+  return first.get_bool();
 }
 simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::document_reference>::operator SIMDJSON_IMPLEMENTATION::ondemand::value() noexcept(false) {
  if (error()) { throw simdjson_error(error()); }
@@ -1043,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>
@@ -76,6 +76,26 @@ public:
   * @returns INCORRECT_TYPE If the JSON value is not a 64-bit integer.
   */
  simdjson_inline simdjson_result<int64_t> get_int64_in_string() noexcept;
+  /**
+   * Cast this JSON value to a 32-bit unsigned integer.
+   *
+   * Calls get_uint64() and checks that the result fits in a uint32_t.
+   *
+   * @returns A 32-bit unsigned integer.
+   * @returns INCORRECT_TYPE If the JSON value is not an unsigned integer.
+   * @returns NUMBER_OUT_OF_RANGE If the value does not fit in a uint32_t.
+   */
+  simdjson_inline simdjson_result<uint32_t> get_uint32() noexcept;
+  /**
+   * Cast this JSON value to a 32-bit signed integer.
+   *
+   * Calls get_int64() and checks that the result fits in an int32_t.
+   *
+   * @returns A 32-bit signed integer.
+   * @returns INCORRECT_TYPE If the JSON value is not an integer.
+   * @returns NUMBER_OUT_OF_RANGE If the value does not fit in an int32_t.
+   */
+  simdjson_inline simdjson_result<int32_t> get_int32() noexcept;
  /**
   * Cast this JSON value to a double.
   *
@@ -299,21 +319,21 @@ public:
   * @returns A signed 64-bit integer.
   * @exception simdjson_error(INCORRECT_TYPE) If the JSON value is not a 64-bit unsigned integer.
   */
-  simdjson_inline operator uint64_t() noexcept(false);
+  explicit simdjson_inline operator uint64_t() noexcept(false);
  /**
   * Cast this JSON value to a signed integer.
   *
   * @returns A signed 64-bit integer.
   * @exception simdjson_error(INCORRECT_TYPE) If the JSON value is not a 64-bit integer.
   */
-  simdjson_inline operator int64_t() noexcept(false);
+  explicit simdjson_inline operator int64_t() noexcept(false);
  /**
   * Cast this JSON value to a double.
   *
   * @returns A double.
   * @exception simdjson_error(INCORRECT_TYPE) If the JSON value is not a valid floating-point number.
   */
-  simdjson_inline operator double() noexcept(false);
+  explicit simdjson_inline operator double() noexcept(false);
  /**
   * Cast this JSON value to a string.
   *
@@ -323,7 +343,7 @@ public:
   *          time it parses a document or when it is destroyed.
   * @exception simdjson_error(INCORRECT_TYPE) if the JSON value is not a string.
   */
-  simdjson_inline operator std::string_view() noexcept(false) simdjson_lifetime_bound;
+  explicit simdjson_inline operator std::string_view() noexcept(false) simdjson_lifetime_bound;
  /**
   * Cast this JSON value to a raw_json_string.
   *
@@ -332,14 +352,14 @@ public:
   * @returns A pointer to the raw JSON for the given string.
   * @exception simdjson_error(INCORRECT_TYPE) if the JSON value is not a string.
   */
-  simdjson_inline operator raw_json_string() noexcept(false) simdjson_lifetime_bound;
+  explicit simdjson_inline operator raw_json_string() noexcept(false) simdjson_lifetime_bound;
  /**
   * Cast this JSON value to a bool.
   *
   * @returns A bool value.
   * @exception simdjson_error(INCORRECT_TYPE) if the JSON value is not true or false.
   */
-  simdjson_inline operator bool() noexcept(false);
+  explicit simdjson_inline operator bool() noexcept(false);
  /**
   * Cast this JSON value to a value when the document is an object or an array.
   *
@@ -724,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
@@ -829,6 +852,8 @@ public:
  simdjson_inline simdjson_result<uint64_t> get_uint64_in_string() noexcept;
  simdjson_inline simdjson_result<int64_t> get_int64() noexcept;
  simdjson_inline simdjson_result<int64_t> get_int64_in_string() noexcept;
+  simdjson_inline simdjson_result<uint32_t> get_uint32() noexcept;
+  simdjson_inline simdjson_result<int32_t> get_int32() noexcept;
  simdjson_inline simdjson_result<double> get_double() noexcept;
  simdjson_inline simdjson_result<double> get_double_in_string() noexcept;
  simdjson_inline simdjson_result<std::string_view> get_string(bool allow_replacement = false) noexcept;
@@ -923,12 +948,12 @@ public:
  explicit simdjson_inline operator T() noexcept(false);
  simdjson_inline operator array() & noexcept(false);
  simdjson_inline operator object() & noexcept(false);
-  simdjson_inline operator uint64_t() noexcept(false);
-  simdjson_inline operator int64_t() noexcept(false);
-  simdjson_inline operator double() noexcept(false);
-  simdjson_inline operator std::string_view() noexcept(false);
-  simdjson_inline operator raw_json_string() noexcept(false);
-  simdjson_inline operator bool() noexcept(false);
+  explicit simdjson_inline operator uint64_t() noexcept(false);
+  explicit simdjson_inline operator int64_t() noexcept(false);
+  explicit simdjson_inline operator double() noexcept(false);
+  explicit simdjson_inline operator std::string_view() noexcept(false);
+  explicit simdjson_inline operator raw_json_string() noexcept(false);
+  explicit simdjson_inline operator bool() noexcept(false);
  simdjson_inline operator value() noexcept(false);
 #endif
  simdjson_inline simdjson_result<size_t> count_elements() & noexcept;
@@ -957,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};
@@ -982,6 +1013,8 @@ public:
  simdjson_inline simdjson_result<uint64_t> get_uint64_in_string() noexcept;
  simdjson_inline simdjson_result<int64_t> get_int64() noexcept;
  simdjson_inline simdjson_result<int64_t> get_int64_in_string() noexcept;
+  simdjson_inline simdjson_result<uint32_t> get_uint32() noexcept;
+  simdjson_inline simdjson_result<int32_t> get_int32() noexcept;
  simdjson_inline simdjson_result<double> get_double() noexcept;
  simdjson_inline simdjson_result<double> get_double_in_string() noexcept;
  simdjson_inline simdjson_result<std::string_view> get_string(bool allow_replacement = false) noexcept;
@@ -1006,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);
-  simdjson_inline operator uint64_t() noexcept(false);
-  simdjson_inline operator int64_t() noexcept(false);
-  simdjson_inline operator double() noexcept(false);
-  simdjson_inline operator std::string_view() noexcept(false);
-  simdjson_inline operator SIMDJSON_IMPLEMENTATION::ondemand::raw_json_string() noexcept(false);
-  simdjson_inline operator bool() noexcept(false);
+  explicit simdjson_inline operator uint64_t() noexcept(false);
+  explicit simdjson_inline operator int64_t() noexcept(false);
+  explicit simdjson_inline operator double() noexcept(false);
+  explicit simdjson_inline operator std::string_view() noexcept(false);
+  explicit simdjson_inline operator SIMDJSON_IMPLEMENTATION::ondemand::raw_json_string() noexcept(false);
+  explicit simdjson_inline operator bool() noexcept(false);
  simdjson_inline operator SIMDJSON_IMPLEMENTATION::ondemand::value() noexcept(false);
 #endif
  simdjson_inline simdjson_result<size_t> count_elements() & noexcept;
@@ -1041,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))
@@ -1069,6 +1108,8 @@ public:
  simdjson_inline simdjson_result<uint64_t> get_uint64_in_string() noexcept;
  simdjson_inline simdjson_result<int64_t> get_int64() noexcept;
  simdjson_inline simdjson_result<int64_t> get_int64_in_string() noexcept;
+  simdjson_inline simdjson_result<uint32_t> get_uint32() noexcept;
+  simdjson_inline simdjson_result<int32_t> get_int32() noexcept;
  simdjson_inline simdjson_result<double> get_double() noexcept;
  simdjson_inline simdjson_result<double> get_double_in_string() noexcept;
  simdjson_inline simdjson_result<std::string_view> get_string(bool allow_replacement = false) noexcept;
@@ -1090,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);
-  simdjson_inline operator uint64_t() noexcept(false);
-  simdjson_inline operator int64_t() noexcept(false);
-  simdjson_inline operator double() noexcept(false);
-  simdjson_inline operator std::string_view() noexcept(false);
-  simdjson_inline operator SIMDJSON_IMPLEMENTATION::ondemand::raw_json_string() noexcept(false);
-  simdjson_inline operator bool() noexcept(false);
+  explicit simdjson_inline operator uint64_t() noexcept(false);
+  explicit simdjson_inline operator int64_t() noexcept(false);
+  explicit simdjson_inline operator double() noexcept(false);
+  explicit simdjson_inline operator std::string_view() noexcept(false);
+  explicit simdjson_inline operator SIMDJSON_IMPLEMENTATION::ondemand::raw_json_string() noexcept(false);
+  explicit simdjson_inline operator bool() noexcept(false);
  simdjson_inline operator SIMDJSON_IMPLEMENTATION::ondemand::value() noexcept(false);
 #endif
  simdjson_inline simdjson_result<size_t> count_elements() & noexcept;
@@ -1124,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))
@@ -95,13 +95,15 @@ simdjson_inline document_stream::document_stream(
  const uint8_t *_buf,
  size_t _len,
  size_t _batch_size,
-  bool _allow_comma_separated
+  bool _allow_comma_separated,
+  stream_format _format
 ) 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
@@ -120,6 +122,7 @@ 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)
@@ -219,7 +222,10 @@ inline void document_stream::start() noexcept {
    error = run_stage1(*parser, batch_start);
  }
  if (error) { return; }
-  doc_index = batch_start;
+  // 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 = document(json_iterator(&buf[batch_start], parser));
  doc.iter._streaming = true;

@@ -300,7 +306,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;
+      doc_index = batch_start + parser->implementation->structural_indexes[0];
    }
  }
 }
@@ -329,10 +335,35 @@ 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) {
-    return p.implementation->stage1(&buf[_batch_start], remaining, stage1_mode::streaming_final);
+    // 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);
  } else {
-    return p.implementation->stage1(&buf[_batch_start], batch_size, stage1_mode::streaming_partial);
+    // 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);
  }
 }

@@ -353,14 +384,21 @@ 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();
-          while(svlen > 1 && (std::isspace(start[svlen-1]) || start[svlen-1] == '\0')) {
+          // 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(static_cast<unsigned char>(start[svlen-1])) || start[svlen-1] == '\0' || static_cast<uint8_t>(start[svlen-1]) == 0x1E || (stream->format == stream_format::comma_delimited && start[svlen-1] == ','))) {
            svlen--;
          }
          return std::string_view(start, svlen);
@@ -441,4 +479,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
@@ -229,13 +229,16 @@ 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
+    bool allow_comma_separated,
+    stream_format format = stream_format::whitespace_delimited
  ) noexcept;

  /**
@@ -284,6 +287,7 @@ 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
@@ -177,9 +177,13 @@ inline simdjson_result<value> object::at_path(std::string_view json_path) noexce
  return at_pointer(json_pointer);
 }

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

    if (remaining_path.empty()) {
-      result.push_back(std::move(val));
-      return result;
+      callback(val);
+      return SUCCESS;
    } else {
-      return val.at_path_with_wildcard(remaining_path);
+      return val.for_each_at_path_with_wildcard(remaining_path, callback);
    }
  }
 }
@@ -347,9 +339,15 @@ simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> simdjs
  return first.at_path(json_path);
 }

-simdjson_inline simdjson_result<std::vector<SIMDJSON_IMPLEMENTATION::ondemand::value>> simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::object>::at_path_with_wildcard(std::string_view json_path) noexcept {
+#if SIMDJSON_SUPPORTS_CONCEPTS
+template <typename Func>
+  requires std::invocable<Func, SIMDJSON_IMPLEMENTATION::ondemand::value>
+#else
+template <typename Func>
+#endif
+simdjson_inline error_code simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::object>::for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept {
  if (error()) { return error(); }
-  return first.at_path_with_wildcard(json_path);
+  return first.for_each_at_path_with_wildcard(json_path, std::forward<Func>(callback));
 }

 inline simdjson_result<bool> simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::object>::reset() noexcept {
@@ -172,13 +172,21 @@ public:
  inline simdjson_result<value> at_path(std::string_view json_path) noexcept;

  /**
-   * Get all values matching the given JSONPath expression with wildcard support.
+   * Call the provided callback for each value matching the given JSONPath
+   * expression with wildcard support.
   * Supports wildcard patterns like ".*" to match all object fields.
   *
   * @param json_path JSONPath expression with wildcards
-   * @return Vector of values matching the wildcard pattern
+   * @param callback Function called for each matching value
+   * @return error_code indicating success or failure
  */
-  inline simdjson_result<std::vector<value>> at_path_with_wildcard(std::string_view json_path) noexcept;
+#if SIMDJSON_SUPPORTS_CONCEPTS
+  template <typename Func>
+    requires std::invocable<Func, value>
+#else
+  template <typename Func>
+#endif
+  inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept;

  /**
   * Reset the iterator so that we are pointing back at the
@@ -328,7 +336,13 @@ public:
  simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> operator[](std::string_view key) && noexcept;
  simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> at_pointer(std::string_view json_pointer) noexcept;
  simdjson_inline simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value> at_path(std::string_view json_path) noexcept;
-  simdjson_inline simdjson_result<std::vector<SIMDJSON_IMPLEMENTATION::ondemand::value>> at_path_with_wildcard(std::string_view json_path) noexcept;
+#if SIMDJSON_SUPPORTS_CONCEPTS
+  template <typename Func>
+    requires std::invocable<Func, SIMDJSON_IMPLEMENTATION::ondemand::value>
+#else
+  template <typename Func>
+#endif
+  simdjson_inline error_code for_each_at_path_with_wildcard(std::string_view json_path, Func&& callback) noexcept;
  inline simdjson_result<bool> reset() noexcept;
  inline simdjson_result<bool> is_empty() noexcept;
  inline simdjson_result<size_t> count_fields() & noexcept;
@@ -27,7 +27,10 @@ simdjson_warn_unused simdjson_inline error_code parser::allocate(size_t new_capa

  // string_capacity copied from document::allocate
  _capacity = 0;
-  size_t string_capacity = SIMDJSON_ROUNDUP_N(5 * new_capacity / 3 + SIMDJSON_PADDING, 64);
+  if(5 * (new_capacity / 3) + SIMDJSON_PADDING < SIMDJSON_PADDING) {
+    return CAPACITY; // overflow, only happen on legacy 32-bit systems with very large capacity
+  }
+  size_t string_capacity = SIMDJSON_ROUNDUP_N(5 * (new_capacity / 3) + SIMDJSON_PADDING, 64);
  string_buf.reset(new (std::nothrow) uint8_t[string_capacity]);
 #if SIMDJSON_DEVELOPMENT_CHECKS
  start_positions.reset(new (std::nothrow) token_position[new_max_depth]);
@@ -133,6 +136,34 @@ 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; }
@@ -140,8 +171,11 @@ inline simdjson_result<document_stream> parser::iterate_many(const uint8_t *buf,
    buf += 3;
    len -= 3;
  }
-  if(allow_comma_separated && batch_size < len) { batch_size = len; }
-  return document_stream(*this, buf, len, batch_size, allow_comma_separated);
+  // 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);
 }

 inline simdjson_result<document_stream> parser::iterate_many(const char *buf, size_t len, size_t batch_size, bool allow_comma_separated) noexcept {
@@ -161,6 +195,48 @@ 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;
 }
@@ -172,7 +248,7 @@ simdjson_pure simdjson_inline size_t parser::max_depth() const noexcept {
 }

 simdjson_inline void parser::set_max_capacity(size_t max_capacity) noexcept {
-  if(max_capacity < dom::MINIMAL_DOCUMENT_CAPACITY) {
+  if(max_capacity > dom::MINIMAL_DOCUMENT_CAPACITY) {
    _max_capacity = max_capacity;
  } else {
    _max_capacity = dom::MINIMAL_DOCUMENT_CAPACITY;
@@ -199,7 +275,7 @@ simdjson_inline simdjson_warn_unused ondemand::parser& parser::get_parser() {
  return *parser::get_parser_instance();
 }

-simdjson_inline bool release_parser() {
+simdjson_inline bool parser::release_parser() {
  auto &parser_instance = parser::get_threadlocal_parser_if_exists();
  if (parser_instance) {
    parser_instance.reset();
@@ -244,32 +244,66 @@ 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 (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.
+   * @param allow_comma_separated @deprecated Use stream_format::comma_delimited instead.
+   *                   When true, maps internally to stream_format::comma_delimited.
+   *                   Defaults to false.
   * @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, 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)
+  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)
    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, 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;
+  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;
  /** @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). */
@@ -388,8 +422,6 @@ public:
  static simdjson_inline bool release_parser();

 private:
-  friend bool release_parser();
-  friend ondemand::parser& get_parser();
  /** Get the thread-local parser instance, allocates it if needed */
  static simdjson_inline simdjson_warn_unused std::unique_ptr<ondemand::parser>& get_parser_instance();
  /** Get the thread-local parser instance, it might be null */
@@ -425,4 +457,4 @@ public:

 } // namespace simdjson

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


+// Compile-time predicate: does T have any std::optional member?
+// Used to decide whether single-pass dispatch is worth it.
+template <typename T>
+consteval bool struct_has_optional_member() {
+  bool result = false;
+  template for (constexpr auto mem : std::define_static_array(std::meta::nonstatic_data_members_of(^^T, std::meta::access_context::unchecked()))) {
+    if constexpr (!std::meta::is_const(mem) && std::meta::is_public(mem)) {
+      using FieldT = [: std::meta::type_of(mem) :];
+      if constexpr (concepts::optional_type<FieldT>) {
+        result = true;
+      }
+    }
+  };
+  return result;
+}
+
 template <typename T, typename ValT>
  requires(user_defined_type<T> && std::is_class_v<T>)
 error_code tag_invoke(deserialize_tag, ValT &val, T &out) noexcept {
@@ -276,25 +292,42 @@ error_code tag_invoke(deserialize_tag, ValT &val, T &out) noexcept {
  } else {
    SIMDJSON_TRY(val.get_object().get(obj));
  }
-  template for (constexpr auto mem : std::define_static_array(std::meta::nonstatic_data_members_of(^^T, std::meta::access_context::unchecked()))) {
-    if constexpr (!std::meta::is_const(mem) && std::meta::is_public(mem)) {
-      constexpr std::string_view key = std::define_static_string(std::meta::identifier_of(mem));
-      if constexpr (concepts::optional_type<decltype(out.[:mem:])>) {
-        // for optional members, it's ok if the key is missing
-        auto error = obj[key].get(out.[:mem:]);
-        if (error && error != NO_SUCH_FIELD) {
-          if(error == NO_SUCH_FIELD) {
-            out.[:mem:].reset();
-            continue;
+  if constexpr (struct_has_optional_member<T>()) {
+    // Single-pass dispatch: walk each JSON object field once, dispatching
+    // to the matching struct member via a compile-time-generated key
+    // comparison chain (with length pre-filter). This avoids the O(K)
+    // full-object scan that obj[key] does for *absent* optional fields.
+    // Worth it when the struct has optionals because some are usually missing.
+    for (auto field : obj) {
+      std::string_view key;
+      SIMDJSON_TRY(field.unescaped_key().get(key));
+      bool matched = false;
+      const size_t key_size = key.size();
+      template for (constexpr auto mem : std::define_static_array(std::meta::nonstatic_data_members_of(^^T, std::meta::access_context::unchecked()))) {
+        if constexpr (!std::meta::is_const(mem) && std::meta::is_public(mem)) {
+          constexpr std::string_view name = std::define_static_string(std::meta::identifier_of(mem));
+          constexpr size_t name_size = name.size();
+          if (!matched && key_size == name_size && key == name) {
+            SIMDJSON_TRY(field.value().get(out.[:mem:]));
+            matched = true;
          }
-          return error;
        }
-      } else {
-        // for non-optional members, the key must be present
+      };
+      // Unmatched value is skipped automatically by object_iterator::operator++().
+      (void)matched;
+    }
+  } else {
+    // Per-field obj[key] dispatch: for structs with all-required fields,
+    // this is O(1) per field when the JSON keys are in declaration order
+    // (find_field_unordered's fast path). Beats single-pass on dense
+    // structs (e.g. Twitter Status with 22 always-present fields).
+    template for (constexpr auto mem : std::define_static_array(std::meta::nonstatic_data_members_of(^^T, std::meta::access_context::unchecked()))) {
+      if constexpr (!std::meta::is_const(mem) && std::meta::is_public(mem)) {
+        constexpr std::string_view key = std::define_static_string(std::meta::identifier_of(mem));
        SIMDJSON_TRY(obj[key].get(out.[:mem:]));
      }
-    }
-  };
+    };
+  }
  return simdjson::SUCCESS;
 }

@@ -305,7 +338,7 @@ error_code tag_invoke(deserialize_tag, ValT &val, T &out) noexcept {
 #if SIMDJSON_STATIC_REFLECTION
  std::string_view str;
  SIMDJSON_TRY(val.get_string().get(str));
-  constexpr auto enumerators = std::define_static_array(std::meta::enumerators_of(^^T));
+  static constexpr auto enumerators = std::define_static_array(std::meta::enumerators_of(^^T));
  template for (constexpr auto enum_val : enumerators) {
    if (str == std::meta::identifier_of(enum_val)) {
      out = [:enum_val:];
@@ -12,6 +12,8 @@
 #include "simdjson/generic/ondemand/value.h"
 #endif // SIMDJSON_CONDITIONAL_INCLUDE

+#include <limits>
+
 namespace simdjson {
 namespace SIMDJSON_IMPLEMENTATION {
 namespace ondemand {
@@ -72,6 +74,18 @@ simdjson_inline simdjson_result<int64_t> value::get_int64() noexcept {
 simdjson_inline simdjson_result<int64_t> value::get_int64_in_string() noexcept {
  return iter.get_int64_in_string();
 }
+simdjson_inline simdjson_result<uint32_t> value::get_uint32() noexcept {
+  uint64_t result;
+  SIMDJSON_TRY(get_uint64().get(result));
+  if (result > (std::numeric_limits<uint32_t>::max)()) { return NUMBER_OUT_OF_RANGE; }
+  return static_cast<uint32_t>(result);
+}
+simdjson_inline simdjson_result<int32_t> value::get_int32() noexcept {
+  int64_t result;
+  SIMDJSON_TRY(get_int64().get(result));
+  if (result > (std::numeric_limits<int32_t>::max)() || result < (std::numeric_limits<int32_t>::min)()) { return NUMBER_OUT_OF_RANGE; }
+  return static_cast<int32_t>(result);
+}
 simdjson_inline simdjson_result<bool> value::get_bool() noexcept {
  return iter.get_bool();
 }
@@ -87,6 +101,8 @@ template<> simdjson_inline simdjson_result<number> value::get() noexcept { retur
 template<> simdjson_inline simdjson_result<double> value::get() noexcept { return get_double(); }
 template<> simdjson_inline simdjson_result<uint64_t> value::get() noexcept { return get_uint64(); }
 template<> simdjson_inline simdjson_result<int64_t> value::get() noexcept { return get_int64(); }
+template<> simdjson_inline simdjson_result<uint32_t> value::get() noexcept { return get_uint32(); }
+template<> simdjson_inline simdjson_result<int32_t> value::get() noexcept { return get_int32(); }
 template<> simdjson_inline simdjson_result<bool> value::get() noexcept { return get_bool(); }


@@ -98,6 +114,8 @@ template<> simdjson_warn_unused simdjson_inline error_code value::get(number& ou
 template<> simdjson_warn_unused simdjson_inline error_code value::get(double& out) noexcept { return get_double().get(out); }
 template<> simdjson_warn_unused simdjson_inline error_code value::get(uint64_t& out) noexcept { return get_uint64().get(out); }
 template<> simdjson_warn_unused simdjson_inline error_code value::get(int64_t& out) noexcept { return get_int64().get(out); }
+template<> simdjson_warn_unused simdjson_inline error_code value::get(uint32_t& out) noexcept { return get_uint32().get(out); }
+template<> simdjson_warn_unused simdjson_inline error_code value::get(int32_t& out) noexcept { return get_int32().get(out); }
 template<>  simdjson_warn_unused simdjson_inline error_code value::get(bool& out) noexcept { return get_bool().get(out); }

 #if SIMDJSON_EXCEPTIONS
@@ -296,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;
  }
@@ -401,6 +425,14 @@ simdjson_inline simdjson_result<int64_t> simdjson_result<SIMDJSON_IMPLEMENTATION
  if (error()) { return error(); }
  return first.get_int64_in_string();
 }
+simdjson_inline simdjson_result<uint32_t> simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value>::get_uint32() noexcept {
+  if (error()) { return error(); }
+  return first.get_uint32();
+}
+simdjson_inline simdjson_result<int32_t> simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value>::get_int32() noexcept {
+  if (error()) { return error(); }
+  return first.get_int32();
+}
 simdjson_inline simdjson_result<double> simdjson_result<SIMDJSON_IMPLEMENTATION::ondemand::value>::get_double() noexcept {
  if (error()) { return error(); }
  return first.get_double();
@@ -559,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
@@ -161,6 +161,28 @@ public:
   */
  simdjson_inline simdjson_result<int64_t> get_int64_in_string() noexcept;

+  /**
+   * Cast this JSON value to a 32-bit unsigned integer.
+   *
+   * Calls get_uint64() and checks that the result fits in a uint32_t.
+   *
+   * @returns A 32-bit unsigned integer.
+   * @returns INCORRECT_TYPE If the JSON value is not an unsigned integer.
+   * @returns NUMBER_OUT_OF_RANGE If the value does not fit in a uint32_t.
+   */
+  simdjson_inline simdjson_result<uint32_t> get_uint32() noexcept;
+
+  /**
+   * Cast this JSON value to a 32-bit signed integer.
+   *
+   * Calls get_int64() and checks that the result fits in an int32_t.
+   *
+   * @returns A 32-bit signed integer.
+   * @returns INCORRECT_TYPE If the JSON value is not an integer.
+   * @returns NUMBER_OUT_OF_RANGE If the value does not fit in an int32_t.
+   */
+  simdjson_inline simdjson_result<int32_t> get_int32() noexcept;
+
  /**
   * Cast this JSON value to a double.
   *
@@ -676,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:
  /**
@@ -746,6 +776,8 @@ public:
  simdjson_inline simdjson_result<uint64_t> get_uint64_in_string() noexcept;
  simdjson_inline simdjson_result<int64_t> get_int64() noexcept;
  simdjson_inline simdjson_result<int64_t> get_int64_in_string() noexcept;
+  simdjson_inline simdjson_result<uint32_t> get_uint32() noexcept;
+  simdjson_inline simdjson_result<int32_t> get_int32() noexcept;
  simdjson_inline simdjson_result<double> get_double() noexcept;
  simdjson_inline simdjson_result<double> get_double_in_string() noexcept;
  simdjson_inline simdjson_result<std::string_view> get_string(bool allow_replacement = false) noexcept;
@@ -873,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
@@ -19,7 +19,12 @@ 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};
+enum class stage1_mode {
+  regular,
+  streaming_partial, streaming_final,
+  json_sequence_partial, json_sequence_final,
+  comma_delimited_partial, comma_delimited_final
+};

 /**
 * Returns true if mode == streaming_partial or mode == streaming_final
@@ -31,7 +36,6 @@ inline bool is_streaming(stage1_mode mode) {
  // return (mode == stage1_mode::streaming_partial || mode == stage1_mode::streaming_final);
 }

-
 namespace internal {


@@ -212,6 +216,12 @@ protected:
   */
  size_t _max_depth{0};

+public:
+  /** Whether to store big integers as strings instead of returning BIGINT_ERROR */
+  bool _number_as_string{false};
+
+protected:
+
  // Declaring these so that subclasses can use them to implement their constructors.
  simdjson_inline dom_parser_implementation() noexcept;
  simdjson_inline dom_parser_implementation(dom_parser_implementation &&other) noexcept;
@@ -19,7 +19,8 @@ enum class tape_type {
  DOUBLE = 'd',
  TRUE_VALUE = 't',
  FALSE_VALUE = 'f',
-  NULL_VALUE = 'n'
+  NULL_VALUE = 'n',
+  BIGINT = 'Z'  // Big integer stored as string in string buffer
 }; // enum class tape_type

 } // namespace internal
@@ -1,12 +1,55 @@
 #ifndef SIMDJSON_JSONPATHUTIL_H
 #define SIMDJSON_JSONPATHUTIL_H

+#include "simdjson/error.h"
 #include <string>
 #include "simdjson/common_defs.h"

+#include <limits>
 #include <utility>

 namespace simdjson {
+namespace internal {
+/**
+ * Parses the next JSON Pointer array index token.
+ *
+ * The caller passes a pointer fragment with no leading '/', such as "123/foo".
+ * On success, array_index receives the parsed index and token_length receives
+ * the number of bytes consumed before the next '/' or the end of the fragment.
+ */
+simdjson_inline error_code parse_json_pointer_array_index(std::string_view json_pointer,
+                                                          size_t &array_index,
+                                                          size_t &token_length) noexcept {
+  array_index = 0;
+  token_length = 0;
+
+  for (; token_length < json_pointer.length() && json_pointer[token_length] != '/';
+       token_length++) {
+    uint8_t digit = uint8_t(json_pointer[token_length] - '0');
+    // Check for non-digit in array index. If it's there, we're trying to get a field in an object.
+    if (digit > 9) {
+      return INCORRECT_TYPE;
+    }
+    // 0 followed by other digits is invalid.
+    if (token_length > 0 && json_pointer[0] == '0') {
+      return INVALID_JSON_POINTER;
+    }
+    if (array_index >
+        (((std::numeric_limits<size_t>::max)() - digit) / 10)) {
+      return INDEX_OUT_OF_BOUNDS;
+    }
+    array_index = array_index * 10 + digit;
+  }
+
+  // Empty string is invalid; so is a "/" with no digits before it.
+  if (token_length == 0) {
+    return INVALID_JSON_POINTER;
+  }
+
+  return SUCCESS;
+}
+} // namespace internal
+
 /**
 * Converts JSONPath to JSON Pointer.
 * @param json_path The JSONPath string to be converted.
@@ -10,13 +10,18 @@
 #include <climits>
 #include <cwchar>

-#ifndef _WIN32
+#if SIMDJSON_HAS_UNISTD_H
 #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 {
@@ -168,10 +173,13 @@ inline padded_string::operator padded_string_view() const noexcept simdjson_life
 }

 inline simdjson_result<padded_string> padded_string::load(std::string_view filename) noexcept {
+  // std::string_view is not guaranteed to be null-terminated, but std::fopen requires
+  // a null-terminated C string. Construct a temporary std::string to ensure null-termination.
+  const std::string null_terminated_filename(filename);
  // Open the file
  SIMDJSON_PUSH_DISABLE_WARNINGS
  SIMDJSON_DISABLE_DEPRECATED_WARNING // Disable CRT_SECURE warning on MSVC: manually verified this is safe
-  std::FILE *fp = std::fopen(filename.data(), "rb");
+  std::FILE *fp = std::fopen(null_terminated_filename.c_str(), "rb");
  SIMDJSON_POP_DISABLE_WARNINGS

  if (fp == nullptr) {
@@ -223,10 +231,13 @@ inline simdjson_result<padded_string> padded_string::load(std::string_view filen

 #if defined(_WIN32) && SIMDJSON_CPLUSPLUS17
 inline simdjson_result<padded_string> padded_string::load(std::wstring_view filename) noexcept {
+  // std::wstring_view is not guaranteed to be null-terminated, but _wfopen requires
+  // a null-terminated wide C string. Construct a temporary std::wstring to ensure null-termination.
+  const std::wstring null_terminated_filename(filename);
  // Open the file using the wide characters
  SIMDJSON_PUSH_DISABLE_WARNINGS
  SIMDJSON_DISABLE_DEPRECATED_WARNING // Disable CRT_SECURE warning on MSVC: manually verified this is safe
-  std::FILE *fp = _wfopen(filename.data(), L"rb");
+  std::FILE *fp = _wfopen(null_terminated_filename.c_str(), L"rb");
  SIMDJSON_POP_DISABLE_WARNINGS

  if (fp == nullptr) {
@@ -349,6 +360,9 @@ inline padded_string padded_string_builder::convert() noexcept {
 }

 inline bool padded_string_builder::reserve(size_t additional) noexcept {
+  if (simdjson_unlikely(additional + size < size)) {
+    return false; // overflow: cannot satisfy request
+  }
  size_t needed = size + additional;
  if (needed <= capacity) {
    return true;
@@ -358,8 +372,9 @@ inline bool padded_string_builder::reserve(size_t additional) noexcept {
  // repeated allocations.
  if (new_capacity < 4096) {
    new_capacity *= 2;
-  } else {
-    new_capacity += new_capacity/2; // grow by 1.5x
+    // overflow guard: ensure new_capacity + new_capacity/2 does not overflow
+  } else if (new_capacity + new_capacity / 2 > new_capacity) {
+    new_capacity += new_capacity / 2; // grow by 1.5x
  }
  char *new_data = internal::allocate_padded_buffer(new_capacity);
  if (new_data == nullptr) {
@@ -375,7 +390,9 @@ inline bool padded_string_builder::reserve(size_t additional) noexcept {
 }


-#ifndef _WIN32
+#if SIMDJSON_HAS_PADDED_MEMORY_MAP
+
+#if SIMDJSON_HAS_UNISTD_H
 simdjson_inline padded_memory_map::padded_memory_map(const char *filename) noexcept {

    int fd = open(filename, O_RDONLY);
@@ -411,7 +428,132 @@ 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()) {
@@ -423,7 +565,8 @@ 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 // _WIN32
+
+#endif // SIMDJSON_HAS_PADDED_MEMORY_MAP

 } // namespace simdjson

@@ -277,11 +277,26 @@ 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

-
-#ifndef _WIN32
+#if SIMDJSON_HAS_PADDED_MEMORY_MAP
 /**
 * A class representing a memory-mapped file with padding.
- * It is only available on non-Windows platforms, as Windows has different APIs for memory mapping.
+ *
+ * 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`).
 */
 class padded_memory_map {
 public:
@@ -289,9 +304,11 @@ 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.
-   * 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.
+   * 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.
   * 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.
@@ -328,8 +345,14 @@ 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 // _WIN32
+#endif // SIMDJSON_HAS_PADDED_MEMORY_MAP



@@ -6,6 +6,15 @@

 #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
@@ -95,7 +104,83 @@ inline padded_string_view pad_with_reserve(std::string& s) noexcept {
  return padded_string_view(s.data(), s.size(), s.capacity());
 }

+inline uint32_t get_page_size() noexcept {
+#if defined(_WINDOWS_) // if and only if someone loaded Windows.h, we can get the page size from there.
+// Otherwise, we assume 4096.
+    static const uint32_t cached = []() -> uint32_t {
+      SYSTEM_INFO si;
+      GetSystemInfo(&si);
+      return static_cast<std::uint32_t>(si.dwPageSize);
+    }();
+    return cached;
+#elif 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

@@ -9,6 +9,9 @@
 #include <memory>
 #include <string>
 #include <ostream>
+#if SIMDJSON_CPLUSPLUS17
+#include <variant>
+#endif

 namespace simdjson {

@@ -73,6 +76,68 @@ public:

 }; // padded_string_view

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

 #endif // SIMDJSON_PADDED_STRING_VIEW_H
@@ -285,5 +285,53 @@ 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
@@ -4,7 +4,7 @@
 #define SIMDJSON_SIMDJSON_VERSION_H

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

 namespace simdjson {
 enum {
@@ -15,7 +15,7 @@ enum {
  /**
   * The minor version (major.MINOR.revision) of simdjson being used.
   */
-  SIMDJSON_VERSION_MINOR = 4,
+  SIMDJSON_VERSION_MINOR = 6,
  /**
   * The revision (major.minor.REVISION) of simdjson being used.
   */
@@ -0,0 +1,11 @@
+{
+  "app_name": "MyApp",
+  "version": "1.0.0",
+  "port": 8080,
+  "debug": true,
+  "features": ["logging", "caching"],
+  "database": {
+    "host": "localhost",
+    "port": 5432
+  }
+}
@@ -268,7 +268,21 @@ class SimdjsonFile:
        print(f"    Adding include: {self} includes {include}")
        if self.is_conditional_include:
            # If I have a dependency file, I can only include something that has a dependency file.
-            assert include.is_conditional_include, f"Error: Amalgamated file '{self}' is trying to include '{include}', but '{include}' is not an amalgamated file. Amalgamated files can only include other amalgamated files to maintain conditional inclusion structure. Check the inclusion rules in the script's 'rules' variable. {rules}"
+            if not include.is_conditional_include:
+                dep = self.dependency_file
+                dep_hint = f" and add it to the dependency file '{dep}'" if dep else ""
+                raise AssertionError(
+                    f"Error: Amalgamated file '{self}' is trying to include '{include}', "
+                    f"but '{include}' is not an amalgamated file.\n\n"
+                    f"FIX: Wrap the #include \"{include}\" in a conditional block:\n\n"
+                    f"    #ifndef SIMDJSON_CONDITIONAL_INCLUDE\n"
+                    f"    #include \"{include}\"\n"
+                    f"    #endif // SIMDJSON_CONDITIONAL_INCLUDE\n\n"
+                    f"This makes the include editor-only (skipped during amalgamation){dep_hint}.\n\n"
+                    f"During amalgamation, '{include}' is already included earlier in the "
+                    f"amalgamated output, so it does not need to be included again.\n\n"
+                    f"{rules}"
+                )
            # TODO make sure we only include amalgamated files that are guaranteed to be included with us (or before us)
            # if include.amalgamator_file:
            #     assert include.amalgamator_file == self, f"{self} cannot include {include}: it should be included from {include.amalgamator_file} instead."
@@ -425,8 +439,10 @@ class Amalgamator:
            self.implementation = "SIMDJSON_BUILTIN_IMPLEMENTATION"

        assert not self.editor_only_region, f"Error: Already in an editor-only region when starting to write '{file}'. Ensure proper nesting of conditional blocks."
+        editor_only_start_line = None
+        bare_endif_lines = []
        with open(file.absolute_path, 'r') as fid2:
-            for line in fid2:
+            for line_number, line in enumerate(fid2, 1):
                line = line.rstrip('\n')

                # Ignore #pragma once, it causes warnings if it ends up in a .cpp file
@@ -439,6 +455,7 @@ class Amalgamator:
                    assert self.in_conditional_include_block, f"Error: File '{file}' uses '#ifndef SIMDJSON_CONDITIONAL_INCLUDE' without a prior '#define SIMDJSON_CONDITIONAL_INCLUDE'. Ensure the define comes first. Stack: {self.include_stack}. {rules}"
                    assert not self.editor_only_region, f"Error: File '{file}' uses '#ifndef SIMDJSON_CONDITIONAL_INCLUDE' twice in a row. Ensure conditional blocks are properly nested and closed. {rules}"
                    self.editor_only_region = True
+                    editor_only_start_line = line_number

                # Handle ignored lines (and ending ignore blocks)
                end_ignore = endif_conditional_re.search(line)
@@ -453,6 +470,12 @@ class Amalgamator:
                            file.add_editor_only_include(included_file)
                    if end_ignore:
                        self.editor_only_region = False
+                        editor_only_start_line = None
+                    else:
+                        # Track bare #endif lines that might be the intended closer
+                        stripped = line.strip()
+                        if stripped == '#endif' or (stripped.startswith('#endif') and 'SIMDJSON_CONDITIONAL_INCLUDE' not in stripped):
+                            bare_endif_lines.append((line_number, line.strip()))
                    continue

                assert not end_ignore, f"Error: File '{file}' has '#endif // SIMDJSON_CONDITIONAL_INCLUDE' without a matching '#ifndef'. Ensure proper conditional block structure. {rules}"
@@ -501,7 +524,35 @@ class Amalgamator:

                self.write(line)

-            assert not self.editor_only_region, f"Error: File '{file}' ended without closing the '#endif // SIMDJSON_CONDITIONAL_INCLUDE'. Ensure all conditional blocks are properly closed. {rules}"
+            if self.editor_only_region:
+                msg = (
+                    f"Error: File '{file}' ended without closing the "
+                    f"'#endif // SIMDJSON_CONDITIONAL_INCLUDE' block "
+                    f"(opened at line {editor_only_start_line}).\n\n"
+                )
+                if bare_endif_lines:
+                    msg += (
+                        f"HINT: Found #endif line(s) inside the block that are missing "
+                        f"the required comment. The amalgamation script looks for exactly:\n\n"
+                        f"    #endif // SIMDJSON_CONDITIONAL_INCLUDE\n\n"
+                        f"but found:\n"
+                    )
+                    for ln, text in bare_endif_lines:
+                        msg += f"    line {ln}: {text}\n"
+                    msg += (
+                        f"\nFIX: Change the #endif to:\n\n"
+                        f"    #endif // SIMDJSON_CONDITIONAL_INCLUDE\n\n"
+                        f"The '// SIMDJSON_CONDITIONAL_INCLUDE' comment is required "
+                        f"for the amalgamation script to recognize it as the closing "
+                        f"of the conditional block.\n"
+                    )
+                else:
+                    msg += (
+                        f"FIX: Add '#endif // SIMDJSON_CONDITIONAL_INCLUDE' to close "
+                        f"the '#ifndef SIMDJSON_CONDITIONAL_INCLUDE' block.\n"
+                    )
+                msg += f"\n{rules}"
+                raise AssertionError(msg)

        self.write(f"/* end file {self.file_to_str(file)} */")

@@ -1,4 +1,4 @@
-/* auto-generated on 2026-03-17 12:38:11 -0400. version 4.4.1 Do not edit! */
+/* auto-generated on 2026-04-02 19:14:16 -0400. version 4.6.1 Do not edit! */
 /* including simdjson.cpp:  */
 /* begin file simdjson.cpp */
 #define SIMDJSON_SRC_SIMDJSON_CPP
@@ -3168,6 +3168,11 @@ struct fixed_string {
            data[i] = str[i];
        }
    }
+    constexpr fixed_string(const unsigned char (&str)[N])  {
+        for (std::size_t i = 0; i < N; ++i) {
+            data[i] = static_cast<char>(str[i]);
+        }
+    }
    char data[N];
    constexpr std::string_view view() const { return {data, N - 1}; }
    constexpr size_t size() const { return N ; }
@@ -7308,6 +7313,12 @@ protected:
   */
  size_t _max_depth{0};

+public:
+  /** Whether to store big integers as strings instead of returning BIGINT_ERROR */
+  bool _number_as_string{false};
+
+protected:
+
  // Declaring these so that subclasses can use them to implement their constructors.
  simdjson_inline dom_parser_implementation() noexcept;
  simdjson_inline dom_parser_implementation(dom_parser_implementation &&other) noexcept;
@@ -7883,7 +7894,8 @@ enum class tape_type {
  DOUBLE = 'd',
  TRUE_VALUE = 't',
  FALSE_VALUE = 'f',
-  NULL_VALUE = 'n'
+  NULL_VALUE = 'n',
+  BIGINT = 'Z'  // Big integer stored as string in string buffer
 }; // enum class tape_type

 } // namespace internal
@@ -14178,6 +14190,9 @@ struct tape_writer {
  /** Write a double value to tape. */
  simdjson_inline void append_double(double value) noexcept;

+  /** Write a big integer (as string) to tape. src points to first digit, len is byte count. */
+  simdjson_inline void append_bigint(const uint8_t *src, size_t len, uint8_t *&string_buf) noexcept;
+
  /**
   * Append a tape entry (an 8-bit type,and 56 bits worth of value).
   */
@@ -14261,6 +14276,18 @@ simdjson_inline void tape_writer::write(uint64_t &tape_loc, uint64_t val, intern
  tape_loc = val | ((uint64_t(char(t))) << 56);
 }

+simdjson_inline void tape_writer::append_bigint(const uint8_t *src, size_t len, uint8_t *&string_buf) noexcept {
+  // Write to string buffer: [4-byte LE length][digits][null]
+  uint32_t str_len = uint32_t(len);
+  memcpy(string_buf, &str_len, sizeof(uint32_t));
+  memcpy(string_buf + sizeof(uint32_t), src, len);
+  string_buf[sizeof(uint32_t) + len] = 0;
+  // Tape entry: offset into string buffer
+  // The caller must set the offset relative to doc.string_buf base
+  append(0, internal::tape_type::BIGINT); // placeholder offset, caller patches
+  string_buf += sizeof(uint32_t) + len + 1;
+}
+
 } // namespace stage2
 } // unnamed namespace
 } // namespace arm64
@@ -15198,7 +15225,23 @@ simdjson_warn_unused simdjson_inline error_code tape_builder::visit_root_string(

 simdjson_warn_unused simdjson_inline error_code tape_builder::visit_number(json_iterator &iter, const uint8_t *value) noexcept {
  iter.log_value("number");
-  return numberparsing::parse_number(value, tape);
+  error_code err = numberparsing::parse_number(value, tape);
+  if (simdjson_unlikely(err == BIGINT_ERROR &&
+      iter.dom_parser._number_as_string)) {
+    // Write big integer to string buffer using the same format as strings.
+    // Scan digits the same way parse_number does (skip optional '-', then digits).
+    const uint8_t *p = value;
+    if (*p == '-') p++;
+    while (numberparsing::is_digit(*p)) p++;
+    size_t len = size_t(p - value);
+    tape.append(current_string_buf_loc - iter.dom_parser.doc->string_buf.get(), internal::tape_type::BIGINT);
+    uint8_t *dst = current_string_buf_loc + sizeof(uint32_t);
+    memcpy(dst, value, len);
+    dst += len;
+    on_end_string(dst);
+    return SUCCESS;
+  }
+  return err;
 }

 simdjson_warn_unused simdjson_inline error_code tape_builder::visit_root_number(json_iterator &iter, const uint8_t *value) noexcept {
@@ -20539,6 +20582,9 @@ struct tape_writer {
  /** Write a double value to tape. */
  simdjson_inline void append_double(double value) noexcept;

+  /** Write a big integer (as string) to tape. src points to first digit, len is byte count. */
+  simdjson_inline void append_bigint(const uint8_t *src, size_t len, uint8_t *&string_buf) noexcept;
+
  /**
   * Append a tape entry (an 8-bit type,and 56 bits worth of value).
   */
@@ -20622,6 +20668,18 @@ simdjson_inline void tape_writer::write(uint64_t &tape_loc, uint64_t val, intern
  tape_loc = val | ((uint64_t(char(t))) << 56);
 }

+simdjson_inline void tape_writer::append_bigint(const uint8_t *src, size_t len, uint8_t *&string_buf) noexcept {
+  // Write to string buffer: [4-byte LE length][digits][null]
+  uint32_t str_len = uint32_t(len);
+  memcpy(string_buf, &str_len, sizeof(uint32_t));
+  memcpy(string_buf + sizeof(uint32_t), src, len);
+  string_buf[sizeof(uint32_t) + len] = 0;
+  // Tape entry: offset into string buffer
+  // The caller must set the offset relative to doc.string_buf base
+  append(0, internal::tape_type::BIGINT); // placeholder offset, caller patches
+  string_buf += sizeof(uint32_t) + len + 1;
+}
+
 } // namespace stage2
 } // unnamed namespace
 } // namespace haswell
@@ -21559,7 +21617,23 @@ simdjson_warn_unused simdjson_inline error_code tape_builder::visit_root_string(

 simdjson_warn_unused simdjson_inline error_code tape_builder::visit_number(json_iterator &iter, const uint8_t *value) noexcept {
  iter.log_value("number");
-  return numberparsing::parse_number(value, tape);
+  error_code err = numberparsing::parse_number(value, tape);
+  if (simdjson_unlikely(err == BIGINT_ERROR &&
+      iter.dom_parser._number_as_string)) {
+    // Write big integer to string buffer using the same format as strings.
+    // Scan digits the same way parse_number does (skip optional '-', then digits).
+    const uint8_t *p = value;
+    if (*p == '-') p++;
+    while (numberparsing::is_digit(*p)) p++;
+    size_t len = size_t(p - value);
+    tape.append(current_string_buf_loc - iter.dom_parser.doc->string_buf.get(), internal::tape_type::BIGINT);
+    uint8_t *dst = current_string_buf_loc + sizeof(uint32_t);
+    memcpy(dst, value, len);
+    dst += len;
+    on_end_string(dst);
+    return SUCCESS;
+  }
+  return err;
 }

 simdjson_warn_unused simdjson_inline error_code tape_builder::visit_root_number(json_iterator &iter, const uint8_t *value) noexcept {
@@ -26895,6 +26969,9 @@ struct tape_writer {
  /** Write a double value to tape. */
  simdjson_inline void append_double(double value) noexcept;

+  /** Write a big integer (as string) to tape. src points to first digit, len is byte count. */
+  simdjson_inline void append_bigint(const uint8_t *src, size_t len, uint8_t *&string_buf) noexcept;
+
  /**
   * Append a tape entry (an 8-bit type,and 56 bits worth of value).
   */
@@ -26978,6 +27055,18 @@ simdjson_inline void tape_writer::write(uint64_t &tape_loc, uint64_t val, intern
  tape_loc = val | ((uint64_t(char(t))) << 56);
 }

+simdjson_inline void tape_writer::append_bigint(const uint8_t *src, size_t len, uint8_t *&string_buf) noexcept {
+  // Write to string buffer: [4-byte LE length][digits][null]
+  uint32_t str_len = uint32_t(len);
+  memcpy(string_buf, &str_len, sizeof(uint32_t));
+  memcpy(string_buf + sizeof(uint32_t), src, len);
+  string_buf[sizeof(uint32_t) + len] = 0;
+  // Tape entry: offset into string buffer
+  // The caller must set the offset relative to doc.string_buf base
+  append(0, internal::tape_type::BIGINT); // placeholder offset, caller patches
+  string_buf += sizeof(uint32_t) + len + 1;
+}
+
 } // namespace stage2
 } // unnamed namespace
 } // namespace icelake
@@ -27915,7 +28004,23 @@ simdjson_warn_unused simdjson_inline error_code tape_builder::visit_root_string(

 simdjson_warn_unused simdjson_inline error_code tape_builder::visit_number(json_iterator &iter, const uint8_t *value) noexcept {
  iter.log_value("number");
-  return numberparsing::parse_number(value, tape);
+  error_code err = numberparsing::parse_number(value, tape);
+  if (simdjson_unlikely(err == BIGINT_ERROR &&
+      iter.dom_parser._number_as_string)) {
+    // Write big integer to string buffer using the same format as strings.
+    // Scan digits the same way parse_number does (skip optional '-', then digits).
+    const uint8_t *p = value;
+    if (*p == '-') p++;
+    while (numberparsing::is_digit(*p)) p++;
+    size_t len = size_t(p - value);
+    tape.append(current_string_buf_loc - iter.dom_parser.doc->string_buf.get(), internal::tape_type::BIGINT);
+    uint8_t *dst = current_string_buf_loc + sizeof(uint32_t);
+    memcpy(dst, value, len);
+    dst += len;
+    on_end_string(dst);
+    return SUCCESS;
+  }
+  return err;
 }

 simdjson_warn_unused simdjson_inline error_code tape_builder::visit_root_number(json_iterator &iter, const uint8_t *value) noexcept {
@@ -33522,6 +33627,9 @@ struct tape_writer {
  /** Write a double value to tape. */
  simdjson_inline void append_double(double value) noexcept;

+  /** Write a big integer (as string) to tape. src points to first digit, len is byte count. */
+  simdjson_inline void append_bigint(const uint8_t *src, size_t len, uint8_t *&string_buf) noexcept;
+
  /**
   * Append a tape entry (an 8-bit type,and 56 bits worth of value).
   */
@@ -33605,6 +33713,18 @@ simdjson_inline void tape_writer::write(uint64_t &tape_loc, uint64_t val, intern
  tape_loc = val | ((uint64_t(char(t))) << 56);
 }

+simdjson_inline void tape_writer::append_bigint(const uint8_t *src, size_t len, uint8_t *&string_buf) noexcept {
+  // Write to string buffer: [4-byte LE length][digits][null]
+  uint32_t str_len = uint32_t(len);
+  memcpy(string_buf, &str_len, sizeof(uint32_t));
+  memcpy(string_buf + sizeof(uint32_t), src, len);
+  string_buf[sizeof(uint32_t) + len] = 0;
+  // Tape entry: offset into string buffer
+  // The caller must set the offset relative to doc.string_buf base
+  append(0, internal::tape_type::BIGINT); // placeholder offset, caller patches
+  string_buf += sizeof(uint32_t) + len + 1;
+}
+
 } // namespace stage2
 } // unnamed namespace
 } // namespace ppc64
@@ -34542,7 +34662,23 @@ simdjson_warn_unused simdjson_inline error_code tape_builder::visit_root_string(

 simdjson_warn_unused simdjson_inline error_code tape_builder::visit_number(json_iterator &iter, const uint8_t *value) noexcept {
  iter.log_value("number");
-  return numberparsing::parse_number(value, tape);
+  error_code err = numberparsing::parse_number(value, tape);
+  if (simdjson_unlikely(err == BIGINT_ERROR &&
+      iter.dom_parser._number_as_string)) {
+    // Write big integer to string buffer using the same format as strings.
+    // Scan digits the same way parse_number does (skip optional '-', then digits).
+    const uint8_t *p = value;
+    if (*p == '-') p++;
+    while (numberparsing::is_digit(*p)) p++;
+    size_t len = size_t(p - value);
+    tape.append(current_string_buf_loc - iter.dom_parser.doc->string_buf.get(), internal::tape_type::BIGINT);
+    uint8_t *dst = current_string_buf_loc + sizeof(uint32_t);
+    memcpy(dst, value, len);
+    dst += len;
+    on_end_string(dst);
+    return SUCCESS;
+  }
+  return err;
 }

 simdjson_warn_unused simdjson_inline error_code tape_builder::visit_root_number(json_iterator &iter, const uint8_t *value) noexcept {
@@ -40711,6 +40847,9 @@ struct tape_writer {
  /** Write a double value to tape. */
  simdjson_inline void append_double(double value) noexcept;

+  /** Write a big integer (as string) to tape. src points to first digit, len is byte count. */
+  simdjson_inline void append_bigint(const uint8_t *src, size_t len, uint8_t *&string_buf) noexcept;
+
  /**
   * Append a tape entry (an 8-bit type,and 56 bits worth of value).
   */
@@ -40794,6 +40933,18 @@ simdjson_inline void tape_writer::write(uint64_t &tape_loc, uint64_t val, intern
  tape_loc = val | ((uint64_t(char(t))) << 56);
 }

+simdjson_inline void tape_writer::append_bigint(const uint8_t *src, size_t len, uint8_t *&string_buf) noexcept {
+  // Write to string buffer: [4-byte LE length][digits][null]
+  uint32_t str_len = uint32_t(len);
+  memcpy(string_buf, &str_len, sizeof(uint32_t));
+  memcpy(string_buf + sizeof(uint32_t), src, len);
+  string_buf[sizeof(uint32_t) + len] = 0;
+  // Tape entry: offset into string buffer
+  // The caller must set the offset relative to doc.string_buf base
+  append(0, internal::tape_type::BIGINT); // placeholder offset, caller patches
+  string_buf += sizeof(uint32_t) + len + 1;
+}
+
 } // namespace stage2
 } // unnamed namespace
 } // namespace westmere
@@ -41731,7 +41882,23 @@ simdjson_warn_unused simdjson_inline error_code tape_builder::visit_root_string(

 simdjson_warn_unused simdjson_inline error_code tape_builder::visit_number(json_iterator &iter, const uint8_t *value) noexcept {
  iter.log_value("number");
-  return numberparsing::parse_number(value, tape);
+  error_code err = numberparsing::parse_number(value, tape);
+  if (simdjson_unlikely(err == BIGINT_ERROR &&
+      iter.dom_parser._number_as_string)) {
+    // Write big integer to string buffer using the same format as strings.
+    // Scan digits the same way parse_number does (skip optional '-', then digits).
+    const uint8_t *p = value;
+    if (*p == '-') p++;
+    while (numberparsing::is_digit(*p)) p++;
+    size_t len = size_t(p - value);
+    tape.append(current_string_buf_loc - iter.dom_parser.doc->string_buf.get(), internal::tape_type::BIGINT);
+    uint8_t *dst = current_string_buf_loc + sizeof(uint32_t);
+    memcpy(dst, value, len);
+    dst += len;
+    on_end_string(dst);
+    return SUCCESS;
+  }
+  return err;
 }

 simdjson_warn_unused simdjson_inline error_code tape_builder::visit_root_number(json_iterator &iter, const uint8_t *value) noexcept {
@@ -46931,6 +47098,9 @@ struct tape_writer {
  /** Write a double value to tape. */
  simdjson_inline void append_double(double value) noexcept;

+  /** Write a big integer (as string) to tape. src points to first digit, len is byte count. */
+  simdjson_inline void append_bigint(const uint8_t *src, size_t len, uint8_t *&string_buf) noexcept;
+
  /**
   * Append a tape entry (an 8-bit type,and 56 bits worth of value).
   */
@@ -47014,6 +47184,18 @@ simdjson_inline void tape_writer::write(uint64_t &tape_loc, uint64_t val, intern
  tape_loc = val | ((uint64_t(char(t))) << 56);
 }

+simdjson_inline void tape_writer::append_bigint(const uint8_t *src, size_t len, uint8_t *&string_buf) noexcept {
+  // Write to string buffer: [4-byte LE length][digits][null]
+  uint32_t str_len = uint32_t(len);
+  memcpy(string_buf, &str_len, sizeof(uint32_t));
+  memcpy(string_buf + sizeof(uint32_t), src, len);
+  string_buf[sizeof(uint32_t) + len] = 0;
+  // Tape entry: offset into string buffer
+  // The caller must set the offset relative to doc.string_buf base
+  append(0, internal::tape_type::BIGINT); // placeholder offset, caller patches
+  string_buf += sizeof(uint32_t) + len + 1;
+}
+
 } // namespace stage2
 } // unnamed namespace
 } // namespace lasx
@@ -47951,7 +48133,23 @@ simdjson_warn_unused simdjson_inline error_code tape_builder::visit_root_string(

 simdjson_warn_unused simdjson_inline error_code tape_builder::visit_number(json_iterator &iter, const uint8_t *value) noexcept {
  iter.log_value("number");
-  return numberparsing::parse_number(value, tape);
+  error_code err = numberparsing::parse_number(value, tape);
+  if (simdjson_unlikely(err == BIGINT_ERROR &&
+      iter.dom_parser._number_as_string)) {
+    // Write big integer to string buffer using the same format as strings.
+    // Scan digits the same way parse_number does (skip optional '-', then digits).
+    const uint8_t *p = value;
+    if (*p == '-') p++;
+    while (numberparsing::is_digit(*p)) p++;
+    size_t len = size_t(p - value);
+    tape.append(current_string_buf_loc - iter.dom_parser.doc->string_buf.get(), internal::tape_type::BIGINT);
+    uint8_t *dst = current_string_buf_loc + sizeof(uint32_t);
+    memcpy(dst, value, len);
+    dst += len;
+    on_end_string(dst);
+    return SUCCESS;
+  }
+  return err;
 }

 simdjson_warn_unused simdjson_inline error_code tape_builder::visit_root_number(json_iterator &iter, const uint8_t *value) noexcept {
@@ -53055,6 +53253,9 @@ struct tape_writer {
  /** Write a double value to tape. */
  simdjson_inline void append_double(double value) noexcept;

+  /** Write a big integer (as string) to tape. src points to first digit, len is byte count. */
+  simdjson_inline void append_bigint(const uint8_t *src, size_t len, uint8_t *&string_buf) noexcept;
+
  /**
   * Append a tape entry (an 8-bit type,and 56 bits worth of value).
   */
@@ -53138,6 +53339,18 @@ simdjson_inline void tape_writer::write(uint64_t &tape_loc, uint64_t val, intern
  tape_loc = val | ((uint64_t(char(t))) << 56);
 }

+simdjson_inline void tape_writer::append_bigint(const uint8_t *src, size_t len, uint8_t *&string_buf) noexcept {
+  // Write to string buffer: [4-byte LE length][digits][null]
+  uint32_t str_len = uint32_t(len);
+  memcpy(string_buf, &str_len, sizeof(uint32_t));
+  memcpy(string_buf + sizeof(uint32_t), src, len);
+  string_buf[sizeof(uint32_t) + len] = 0;
+  // Tape entry: offset into string buffer
+  // The caller must set the offset relative to doc.string_buf base
+  append(0, internal::tape_type::BIGINT); // placeholder offset, caller patches
+  string_buf += sizeof(uint32_t) + len + 1;
+}
+
 } // namespace stage2
 } // unnamed namespace
 } // namespace lsx
@@ -54075,7 +54288,23 @@ simdjson_warn_unused simdjson_inline error_code tape_builder::visit_root_string(

 simdjson_warn_unused simdjson_inline error_code tape_builder::visit_number(json_iterator &iter, const uint8_t *value) noexcept {
  iter.log_value("number");
-  return numberparsing::parse_number(value, tape);
+  error_code err = numberparsing::parse_number(value, tape);
+  if (simdjson_unlikely(err == BIGINT_ERROR &&
+      iter.dom_parser._number_as_string)) {
+    // Write big integer to string buffer using the same format as strings.
+    // Scan digits the same way parse_number does (skip optional '-', then digits).
+    const uint8_t *p = value;
+    if (*p == '-') p++;
+    while (numberparsing::is_digit(*p)) p++;
+    size_t len = size_t(p - value);
+    tape.append(current_string_buf_loc - iter.dom_parser.doc->string_buf.get(), internal::tape_type::BIGINT);
+    uint8_t *dst = current_string_buf_loc + sizeof(uint32_t);
+    memcpy(dst, value, len);
+    dst += len;
+    on_end_string(dst);
+    return SUCCESS;
+  }
+  return err;
 }

 simdjson_warn_unused simdjson_inline error_code tape_builder::visit_root_number(json_iterator &iter, const uint8_t *value) noexcept {
@@ -59598,6 +59827,9 @@ struct tape_writer {
  /** Write a double value to tape. */
  simdjson_inline void append_double(double value) noexcept;

+  /** Write a big integer (as string) to tape. src points to first digit, len is byte count. */
+  simdjson_inline void append_bigint(const uint8_t *src, size_t len, uint8_t *&string_buf) noexcept;
+
  /**
   * Append a tape entry (an 8-bit type,and 56 bits worth of value).
   */
@@ -59681,6 +59913,18 @@ simdjson_inline void tape_writer::write(uint64_t &tape_loc, uint64_t val, intern
  tape_loc = val | ((uint64_t(char(t))) << 56);
 }

+simdjson_inline void tape_writer::append_bigint(const uint8_t *src, size_t len, uint8_t *&string_buf) noexcept {
+  // Write to string buffer: [4-byte LE length][digits][null]
+  uint32_t str_len = uint32_t(len);
+  memcpy(string_buf, &str_len, sizeof(uint32_t));
+  memcpy(string_buf + sizeof(uint32_t), src, len);
+  string_buf[sizeof(uint32_t) + len] = 0;
+  // Tape entry: offset into string buffer
+  // The caller must set the offset relative to doc.string_buf base
+  append(0, internal::tape_type::BIGINT); // placeholder offset, caller patches
+  string_buf += sizeof(uint32_t) + len + 1;
+}
+
 } // namespace stage2
 } // unnamed namespace
 } // namespace rvv_vls
@@ -60618,7 +60862,23 @@ simdjson_warn_unused simdjson_inline error_code tape_builder::visit_root_string(

 simdjson_warn_unused simdjson_inline error_code tape_builder::visit_number(json_iterator &iter, const uint8_t *value) noexcept {
  iter.log_value("number");
-  return numberparsing::parse_number(value, tape);
+  error_code err = numberparsing::parse_number(value, tape);
+  if (simdjson_unlikely(err == BIGINT_ERROR &&
+      iter.dom_parser._number_as_string)) {
+    // Write big integer to string buffer using the same format as strings.
+    // Scan digits the same way parse_number does (skip optional '-', then digits).
+    const uint8_t *p = value;
+    if (*p == '-') p++;
+    while (numberparsing::is_digit(*p)) p++;
+    size_t len = size_t(p - value);
+    tape.append(current_string_buf_loc - iter.dom_parser.doc->string_buf.get(), internal::tape_type::BIGINT);
+    uint8_t *dst = current_string_buf_loc + sizeof(uint32_t);
+    memcpy(dst, value, len);
+    dst += len;
+    on_end_string(dst);
+    return SUCCESS;
+  }
+  return err;
 }

 simdjson_warn_unused simdjson_inline error_code tape_builder::visit_root_number(json_iterator &iter, const uint8_t *value) noexcept {
@@ -64189,6 +64449,9 @@ struct tape_writer {
  /** Write a double value to tape. */
  simdjson_inline void append_double(double value) noexcept;

+  /** Write a big integer (as string) to tape. src points to first digit, len is byte count. */
+  simdjson_inline void append_bigint(const uint8_t *src, size_t len, uint8_t *&string_buf) noexcept;
+
  /**
   * Append a tape entry (an 8-bit type,and 56 bits worth of value).
   */
@@ -64272,6 +64535,18 @@ simdjson_inline void tape_writer::write(uint64_t &tape_loc, uint64_t val, intern
  tape_loc = val | ((uint64_t(char(t))) << 56);
 }

+simdjson_inline void tape_writer::append_bigint(const uint8_t *src, size_t len, uint8_t *&string_buf) noexcept {
+  // Write to string buffer: [4-byte LE length][digits][null]
+  uint32_t str_len = uint32_t(len);
+  memcpy(string_buf, &str_len, sizeof(uint32_t));
+  memcpy(string_buf + sizeof(uint32_t), src, len);
+  string_buf[sizeof(uint32_t) + len] = 0;
+  // Tape entry: offset into string buffer
+  // The caller must set the offset relative to doc.string_buf base
+  append(0, internal::tape_type::BIGINT); // placeholder offset, caller patches
+  string_buf += sizeof(uint32_t) + len + 1;
+}
+
 } // namespace stage2
 } // unnamed namespace
 } // namespace fallback
@@ -64455,7 +64730,23 @@ simdjson_warn_unused simdjson_inline error_code tape_builder::visit_root_string(

 simdjson_warn_unused simdjson_inline error_code tape_builder::visit_number(json_iterator &iter, const uint8_t *value) noexcept {
  iter.log_value("number");
-  return numberparsing::parse_number(value, tape);
+  error_code err = numberparsing::parse_number(value, tape);
+  if (simdjson_unlikely(err == BIGINT_ERROR &&
+      iter.dom_parser._number_as_string)) {
+    // Write big integer to string buffer using the same format as strings.
+    // Scan digits the same way parse_number does (skip optional '-', then digits).
+    const uint8_t *p = value;
+    if (*p == '-') p++;
+    while (numberparsing::is_digit(*p)) p++;
+    size_t len = size_t(p - value);
+    tape.append(current_string_buf_loc - iter.dom_parser.doc->string_buf.get(), internal::tape_type::BIGINT);
+    uint8_t *dst = current_string_buf_loc + sizeof(uint32_t);
+    memcpy(dst, value, len);
+    dst += len;
+    on_end_string(dst);
+    return SUCCESS;
+  }
+  return err;
 }

 simdjson_warn_unused simdjson_inline error_code tape_builder::visit_root_number(json_iterator &iter, const uint8_t *value) noexcept {
@@ -38,55 +38,43 @@ namespace {
 using namespace simd;

 simdjson_inline json_character_block json_character_block::classify(const simd::simd8x64<uint8_t>& in) {
-  // Functional programming causes trouble with Visual Studio.
-  // Keeping this version in comments since it is much nicer:
-  // auto v = in.map<uint8_t>([&](simd8<uint8_t> chunk) {
-  //  auto nib_lo = chunk & 0xf;
-  //  auto nib_hi = chunk.shr<4>();
-  //  auto shuf_lo = nib_lo.lookup_16<uint8_t>(16, 0, 0, 0, 0, 0, 0, 0, 0, 8, 12, 1, 2, 9, 0, 0);
-  //  auto shuf_hi = nib_hi.lookup_16<uint8_t>(8, 0, 18, 4, 0, 1, 0, 1, 0, 0, 0, 3, 2, 1, 0, 0);
-  //  return shuf_lo & shuf_hi;
-  // });
-  const simd8<uint8_t> table1(16, 0, 0, 0, 0, 0, 0, 0, 0, 8, 12, 1, 2, 9, 0, 0);
-  const simd8<uint8_t> table2(8, 0, 18, 4, 0, 1, 0, 1, 0, 0, 0, 3, 2, 1, 0, 0);
-
-  simd8x64<uint8_t> v(
-     (in.chunks[0] & 0xf).lookup_16(table1) & (in.chunks[0].shr<4>()).lookup_16(table2),
-     (in.chunks[1] & 0xf).lookup_16(table1) & (in.chunks[1].shr<4>()).lookup_16(table2),
-     (in.chunks[2] & 0xf).lookup_16(table1) & (in.chunks[2].shr<4>()).lookup_16(table2),
-     (in.chunks[3] & 0xf).lookup_16(table1) & (in.chunks[3].shr<4>()).lookup_16(table2)
+  const uint8x16_t op_table = simd8<uint8_t>(
+    0xff, 0, ',', ':', 0, '[', ']', '{', '}', 0, 0, 0, 0, 0, 0, 0
+  );
+  const uint8x16_t ws_table = simd8<uint8_t>(
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff, 0, 0, 0xff, 0, 0
  );

+  const uint8x16_t d0_0 = in.chunks[0];
+  const uint8x16_t d0_1 = in.chunks[1];
+  const uint8x16_t d0_2 = in.chunks[2];
+  const uint8x16_t d0_3 = in.chunks[3];

-  // We compute whitespace and op separately. If the code later only use one or the
-  // other, given the fact that all functions are aggressively inlined, we can
-  // hope that useless computations will be omitted. This is namely case when
-  // minifying (we only need whitespace). *However* if we only need spaces,
-  // it is likely that we will still compute 'v' above with two lookup_16: one
-  // could do it a bit cheaper. This is in contrast with the x64 implementations
-  // where we can, efficiently, do the white space and structural matching
-  // separately. One reason for this difference is that on ARM NEON, the table
-  // lookups either zero or leave unchanged the characters exceeding 0xF whereas
-  // on x64, the equivalent instruction (pshufb) automatically applies a mask,
-  // ignoring the 4 most significant bits. Thus the x64 implementation is
-  // optimized differently. This being said, if you use this code strictly
-  // just for minification (or just to identify the structural characters),
-  // there is a small untaken optimization opportunity here. We deliberately
-  // do not pick it up.
+  const uint8x16_t match_op_0 = vceqq_u8(vqtbl1q_u8(op_table, vshrq_n_u8(vaddq_u8(d0_0, vdupq_n_u8(3)), 4)), d0_0);
+  const uint8x16_t match_op_1 = vceqq_u8(vqtbl1q_u8(op_table, vshrq_n_u8(vaddq_u8(d0_1, vdupq_n_u8(3)), 4)), d0_1);
+  const uint8x16_t match_op_2 = vceqq_u8(vqtbl1q_u8(op_table, vshrq_n_u8(vaddq_u8(d0_2, vdupq_n_u8(3)), 4)), d0_2);
+  const uint8x16_t match_op_3 = vceqq_u8(vqtbl1q_u8(op_table, vshrq_n_u8(vaddq_u8(d0_3, vdupq_n_u8(3)), 4)), d0_3);

-  uint64_t op = simd8x64<bool>(
-        v.chunks[0].any_bits_set(0x7),
-        v.chunks[1].any_bits_set(0x7),
-        v.chunks[2].any_bits_set(0x7),
-        v.chunks[3].any_bits_set(0x7)
-  ).to_bitmask();
+  const uint8x16_t match_ws_0 = vqtbx1q_u8(vceqq_u8(d0_0, vdupq_n_u8(' ')), ws_table, d0_0);
+  const uint8x16_t match_ws_1 = vqtbx1q_u8(vceqq_u8(d0_1, vdupq_n_u8(' ')), ws_table, d0_1);
+  const uint8x16_t match_ws_2 = vqtbx1q_u8(vceqq_u8(d0_2, vdupq_n_u8(' ')), ws_table, d0_2);
+  const uint8x16_t match_ws_3 = vqtbx1q_u8(vceqq_u8(d0_3, vdupq_n_u8(' ')), ws_table, d0_3);

-  uint64_t whitespace = simd8x64<bool>(
-        v.chunks[0].any_bits_set(0x18),
-        v.chunks[1].any_bits_set(0x18),
-        v.chunks[2].any_bits_set(0x18),
-        v.chunks[3].any_bits_set(0x18)
-  ).to_bitmask();
+  const uint8x16_t bit_mask = simd8<uint8_t>(
+    0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80,
+    0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80
+  );
+
+  uint8x16_t op_sum0 = vpaddq_u8(vandq_u8(match_op_0, bit_mask), vandq_u8(match_op_1, bit_mask));
+  uint8x16_t ws_sum0 = vpaddq_u8(vandq_u8(match_ws_0, bit_mask), vandq_u8(match_ws_1, bit_mask));
+  uint8x16_t op_sum1 = vpaddq_u8(vandq_u8(match_op_2, bit_mask), vandq_u8(match_op_3, bit_mask));
+  uint8x16_t ws_sum1 = vpaddq_u8(vandq_u8(match_ws_2, bit_mask), vandq_u8(match_ws_3, bit_mask));
+  op_sum0 = vpaddq_u8(op_sum0, op_sum1);
+  ws_sum0 = vpaddq_u8(ws_sum0, ws_sum1);
+  op_sum0 = vpaddq_u8(op_sum0, op_sum0);
+  ws_sum0 = vpaddq_u8(ws_sum0, ws_sum0);
+  const uint64_t op = vgetq_lane_u64(vreinterpretq_u64_u8(op_sum0), 0);
+  const uint64_t whitespace = vgetq_lane_u64(vreinterpretq_u64_u8(ws_sum0), 0);

  return { whitespace, op };
 }
@@ -132,7 +120,7 @@ simdjson_warn_unused error_code implementation::minify(const uint8_t *buf, size_
  return arm64::stage1::json_minifier::minify<64>(buf, len, dst, dst_len);
 }

-simdjson_warn_unused error_code dom_parser_implementation::stage1(const uint8_t *_buf, size_t _len, stage1_mode streaming) noexcept {
+simdjson_flatten simdjson_warn_unused error_code dom_parser_implementation::stage1(const uint8_t *_buf, size_t _len, stage1_mode streaming) noexcept {
  this->buf = _buf;
  this->len = _len;
  return arm64::stage1::json_structural_indexer::index<64>(buf, len, *this, streaming);
@@ -226,9 +226,15 @@ 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
+      // 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.
      add_structural();
-      while (idx+1<len && !char_is_space_or_operator(buf[idx+1])) {
+      while (idx+1<len && !char_is_space_or_operator(buf[idx+1]) && buf[idx+1] != 0x1e) {
        idx++;
      };
    }
@@ -283,6 +289,56 @@ 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;
 }
@@ -97,9 +97,280 @@ 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
@@ -314,7 +314,6 @@ 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--; }
@@ -342,6 +341,56 @@ 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();
@@ -291,7 +291,20 @@ simdjson_warn_unused simdjson_inline error_code json_iterator::visit_root_primit
    case '"': return visitor.visit_root_string(*this, value);
    case 't': return visitor.visit_root_true_atom(*this, value);
    case 'f': return visitor.visit_root_false_atom(*this, value);
+#if SIMDJSON_ENABLE_NAN_INF
+    case 'n': {
+      auto err = visitor.visit_root_null_atom(*this, value);
+      if (err == SUCCESS) { return err; }
+      // propagate the error value returned by a bad 'null' atom if parsing 'nan' fails
+      return visitor.visit_root_nan_atom(*this, value, err);
+    }
+    // 'N' isn't a canonically recognized atom, so we return a TAPE_ERROR if failure occurs
+    case 'N': return visitor.visit_root_nan_atom(*this, value, TAPE_ERROR);
+    case 'i':
+    case 'I': return visitor.visit_root_inf_atom(*this, value);
+#else
    case 'n': return visitor.visit_root_null_atom(*this, value);
+#endif
    case '-':
    case '0': case '1': case '2': case '3': case '4':
    case '5': case '6': case '7': case '8': case '9':
@@ -313,7 +326,20 @@ simdjson_warn_unused simdjson_inline error_code json_iterator::visit_primitive(V
  switch (*value) {
    case 't': return visitor.visit_true_atom(*this, value);
    case 'f': return visitor.visit_false_atom(*this, value);
+#if SIMDJSON_ENABLE_NAN_INF
+    case 'n': {
+      auto err = visitor.visit_null_atom(*this, value);
+      if (err == SUCCESS) { return err; }
+      // propagate the error value returned by a bad 'null' atom if parsing 'nan' fails
+      return visitor.visit_nan_atom(*this, value, err);
+    }
+    // 'N' isn't a canonically recognized atom, so we return a TAPE_ERROR if failure occurs
+    case 'N': return visitor.visit_nan_atom(*this, value, TAPE_ERROR);
+    case 'i':
+    case 'I': return visitor.visit_inf_atom(*this, value);
+#else
    case 'n': return visitor.visit_null_atom(*this, value);
+#endif
    default:
      log_error("Non-value found when value was expected!");
      return TAPE_ERROR;
@@ -325,4 +351,4 @@ simdjson_warn_unused simdjson_inline error_code json_iterator::visit_primitive(V
 } // namespace SIMDJSON_IMPLEMENTATION
 } // namespace simdjson

-#endif // SIMDJSON_SRC_GENERIC_STAGE2_JSON_ITERATOR_H
+#endif // SIMDJSON_SRC_GENERIC_STAGE2_JSON_ITERATOR_H
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Francisco Geiman Thiesen	4d9d948627	deserialize: single-pass dispatch for structs with optional fields The reflection deserializer used `obj[key].get(out.member)` per struct field, which delegates to find_field_unordered. For absent optional fields this scans the entire JSON object before returning NO_SUCH_FIELD — O(K) per absent optional, where K is the JSON object's field count. A struct with N optionals where most are absent pays O(N*K) per record. CITM hits this hard: CITMEvent has 7 optional fields; most events leave several of them null/missing, so we re-scan each event many times. Switch to single-pass dispatch when the struct has any std::optional member: walk the JSON object exactly once, dispatch each visited key to the matching struct member via a compile-time-generated key comparison (with length pre-filter), let object_iterator::operator++ auto-skip values for unknown keys. For structs with all-required fields (Twitter Status, User), keep the existing per-field obj[key] path. It's O(1) per field on in-order JSON and faster than the unrolled compare chain for dense, in-order objects. Measured (TRUE A/B, 7 alternating rounds, single docker invocation): CITM static_reflection: 2084 -> 2387 MB/s +14.5% CITM from: 2053 -> 2358 MB/s +14.9% Twitter static_reflection: 3416 -> 3419 MB/s break-even Twitter from: 3416 -> 3417 MB/s break-even All static_reflection_comprehensive_tests pass.	2026-05-09 04:55:37 -07:00
Daniel Lemire	ec49efa5da	avoid unnecessary pointer member (#2715 )	2026-05-08 00:26:57 -04:00
Daniel Lemire	a16e5128fe	pendantic guard	2026-05-07 23:13:40 -04:00
Alecto Irene Perez	bd42858383	fix -Wunneeded-internal-declaration warning (#2714 )	2026-05-07 21:46:52 -04:00
jmestwa-coder	7d30ff2574	JSON Pointer array index overflow handling (#2713 )	2026-05-07 19:07:39 -04:00
Francisco Geiman Thiesen	42c047a927	builder: position-as-local writer for reflection serializer (#2708 ) The dominant cost in the reflection serializer was the strict-aliasing reload pattern: every char* write through `string_builder::buffer.get()` forced the compiler to assume `string_builder::position` and `::capacity` may have been clobbered, so it reloaded both members from memory after each byte. perf annotate showed `ldr [position]` and `ldr [capacity]` taking 15-20% of CITM serialization time. This change refactors the reflection atom path to use an internal `writer` struct (buffer pointer + position + capacity + back-ref to string_builder). The writer lives as a stack-local in the top-level append() entry point, threaded through the inlined atom() chain via `writer&`. After SROA, the three fields are register-resident across the entire serialization. The `pos` is never round-tripped through memory between writes — it's a local size_t. This mirrors the pattern Glaze uses (passing `B&& b, auto&& ix` through every helper). The simdjson-specific bit is keeping the public string_builder API intact: only the internal atom() family is refactored to take `writer&`. The top-level append(string_builder&, T) constructs a writer on the stack, threads it through atom(), then syncs the local position back at the end. For string fields specifically, the escape path is also inlined through the writer — the existing `write_string_escaped(input, out)` helper already takes a destination pointer and returns bytes-written, so it composes cleanly with `w.ptr + w.pos`. Without this, sync/ reload around each string write was a real cost on Twitter (-7%). Performance =========== TRUE A/B in single docker invocation, 7 alternating rounds, byte- identical output, all static_reflection_comprehensive_tests pass. Build: clang-p2996 21.0.0git, -O3 -DNDEBUG, aarch64 Linux. CITM Catalog (496 682 bytes): baseline (master): 4356 MB/s patched: 6776 MB/s +55.5% Glaze: 4860 MB/s simdjson now 39.4% AHEAD of Glaze Twitter (81 927 bytes): baseline (master): 6437 MB/s patched: 6452 MB/s +0.2% (break-even) Twitter is string-heavy; the writer's gain over the existing member-based path is small here, but it no longer regresses. Default initial capacity is unchanged at 1024.	2026-05-07 13:28:03 -04:00
Alecto Irene Perez	376ef7e8e9	Add support for writing NaN/Infinity if SIMDJSON_ENABLE_NAN_INF is enabled (#2711 ) * Add tests for dumping out NaN/Infinity to the json builder * If SIMDJSON_ENABLE_NAN_INF is set, write out NaN and Infinity * Add tests for dumping out NaN/Infinity when serializing DOM * If SIMDJSON_ENABLE_NAN_INF, use 'NaN' and 'Infinity' for nan/inf * Fix bug where 'Inf' as a root atom + spaces of padding parses incorrectly * Update FracturedJson printers so tables containing NaN/Infinity are aligned	2026-05-07 13:11:03 -04:00
Daniel Lemire	0a23ebbfef	adding gcc16 (#2712 )	2026-05-07 13:10:42 -04:00
Daniel Lemire	9803884546	overflow patch.	2026-05-06 17:37:18 -04:00
Alecto Irene Perez	b9b20be80e	Add support for parsing NaN and Infinity as requested in #1540 , #2414 , and #2540 (#2696 ) * add compile option 'SIMDJSON_ENABLE_NAN_INF' but disable by default * extend parser to support NaN/Infinity when SIMDJSON_ENABLE_NAN_INF=1 * update tests to check parsing of NaN/Infinity, when enabled * update minefield tests: mark nan/inf tests as passing when nan/inf is ON * update CI/CD to run tests with extensions for NaN/Infinity enabled	2026-05-04 15:24:26 -04:00
Francisco Geiman Thiesen	f902769b35	builder: force-inline atom templates and replace integer writer (#2707 ) * builder: force-inline atom templates and replace integer writer Two complementary changes that together speed up reflection-driven JSON serialization by ~28% on integer-heavy structs (CITM) and ~12% on string-heavy structs (Twitter). (1) Add simdjson_really_inline (always_inline) to the hot atom<T> template overloads (arithmetic, struct, container, optional, string-like). The constexpr-only declaration was only a hint; the compiler routinely chose to leave atom<unsigned long> as a real out-of-line function. (2) Replace string_builder::append<UInt> body with a forward cascade-on-magnitude integer writer. The old code computed digit_count(v) upfront and wrote backward in a loop; the new code is a straight-line if/else cascade that writes digits forward, no loop, no helper call. Either change alone gives only modest gains. Together they unlock the compiler's cross-call optimization: with all atoms inlined and the integer writer reduced to straight-line code, the compiler can hoist b.position into a register across the whole struct serialization, fold redundant capacity_check calls, and eliminate the strict-aliasing penalty that otherwise forces b.position/b.capacity reloads after every char* write. Output is byte-identical to master on CITM (496682 bytes) and Twitter (81927 bytes). All static_reflection_comprehensive_tests pass. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * builder: de-recurse write_uint_jeaiii so always_inline applies on g++/MSVC g++ ('inlining failed in call to always_inline ...: function not considered for inlining') and MSVC ('warning C4714: __forceinline not inlined' under warnings-as-errors) both refuse to inline recursive functions marked simdjson_really_inline. The original write_uint_jeaiii called itself in the >=10^4 branches. Refactor into a non-recursive DAG of helpers: write_lt100, write_lt10000, write_4_digits, write_lt1e8, write_uint_jeaiii. Each calls strictly smaller-domain helpers, no cycles. Same straight-line cascade behavior, same byte output, but every node is now a candidate for always_inline on all compilers. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * builder: port signed-int append to jeaiii writer and drop digit_count helpers The signed-integer branch in string_builder::append was structurally identical to the OLD unsigned branch — same digit_count() upfront + backward 4-digit batched loop. Port it to use the same forward write_uint_jeaiii() helper as the unsigned branch (write '-' unconditionally and advance position only if negative — branchless). This makes int_log2 / fast_digit_count_32 / fast_digit_count_64 / digit_count fully unused (verified via grep across include/ and src/); remove them, ~80 lines of dead code. The signed write path now benefits from the same compiler-level optimization (full inlining, capacity-check fusion, no opaque-loop boundary) as the unsigned path. Signed-int microbench (200 × 100k values, mixed magnitude and sign): 2272 → 2685 MB/s (+18.2%). CITM and Twitter benchmarks unchanged in shape and remain byte-identical to baseline output. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com> * fix tests --------- Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com> Co-authored-by: Daniel Lemire <daniel@lemire.me>	2026-05-04 13:55:49 -04:00
Daniel Lemire	389f7ce8e3	fixing issue 2703 (#2705 )	2026-04-30 21:59:36 -04:00
Francisco Geiman Thiesen	32b52e3f34	builder: coalesce per-field separator+key+colon into one constexpr write (#2698 ) Each non-first field in a reflection-driven struct serialization was emitting three separate string_builder::append calls (',', "\"key\"", ':'), each going through capacity_check + a small write. Combine them into a single compile-time string per field so each field does one capacity_check and one memcpy. Same pattern fixed in atom(), append(), and extract_from(). Measured under clang-p2996 -O3 -DNDEBUG -freflection -std=c++26 (median of 5 contemporaneous runs, output byte-identical to baseline): CITM serialization (496682 bytes): simdjson_reuse_buffer: 3192 -> 3673 MB/s (+15.1%) simdjson_static_reflection: 3014 -> 3443 MB/s (+14.2%) simdjson_to: 2717 -> 3234 MB/s (+19.0%) simdjson_to_reuse: 2836 -> 3226 MB/s (+13.7%) Twitter serialization (81927 bytes): simdjson_reuse_buffer: 6637 -> 7162 MB/s (+7.9%) simdjson_static_reflection: 5527 -> 5915 MB/s (+7.0%) simdjson_to: 5070 -> 5350 MB/s (+5.5%) simdjson_to_reuse: 4976 -> 5303 MB/s (+6.6%) extract_from (out-of-tree micro-bench, 100 records per call): User 4-of-9 fields: 1833 -> 1888 MB/s (+3.0%) Status 3-of-6 fields: 4286 -> 4334 MB/s (+1.1%) Parsing benchmarks unchanged. tests/builder/static_reflection_comprehensive_tests still passes (round-trip through extract_from / extract_into is verified).	2026-04-30 21:02:41 -04:00
jmestwa-coder	b3fe96cdb2	Align source() output for comma-delimited streams with json_sequence behavior (#2699 )	2026-04-29 13:05:45 -04:00
Daniel Lemire	45d296e219	Update compiler requirements in basics.md Added support for Fil-C, a memory-safe C/C++ compiler, to the requirements section.	2026-04-22 13:54:15 -04:00
Daniel Lemire	c1681e9d0a	build with filc (#2695 )	2026-04-22 13:17:25 -04:00
Daniel Lemire	63b10bca21	new optimization to the ARM NEON kernel (#2692 ) * new optimization to the ARM NEON kernel * portability hack	2026-04-20 17:16:50 -04:00
Daniel Lemire	3b782fab7a	fixes 2690 (typo)	2026-04-20 12:09:39 -04:00
Daniel Lemire	df16e96767	fix: ondemand for wildcard matches (#2686 ) * fixing issue 2684 * simplifying. * update * more fixes * moving example * adding forward declaration	2026-04-17 14:20:57 -04:00
Daniel Lemire	2e7ad956eb	Merge branch 'master' of github.com:simdjson/simdjson	2026-04-15 12:52:47 -04:00
Daniel Lemire	30d7204312	pedantic guard	2026-04-15 12:52:31 -04:00
metsw24-max	b6af1a0456	Fix undefined behavior in document_stream parsing due to unsafe std::isspace usage (#2680 )	2026-04-14 23:03:44 -04:00
Daniel Lemire	7cc60672e3	Merge branch 'master' of github.com:simdjson/simdjson	2026-04-13 17:55:05 -04:00
Daniel Lemire	3ecda9ee99	pedantic checks for 32-bit systems who try to allocate enormous capacities.	2026-04-13 17:54:35 -04:00
Daniel Lemire	b648a5fc0a	Add std::ranges support for On-Demand API (variant) (#2678 ) * add std::ranges support for On-Demand API (#2382) Add zero-cost range wrappers (array_range, object_range) that satisfy std::ranges::input_range, enabling std::views::transform and other C++20 range adaptors with the On-Demand parser. Uses direct forwarding via simdjson_inline with no value buffering, avoiding the per-element overhead (~20%) of the previous approach. Guarded by SIMDJSON_SUPPORTS_RANGES. * fix: replace non-ASCII em dash in test comment The just_ascii CI check flags any non-ASCII characters in source files. * let us see what we get with this... * minor tweak * minor update * update doc --------- Co-authored-by: Justin Li <justin53@bu.edu>	2026-04-13 15:25:02 -04:00
Daniel Lemire	4ec44e88c9	adding memory-file mapping to Windows + better doc (#2676 ) * adding memory-file mapping to Windows. * making memory-file mapping optional under windows, as it is fragile * removing non-ascii * saving. * bumping up * take 2	2026-04-12 18:12:31 -04:00
Daniel Lemire	ede3129081	modernizing the benchmarks (#2679 )	2026-04-12 18:09:46 -04:00
Daniel Lemire	8ea4c1c2e6	being more precise	2026-04-12 17:06:27 -04:00
Daniel Lemire	486b2a3828	minor update	2026-04-11 14:45:38 -04:00
Daniel Lemire	22773f3c70	documenting C++26 usage with iterate_many	2026-04-11 14:41:05 -04:00
Daniel Lemire	249eb2c28a	better construction.	2026-04-11 14:23:15 -04:00
Daniel Lemire	94c429aa70	finishing up the new streaming (#2674 ) * finishing up the new streaming * fixed silly warnings. * tweak * adding more tests * minor fixes * more fixes	2026-04-11 14:16:43 -04:00
Jaël Champagne Gareau	72e51a9a81	Add support for RFC 7464 JSON text sequences and comma-delimited documents (#2664 ) * add support for RFC 7464 documents * add threaded comma-delimited parse_many support * fix failing tests in CI	2026-04-10 20:26:00 -04:00
Daniel Lemire	1a57afec1f	Various guards (#2673 ) * adding a guard in document::allocate. Co-authored-by: jmestwa-coder jmestwa@gmail.com * adding a max depth Co-authored-by: jmestwa-coder jmestwa@gmail.com	2026-04-10 20:19:46 -04:00
Daniel Lemire	4de7426b9f	amalgamate should provide nicer error messages (#2672 )	2026-04-10 17:42:57 -04:00
Daniel Lemire	85cadf4074	adding a C++17 padded_input for convenience. (#2667 ) * adding a C++17 padded_input for convenience. * adding header * tuning. * being explicit * reworking the docu * avoid windows.h * Update include/simdjson/padded_string_view-inl.h Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> * Update tests/ondemand/ondemand_padded_input.cpp Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> * Update tests/ondemand/ondemand_readme_examples.cpp Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> * Update doc/performance.md Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> * minor update --------- Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>	2026-04-09 14:07:44 -04:00
Daniel Lemire	bc48e72070	literals should be guarded (#2669 )	2026-04-09 14:07:29 -04:00
Jaël Champagne Gareau	8955c2c6d5	Fix failing `just_ascii` test (#2661 ) * fix just_ascii errors in test/benchmark sources * make just_ascii test run in CI	2026-04-05 11:11:35 -04:00
Daniel Lemire	73e69a5e84	Get reflection working without warnings under GCC 16 (#2658 ) * wip gcc16 * progress * minor gcc16 fixes * final step * Update include/simdjson/padded_string-inl.h Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> * Update include/simdjson/padded_string.h Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> * renaming test function --------- Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>	2026-04-03 15:32:42 -04:00
Daniel Lemire	fb83b114ef	4.6.1	2026-04-03 15:26:12 -04:00
jmestwa-coder	542cd7af71	parser.load(string_view) does not respect view length when opening files (#2659 )	2026-04-03 15:25:03 -04:00
Daniel Lemire	769364abb2	simplifying the logic	2026-03-30 20:01:35 -04:00
Daniel Lemire	f25d5f9fc2	4.6.0 (#2655 )	2026-03-30 19:51:00 -04:00
Eyüp Can Akman	12fb30ae9c	add get_int32() and get_uint32() to the On Demand API (#2638 ) * add get_int32() and get_uint32() to the On Demand API Add convenience methods that call get_int64()/get_uint64() and range-check the result, returning NUMBER_OUT_OF_RANGE on overflow. Added to value, document, document_reference, and their simdjson_result wrappers. Closes #1890 * fix document_reference streaming for get_int32/get_uint32 The document_reference getters delegated to document::get_int32/get_uint32 which call get_root_int64/get_root_uint64 with allow_trailing_content=true, rejecting the next document in a stream as trailing content. Call get_root_value_iterator().get_root_int64/get_root_uint64(false) directly to allow trailing content, matching get_int64/get_uint64. Add streaming tests for both getters. * add get_int32/get_uint32 to basics.md * add get_int32/get_uint32 to wrong-type error tests * add get<uint32_t>/get<int32_t> template specializations Wire the 32-bit getters into the generic get<T>() and get(T&) dispatch so that doc.get<uint32_t>() compiles on C++11/14/17 without requiring the C++20 concepts path in std_deserialize.h.	2026-03-30 10:16:31 -04:00
uwezkhan	c0a952687d	Add overflow checks in padded_string_builder::reserve (#2653 ) * Add overflow checks in padded_string_builder::reserve * updated --------- Co-authored-by: uwezkhan06 <uwezkhan055@gmail.com>	2026-03-30 10:16:05 -04:00
uwezkhan	307ddd4415	Avoid overflow in padded_string_builder::reserve (#2654 ) Co-authored-by: uwezkhan06 <uwezkhan055@gmail.com>	2026-03-30 10:13:08 -04:00
Edoardo Bortolozzo	21657455ed	build: add SIMDJSON_INSTALL option (#2649 )	2026-03-29 15:54:44 -04:00
jmestwa-coder	afb1c9f4b1	correct inverted clamp in set_max_capacity (#2651 )	2026-03-29 15:54:28 -04:00
uwezkhan	9973f7b3a3	Fix fopen usage with string_view (#2652 ) Co-authored-by: uwezkhan06 <uwezkhan055@gmail.com>	2026-03-29 15:54:11 -04:00
Daniel Lemire	18d612df15	4.5.0	2026-03-25 17:26:13 -04:00
harshanagd	bddb23177e	feat: Add DOM tape support for big integers (opt-in) (#2640 ) When parser.number_as_string(true) is set and a number exceeds uint64 range, write the raw digits to the string buffer and emit a BIGINT ('Z') tape tag instead of returning BIGINT_ERROR. Default behavior unchanged. Changes: - tape_type.h: add BIGINT = 'Z' - dom_parser_implementation.h: add _number_as_string flag - parser.h: add number_as_string() getter/setter - parser-inl.h: propagate flag before parse - tape_builder.h: visit_number checks flag on BIGINT_ERROR - tape_writer.h: add append_bigint helper - serialization-inl.h: handle BIGINT in serialization (raw digits) - tape.md: document big integer tape format Builds on PR #2139 which added BIGINT_ERROR detection. All 119 existing tests pass — default behavior unchanged. Closes #167 Co-authored-by: harshagd <harshagd@amazon.com>	2026-03-25 17:25:37 -04:00
Rajdeep	2c5de6c6ed	Fix PCH build failure with <bit> on non-C++20 compilers (#2646 ) * Added benchmarks for on-demand get_int64 and get_double * Remove local IDE settings * Fix PCH build failure with <bit> on non-C++20 compilers * Update bench_dom_api.cpp	2026-03-25 17:20:43 -04:00
Daniel Lemire	844e5eac23	bump google bench	2026-03-25 09:29:33 -04:00
Daniel Lemire	45caa861cd	Update README with talk information Added details about talks at QCon San Francisco 2019 and CppCon 2025.	2026-03-24 22:00:42 -04:00
Andrey Abramov	50bf372d3f	Add SereneDB to the list of projects (#2641 ) Add SereneDB to the list of projects	2026-03-22 12:37:23 -04:00
Daniel Lemire	b4a0fd3ff4	4.4.2	2026-03-20 11:12:35 -04:00
Levi Zim	a1ff05a5e8	Fix RISC-V compilation without RVV (#2637 ) #2617 introduced an RVV check that only checks if the compiler supports RVV intrinsics without checking if RVV is enabled at compile time. This has caused compilation failure of node.js on riscv64. Fix it by appending a check for __riscv_vector.	2026-03-20 11:11:38 -04:00