4.1.0 (#2532)

* Adding compile time json path

* using string_view

* Adding support for compile-time json pointer as well.

* Removing unnecessary comment

* Tests now working, still will re-review.

* Adding documentation on the compile-time json path/pointer parsing feature.

* Adding benchmark showing the significant performance advantage of using compiled paths whenever you have them a priori.

* going for JSONPath (correct wording).

* minor update (mostly doc)

---------

Co-authored-by: Daniel Lemire <daniel@lemire.me>

.circleci/config.yml

@@ -1,316 +0,0 @@
-version: 2.1
-
-
-# We constantly run out of memory so please do not use parallelism (-j, -j4).
-
-# Reusable image / compiler definitions
-executors:
-  gcc8:
-    docker:
-      - image: conanio/gcc8
-        environment:
-          CXX: g++-8
-          CC: gcc-8
-          CMAKE_BUILD_FLAGS:
-          CTEST_FLAGS: --output-on-failure
-
-  gcc9:
-    docker:
-      - image: conanio/gcc9
-        environment:
-          CXX: g++-9
-          CC: gcc-9
-          CMAKE_BUILD_FLAGS:
-          CTEST_FLAGS: --output-on-failure
-
-  gcc10:
-    docker:
-      - image: conanio/gcc10
-        environment:
-          CXX: g++-10
-          CC: gcc-10
-          CMAKE_BUILD_FLAGS:
-          CTEST_FLAGS: --output-on-failure
-
-  clang10:
-    docker:
-      - image: conanio/clang10
-        environment:
-          CXX: clang++-10
-          CC: clang-10
-          CMAKE_BUILD_FLAGS:
-          CTEST_FLAGS: --output-on-failure
-
-  clang9:
-    docker:
-      - image: conanio/clang9
-        environment:
-          CXX: clang++-9
-          CC: clang-9
-          CMAKE_BUILD_FLAGS:
-          CTEST_FLAGS: --output-on-failure
-
-  clang6:
-    docker:
-      - image: conanio/clang60
-        environment:
-          CXX: clang++-6.0
-          CC: clang-6.0
-          CMAKE_BUILD_FLAGS:
-          CTEST_FLAGS: --output-on-failure
-
-# Reusable test commands (and initializer for clang 6)
-commands:
-  dependency_restore:
-    steps:
-      - restore_cache:
-          keys:
-            - cmake-cache-{{ checksum "dependencies/CMakeLists.txt" }}
-
-  dependency_cache:
-    steps:
-      - save_cache:
-          key: cmake-cache-{{ checksum "dependencies/CMakeLists.txt" }}
-          paths:
-            - dependencies/.cache
-
-  install_cmake:
-    steps:
-      - run: apt-get update -qq
-      - run: apt-get install -y cmake
-
-  cmake_prep:
-    steps:
-      - checkout
-      - run: mkdir -p build
-
-  cmake_build_cache:
-    steps:
-      - cmake_prep
-      - dependency_restore
-      - run: cmake  -DSIMDJSON_DEVELOPER_MODE=ON $CMAKE_FLAGS -DCMAKE_INSTALL_PREFIX:PATH=destination -B build .
-      - dependency_cache # dependencies are produced in the configure step
-
-  cmake_build:
-    steps:
-      - cmake_build_cache
-      - run: cmake  --build build
-
-  cmake_test:
-    steps:
-      - cmake_build
-      - run: |
-          cd build &&
-          tools/json2json -h &&
-          ctest $CTEST_FLAGS -L acceptance &&
-          ctest $CTEST_FLAGS -LE acceptance -LE explicitonly
-
-  cmake_assert_test:
-    steps:
-      - run: |
-          cd build &&
-          tools/json2json -h &&
-          ctest $CTEST_FLAGS -L assert
-
-  cmake_test_all:
-    steps:
-      - cmake_build
-      - run: |
-          cd build &&
-          tools/json2json -h &&
-          ctest $CTEST_FLAGS -DSIMDJSON_IMPLEMENTATION="haswell;westmere;fallback" -L acceptance -LE per_implementation &&
-          SIMDJSON_FORCE_IMPLEMENTATION=haswell ctest $CTEST_FLAGS -L per_implementation -LE explicitonly &&
-          SIMDJSON_FORCE_IMPLEMENTATION=westmere ctest $CTEST_FLAGS -L per_implementation -LE explicitonly &&
-          SIMDJSON_FORCE_IMPLEMENTATION=fallback ctest $CTEST_FLAGS -L per_implementation -LE explicitonly &&
-          ctest $CTEST_FLAGS -LE "acceptance|per_implementation" # Everything we haven't run yet, run now.
-
-
-  cmake_perftest:
-    steps:
-      - cmake_build_cache
-      - run: |
-          cmake -DSIMDJSON_ENABLE_DOM_CHECKPERF=ON --build  build --target checkperf &&
-          cd build &&
-          ctest --output-on-failure -R checkperf
-
-  # we not only want cmake to build and run tests, but we want also a successful installation from which we can build, link and run programs
-  cmake_install_test: # this version builds, install, test and then verify from the installation
-    steps:
-      - run: cd build && make install
-      - run: 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++ -Ibuild/destination/include -Lbuild/destination/lib -std=c++17 -Wl,-rpath,build/destination/lib -o linkandrun tmp.cpp -lsimdjson && ./linkandrun jsonexamples/twitter.json
-
-  cmake_installed_test_cxx20: # assuming that it was installed, this tries to build using C++20
-    steps:
-      - run: 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++ -Ibuild/destination/include -Lbuild/destination/lib -std=c++20 -Wl,-rpath,build/destination/lib -o linkandrun tmp.cpp -lsimdjson && ./linkandrun jsonexamples/twitter.json
-
-jobs:
-
-  # static
-  justlib-gcc10:
-    description: Build just the library, install it and do a basic test
-    executor: gcc10
-    environment: { CMAKE_FLAGS: -DSIMDJSON_JUST_LIBRARY=ON }
-    steps: [ cmake_build, cmake_install_test, cmake_installed_test_cxx20 ]
-  assert-gcc10:
-    description: Build the library with asserts on, install it and run tests
-    executor: gcc10
-    environment: { CMAKE_FLAGS: -DSIMDJSON_GOOGLE_BENCHMARKS=OFF -DCMAKE_CXX_FLAGS_RELEASE=-O3 }
-    steps: [ cmake_test, cmake_assert_test ]
-  assert-clang10:
-    description: Build just the library, install it and do a basic test
-    executor: clang10
-    environment: { CMAKE_FLAGS: -DSIMDJSON_GOOGLE_BENCHMARKS=OFF -DCMAKE_CXX_FLAGS_RELEASE=-O3 }
-    steps: [ cmake_test, cmake_assert_test ]
-  gcc10-perftest:
-    description: Build and run performance tests on GCC 10 and AVX 2 with a cmake static build, this test performance regression
-    executor: gcc10
-    environment: { CMAKE_FLAGS: -DSIMDJSON_GOOGLE_BENCHMARKS=OFF -DBUILD_SHARED_LIBS=OFF }
-    steps: [ cmake_perftest ]
-  gcc10:
-    description: Build and run tests on GCC 10 and AVX 2 with a cmake static build
-    executor: gcc10
-    environment: { CMAKE_FLAGS: -DSIMDJSON_GOOGLE_BENCHMARKS=ON -DBUILD_SHARED_LIBS=OFF }
-    steps: [ cmake_test, cmake_install_test, cmake_installed_test_cxx20 ]
-  clang6:
-    description: Build and run tests on clang 6 and AVX 2 with a cmake static build
-    executor: clang6
-    environment: { CMAKE_FLAGS: -DSIMDJSON_GOOGLE_BENCHMARKS=ON -DBUILD_SHARED_LIBS=OFF }
-    steps: [ cmake_test, cmake_install_test ]
-  clang10:
-    description: Build and run tests on clang 10 and AVX 2 with a cmake static build
-    executor: clang10
-    environment: { CMAKE_FLAGS: -DSIMDJSON_GOOGLE_BENCHMARKS=ON  -DBUILD_SHARED_LIBS=OFF }
-    steps: [ cmake_test, cmake_install_test, cmake_installed_test_cxx20 ]
-  # libcpp
-  libcpp-clang10:
-    description: Build and run tests on clang 10 and AVX 2 with a cmake static build and libc++
-    executor: clang10
-    environment: { CMAKE_FLAGS: -DSIMDJSON_USE_LIBCPP=ON  -DBUILD_SHARED_LIBS=OFF }
-    steps: [ cmake_test, cmake_install_test, cmake_installed_test_cxx20 ]
-  # sanitize
-  sanitize-gcc10:
-    description: Build and run tests on GCC 10 and AVX 2 with a cmake sanitize build
-    executor: gcc10
-    environment: { CMAKE_FLAGS: -DCMAKE_BUILD_TYPE=Debug -DBUILD_SHARED_LIBS=ON -DSIMDJSON_SANITIZE=ON, CTEST_FLAGS: --output-on-failure -LE explicitonly }
-    steps: [ cmake_test ]
-  sanitize-clang10:
-    description: Build and run tests on clang 10 and AVX 2 with a cmake sanitize build
-    executor: clang10
-    environment: { CMAKE_FLAGS: -DBUILD_SHARED_LIBS=ON -DSIMDJSON_NO_FORCE_INLINING=ON -DSIMDJSON_SANITIZE=ON, CTEST_FLAGS: --output-on-failure -LE explicitonly }
-    steps: [ cmake_test ]
-  threadsanitize-gcc10:
-    description: Build and run tests on GCC 10 and AVX 2 with a cmake sanitize build
-    executor: gcc10
-    environment: { CMAKE_FLAGS: -DBUILD_SHARED_LIBS=ON -DSIMDJSON_SANITIZE_THREADS=ON, CTEST_FLAGS: --output-on-failure -LE explicitonly }
-    steps: [ cmake_test ]
-  threadsanitize-clang10:
-    description: Build and run tests on clang 10 and AVX 2 with a cmake sanitize build
-    executor: clang10
-    environment: { CMAKE_FLAGS: -DBUILD_SHARED_LIBS=ON  -DSIMDJSON_NO_FORCE_INLINING=ON -DSIMDJSON_SANITIZE_THREADS=ON, CTEST_FLAGS: --output-on-failure -LE explicitonly }
-    steps: [ cmake_test ]
-  # dynamic
-  dynamic-gcc10:
-    description: Build and run tests on GCC 10 and AVX 2 with a cmake dynamic build
-    executor: gcc10
-    environment: { CMAKE_FLAGS: -DBUILD_SHARED_LIBS=ON }
-    steps: [ cmake_test, cmake_install_test ]
-  dynamic-clang10:
-    description: Build and run tests on clang 10 and AVX 2 with a cmake dynamic build
-    executor: clang10
-    environment: { CMAKE_FLAGS: -DBUILD_SHARED_LIBS=ON }
-    steps: [ cmake_test, cmake_install_test ]
-
-  # unthreaded
-  unthreaded-gcc10:
-    description: Build and run tests on GCC 10 and AVX 2 *without* threads
-    executor: gcc10
-    environment: { CMAKE_FLAGS: -DSIMDJSON_ENABLE_THREADS=OFF }
-    steps: [ cmake_test, cmake_install_test ]
-  unthreaded-clang10:
-    description: Build and run tests on Clang 10 and AVX 2 *without* threads
-    executor: clang10
-    environment: { CMAKE_FLAGS: -DSIMDJSON_ENABLE_THREADS=OFF }
-    steps: [ cmake_test, cmake_install_test ]
-
-  # noexcept
-  noexcept-gcc10:
-    description: Build and run tests on GCC 10 and AVX 2 with exceptions off
-    executor: gcc10
-    environment: { CMAKE_FLAGS: -DSIMDJSON_EXCEPTIONS=OFF }
-    steps: [ cmake_test, cmake_install_test ]
-  noexcept-clang10:
-    description: Build and run tests on Clang 10 and AVX 2 with exceptions off
-    executor: clang10
-    environment: { CMAKE_FLAGS: -DSIMDJSON_EXCEPTIONS=OFF }
-    steps: [ cmake_test, cmake_install_test ]
-
-  #
-  # Misc.
-  #
-
-  # make (test and checkperf)
-  arch-haswell-gcc10:
-    description: Build, run tests and check performance on GCC 10 with -march=haswell
-    executor: gcc10
-    environment: { CXXFLAGS: -march=haswell }
-    steps: [ cmake_test ]
-  arch-nehalem-gcc10:
-    description: Build, run tests and check performance on GCC 10 with -march=nehalem
-    executor: gcc10
-    environment: { CXXFLAGS: -march=nehalem }
-    steps: [ cmake_test ]
-  sanitize-haswell-gcc10:
-    description: Build and run tests on GCC 10 and AVX 2 with a cmake sanitize build
-    executor: gcc10
-    environment: {  CXXFLAGS: -march=haswell, CMAKE_FLAGS: -DCMAKE_BUILD_TYPE=Debug -DBUILD_SHARED_LIBS=ON -DSIMDJSON_SANITIZE=ON, CTEST_FLAGS: --output-on-failure -LE explicitonly }
-    steps: [ cmake_test ]
-  sanitize-haswell-clang10:
-    description: Build and run tests on clang 10 and AVX 2 with a cmake sanitize build
-    executor: clang10
-    environment: { CXXFLAGS: -march=haswell, CMAKE_FLAGS: -DBUILD_SHARED_LIBS=ON  -DSIMDJSON_NO_FORCE_INLINING=ON -DSIMDJSON_SANITIZE=ON, CTEST_FLAGS: --output-on-failure -LE explicitonly }
-    steps: [ cmake_test ]
-
-workflows:
-  version: 2.1
-  build_and_test:
-    jobs:
-      # full multi-implementation tests
-      #- gcc7 tested on GitHub actions
-      - gcc10 # do not delete this as it tests our performance
-      - clang6
-      #- clang10 # this gets tested a lot below
-
-      # libc++
-      - libcpp-clang10
-
-      # full single-implementation tests
-      - sanitize-gcc10
-      - sanitize-clang10
-      - threadsanitize-gcc10
-      - threadsanitize-clang10
-      - dynamic-gcc10
-      - dynamic-clang10
-      - unthreaded-gcc10
-      - unthreaded-clang10
-
-      # no exceptions
-      - noexcept-gcc10
-      - noexcept-clang10
-
-      # quicker make single-implementation tests
-      - arch-haswell-gcc10
-      - arch-nehalem-gcc10
-
-
-      # sanitized single-implementation tests
-      - sanitize-haswell-gcc10
-      - sanitize-haswell-clang10
-
-      # testing "just the library"
-      - justlib-gcc10
-
-      # testing asserts
-      - assert-gcc10
-      - assert-clang10
-
-      # TODO add windows: https://circleci.com/docs/2.0/configuration-reference/#windows

.github/workflows/documentation.yml

@@ -2,7 +2,13 @@ name: Doxygen GitHub Pages
 
 on:
   release:
-    types: [created]
+    # Trigger when a release object is created and when it's published.
+    # Some GitHub flows create a release object then publish it later; include both.
+    types: [created, published]
+  # Also trigger on tag creation pushes so releasing via Git tags still runs the workflow
+  push:
+    tags:
+      - "v*"  # common release tag pattern like v1.2.3
   # Allows you to run this workflow manually from the Actions tab
   workflow_dispatch:
 
@@ -27,7 +33,7 @@ jobs:
       - name: Generate Doxygen Documentation
         run: doxygen
       - name: Deploy to GitHub Pages
-        uses: peaceiris/actions-gh-pages@v3
+        uses: peaceiris/actions-gh-pages@v4
         with:
           github_token: ${{ secrets.GITHUB_TOKEN }}
           publish_dir: doc/api/html

CMakeLists.txt

@@ -3,7 +3,7 @@ cmake_minimum_required(VERSION 3.14)
 project(
     simdjson
     # The version number is modified by tools/release.py
-    VERSION 4.0.7
+    VERSION 4.1.0
     DESCRIPTION "Parsing gigabytes of JSON per second"
     HOMEPAGE_URL "https://simdjson.org/"
     LANGUAGES CXX C
@@ -20,8 +20,8 @@ string(
 # ---- Options, variables ----
 
 # These version numbers are modified by tools/release.py
-set(SIMDJSON_LIB_VERSION "27.0.0" CACHE STRING "simdjson library version")
-set(SIMDJSON_LIB_SOVERSION "27" CACHE STRING "simdjson library soversion")
+set(SIMDJSON_LIB_VERSION "28.0.0" CACHE STRING "simdjson library version")
+set(SIMDJSON_LIB_SOVERSION "28" 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)

Doxyfile

@@ -38,7 +38,7 @@ PROJECT_NAME           = simdjson
 # could be handy for archiving the generated documentation or if some version
 # control system is used.
 
-PROJECT_NUMBER         = "4.0.7"
+PROJECT_NUMBER         = "4.1.0"
 
 # 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

README.md

@@ -67,6 +67,9 @@ Real-world usage
 
 If you are planning to use simdjson in a product, please work from one of our releases.
 
+
+
+
 Quick Start
 -----------
 
@@ -83,7 +86,7 @@ The simdjson library is easily consumable with a single .h and .cpp file.
    ```
 2. Create `quickstart.cpp`:
 
-```c++
+```cpp
 #include <iostream>
 #include "simdjson.h"
 using namespace simdjson;
@@ -227,6 +230,13 @@ Contributing to simdjson
 Head over to [CONTRIBUTING.md](CONTRIBUTING.md) for information on contributing to simdjson, and
 [HACKING.md](HACKING.md) for information on source, building, and architecture/design.
 
+
+Stars
+------
+
+[![Star History Chart](https://api.star-history.com/svg?repos=simdjson/simdjson&type=Date)](https://www.star-history.com/#simdjson/simdjson&Date)
+
+
 License
 -------
 

benchmark/accessor_performance/README.md

@@ -0,0 +1,46 @@
+# Accessor Performance Benchmarks (C++26)
+
+These benchmarks compare the performance of runtime vs compile-time JSON accessors.
+For the comparison to be meaningful, you must build simdjson with support for
+C++26 reflexion. See the `p2996` repository in the main project directory.
+
+## Files
+
+- `accessor_benchmark.h` - Common benchmark framework and test data
+- `runtime_accessors.h` - Runtime `at_path()` benchmarks
+- `compile_time_accessors.h` - Compile-time `at_path_compiled()` benchmarks (requires C++26 reflection)
+
+## Benchmarks
+
+Each benchmark measures parsing + single field access:
+
+1. **accessor_simple** - Simple field: `.name`
+2. **accessor_nested** - Nested field: `.address.city`
+3. **accessor_deep** - Deep nested field: `.address.coordinates.lat`
+
+## Building (Linux/macOS)
+
+```bash
+cmake -B build -D SIMDJSON_STATIC_REFLECTION=ON -DSIMDJSON_DEVELOPER_MODE=ON
+cmake --build build --target=bench_ondemand
+```
+
+The `SIMDJSON_STATIC_REFLECTION` will be made unnecessary once mainstream compilers
+begin supporting C++26 sufficiently well.
+
+## Running (Linux/macOS)
+
+
+```bash
+# Run all accessor benchmarks
+./build/bench_ondemand --benchmark_filter="accessor"
+```
+
+## Results
+
+We find that compile-time accessors show performance improvements that scale with path depth:
+- Simple fields: ~1.2x faster
+- Nested fields: ~1.5x faster
+- Deep nested fields: ~1.8x faster
+
+The speedup comes from eliminating runtime path parsing and conversion overhead.

benchmark/accessor_performance/accessor_benchmark.h

@@ -0,0 +1,132 @@
+#pragma once
+
+#include "json_benchmark/file_runner.h"
+#include <string>
+
+namespace accessor_performance {
+
+using namespace json_benchmark;
+
+// Test JSON for accessor benchmarks
+static const char* TEST_JSON = R"({
+  "name": "Alice",
+  "age": 30,
+  "email": "alice@example.com",
+  "address": {
+    "street": "123 Main St",
+    "city": "Boston",
+    "state": "MA",
+    "zip": 12345,
+    "coordinates": {
+      "lat": 42.3601,
+      "lon": -71.0589
+    }
+  },
+  "scores": [95, 87, 92, 88, 91],
+  "preferences": {
+    "theme": "dark",
+    "notifications": {
+      "email": true,
+      "push": false,
+      "sms": true
+    }
+  }
+})";
+
+// Struct definitions for compile-time validation
+#if SIMDJSON_STATIC_REFLECTION
+struct Coordinates {
+  double lat;
+  double lon;
+};
+
+struct Address {
+  std::string street;
+  std::string city;
+  std::string state;
+  int64_t zip;
+  Coordinates coordinates;
+};
+
+struct Notifications {
+  bool email;
+  bool push;
+  bool sms;
+};
+
+struct Preferences {
+  std::string theme;
+  Notifications notifications;
+};
+
+struct TestData {
+  std::string name;
+  int64_t age;
+  std::string email;
+  Address address;
+  std::vector<int64_t> scores;
+  Preferences preferences;
+};
+#endif // SIMDJSON_STATIC_REFLECTION
+
+// Single-access benchmark runner: measures ONE field access per iteration
+template<typename I>
+struct single_access_runner : public file_runner<I> {
+  std::string result_string;
+  int64_t result_int{};
+  double result_double{};
+  bool result_bool{};
+
+  bool setup(benchmark::State &state) {
+    this->json = simdjson::padded_string(TEST_JSON, strlen(TEST_JSON));
+    state.SetBytesProcessed(int64_t(state.iterations()) * int64_t(this->json.size()));
+    return true;
+  }
+
+  bool before_run(benchmark::State &state) {
+    if (!file_runner<I>::before_run(state)) { return false; }
+    result_string.clear();
+    result_int = 0;
+    result_double = 0.0;
+    result_bool = false;
+    return true;
+  }
+
+  bool run(benchmark::State &) {
+    return this->implementation.run(this->json, result_string, result_int, result_double, result_bool);
+  }
+
+  template<typename R>
+  bool diff(benchmark::State &state, single_access_runner<R> &reference) {
+    if (result_string != reference.result_string ||
+        result_int != reference.result_int ||
+        result_double != reference.result_double ||
+        result_bool != reference.result_bool) {
+      std::cerr << "Accessor benchmark results differ!" << std::endl;
+      return false;
+    }
+    return true;
+  }
+
+  size_t items_per_iteration() {
+    return 1;
+  }
+};
+
+// Benchmark template definitions
+struct runtime_at_path_simple;
+template<typename I> simdjson_inline static void accessor_simple(benchmark::State &state) {
+  run_json_benchmark<single_access_runner<I>, single_access_runner<runtime_at_path_simple>>(state);
+}
+
+struct runtime_at_path_nested;
+template<typename I> simdjson_inline static void accessor_nested(benchmark::State &state) {
+  run_json_benchmark<single_access_runner<I>, single_access_runner<runtime_at_path_nested>>(state);
+}
+
+struct runtime_at_path_deep;
+template<typename I> simdjson_inline static void accessor_deep(benchmark::State &state) {
+  run_json_benchmark<single_access_runner<I>, single_access_runner<runtime_at_path_deep>>(state);
+}
+
+} // namespace accessor_performance

benchmark/accessor_performance/compile_time_accessors.h

@@ -0,0 +1,56 @@
+#pragma once
+
+#if SIMDJSON_EXCEPTIONS && SIMDJSON_STATIC_REFLECTION
+
+#include "accessor_benchmark.h"
+
+namespace accessor_performance {
+
+using namespace simdjson;
+
+struct compile_time_at_path_simple {
+  ondemand::parser parser{};
+
+  bool run(simdjson::padded_string &json, std::string &result_str, int64_t&, double&, bool&) {
+    auto doc = parser.iterate(json);
+    std::string_view name;
+    auto r = ondemand::json_path::at_path_compiled<TestData, ".name">(doc);
+    if (r.get(name) != SUCCESS) return false;
+    result_str = name;
+    return true;
+  }
+};
+
+struct compile_time_at_path_nested {
+  ondemand::parser parser{};
+
+  bool run(simdjson::padded_string &json, std::string &result_str, int64_t&, double&, bool&) {
+    auto doc = parser.iterate(json);
+    std::string_view city;
+    auto r = ondemand::json_path::at_path_compiled<TestData, ".address.city">(doc);
+    if (r.get(city) != SUCCESS) return false;
+    result_str = city;
+    return true;
+  }
+};
+
+struct compile_time_at_path_deep {
+  ondemand::parser parser{};
+
+  bool run(simdjson::padded_string &json, std::string&, int64_t&, double &result_dbl, bool&) {
+    auto doc = parser.iterate(json);
+    double lat;
+    auto r = ondemand::json_path::at_path_compiled<TestData, ".address.coordinates.lat">(doc);
+    if (r.get(lat) != SUCCESS) return false;
+    result_dbl = lat;
+    return true;
+  }
+};
+
+BENCHMARK_TEMPLATE(accessor_simple, compile_time_at_path_simple)->UseManualTime();
+BENCHMARK_TEMPLATE(accessor_nested, compile_time_at_path_nested)->UseManualTime();
+BENCHMARK_TEMPLATE(accessor_deep, compile_time_at_path_deep)->UseManualTime();
+
+} // namespace accessor_performance
+
+#endif // SIMDJSON_EXCEPTIONS && SIMDJSON_STATIC_REFLECTION

benchmark/accessor_performance/runtime_accessors.h

@@ -0,0 +1,53 @@
+#pragma once
+
+#if SIMDJSON_EXCEPTIONS
+
+#include "accessor_benchmark.h"
+
+namespace accessor_performance {
+
+using namespace simdjson;
+
+struct runtime_at_path_simple {
+  ondemand::parser parser{};
+
+  bool run(simdjson::padded_string &json, std::string &result_str, int64_t&, double&, bool&) {
+    auto doc = parser.iterate(json);
+    std::string_view name;
+    if (doc.at_path(".name").get(name) != SUCCESS) return false;
+    result_str = name;
+    return true;
+  }
+};
+
+struct runtime_at_path_nested {
+  ondemand::parser parser{};
+
+  bool run(simdjson::padded_string &json, std::string &result_str, int64_t&, double&, bool&) {
+    auto doc = parser.iterate(json);
+    std::string_view city;
+    if (doc.at_path(".address.city").get(city) != SUCCESS) return false;
+    result_str = city;
+    return true;
+  }
+};
+
+struct runtime_at_path_deep {
+  ondemand::parser parser{};
+
+  bool run(simdjson::padded_string &json, std::string&, int64_t&, double &result_dbl, bool&) {
+    auto doc = parser.iterate(json);
+    double lat;
+    if (doc.at_path(".address.coordinates.lat").get(lat) != SUCCESS) return false;
+    result_dbl = lat;
+    return true;
+  }
+};
+
+BENCHMARK_TEMPLATE(accessor_simple, runtime_at_path_simple)->UseManualTime();
+BENCHMARK_TEMPLATE(accessor_nested, runtime_at_path_nested)->UseManualTime();
+BENCHMARK_TEMPLATE(accessor_deep, runtime_at_path_deep)->UseManualTime();
+
+} // namespace accessor_performance
+
+#endif // SIMDJSON_EXCEPTIONS

benchmark/bench_ondemand.cpp

@@ -148,4 +148,9 @@ SIMDJSON_POP_DISABLE_WARNINGS
 #include "large_amazon_cellphones/simdjson_dom.h"
 #include "large_amazon_cellphones/simdjson_ondemand.h"
 
+#include "accessor_performance/runtime_accessors.h"
+#if SIMDJSON_STATIC_REFLECTION
+#include "accessor_performance/compile_time_accessors.h"
+#endif
+
 BENCHMARK_MAIN();

doc/basics.md

@@ -26,6 +26,7 @@ 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)
+- [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)
   * [Disabling exceptions](#disabling-exceptions)
@@ -66,7 +67,7 @@ Including simdjson
 To include simdjson, copy [simdjson.h](/singleheader/simdjson.h) and [simdjson.cpp](/singleheader/simdjson.cpp)
 into your project. Then include it in your project with:
 
-```c++
+```cpp
 #include "simdjson.h"
 using namespace simdjson; // optional
 ```
@@ -174,7 +175,7 @@ access by creating a `ondemand::parser` and calling the `iterate()` method. The
 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"`):
 
-```c++
+```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
@@ -184,7 +185,7 @@ If you prefer not to create your own `ondemand::parser` instance, you can access
 a thread-local version by calling `ondemand::parser.get_parser()`.
 
 
-```c++
+```cpp
 ondemand::document doc = ondemand::parser.get_parser().iterate(json);
 ```
 
@@ -194,7 +195,7 @@ document per thread at any one time.
 
 You can also create a padded string---and call `iterate()`:
 
-```c++
+```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
@@ -202,7 +203,7 @@ 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:
 
-```c++
+```cpp
 ondemand::parser parser;
 char json[3+SIMDJSON_PADDING];
 strcpy(json, "[1]");
@@ -214,14 +215,14 @@ reference is non-const, it will allocate padding as needed.
 
 You can copy your data directly on a `simdjson::padded_string` as follows:
 
-```c++
+```cpp
 const char * data = "my data"; // 7 bytes
 simdjson::padded_string my_padded_data(data, 7); // copies to a padded buffer
 ```
 
 Or as follows...
 
-```c++
+```cpp
 std::string data = "my data";
 simdjson::padded_string my_padded_data(data); // copies to a padded buffer
 ```
@@ -229,7 +230,7 @@ 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:
 
 
-```c++
+```cpp
 ondemand::document doc = parser.iterate(my_padded_data);
 ```
 
@@ -241,7 +242,7 @@ 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:
 
-```c++
+```cpp
 std::string json = "[1]";
 ondemand::document doc = parser.iterate(simdjson::pad(json));
 ```
@@ -452,7 +453,7 @@ support for users who avoid exceptions. See [the simdjson error handling documen
 * **Field Access:** To get the value of the "foo" field in an object, use `object["foo"]`. This will
   scan through the object looking for the field with the matching string, doing a character-by-character
   comparison. It may generate the error `simdjson::NO_SUCH_FIELD` if there is no such key in the object, it may throw an exception (see [Error handling](#error-handling)). For efficiency reason, you should avoid looking up the same field repeatedly: e.g., do
-  not do `object["foo"]` followed by `object["foo"]` with the same `object` instance. Generally, you should not mix and match iterating through an object (`for(auto field : object) {...}`) and key accesses (`object["foo"]`): if you need to iterate through an object after a key access, you need to call `reset()` on the object. Whenever you call `reset()`, you need to keep in mind that though you can iterate over the array repeatedly, values should be consumed only once (e.g., repeatedly calling `unescaped_key()` on the same  key is forbidden). Keep in mind that On-Demand does not buffer or save the result of the parsing: if you repeatedly access `object["foo"]`, then it must repeatedly seek the key and parse the content. The library does not provide a distinct function to check if a key is present, instead we recommend you attempt to access the key: e.g., by doing `ondemand::value val{}; if (!object["foo"].get(val)) {...}`, you have that `val` contains the requested value inside the if clause.  It is your responsibility as a user to temporarily keep a reference to the value (`auto v = object["foo"]`), or to consume the content and store it in your own data structures. If you consume an
+  not do `object["foo"]` followed by `object["foo"]` with the same `object` instance. Generally, you should not mix and match iterating through an object (`for(auto field : object) {...}`) and key accesses (`object["foo"]`): if you need to iterate through an object after a key access, you need to call `reset()` on the object. Whenever you call `reset()`, you need to keep in mind that though you can iterate over the array repeatedly, values should be consumedonly once (e.g., repeatedly calling `unescaped_key()` on the same  key is forbidden). Keep in mind that On-Demand does not buffer or save the result of the parsing: if you repeatedly access `object["foo"]`, then it must repeatedly seek the key and parse the content. The library does not provide a distinct function to check if a key is present, instead we recommend you attempt to access the key: e.g., by doing `ondemand::value val{}; if (!object["foo"].get(val)) {...}`, you have that `val` contains the requested value inside the if clause.  It is your responsibility as a user to temporarily keep a reference to the value (`auto v = object["foo"]`), or to consume the content and store it in your own data structures. If you consume an
   object twice: `std::string_view(object["foo"]` followed by `std::string_view(object["foo"]` then your code
   is in error. Furthermore, you can only consume one field at a time, on the same object. The
   value instance you get from  `content["bids"]` becomes invalid when you call `content["asks"]`.
@@ -474,7 +475,7 @@ support for users who avoid exceptions. See [the simdjson error handling documen
   > which returns a `std::string_view` instance pointing directly in the document, like `key()`, although,
   > unlike `key()`, it has to determine the location of the final quote character.
   >
-  > ```c++
+  > ```cpp
   > auto json = R"({"k\u0065y": 1})"_padded;
   > ondemand::parser parser;
   > auto doc = parser.iterate(json);
@@ -498,7 +499,7 @@ support for users who avoid exceptions. See [the simdjson error handling documen
   > This will only look forward, and will fail to find fields in the wrong order: for example, this
   > will fail:
   >
-  > ```c++
+  > ```cpp
   > ondemand::parser parser;
   > auto json = R"(  { "x": 1, "y": 2 }  )"_padded;
   > auto doc = parser.iterate(json);
@@ -508,7 +509,7 @@ support for users who avoid exceptions. See [the simdjson error handling documen
   >
   > By contrast, using the default (order-insensitive) lookup succeeds:
   >
-  > ```c++
+  > ```cpp
   > ondemand::parser parser;
   > auto json = R"(  { "x": 1, "y": 2 }  )"_padded;
   > auto doc = parser.iterate(json);
@@ -516,20 +517,20 @@ support for users who avoid exceptions. See [the simdjson error handling documen
   > double x = doc["x"]; // Success: [] loops back around to find "x"
   > ```
 * **Output to strings:** Given a document, a value, an array or an object in a JSON document, you can output a JSON string version suitable to be parsed again as JSON content: `simdjson::to_json_string(element)`. A call to `to_json_string` consumes fully the element: if you apply it on a document, the internal pointer is advanced to the end of the document. The `simdjson::to_json_string` does not allocate memory. The `to_json_string` function should not be confused with retrieving the value of a string instance which are escaped and represented using a lightweight `std::string_view` instance pointing at an internal string buffer inside the parser instance. To illustrate, the first of the following two code segments will print the unescaped string `"test"` complete with the quote whereas the second one will print the escaped content of the string (without the quotes).
-  > ```C++
+  > ```cpp
   > // serialize a JSON to an escaped std::string instance so that it can be parsed again as JSON
   > auto silly_json = R"( { "test": "result"  }  )"_padded;
   > ondemand::document doc = parser.iterate(silly_json);
   > std::cout << simdjson::to_json_string(doc["test"]) << std::endl; // Requires simdjson 1.0 or better
   >````
-  > ```C++
+  > ```cpp
   > // retrieves an unescaped string value as a string_view instance
   > auto silly_json = R"( { "test": "result"  }  )"_padded;
   > ondemand::document doc = parser.iterate(silly_json);
   > std::cout << std::string_view(doc["test"]) << std::endl;
   >````
   You can use `to_json_string` to efficiently extract components of a JSON document to reconstruct a new JSON document, as in the following example:
-  > ```C++
+  > ```cpp
   > auto cars_json = R"( [
   >   { "make": "Toyota", "model": "Camry",  "year": 2018, "tire_pressure": [ 40.1, 39.9, 37.7, 40.4 ] },
   >   { "make": "Kia",    "model": "Soul",   "year": 2012, "tire_pressure": [ 30.1, 31.0, 28.6, 28.7 ] },
@@ -562,7 +563,7 @@ support for users who avoid exceptions. See [the simdjson error handling documen
   `uint64_t`, `int64_t`, `bool`, `ondemand::object` and `ondemand::array`) and pass it by reference
   to `get()` which gives you back an error code: e.g.,
 
-  ```c++
+  ```cpp
   auto abstract_json = R"(
     { "str" : { "123" : {"abc" : 3.14 } } }
   )"_padded;
@@ -583,7 +584,7 @@ support for users who avoid exceptions. See [the simdjson error handling documen
   whole array. You should only call `count_elements` as a last resort as it may
   require scanning the document twice or more. You should never use the `count_elements` as part of an attempt to iterate through the array: use a `for` loop to iterate through arrays. In the spirit of On-Demand, the `count_elements` function does not validate the values in the array: they are validated when they are consumed. You may use it as follows if your document is itself an array:
 
-  ```C++
+  ```cpp
   auto cars_json = R"( [ 40.1, 39.9, 37.7, 40.4 ] )"_padded;
   auto doc = parser.iterate(cars_json);
   size_t count = doc.count_elements(); // requires simdjson 1.0 or better
@@ -611,7 +612,7 @@ support for users who avoid exceptions. See [the simdjson error handling documen
   whole objects. You should only call `count_fields` as a last resort as it may
   require scanning the document twice or more.  You may use it as follows if your document is itself an object:
 
-  ```C++
+  ```cpp
   ondemand::parser parser;
   auto json = R"( { "test":{ "val1":1, "val2":2 } }   )"_padded;
   auto doc = parser.iterate(json);
@@ -642,7 +643,7 @@ support for users who avoid exceptions. See [the simdjson error handling documen
   You must still validate and consume the values (e.g., call `is_null()`) after calling `type()`.
    You may also access [the raw JSON string](#general-direct-access-to-the-raw-json-string).
   For example, the following is a quick and dirty recursive function that verbosely prints the JSON document as JSON. This example also illustrates lifecycle requirements: the `document` instance holds the iterator. The document must remain in scope while you are accessing instances of `value`, `object` and `array`.
-  ```c++
+  ```cpp
   void recursive_print_json(ondemand::value element) {
     bool add_comma;
     switch (element.type()) {
@@ -724,7 +725,7 @@ Let us review these concepts with some additional examples. For simplicity, we o
 
 The first example illustrates how we can chain operations. In this instance, we repeatedly select keys using the bracket operator (`doc["str"]`) and then finally request a number (using `get_double()`). It is safe to write code in this manner: if any step causes an error, the error status propagates and an exception is thrown at the end. You do not need to constantly check for errors.
 
-```C++
+```cpp
 auto abstract_json = R"(
   { "str" : { "123" : {"abc" : 3.14 } } }
 )"_padded;
@@ -738,7 +739,7 @@ an array of objects. We iterate through the objects using a for-loop. Within eac
 the bracket operator (e.g., `car["make"]`) to select values. We also show how we can iterate through an
 array, corresponding to the key `tire_pressure`,  that is contained inside each object.
 
-```c++
+```cpp
 ondemand::parser parser;
 auto cars_json = R"( [
   { "make": "Toyota", "model": "Camry",  "year": 2018, "tire_pressure": [ 40.1, 39.9, 37.7, 40.4 ] },
@@ -768,7 +769,7 @@ for (ondemand::object car : parser.iterate(cars_json)) {
 The previous example had an array of objects, but we can use essentially the same
 approach with an object of objects.
 
-```c++
+```cpp
 ondemand::parser parser;
 auto cars_json = R"( {
   "identifier1":{ "make": "Toyota", "model": "Camry",  "year": 2018, "tire_pressure": [ 40.1, 39.9, 37.7, 40.4 ] },
@@ -803,7 +804,7 @@ for (ondemand::field key_car : doc.get_object()) {
 
 The following example illustrates how you may also iterate through object values, effectively visiting all key-value pairs in the object.
 
-```C++
+```cpp
 #include <iostream>
 #include "simdjson.h"
 using namespace std;
@@ -852,7 +853,7 @@ The C++26 approach is even simpler.
 
 Suppose you have your own types, such as a `Car` struct:
 
-```C++
+```cpp
 struct Car {
   std::string make;
   std::string model;
@@ -864,7 +865,7 @@ struct Car {
 You might want to write code that automatically parses the JSON content to your custom
 type:
 
-```C++
+```cpp
   padded_string json = R"( [ { "make": "Toyota", "model": "Camry",  "year": 2018,
        "tire_pressure": [ 40.1, 39.9 ] },
   { "make": "Kia",    "model": "Soul",   "year": 2012,
@@ -889,7 +890,7 @@ is automatically provided by simdjson if C++20 (and concepts) are available.
 See [Use `tag_invoke` for custom types](#2-use-tag_invoke-for-custom-types-c20) if you have
 C++20 support.
 
-```c++
+```cpp
 #if !SIMDJSON_SUPPORTS_CONCEPTS
 // The code is unnecessary with C++20:
 template <>
@@ -912,7 +913,7 @@ simdjson::ondemand::value::get() noexcept {
 
 We may then provide support for our `Car` struct:
 
-```C++
+```cpp
 template <>
 simdjson_inline simdjson_result<Car> simdjson::ondemand::value::get() noexcept {
   ondemand::object obj;
@@ -929,7 +930,7 @@ simdjson_inline simdjson_result<Car> simdjson::ondemand::value::get() noexcept {
 
 And that is all that is needed! The following code is a complete example:
 
-```c++
+```cpp
 #include "simdjson.h"
 #include <iostream>
 #include <vector>
@@ -1000,7 +1001,7 @@ Observe that we require an explicit cast (`Car c(val)` instead of `for (Car c :
 
 If you prefer to avoid exceptions, you may modify the `main` function as follows:
 
-```c++
+```cpp
 int main(void) {
   padded_string json = R"( [ { "make": "Toyota", "model": "Camry",  "year": 2018,
        "tire_pressure": [ 40.1, 39.9 ] },
@@ -1030,7 +1031,7 @@ the `ondemand::document` type. In this instance, we must replace the function wi
 `simdjson_result<Car> simdjson::ondemand::document::get() &`. The following is a complete
 example:
 
-```C++
+```cpp
 #include "simdjson.h"
 #include <iostream>
 #include <vector>
@@ -1110,7 +1111,7 @@ The simdjson library takes advantage of C++20. An immediate benefit
 is that you can deserialize JSON data directly in standard containers
 and other standard value types:
 
-```C++
+```cpp
 simdjson::padded_string json = R"({"data" : [1,2,3,4]})"_padded;
 
 simdjson::ondemand::parser parser;
@@ -1120,7 +1121,7 @@ std::vector<uint8_t> array = d["data"].get<std::vector<uint8_t>>();
 
 Appending to an existing container is just as easy:
 
-```C++
+```cpp
 std::vector<uint32_t> array = {0, 0};
 
 simdjson::padded_string json = R"({"data" : [1,2,3,4]})"_padded;
@@ -1147,7 +1148,7 @@ to 1, otherwise it is set to 0.
 
 Consider a custom class `Car`:
 
-```C++
+```cpp
 struct Car {
   std::string make;
   std::string model;
@@ -1164,7 +1165,7 @@ You may support deserializing directly from a JSON value or document to your own
 by defining a single `tag_invoke` function:
 
 
-```C++
+```cpp
 namespace simdjson {
 // This tag_invoke MUST be inside simdjson namespace
 template <typename simdjson_value>
@@ -1279,7 +1280,7 @@ By default, we support a wide range of standard templates such as
 etc. They are handled automatically.
 
 E.g., you can recover an `std::unique_ptr<Car>` like so:
-```C++
+```cpp
 int main() {
   auto const json = R"( { "make": "Toyota", "model": "Camry",  "year": 2018,
        "tire_pressure": [ 40.1, 39.9 ] })"_padded;
@@ -1293,7 +1294,7 @@ int main() {
 
 You may also conditionally fill in `std::optional` values.
 
-```C++
+```cpp
   padded_string json =
       R"( { "car1": { "make": "Toyota", "model": "Camry",  "year": 2018,
        "tire_pressure": [ 40.1, 39.9 ] }
@@ -1312,7 +1313,7 @@ You can also deserialize to map-like types with keys that can be constructed
 from `std::string_view` instances:
 
 
-```C++
+```cpp
   padded_string json =
       R"( { "car1": { "make": "Toyota", "model": "Camry",  "year": 2018,
        "tire_pressure": [ 40.1, 39.9 ] }
@@ -1332,7 +1333,7 @@ Suppose for example that you want to construct an instance of `std::list<Car>`,
 you also want to filter out any car made by Toyota. You may provide your own
 `tag_invoke` function:
 
-```c++
+```cpp
 namespace simdjson {
 // suppose we want to filter out all Toyotas
 template <typename simdjson_value>
@@ -1377,7 +1378,7 @@ Then you can deserialize a type such as `Car` automatically:
 
 
 
-```C++
+```cpp
 struct Car {
   std::string make;
   std::string model;
@@ -1543,7 +1544,7 @@ Minifying JSON strings without parsing
 
 In some cases, you may have valid JSON strings that you do not wish to parse but that you wish to minify. That is, you wish to remove all unnecessary spaces. We have a fast function for this purpose (`simdjson::minify(const char * input, size_t length, const char * output, size_t& new_length)`). This function does not validate your content, and it does not parse it.  It is much faster than parsing the string and re-serializing it in minified form (`simdjson::minify(parser.parse())`). Usage is relatively simple. You must pass an input pointer with a length parameter, as well as an output pointer and an output length parameter (by reference). The output length parameter is not read, but written to. The output pointer should point to a valid memory region that is as large as the original string length. The input pointer and input length are read, but not written to.
 
-```C++
+```cpp
   // Starts with a valid JSON document as a string.
   // It does not have to be null-terminated.
   const char * some_string = "[ 1, 2, 3, 4] ";
@@ -1564,7 +1565,7 @@ UTF-8 validation (alone)
 
 The simdjson library has fast functions to validate UTF-8 strings. They are many times faster than most functions commonly found in libraries. You can use our fast functions, even if you do not care about JSON.
 
-```C++
+```cpp
   const char * some_string = "[ 1, 2, 3, 4] ";
   size_t length = std::strlen(some_string);
   bool is_ok = simdjson::validate_utf8(some_string, length);
@@ -1581,11 +1582,11 @@ JSON Pointer
 
 The simdjson library also supports [JSON pointer](https://tools.ietf.org/html/rfc6901) through the `at_pointer()` method, letting you reach further down into the document in a single call. JSON Pointer is supported by both the [DOM approach](https://github.com/simdjson/simdjson/blob/master/doc/dom.md#json-pointer) as well as the On-Demand approach.
 
-**Note:** The On-Demand implementation of JSON Pointer relies on `find_field` which implies that it does not unescape keys when matching.
+**Note:** When matching keys, we do a byte-by-byte comparison. We do not unescape keys when matching.
 
 Consider the following example:
 
-```c++
+```cpp
 auto cars_json = R"( [
   { "make": "Toyota", "model": "Camry",  "year": 2018, "tire_pressure": [ 40.1, 39.9, 37.7, 40.4 ] },
   { "make": "Kia",    "model": "Soul",   "year": 2012, "tire_pressure": [ 30.1, 31.0, 28.6, 28.7 ] },
@@ -1603,7 +1604,7 @@ select the value. If your keys contain the characters '/' or '~', they must be e
 
 For multiple JSON Pointer queries on a document, one can call `at_pointer` multiple times.
 
-```c++
+```cpp
 auto cars_json = R"( [
   { "make": "Toyota", "model": "Camry",  "year": 2018, "tire_pressure": [ 40.1, 39.9, 37.7, 40.4 ] },
   { "make": "Kia",    "model": "Soul",   "year": 2012, "tire_pressure": [ 30.1, 31.0, 28.6, 28.7 ] },
@@ -1624,7 +1625,7 @@ In most instances, a JSON Pointer is an ASCII string and the keys in a JSON docu
 are ASCII strings. We support UTF-8 in JSON Pointer, but key values are matched exactly, without unescaping or Unicode normalization. We do a byte-by-byte comparison. The e acute character is
 considered distinct from its escaped version `\u00E9`. E.g.,
 
-```c++
+```cpp
 const padded_string json = "{\"\\u00E9\":123}"_padded;
 auto doc = parser.iterate(json);
 doc.at_pointer("/\\u00E9") == 123; // true
@@ -1633,7 +1634,7 @@ doc.at_pointer((const char*)u8"/\u00E9") // returns an error (NO_SUCH_FIELD)
 
 Note that `at_pointer` calls [`rewind`](#rewind) to reset the parser at the beginning of the document. Hence, it invalidates all previously parsed values, objects and arrays: make sure to consume the values between each call to  `at_pointer`. Consider the following example where one wants to store each object from the JSON into a vector of `struct car_type`:
 
-```c++
+```cpp
 struct car_type {
     std::string make;
     std::string model;
@@ -1676,7 +1677,7 @@ for (int i = 0; i < 3; i++) {
 
 Furthermore, `at_pointer` calls `rewind` at the beginning of the call (i.e. the document is not reset after `at_pointer`). Consider the following example,
 
-```c++
+```cpp
 auto json = R"( {
   "k0": 27,
   "k1": [13,26],
@@ -1696,7 +1697,7 @@ be represented as `value` instances. You can check that a document is a scalar w
 JSONPath
 ------------
 
-The simdjson library supports a subset of [JSONPath](https://datatracker.ietf.org/doc/html/draft-normington-jsonpath-00) through the `at_path()` method, allowing you to reach further into the document in a single call. The subset of JSONPath that is implemented is the subset that is trivially convertible into the JSON Pointer format, using `.` to access a field and `[]` to access a specific index.
+The simdjson library supports a subset of [JSONPath](https://www.rfc-editor.org/rfc/rfc9535) (RFC 9535) through the `at_path()` method, allowing you to reach further into the document in a single call. The subset of JSONPath that is implemented is the subset that is trivially convertible into the JSON Pointer format, using `.` to access a field and `[]` to access a specific index.
 
 This implementation relies on `at_path()` converting its argument to JSON Pointer and then calling `at_pointer`, which makes use of
 [`rewind`](#rewind) to reset the parser at the beginning of the document. Hence, it invalidates all previously parsed values, objects
@@ -1704,7 +1705,7 @@ This implementation relies on `at_path()` converting its argument to JSON Pointe
 
 Consider the following example:
 
-```c++
+```cpp
 auto cars_json = R"( [
   { "make": "Toyota", "model": "Camry",  "year": 2018, "tire_pressure": [ 40.1, 39.9, 37.7, 40.4 ] },
   { "make": "Kia",    "model": "Soul",   "year": 2012, "tire_pressure": [ 30.1, 31.0, 28.6, 28.7 ] },
@@ -1717,7 +1718,7 @@ cout << cars.at_path("[0].tire_pressure[1]") << endl; // Prints 39.9
 
 A call to `at_path(json_path)` can result in any of the errors that are returned by the `at_pointer` method and if the conversion of `json_path` to JSON Pointer fails, it will lead to an `simdjson::INVALID_JSON_POINTER`error.
 
-```c++
+```cpp
 auto cars_json = R"( [
   { "make": "Toyota", "model": "Camry",  "year": 2018, "tire_pressure": [ 40.1, 39.9, 37.7, 40.4 ] },
   { "make": "Kia",    "model": "Soul",   "year": 2012, "tire_pressure": [ 30.1, 31.0, 28.6, 28.7 ] },
@@ -1734,7 +1735,7 @@ are ASCII strings. We support UTF-8 within a JSONPath expression, but key values
 matched exactly, without unescaping or Unicode normalization. We do a byte-by-byte comparison.
 The e acute character is considered distinct from its escaped version `\u00E9`. E.g.,
 
-```c++
+```cpp
 const padded_string json = "{\"\\u00E9\":123}"_padded;
 auto doc = parser.iterate(json);
 doc.at_path(".\\u00E9") == 123; // true
@@ -1744,7 +1745,7 @@ doc.at_path((const char*)u8".\u00E9") // returns an error (NO_SUCH_FIELD)
 
 We also support the `$` prefix. When you start a JSONPath expression with $, you are indicating that the path starts from the root of the JSON document. E.g.,
 
-```c++
+```cpp
 auto json = R"( { "c" :{ "foo": { "a": [ 10, 20, 30 ] }}, "d": { "foo2": { "a": [ 10, 20, 30 ] }} , "e": 120 })"_padded;
 ondemand::parser parser;
 ondemand::document doc = parser.iterate(json);
@@ -1753,6 +1754,75 @@ int64_t x = obj.at_path("$.c.foo.a[1]"); // 20
 x = obj.at_path("$.d.foo2.a.2"); // 30
 ```
 
+
+
+### C++26
+
+
+We also support shit
+If you have C++26 support with reflection, and you have set the `SIMDJSON_STATIC_REFLECTION` macro, e
+
+```cpp
+#define SIMDJSON_STATIC_REFLECTION 1
+//...
+#include "simdjson.h"
+```
+
+```cpp
+auto cars_json = R"( [
+  { "make": "Toyota", "model": "Camry",  "year": 2018, "tire_pressure": [ 40.1, 39.9, 37.7, 40.4 ] },
+  { "make": "Kia",    "model": "Soul",   "year": 2012, "tire_pressure": [ 30.1, 31.0, 28.6, 28.7 ] },
+  { "make": "Toyota", "model": "Tercel", "year": 1999, "tire_pressure": [ 29.8, 30.0, 30.2, 30.5 ] }
+] )"_padded;
+ondemand::parser parser;
+auto cars = parser.iterate(cars_json);
+cout << cars.at_path("[0].tire_pressure[1]") << endl; // Prints 39.9
+```
+
+### C++26
+
+
+We also support shit
+If you have C++26 support with reflection, and you have set the `SIMDJSON_STATIC_REFLECTION` macro, e
+
+```cpp
+#define SIMDJSON_STATIC_REFLECTION 1
+//...
+#include "simdjson.h"
+```
+
+```cpp
+auto cars_json = R"( [
+  { "make": "Toyota", "model": "Camry",  "year": 2018, "tire_pressure": [ 40.1, 39.9, 37.7, 40.4 ] },
+  { "make": "Kia",    "model": "Soul",   "year": 2012, "tire_pressure": [ 30.1, 31.0, 28.6, 28.7 ] },
+  { "make": "Toyota", "model": "Tercel", "year": 1999, "tire_pressure": [ 29.8, 30.0, 30.2, 30.5 ] }
+] )"_padded;
+ondemand::parser parser;
+auto cars = parser.iterate(cars_json);
+cout << cars.at_path("[0].tire_pressure[1]") << endl; // Prints 39.9
+```
+
+## Compile-Time JSONPath and JSON Pointer (C++26 Reflection)
+
+simdjson 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
+is validated at compile-time.
+
+**Requirements:** C++26 compiler with P2996 reflection support and `-DSIMDJSON_STATIC_REFLECTION=ON` build flag.
+
+```cpp
+ondemand::parser parser;
+auto doc = parser.iterate(json);
+
+// Without validation - path parsed at compile time only
+std::string_view city;
+result = ondemand::json_path::at_path_compiled<".address.city">(doc);
+result.get(city);
+```
+
+We further provide type-validation so that you can check that the types are as you expect.
+
+**See [Compile-Time Accessors](compile_time_accessors.md) for complete documentation.**
+
 Error handling
 --------------
 
@@ -1761,7 +1831,7 @@ Error handling with exception and a single try/catch clause makes the code simpl
 The entire simdjson API is usable with and without exceptions. All simdjson APIs that can fail return `simdjson_result<T>`, which is a &lt;value, error_code&gt;
 pair. You can retrieve the value with .get() without generating an exception, like so:
 
-```c++
+```cpp
 ondemand::document doc;
 auto error = parser.iterate(json).get(doc);
 if(error) { std::cerr << simdjson::error_message(error); exit(1); }
@@ -1798,7 +1868,7 @@ set of warnings: they can identify variables that are written to but never other
 Let us illustrate with an example where we try to access a number that is not valid (`3.14.1`).
 If we want to proceed without throwing and catching exceptions, we can do so as follows:
 
-```C++
+```cpp
 bool simple_error_example() {
     ondemand::parser parser;
     auto json = R"({"bad number":3.14.1 })"_padded;
@@ -1820,7 +1890,7 @@ Observe how we verify the error variable before accessing the retrieved number (
 
 The equivalent with exception handling might look as follows.
 
-```C++
+```cpp
   bool simple_error_example_except() {
     TEST_START();
     ondemand::parser parser;
@@ -1861,7 +1931,7 @@ We can write a "quick start" example where we attempt to parse the following JSO
 Our program loads the file, selects value corresponding to key `"search_metadata"` which expected to be an object, and then
 it selects the key `"count"` within that object.
 
-```C++
+```cpp
 #include <iostream>
 #include "simdjson.h"
 
@@ -1893,7 +1963,7 @@ triggering exceptions. To do this, we use `["statuses"].at(0)["id"]`. We break t
 Observe how we use the `at` method when querying an index into an array, and not the bracket operator.
 
 
-```C++
+```cpp
 #include <iostream>
 #include "simdjson.h"
 
@@ -1919,7 +1989,7 @@ to iterate through the values of an array. We deliberately forbid this usage to
 
 This is how the example in "Using the parsed JSON" could be written using only error code checking (without exceptions):
 
-```c++
+```cpp
 bool parse() {
   ondemand::parser parser;
   auto cars_json = R"( [
@@ -1976,7 +2046,7 @@ bool parse() {
 For safety, you should only use our ondemand instances (e.g., `ondemand::object`)
 after you have initialized them and checked that there is no error:
 
-```c++
+```cpp
     ondemand::object car; // invalid until the get() succeeds
     // the `car` instance should not use used before it is initialized
     error = car_value.get_object().get(car);
@@ -1989,7 +2059,7 @@ after you have initialized them and checked that there is no error:
 
 The following examples illustrates how to iterate through the content of an object without
 having to handle exceptions.
-```c++
+```cpp
   auto json = R"({"k\u0065y": 1})"_padded;
   ondemand::parser parser;
   ondemand::document doc;
@@ -2025,7 +2095,7 @@ target_compile_definitions(simdjson PUBLIC SIMDJSON_EXCEPTIONS=OFF)
 
 Users more comfortable with an exception flow may choose to directly cast the `simdjson_result<T>` to the desired type:
 
-```c++
+```cpp
 simdjson::ondemand::document doc = parser.iterate(json); // Throws an exception if there was an error!
 ```
 
@@ -2035,7 +2105,7 @@ program from continuing if there was an error.
 
 If one is willing to trigger exceptions, it is possible to write simpler code:
 
-```C++
+```cpp
 #include <iostream>
 #include "simdjson.h"
 
@@ -2052,7 +2122,7 @@ int main(void) {
 
 You can do handle errors gracefully as well...
 
-```C++
+```cpp
 #include <iostream>
 #include "simdjson.h"
 int main(void) {
@@ -2079,7 +2149,7 @@ When the input was a `padding_string` or another null-terminated source, then yo
 use the `const char *` pointer as a C string. As an example, consider the following
 example where we used the exception-free simdjson interface:
 
-```c++
+```cpp
 auto broken_json = R"( {"double": 13.06, false, "integer": -343} )"_padded;    // Missing key
 ondemand::parser parser;
 auto doc = parser.iterate(broken_json);
@@ -2099,7 +2169,7 @@ if (error) {
 
 You may also use `current_location()` with exceptions as follows:
 
-```c++
+```cpp
 auto broken_json = R"( {"double": 13.06, false, "integer": -343} )"_padded;
 ondemand::parser parser;
 ondemand::document doc = parser.iterate(broken_json);
@@ -2116,7 +2186,7 @@ had to go through a value without a key before (`false`), a `TAPE_ERROR` error i
 The pointer returned by the `current_location()` method then points at the location of the error. The `current_location()` may also be used when the error is triggered
 by a user action, even if the JSON input is valid. Consider the following example:
 
-```c++
+```cpp
 auto json = R"( [1,2,3] )"_padded;
 ondemand::parser parser;
 auto doc = parser.iterate(json);
@@ -2131,7 +2201,7 @@ if (error) {
 If the location is invalid (i.e. at the end of a document), the `current_location()`
 methods returns an `OUT_OF_BOUNDS` error. For example:
 
-```c++
+```cpp
 auto json = R"( [1,2,3] )"_padded;
 ondemand::parser parser;
 auto doc = parser.iterate(json);
@@ -2147,7 +2217,7 @@ then the document has more content.
 Finally, the `current_location()` method may also be used even when no exceptions/errors
 are thrown. This can be helpful for users that want to know the current state of iteration during parsing. For example:
 
-```c++
+```cpp
 auto json = R"( [[1,2,3], -23.4, {"key": "value"}, true] )"_padded;
 ondemand::parser parser;
 auto doc = parser.iterate(json);
@@ -2180,7 +2250,7 @@ content.
 
 Example 1.
 
-```C++
+```cpp
   auto json = R"([1, 2] foo ])"_padded;
   ondemand::parser parser;
   ondemand::document doc = parser.iterate(json);
@@ -2223,7 +2293,7 @@ that you have created so far (including unescaped strings).
 In the following example, we print on the screen the number of cars in the JSON input file
 before printout the data.
 
-```C++
+```cpp
   ondemand::parser parser;
   auto cars_json = R"( [
     { "make": "Toyota", "model": "Camry",  "year": 2018, "tire_pressure": [ 40.1, 39.9, 37.7, 40.4 ] },
@@ -2271,7 +2341,7 @@ individual document must be no larger than 4 GB.
 
 Here is an example:
 
-```c++
+```cpp
 auto json = R"({ "foo": 1 } { "foo": 2 } { "foo": 3 } )"_padded;
 ondemand::parser parser;
 ondemand::document_stream docs = parser.iterate_many(json);
@@ -2293,7 +2363,7 @@ The `iterate_many` function can also take an optional parameter `size_t batch_si
 
 The following toy examples illustrates how to get capacity errors. It is an artificial example since you should never use a `batch_size` of 50 bytes (it is far too small).
 
-```c++
+```cpp
 // We are going to set the capacity to 50 bytes which means that we cannot
 // loading a document longer than 50 bytes. The first few documents are small,
 // but the last one is large. We will get an error at the last document.
@@ -2353,7 +2423,7 @@ methods appropriately. In particular, a valid JSON number has no leading and no
 numbers (although you have access to the raw string with the `raw_json_token()` method,  see [General direct access to the raw JSON string](#general-direct-access-to-the-raw-json-string)
 ). As an example, suppose we have the following JSON text:
 
-```c++
+```cpp
 auto json =
 {
    "ticker":{
@@ -2387,7 +2457,7 @@ auto json =
 
 Now, suppose that a user wants to get the time stamp from the `timestampstr` key. One could do the following:
 
-```c++
+```cpp
 ondemand::parser parser;
 auto doc = parser.iterate(json);
 uint64_t time = doc.at_pointer("/timestampstr").get_uint64_in_string();
@@ -2396,7 +2466,7 @@ std::cout << time << std::endl;   // Prints 1399490941
 
 Another thing a user might want to do is extract the `markets` array and get the market name, price and volume. Here is one way to do so:
 
-```c++
+```cpp
 ondemand::parser parser;
 auto doc = parser.iterate(json);
 
@@ -2418,7 +2488,7 @@ Market: btce    Price: 432.89   Volume: 8561.06
 
 Finally, here is an example dealing with errors where the user wants to convert the string `"Infinity"`(`"change"` key) to a float with infinity value.
 
-```c++
+```cpp
 ondemand::parser parser;
 auto doc = parser.iterate(json);
 // Get "change"/"Infinity" key/value pair
@@ -2487,7 +2557,7 @@ The `get_number()` function is designed with performance in mind. When calling `
 
 
 Consider the following example:
-```C++
+```cpp
     ondemand::parser parser;
     padded_string docdata = R"([1.0, 3, 1, 3.1415,-13231232,9999999999999999999])"_padded;
     ondemand::document doc = parser.iterate(docdata);
@@ -2534,7 +2604,7 @@ unsigned integers. Calling `get_number_type()` on the values returns `ondemand::
 You can try to represent these big integers as 64-bit floating-point numbers, though you typically lose
 precision in the process (as illustrated in the example).
 
-```C++
+```cpp
   ondemand::parser parser;
   padded_string docdata = R"([-9223372036854775809, 18446744073709551617, 99999999999999999999999 ])"_padded;
   double dexpected[] = {-9223372036854775808.0, 18446744073709551616.0, 1e23};
@@ -2557,7 +2627,7 @@ This program might print:
 You may get access to the underlying string representing the big integer with
 `raw_json_token()` and you may parse the resulting number strings using your own parser.
 
-```c++
+```cpp
   ondemand::parser parser;
   padded_string docdata = R"([-9223372036854775809, 18446744073709551617, 99999999999999999999999 ])"_padded;
   ondemand::document doc = parser.iterate(docdata);
@@ -2596,7 +2666,7 @@ you should ensure that you have sufficient memory space: the total size of the s
 `simdjson::SIMDJSON_PADDING` bytes. The following example illustrates how we can unescape
 JSON string to a user-provided buffer:
 
-```C++
+```cpp
     auto json = R"( {"name": "Jack The Ripper \u0033"} )"_padded;
     // We create a buffer large enough to store all strings we need:
     std::unique_ptr<uint8_t[]> buffer(new uint8_t[json.size() + simdjson::SIMDJSON_PADDING]);
@@ -2620,7 +2690,7 @@ purpose. It provides a view on the key, including the starting quote character,
 and everything up to the next `:` character after the final quote character. E.g.,
 if the key is `"name"` then `key_raw_json_token()` returns a `std::string_view`  which
 begins with `"name"` and may containing trailing white-space characters.
-```C++
+```cpp
   auto json = R"( {"name" : "Jack The Ripper \u0033"} )"_padded;
   ondemand::parser parser;
   ondemand::document doc = parser.iterate(json);
@@ -2643,7 +2713,7 @@ The library makes this possible by providing a `raw_json_token` method which ret
 a `std::string_view` instance containing the value as a string which you may then
 parse as you see fit.
 
-```C++
+```cpp
 simdjson::ondemand::parser parser;
 simdjson::padded_string docdata =  R"({"value":12321323213213213213213213213211223})"_padded;
 simdjson::ondemand::document doc = parser.iterate(docdata);
@@ -2656,7 +2726,7 @@ The `raw_json_token` method even works when the JSON value is a string. In such
 will return the complete string with the quotes and with eventual escaped sequences as in the
 source document.
 
-```C++
+```cpp
 simdjson::ondemand::parser parser;
 simdjson::padded_string docdata =  R"({"value":"12321323213213213213213213213211223"})"_padded;
 simdjson::ondemand::document doc = parser.iterate(docdata);
@@ -2704,7 +2774,7 @@ If your value is an array or an object, `raw_json_token()` returns effectively a
 character (`[`) or (`}`) which is not very useful. For arrays and objects, we have another
 method called `raw_json()` which consumes (traverses) the array or the object.
 
-```C++
+```cpp
 simdjson::ondemand::parser parser;
 simdjson::padded_string docdata =  R"({"value":123})"_padded;
 simdjson::ondemand::document doc = parser.iterate(docdata);
@@ -2713,7 +2783,7 @@ string_view token = obj.raw_json(); // gives you `{"value":123}`
 ```
 
 
-```C++
+```cpp
 simdjson::ondemand::parser parser;
 simdjson::padded_string docdata =  R"([1,2,3])"_padded;
 simdjson::ondemand::document doc = parser.iterate(docdata);
@@ -2724,7 +2794,7 @@ string_view token = arr.raw_json(); // gives you `[1,2,3]`
 Because `raw_json()` consumes to object or the array, if you want to both have
 access to the raw string, and also use the array or object, you should call `reset()`.
 
-```C++
+```cpp
 simdjson::ondemand::parser parser;
 simdjson::padded_string docdata =  R"({"value":123})"_padded;
 simdjson::ondemand::document doc = parser.iterate(docdata);
@@ -2740,7 +2810,7 @@ value is an array or an object. Otherwise, it acts as `raw_json_token()`.
 It is useful if you do not care for the type of the value and just wants a
 string representation.
 
-```C++
+```cpp
   auto json = R"( [1,2,"fds", {"a":1}, [1,344]] )"_padded;
   ondemand::parser parser;
   ondemand::document doc = parser.iterate(json);
@@ -2751,7 +2821,7 @@ string representation.
   }
 ```
 
-```C++
+```cpp
   auto json = R"( {"key1":1,"key2":2,"key3":"fds", "key4":{"a":1}, "key5":[1,344]} )"_padded;
   ondemand::parser parser;
   ondemand::document doc = parser.iterate(json);
@@ -2799,7 +2869,7 @@ However, they are cases where you need to store a string result in a `std::strin
 instance. You can do so with a templated version of the `to_string()` method which takes as
 a parameter a reference to a `std::string`.
 
-```C++
+```cpp
   auto json = R"({
   "name": "Daniel",
   "age": 42
@@ -2813,7 +2883,7 @@ a parameter a reference to a `std::string`.
 
 The same routine can be written without exceptions handling:
 
-```C++
+```cpp
   std::string name;
   auto error = doc["name"].get_string(name);
   if (error) { /* handle error */ }
@@ -2826,7 +2896,7 @@ only consume a JSON string once.
 Because `get_string()` is a template that requires a type that can be assigned a `std::string`, you
 can use it with features such as `std::optional`:
 
-```C++
+```cpp
   auto json = R"({ "foo1": "3.1416" } )"_padded;
   ondemand::parser parser;
   ondemand::document doc = parser.iterate(json);
@@ -2907,7 +2977,7 @@ For simplicity, we do not include full error support: this code would throw exce
 
 * Example 1: ZuluBBox
 
-```C++
+```cpp
 struct ZuluBBox {
   double xmin;
   double ymin;
@@ -3011,7 +3081,7 @@ bool example() {
 
 * Example 2: Demos
 
-```C++
+```cpp
 bool example() {
   auto json = R"+( {
     "5f08a730b280e54fd1e75a7046b93fdc": {
@@ -3087,7 +3157,7 @@ bool example() {
 
 * Example 3: CRT
 
-```C++
+```cpp
 
 bool example() {
   padded_string padded_input_json = R"([
@@ -3164,7 +3234,7 @@ bool example() {
 
 * Example 4: Passing an array to a function
 
-```C++
+```cpp
 
 #include "simdjson.h"
 #include <iostream>
@@ -3259,13 +3329,13 @@ Performance tips
     }
   ```
 - If possible, refer to each object and array in your code once. For example, the following code repeatedly refers to the `"data"` key to create an object...
-	```C++
+	```cpp
 	std::string_view make = o["data"]["make"];
 	std::string_view model = o["data"]["model"];
 	std::string_view year = o["data"]["year"];
   ```
   We expect that it is more efficient to access the `"data"` key once:
-  ```C++
+  ```cpp
 	simdjson::ondemand::object data = o["data"];
 	std::string_view model = data["model"];
 	std::string_view year = data["year"];

doc/basics_doxygen.md

@@ -1,5 +1,8 @@
 We take our documentation seriously. Please start reading the documentation before you attempt to use simdjson. We hope you will enjoy reading us.
 
-* Basics: https://github.com/simdjson/simdjson/blob/master/doc/basics.md is an overview of how to use simdjson and its APIs.
-* iterate_many: https://github.com/simdjson/simdjson/blob/master/doc/iterate_many.md describes an interface providing features to work with files or streams containing multiple small JSON documents. As fast and convenient as possible.
-* Performance: https://github.com/simdjson/simdjson/blob/master/doc/performance.md shows some more advanced scenarios and how to tune for them.
+* [Basics](doc/basics.md) is an overview of how to use simdjson and its APIs.
+* [Builder](doc/builder.md) is an overview of how to efficiently write JSON strings using simdjson.
+* [Performance](doc/performance.md) shows some more advanced scenarios and how to tune for them.
+* [Implementation Selection](doc/implementation-selection.md) describes runtime CPU detection and
+  how you can work with it.
+* [API](https://simdjson.github.io/simdjson/) contains the automatically generated API documentation.

doc/builder.md

@@ -60,7 +60,7 @@ The later method (`view()`) is recommended.  For performance reasons, we expect
 Example: string_builder
 ---------------------------
 
-```C++
+```cpp
 struct Car {
     std::string make;
     std::string model;

doc/compile_time_accessors.md

@@ -0,0 +1,444 @@
+# Compile-Time JSONPath and JSON Pointer Accessors
+
+**Note:** This feature requires C++26 Static Reflection support (P2996) and is currently only available with experimental compilers. You must enable it with `-DSIMDJSON_STATIC_REFLECTION=ON` when building.
+
+## Overview
+
+simdjson provides compile-time JSONPath and JSON Pointer accessors that validate paths against struct definitions at compile time and generate optimized accessor code with zero runtime overhead. This combines the safety of compile-time type checking with the performance of pre-parsed, pre-validated access paths.
+
+## Requirements
+
+- C++26 compiler with Static Reflection support (P2996)
+- Experimental compiler flags:
+  - Clang with P2996 support: `-std=c++26 -freflection -fexpansion-statements`
+- Build configuration: `-DSIMDJSON_STATIC_REFLECTION=ON`
+
+## How It Works
+
+**Compile Time:**
+1. Path string is parsed and converted to access steps
+2. Path is validated against struct definition using reflection
+3. Field types are checked and verified
+4. Optimized accessor code is generated
+
+**Runtime:**
+- Direct navigation with no parsing
+- No validation overhead
+- No string comparisons for path components
+- Type-safe extraction
+
+## Two Usage Modes
+
+### Mode 1: With Type Validation (Recommended)
+
+When you provide a struct type, the compiler validates the entire path at compile time:
+
+```cpp
+struct User {
+  std::string name;
+  int age;
+  std::vector<std::string> emails;
+};
+
+const padded_string json = R"({
+  "name": "Alice",
+  "age": 30,
+  "emails": ["alice@example.com", "alice@work.com"]
+})"_padded;
+
+ondemand::parser parser;
+auto doc = parser.iterate(json);
+
+// Compile-time validation: checks that User has "name" field of type std::string
+std::string name;
+auto result = ondemand::json_path::at_path_compiled<User, ".name">(doc);
+result.get(name); // name = "Alice"
+
+// Compile-time validation: checks that "emails" is array-like with string elements
+std::string email;
+result = ondemand::json_path::at_path_compiled<User, ".emails[0]">(doc);
+result.get(email); // email = "alice@example.com"
+```
+
+**Benefits:**
+- **Compile-time errors** if path doesn't exist in struct
+- **Type safety** - verifies field types match expected types
+- **Refactoring protection** - renaming struct fields causes compile errors
+
+**What gets validated:**
+- Field existence
+- Field types
+- Array/container access validity
+- Nested struct navigation
+
+### Mode 2: Without Validation
+
+When you omit the struct type, the path is parsed at compile time but not validated:
+
+```cpp
+const padded_string json = R"({
+  "name": "Alice",
+  "age": 30,
+  "address": {"city": "Boston"}
+})"_padded;
+
+ondemand::parser parser;
+auto doc = parser.iterate(json);
+
+// No compile-time validation - path is only parsed
+std::string name;
+auto result = ondemand::json_path::at_path_compiled<".name">(doc);
+result.get(name); // name = "Alice"
+
+std::string_view city;
+result = ondemand::json_path::at_path_compiled<".address.city">(doc);
+result.get(city); // city = "Boston"
+```
+
+**Benefits:**
+- Works with dynamic/unknown JSON structures
+- Still benefits from compile-time path parsing
+- No runtime string parsing overhead
+
+**Use when:**
+- JSON structure is not known at compile time
+- Working with varied JSON schemas
+- Prototyping or exploratory parsing
+
+## JSONPath Syntax
+
+JSONPath uses dot notation and bracket notation for field access:
+
+### Supported Syntax
+
+| Syntax | Description | Example |
+|--------|-------------|---------|
+| `.field` | Dot notation for field access | `.name`, `.address.city` |
+| `["field"]` | Bracket notation with quotes | `["name"]`, `["address"]["city"]` |
+| `[index]` | Array index access | `[0]`, `[1]` |
+| Mixed | Combination of notations | `.emails[0]`, `["users"][0].name` |
+| `$` prefix | Optional root indicator | `$.name`, `$["name"]` |
+
+### Examples
+
+```cpp
+struct Address {
+  std::string city;
+  int zip;
+};
+
+struct Person {
+  std::string name;
+  int age;
+  Address address;
+  std::vector<std::string> emails;
+};
+
+// Dot notation
+at_path_compiled<Person, ".name">(doc)
+at_path_compiled<Person, ".address.city">(doc)
+
+// Bracket notation
+at_path_compiled<Person, "[\"name\"]">(doc)
+at_path_compiled<Person, "[\"address\"][\"city\"]">(doc)
+
+// Array access
+at_path_compiled<Person, ".emails[0]">(doc)
+at_path_compiled<Person, ".emails[1]">(doc)
+
+// Mixed notation
+at_path_compiled<Person, ".address[\"zip\"]">(doc)
+at_path_compiled<Person, "[\"emails\"][0]">(doc)
+
+// With root indicator
+at_path_compiled<Person, "$.name">(doc)
+at_path_compiled<Person, "$.address.city">(doc)
+```
+
+## JSON Pointer Syntax
+
+JSON Pointer (RFC 6901) uses slash-separated paths:
+
+### Supported Syntax
+
+| Syntax | Description | Example |
+|--------|-------------|---------|
+| `/field` | Field access | `/name`, `/address/city` |
+| `/index` | Array index | `/0`, `/1` |
+| `~0` | Escaped `~` | `/field~0name` → field~name |
+| `~1` | Escaped `/` | `/field~1name` → field/name |
+
+### Examples
+
+```cpp
+struct Car {
+  std::string make;
+  std::string model;
+  int64_t year;
+  std::vector<double> tire_pressure;
+};
+
+// Field access
+at_pointer_compiled<Car, "/make">(doc)
+at_pointer_compiled<Car, "/model">(doc)
+
+// Array access
+at_pointer_compiled<Car, "/tire_pressure/0">(doc)
+at_pointer_compiled<Car, "/tire_pressure/1">(doc)
+
+// Root pointer (returns whole document)
+at_pointer_compiled<Car, "">(doc)
+at_pointer_compiled<Car, "/">(doc)
+```
+
+## API Reference
+
+### JSONPath Functions
+
+```cpp
+// With type validation
+template<typename T, constevalutil::fixed_string Path, typename DocOrValue>
+simdjson_result<value> at_path_compiled(DocOrValue& doc_or_val);
+
+// Without validation
+template<constevalutil::fixed_string Path, typename DocOrValue>
+simdjson_result<value> at_path_compiled(DocOrValue& doc_or_val);
+```
+
+### JSON Pointer Functions
+
+```cpp
+// With type validation
+template<typename T, constevalutil::fixed_string Pointer, typename DocOrValue>
+simdjson_result<value> at_pointer_compiled(DocOrValue& doc_or_val);
+
+// Without validation
+template<constevalutil::fixed_string Pointer, typename DocOrValue>
+simdjson_result<value> at_pointer_compiled(DocOrValue& doc_or_val);
+```
+
+### Direct Field Extraction
+
+Extract values directly into variables with compile-time type checking:
+
+```cpp
+// JSONPath
+template<typename T, constevalutil::fixed_string Path>
+struct path_accessor {
+  template<typename DocOrValue, typename FieldType>
+  static error_code extract_field(DocOrValue& doc_or_val, FieldType& target);
+};
+
+// JSON Pointer
+template<typename T, constevalutil::fixed_string Pointer>
+struct pointer_accessor {
+  template<typename DocOrValue, typename FieldType>
+  static error_code extract_field(DocOrValue& doc_or_val, FieldType& target);
+};
+```
+
+**Example:**
+
+```cpp
+struct User {
+  std::string name;
+  int age;
+};
+
+ondemand::parser parser;
+auto doc = parser.iterate(json);
+
+// Extract directly into variable
+std::string name;
+ondemand::json_path::path_accessor<User, ".name">::extract_field(doc, name);
+
+int age;
+ondemand::json_path::pointer_accessor<User, "/age">::extract_field(doc, age);
+```
+
+The compiler verifies that the target variable type matches the field type at the path.
+
+## Complete Examples
+
+### Example 1: Validated Access
+
+```cpp
+#include "simdjson.h"
+using namespace simdjson;
+
+struct Car {
+  std::string make;
+  std::string model;
+  int64_t year;
+  std::vector<double> tire_pressure;
+};
+
+int main() {
+  const padded_string json = R"({
+    "make": "Toyota",
+    "model": "Camry",
+    "year": 2018,
+    "tire_pressure": [40.1, 39.9, 37.7, 40.4]
+  })"_padded;
+
+  ondemand::parser parser;
+  auto doc = parser.iterate(json);
+
+  // Type-validated access
+  std::string make;
+  auto result = ondemand::json_path::at_path_compiled<Car, ".make">(doc);
+  result.get(make); // make = "Toyota"
+
+  // Array access with validation
+  double pressure;
+  result = ondemand::json_path::at_path_compiled<Car, ".tire_pressure[1]">(doc);
+  result.get(pressure); // pressure = 39.9
+
+  return 0;
+}
+```
+
+### Example 2: Non-Validated Access
+
+```cpp
+#include "simdjson.h"
+using namespace simdjson;
+
+int main() {
+  const padded_string json = R"({
+    "user": {
+      "name": "Alice",
+      "preferences": {
+        "theme": "dark",
+        "notifications": true
+      }
+    }
+  })"_padded;
+
+  ondemand::parser parser;
+  auto doc = parser.iterate(json);
+
+  // No validation - works with any JSON structure
+  std::string_view theme;
+  auto result = ondemand::json_path::at_path_compiled<".user.preferences.theme">(doc);
+  result.get(theme); // theme = "dark"
+
+  bool notifications;
+  result = ondemand::json_path::at_path_compiled<".user.preferences.notifications">(doc);
+  result.get(notifications); // notifications = true
+
+  return 0;
+}
+```
+
+### Example 3: Direct Extraction
+
+```cpp
+#include "simdjson.h"
+using namespace simdjson;
+
+struct Person {
+  std::string name;
+  int age;
+  std::vector<std::string> emails;
+};
+
+int main() {
+  const padded_string json = R"({
+    "name": "Bob",
+    "age": 25,
+    "emails": ["bob@example.com", "bob@work.com"]
+  })"_padded;
+
+  ondemand::parser parser;
+  auto doc = parser.iterate(json);
+
+  // Extract with type validation
+  std::string name;
+  ondemand::json_path::path_accessor<Person, ".name">::extract_field(doc, name);
+  // name = "Bob"
+
+  int age;
+  ondemand::json_path::pointer_accessor<Person, "/age">::extract_field(doc, age);
+  // age = 25
+
+  std::string email;
+  ondemand::json_path::path_accessor<Person, ".emails[0]">::extract_field(doc, email);
+  // email = "bob@example.com"
+
+  return 0;
+}
+```
+
+## Error Handling
+
+Compile-time errors occur when:
+- Path doesn't exist in struct: `static_assert` failure
+- Field type mismatch: `static_assert` failure
+- Invalid array access on non-array field: `static_assert` failure
+
+Runtime errors occur when:
+- JSON structure doesn't match expected structure
+- Array index out of bounds
+- Type conversion failures
+
+```cpp
+struct User {
+  std::string name;
+  int age;
+};
+
+// Compile-time error: no "email" field in User
+// auto result = ondemand::json_path::at_path_compiled<User, ".email">(doc);
+
+// Compile-time error: age is not an array
+// auto result = ondemand::json_path::at_path_compiled<User, ".age[0]">(doc);
+
+// Runtime error if JSON doesn't have "name" field
+auto result = ondemand::json_path::at_path_compiled<User, ".name">(doc);
+std::string name;
+if (result.get(name) != SUCCESS) {
+  // Handle error
+}
+```
+
+## Performance
+
+Compile-time accessors provide:
+- **Zero path parsing overhead** - paths parsed at compile time
+- **Zero validation overhead** - validation done at compile time
+- **Direct field access** - no runtime path traversal
+- **Type-safe extraction** - no dynamic type checking
+
+Compared to runtime `at_path()` and `at_pointer()`:
+- Eliminates runtime path string parsing
+- Eliminates runtime path validation
+- Generates optimal code path directly
+
+## Limitations
+
+- Requires C++26 compiler with P2996 support (experimental)
+- Paths must be compile-time constants (string literals)
+- Cannot use runtime-computed paths
+- Limited to struct types that support reflection
+- Array indices must be compile-time constants in the path
+
+## When to Use
+
+**Use compile-time accessors when:**
+- You have well-defined struct types
+- JSON structure is known at compile time
+- You want maximum type safety
+- Performance is critical
+
+**Use runtime `at_path()`/`at_pointer()` when:**
+- JSON structure varies or is unknown
+- Paths are computed at runtime
+- Working with C++20 or earlier
+- Flexibility is more important than compile-time checks
+
+## See Also
+
+- [JSON Pointer](basics.md#json-pointer) - Runtime JSON Pointer support
+- [JSONPath](basics.md#jsonpath) - Runtime JSONPath support
+- [Static Reflection for Deserialization](basics.md#3-using-static-reflection-c26) - Using reflection for full struct deserialization

doc/dom.md

@@ -41,7 +41,7 @@ The Basics: Loading and Parsing JSON Documents using the DOM front-end
 The simdjson library offers a simple DOM tree API, which you can access by creating a
 `dom::parser` and calling the `load()` method:
 
-```c++
+```cpp
 dom::parser parser;
 dom::element doc = parser.load(filename); // load and parse a file
 ```
@@ -49,21 +49,21 @@ dom::element doc = parser.load(filename); // load and parse a file
 Or by creating a padded string (for efficiency reasons, simdjson requires a string with
 SIMDJSON_PADDING bytes at the end) and calling `parse()`:
 
-```c++
+```cpp
 dom::parser parser;
 dom::element doc = parser.parse("[1,2,3]"_padded); // parse a string, the _padded suffix creates a simdjson::padded_string instance
 ```
 
 You can copy your data directly on a `simdjson::padded_string` as follows:
 
-```c++
+```cpp
 const char * data = "my data"; // 7 bytes
 simdjson::padded_string my_padded_data(data, 7); // copies to a padded buffer
 ```
 
 Or as follows...
 
-```c++
+```cpp
 std::string data = "my data";
 simdjson::padded_string my_padded_data(data); // copies to a padded buffer
 ```
@@ -83,7 +83,7 @@ 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:
 
-```c++
+```cpp
 std::string json = "[1]";
 dom::element doc = parser.parse(simdjson::pad(json));
 ```
@@ -117,7 +117,7 @@ Once you have an element, you can navigate it with idiomatic C++ iterators, oper
   dom::object and dom::array. An exception (`simdjson::simdjson_error`) is thrown if the cast is not possible.
 * **Extracting Values (without exceptions):** You can use a variant usage of `get()` with error codes to avoid exceptions. You first declare the variable of the appropriate type (`double`, `uint64_t`, `int64_t`, `bool`, `std::string_view`,
   `dom::object` and `dom::array`) and pass it by reference to `get()` which gives you back an error code: e.g.,
-  ```c++
+  ```cpp
   simdjson::error_code error;
   simdjson::padded_string numberstring = "1.2"_padded; // our JSON input ("1.2")
   simdjson::dom::parser parser;
@@ -152,7 +152,7 @@ Once you have an element, you can navigate it with idiomatic C++ iterators, oper
 
 The following code illustrates all of the above:
 
-```c++
+```cpp
 auto cars_json = R"( [
   { "make": "Toyota", "model": "Camry",  "year": 2018, "tire_pressure": [ 40.1, 39.9, 37.7, 40.4 ] },
   { "make": "Kia",    "model": "Soul",   "year": 2012, "tire_pressure": [ 30.1, 31.0, 28.6, 28.7 ] },
@@ -185,7 +185,7 @@ for (dom::object car : parser.parse(cars_json)) {
 
 Here is a different example illustrating the same ideas:
 
-```C++
+```cpp
 auto abstract_json = R"( [
     {  "12345" : {"a":12.34, "b":56.78, "c": 9998877}   },
     {  "12545" : {"a":11.44, "b":12.78, "c": 11111111}  }
@@ -207,7 +207,7 @@ for (dom::object obj : parser.parse(abstract_json)) {
 And another one:
 
 
-```C++
+```cpp
   auto abstract_json = R"(
     {  "str" : { "123" : {"abc" : 3.14 } } } )"_padded;
   dom::parser parser;
@@ -221,7 +221,7 @@ C++17 Support
 
 While the simdjson library can be used in any project using C++ 11 and above, field iteration has special support C++ 17's destructuring syntax. For example:
 
-```c++
+```cpp
 padded_string json = R"(  { "foo": 1, "bar": 2 }  )"_padded;
 dom::parser parser;
 dom::object object; // invalid until the get() succeeds
@@ -234,7 +234,7 @@ for (auto [key, value] : object) {
 
 For comparison, here is the C++ 11 version of the same code:
 
-```c++
+```cpp
 // C++ 11 version for comparison
 padded_string json = R"(  { "foo": 1, "bar": 2 }  )"_padded;
 dom::parser parser;
@@ -251,7 +251,7 @@ C++20 Support
 
 simdjson library also supports some C++20 feature including `std::ranges`:
 
-```c++
+```cpp
 auto cars_json = R"( [
   { "make": "Toyota", "model": "Camry",  "year": 2018, "tire_pressure": [ 40.1, 39.9, 37.7, 40.4 ] },
   { "make": "Kia",    "model": "Soul",   "year": 2012, "tire_pressure": [ 30.1, 31.0, 28.6, 28.7 ] },
@@ -270,7 +270,7 @@ JSON Pointer
 The simdjson library also supports [JSON pointer](https://tools.ietf.org/html/rfc6901) through the
 `at_pointer()` method, letting you reach further down into the document in a single call:
 
-```c++
+```cpp
 auto cars_json = R"( [
   { "make": "Toyota", "model": "Camry",  "year": 2018, "tire_pressure": [ 40.1, 39.9, 37.7, 40.4 ] },
   { "make": "Kia",    "model": "Soul",   "year": 2012, "tire_pressure": [ 30.1, 31.0, 28.6, 28.7 ] },
@@ -291,7 +291,7 @@ You can apply a JSON Pointer expression to any node and the path gets interprete
 
 Consider the following example:
 
-```c++
+```cpp
 auto cars_json = R"( [
   { "make": "Toyota", "model": "Camry",  "year": 2018, "tire_pressure": [ 40.1, 39.9, 37.7, 40.4 ] },
   { "make": "Kia",    "model": "Soul",   "year": 2012, "tire_pressure": [ 30.1, 31.0, 28.6, 28.7 ] },
@@ -313,11 +313,11 @@ JSONPath
 ------------
 
 
-The simdjson library supports a subset of [JSONPath](https://datatracker.ietf.org/doc/html/draft-normington-jsonpath-00) through the `at_path()` method, allowing you to reach further into the document in a single call. The subset of JSONPath that is implemented is the subset that is trivially convertible into the JSON Pointer format, using `.` to access a field and `[]` to access a specific index.
+The simdjson library supports a subset of [JSONPath](https://www.rfc-editor.org/rfc/rfc9535) (RFC 9535) through the `at_path()` method, allowing you to reach further into the document in a single call. The subset of JSONPath that is implemented is the subset that is trivially convertible into the JSON Pointer format, using `.` to access a field and `[]` to access a specific index.
 
 Consider the following example:
 
-```c++
+```cpp
 auto cars_json = R"( [
   { "make": "Toyota", "model": "Camry",  "year": 2018, "tire_pressure": [ 40.1, 39.9, 37.7, 40.4 ] },
   { "make": "Kia",    "model": "Soul",   "year": 2012, "tire_pressure": [ 30.1, 31.0, 28.6, 28.7 ] },
@@ -336,7 +336,7 @@ cout << p << endl; // Prints 39.9
 
 We also support the `$` prefix. When you start a JSONPath expression with $, you are indicating that the path starts from the root of the JSON document. E.g.,
 
-```c++
+```cpp
 auto json = R"( { "c" :{ "foo": { "a": [ 10, 20, 30 ] }}, "d": { "foo2": { "a": [ 10, 20, 30 ] }} , "e": 120 })"_padded;
 dom::parser parser;
 dom::element doc;
@@ -428,7 +428,7 @@ Error Handling
 All simdjson APIs that can fail return `simdjson_result<T>`, which is a &lt;value, error_code&gt;
 pair. You can retrieve the value with .get(), like so:
 
-```c++
+```cpp
 dom::element doc;
 auto error = parser.parse(json).get(doc);
 if (error) { cerr << error << endl; exit(1); }
@@ -462,7 +462,7 @@ We can write a "quick start" example where we attempt to parse the following JSO
 Our program loads the file, selects value corresponding to key "search_metadata" which expected to be an object, and then
 it selects the key "count" within that object.
 
-```C++
+```cpp
 #include <iostream>
 #include "simdjson.h"
 
@@ -490,7 +490,7 @@ triggering exceptions. To do this, we use `["statuses"].at(0)["id"]`. We break t
 
 Observe how we use the `at` method when querying an index into an array, and not the bracket operator.
 
-```C++
+```cpp
 #include <iostream>
 #include "simdjson.h"
 
@@ -514,7 +514,7 @@ over the content of an array.
 
 This is how the example in "Using the Parsed JSON" could be written using only error code checking:
 
-```c++
+```cpp
 auto cars_json = R"( [
   { "make": "Toyota", "model": "Camry",  "year": 2018, "tire_pressure": [ 40.1, 39.9, 37.7, 40.4 ] },
   { "make": "Kia",    "model": "Soul",   "year": 2012, "tire_pressure": [ 30.1, 31.0, 28.6, 28.7 ] },
@@ -561,7 +561,7 @@ for (dom::element car_element : cars) {
 
 Here is another example:
 
-```C++
+```cpp
 auto abstract_json = R"( [
     {  "12345" : {"a":12.34, "b":56.78, "c": 9998877}   },
     {  "12545" : {"a":11.44, "b":12.78, "c": 11111111}  }
@@ -594,7 +594,7 @@ for (dom::element elem : array) {
 
 And another one:
 
-```C++
+```cpp
   auto abstract_json = R"(
     {  "str" : { "123" : {"abc" : 3.14 } } } )"_padded;
   dom::parser parser;
@@ -608,7 +608,7 @@ Notice how we can string several operations (`parser.parse(abstract_json)["str"]
 
 The next two functions will take as input a JSON document containing an array with a single element, either a string or a number. They return true upon success.
 
-```C++
+```cpp
 simdjson::dom::parser parser{};
 
 bool parse_double(const char *j, double &d) {
@@ -640,7 +640,7 @@ target_compile_definitions(simdjson PUBLIC SIMDJSON_EXCEPTIONS=OFF)
 
 Users more comfortable with an exception flow may choose to directly cast the `simdjson_result<T>` to the desired type:
 
-```c++
+```cpp
 dom::element doc = parser.parse(json); // Throws an exception if there was an error!
 ```
 
@@ -650,7 +650,7 @@ program from continuing if there was an error.
 
 If one is willing to trigger exceptions, it is possible to write simpler code:
 
-```C++
+```cpp
 #include <iostream>
 #include "simdjson.h"
 
@@ -671,7 +671,7 @@ inspect or walk over JSON elements. To do that, you can use iterators and the ty
 example, here's a quick and dirty recursive function that verbosely prints the JSON document as JSON
 (* ignoring nuances like trailing commas and escaping strings, for brevity's sake):
 
-```c++
+```cpp
 void print_json(dom::element element) {
   switch (element.type()) {
     case dom::element_type::ARRAY:
@@ -727,7 +727,7 @@ and reuse it. The simdjson library will allocate and retain internal buffers bet
 buffers hot in cache and keeping memory allocation and initialization to a minimum. In this manner,
 you can parse terabytes of JSON data without doing any new allocation.
 
-```c++
+```cpp
 dom::parser parser;
 
 // This initializes buffers and a document big enough to handle this JSON.
@@ -770,7 +770,7 @@ without bound:
 
 * You can set a *max capacity* when constructing a parser:
 
-  ```c++
+  ```cpp
   dom::parser parser(1000*1000); // Never grow past documents > 1MB
   for (web_request request : listen()) {
     dom::element doc;
@@ -786,7 +786,7 @@ without bound:
 * You can set a *fixed capacity* that never grows, as well, which can be excellent for
   predictability and reliability, since simdjson will never call malloc after startup!
 
-  ```c++
+  ```cpp
   dom::parser parser(0); // This parser will refuse to automatically grow capacity
   auto error = parser.allocate(1000*1000); // This allocates enough capacity to handle documents <= 1MB
   if (error) { cerr << error << endl; exit(1); }
@@ -817,7 +817,7 @@ When calling `parser.parse` on a pointer (e.g., `parser.parse(my_char_pointer, m
 Some users may not be able use our `padded_string` class or to load the data directly from disk (`parser.load`). They may need to pass data pointers to the library.  If these users wish to avoid temporary copies and corresponding temporary memory allocations, they may want to call `parser.parse` with the `realloc_if_needed` parameter set to false (e.g., `parser.parse(my_char_pointer, my_length_in_bytes, false)`). In such cases, they need to ensure that there are at least SIMDJSON_PADDING extra bytes at the end that can be safely accessed and read. They do not need to initialize the padded bytes to any value in particular. The following example is safe:
 
 
-```C++
+```cpp
 const char *json      = R"({"key":"value"})";
 const size_t json_len = std::strlen(json);
 std::unique_ptr<char[]> padded_json_copy{new char[json_len + SIMDJSON_PADDING]};

doc/implementation-selection.md

@@ -55,7 +55,7 @@ Inspecting the Detected Implementation
 
 You can check what implementation is running with `active_implementation`:
 
-```c++
+```cpp
 cout << "simdjson v" << SIMDJSON_VERSION << endl;
 cout << "Detected the best implementation for your machine: " << simdjson::get_active_implementation()->name();
 cout << "(" << simdjson::get_active_implementation()->description() << ")" << endl;
@@ -68,7 +68,7 @@ Querying Available Implementations
 
 You can list all available implementations, regardless of which one was selected:
 
-```c++
+```cpp
 for (auto implementation : simdjson::get_available_implementations()) {
   cout << implementation->name() << ": " << implementation->description() << endl;
 }
@@ -76,7 +76,7 @@ for (auto implementation : simdjson::get_available_implementations()) {
 
 And look them up by name:
 
-```c++
+```cpp
 cout << simdjson::get_available_implementations()["fallback"]->description() << endl;
 ```
 When an implementation is not available, the bracket call `simdjson::get_available_implementations()[name]`
@@ -93,7 +93,7 @@ Manually Selecting the Implementation
 If you're trying to do performance tests or see how different implementations of simdjson run, you
 can select the CPU architecture yourself:
 
-```c++
+```cpp
 // Use the fallback implementation, even though my machine is fast enough for anything
 simdjson::get_active_implementation() = simdjson::get_available_implementations()["fallback"];
 ```
@@ -102,7 +102,7 @@ You are responsible for ensuring that the requirements of the selected implement
 Furthermore, you should check that the implementation is available before setting it to `simdjson::get_active_implementation()`
 by comparing it with the null pointer.
 
-```c++
+```cpp
 auto my_implementation = simdjson::get_available_implementations()["haswell"];
 if (! my_implementation) { exit(1); }
 if (! my_implementation->supported_by_runtime_system()) { exit(1); }
@@ -114,7 +114,7 @@ Checking that an Implementation can Run on your System
 
 You should call `supported_by_runtime_system()` to compare the processor's features with the need of the implementation.
 
-```c++
+```cpp
 for (auto implementation : simdjson::get_available_implementations()) {
   if (implementation->supported_by_runtime_system()) {
     cout << implementation->name() << ": " << implementation->description() << endl;

doc/iterate_many.md

@@ -132,7 +132,7 @@ E.g., `[1,2]{"32":1}` is recognized as two documents.
 Some official formats **(non-exhaustive list)**:
 - [Newline-Delimited JSON (NDJSON)](https://github.com/ndjson/ndjson-spec/)
 - [JSON lines (JSONL)](http://jsonlines.org/)
-- [Record separator-delimited JSON (RFC 7464)](https://tools.ietf.org/html/rfc7464) <- Not supported by JsonStream!
+- [Record separator-delimited JSON (RFC 7464)](https://tools.ietf.org/html/rfc7464) <- Not supported by simdjson!
 - [More on Wikipedia...](https://en.wikipedia.org/wiki/JSON_streaming)
 
 API
@@ -140,7 +140,7 @@ API
 
 Example:
 
-```c++
+```cpp
 auto json = R"({ "foo": 1 } { "foo": 2 } { "foo": 3 } )"_padded;
 ondemand::parser parser;
 ondemand::document_stream docs = parser.iterate_many(json);
@@ -197,7 +197,7 @@ and `error()` to check if there were any error.
 Let us illustrate the idea with code:
 
 
-```C++
+```cpp
     auto json = R"([1,2,3]  {"1":1,"2":3,"4":4} [1,2,3]  )"_padded;
     simdjson::ondemand::parser parser;
     simdjson::ondemand::document_stream stream;
@@ -238,7 +238,7 @@ Some users may need to work with truncated streams. The simdjson may truncate do
 
 Consider the following example where a truncated document (`{"key":"intentionally unclosed string  `) containing 39 bytes has been left within the stream. In such cases, the first two whole documents are parsed and returned, and the `truncated_bytes()` method returns 39.
 
-```C++
+```cpp
     auto json = R"([1,2,3]  {"1":1,"2":3,"4":4} {"key":"intentionally unclosed string  )"_padded;
     simdjson::ondemand::parser parser;
     simdjson::ondemand::document_stream stream;
@@ -267,7 +267,7 @@ is effectively ignored, as it is set to at least the document size.
 
 Example:
 
-```C++
+```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;
@@ -314,7 +314,7 @@ the simdjson library.
 
 Consider a custom class `Car`:
 
-```C++
+```cpp
 struct Car {
   std::string make;
   std::string model;
@@ -328,7 +328,7 @@ You may support deserializing directly from a JSON value or document to your own
 by defining a single `tag_invoke` function:
 
 
-```C++
+```cpp
 namespace simdjson {
 // This tag_invoke MUST be inside simdjson namespace
 template <typename simdjson_value>
@@ -370,7 +370,7 @@ tag_invoke functions.
 Given a stream of JSON documents, you can add them to a data structure
 such as a `std::vector<Car>` like so if you support exceptions:
 
-```C++
+```cpp
   padded_string json =
       R"( { "make": "Toyota", "model": "Camry",  "year": 2018,
        "tire_pressure": [ 40.1, 39.9 ] }
@@ -391,7 +391,7 @@ such as a `std::vector<Car>` like so if you support exceptions:
 Otherwise you may use this longer version for explicit handling of errors:
 
 
-```C++
+```cpp
   std::vector<Car> cars;
   for(auto doc : stream) {
     Car c;

doc/ondemand_design.md

@@ -23,7 +23,7 @@ applications with a computation efficiency that is difficult to surpass.
 
 A code example illustrates our API from a programmer's point of view:
 
-```c++
+```cpp
 ondemand::parser parser;
 auto doc = parser.iterate(json);
 for (auto tweet : doc["statuses"]) {
@@ -109,7 +109,7 @@ The DOM approach was the only way to parse JSON documents up to version 0.6 of t
 Our DOM API looks similar to our On-Demand example, except
 it calls `parse` instead of `iterate`:
 
-```c++
+```cpp
 dom::parser parser;
 auto doc = parser.parse(json);
 for (auto tweet : doc["statuses"]) {
@@ -157,7 +157,7 @@ examples. To make it short enough to use as an example at all, it has heavily re
 a part of the problem (does not get user.screen_name), it has bugs (it does not handle sub-objects
 in a tweet at all), and it uses a theoretical, simple event-based API that minimizes ceremony.
 
-```c++
+```cpp
 struct twitter_callbacks {
   bool in_statuses;
   bool in_tweet;
@@ -284,14 +284,14 @@ To help visualize the algorithm, we'll walk through the example C++ given at the
 
    This declaration does not allocate any memory; that will happen in the next step.
 
-   ```c++
+   ```cpp
    ondemand::parser parser;
    ```
 
 2. We then start iterating the JSON document by allocating internal parser buffers, preprocessing
    the JSON, and initializing the iterator.
 
-   ```c++
+   ```cpp
    auto doc = parser.iterate(json);
    ```
 
@@ -337,14 +337,14 @@ To help visualize the algorithm, we'll walk through the example C++ given at the
 3. We iterate over the "statuses" field using a typical C++ iterator, reading past the initial
    `{ "statuses": [ {`.
 
-   ```c++
+   ```cpp
    for (ondemand::object tweet : doc["statuses"]) {
    ```
 
    This shorthand does a lot, and it is helpful to see what it expands to.
    Comments in front of each one explain what's going on:
 
-   ```c++
+   ```cpp
    // Validate that the top-level value is an object: check for {. Increase depth to 2 (root > field).
    ondemand::object top = doc.get_object();
 
@@ -396,7 +396,7 @@ To help visualize the algorithm, we'll walk through the example C++ given at the
 
 4. We get the `"text"` field as a string.
 
-   ```c++
+   ```cpp
    std::string_view text        = tweet["text"];
    ```
 
@@ -435,7 +435,7 @@ To help visualize the algorithm, we'll walk through the example C++ given at the
 
 4. We get the `"screen_name"` from the `"user"` object.
 
-   ```c++
+   ```cpp
       ondemand::object user        = tweet["user"];
       screen_name                  = user["screen_name"];
    ```
@@ -469,7 +469,7 @@ To help visualize the algorithm, we'll walk through the example C++ given at the
 
 5. We get `"retweet_count"` as an unsigned integer.
 
-   ```c++
+   ```cpp
    uint64_t         retweets    = tweet["retweet_count"];
    ```
 
@@ -513,7 +513,7 @@ To help visualize the algorithm, we'll walk through the example C++ given at the
 
 6. We loop to the next tweet.
 
-   ```c++
+   ```cpp
    for (ondemand::object tweet : doc["statuses"]) {
      ...
    }
@@ -521,7 +521,7 @@ To help visualize the algorithm, we'll walk through the example C++ given at the
 
    The relevant parts of the loop  are:
 
-   ```c++
+   ```cpp
    while (iter != statuses.end()) {
      ondemand::object tweet = *iter;
      ...
@@ -566,7 +566,7 @@ To help visualize the algorithm, we'll walk through the example C++ given at the
 
 8. The loop ends. Recall the relevant parts of the statuses loop:
 
-   ```c++
+   ```cpp
    while (iter != statuses.end()) {
      ondemand::object tweet = *iter;
      ...
@@ -610,7 +610,7 @@ When the user requests strings, we unescape them to a single string buffer much
 so that users enjoy the same string performance as the core simdjson. We do not write the length to the
 string buffer, however; that is stored in the `string_view` instance we return to the user.
 
-```C++
+```cpp
   ondemand::parser parser;
   auto doc = parser.iterate(json);
   std::set<std::string_view> default_users;
@@ -645,7 +645,7 @@ from the `unescaped_key()` method has a lifecycle tied to the `parser` instance:
 is destroyed or reused with another document, the `std::string_view` instance becomes invalid.
 
 
-```C++
+```cpp
 auto doc = parser.iterate(json);
 for(auto field : doc.get_object())  {
       std::string_view keyv = field.unescaped_key();
@@ -670,7 +670,7 @@ in production systems:
   Some care is needed when using the On-Demand API in scenarios where you need to access several sibling arrays or objects because
   only one object or array can be active at any one time. Let us consider the following example:
 
-```C++
+```cpp
     ondemand::parser parser;
     const padded_string json = R"({ "parent": {"child1": {"name": "John"} , "child2": {"name": "Daniel"}} })"_padded;
     auto doc = parser.iterate(json);
@@ -688,7 +688,7 @@ in production systems:
 
 A correct usage is given by the following example:
 
-```C++
+```cpp
     ondemand::parser parser;
     const padded_string json = R"({ "parent": {"child1": {"name": "John"} , "child2": {"name": "Daniel"}} })"_padded;
     auto doc = parser.iterate(json);
@@ -754,7 +754,7 @@ Some users wish to run at the best possible speed. Under recent Intel and AMD pr
 
 Given that the On-Demand API offer limited runtime dispatching, it matters that your code is compiled against a specific CPU target. You should verify that the code is compiled against the target you expect. Thankfully, the simdjson library will tell you exactly what it detects as an implementation: `icelake` (AVX512 x64 processors), `haswell` (AVX2 x64 processors), `westmere` (SSE4 x64 processors), `arm64` (64-bit ARM), `ppc64` (64-bit POWER), `lasx` (LoongArch), `lsx` (LoongArch),  `fallback` (others). Under x64 processors, many programmers will want to target `haswell` whereas under ARM, most programmers will want to target `arm64` (and it should do so automatically). The `fallback` is probably only good for testing purposes, not for deployment.
 
-```C++
+```cpp
   std::cout << simdjson::builtin_implementation()->name() << std::endl;
 ```
 

doc/parse_many.md

@@ -132,7 +132,7 @@ Whitespace Characters:
 Some official formats **(non-exhaustive list)**:
 - [Newline-Delimited JSON (NDJSON)](https://github.com/ndjson/ndjson-spec)
 - [JSON lines (JSONL)](http://jsonlines.org/)
-- [Record separator-delimited JSON (RFC 7464)](https://tools.ietf.org/html/rfc7464) <- Not supported by JsonStream!
+- [Record separator-delimited JSON (RFC 7464)](https://tools.ietf.org/html/rfc7464) <- Not supported by simdjson!
 - [More on Wikipedia...](https://en.wikipedia.org/wiki/JSON_streaming)
 
 API
@@ -184,7 +184,7 @@ You may also call the `source()` method to get a `std::string_view` instance on
 Let us illustrate the idea with code:
 
 
-```C++
+```cpp
     auto json = R"([1,2,3]  {"1":1,"2":3,"4":4} [1,2,3]  )"_padded;
     simdjson::dom::parser parser;
     simdjson::dom::document_stream stream;
@@ -225,7 +225,7 @@ Some users may need to work with truncated streams. The simdjson may truncate do
 
 Consider the following example where a truncated document (`{"key":"intentionally unclosed string  `) containing 39 bytes has been left within the stream. In such cases, the first two whole documents are parsed and returned, and the `truncated_bytes()` method returns 39.
 
-```C++
+```cpp
     auto json = R"([1,2,3]  {"1":1,"2":3,"4":4} {"key":"intentionally unclosed string  )"_padded;
     simdjson::dom::parser parser;
     simdjson::dom::document_stream stream;

doc/performance.md

@@ -47,7 +47,7 @@ and reuse it. The simdjson library will allocate and retain internal buffers bet
 buffers hot in cache and keeping memory allocation and initialization to a minimum. In this manner,
 you can parse terabytes of JSON data without doing any new allocation.
 
-```c++
+```cpp
 ondemand::parser parser;
 
 // This initializes buffers  big enough to handle this JSON.
@@ -71,14 +71,14 @@ Reusing string buffers
 
 We recommend against creating many `std::string` or `simdjson::padded_string` instances to store the JSON content in your application. [Creating many non-trivial objects is convenient but often surprisingly slow](https://lemire.me/blog/2020/08/08/performance-tip-constructing-many-non-trivial-objects-is-slow/). Instead, as much as possible, you should allocate (once or a few times) reusable memory buffers where you write your JSON content. If you have a buffer `json_str` (of type `char*`) allocated for  `capacity` bytes and you store a JSON document spanning `length` bytes, you can pass it to simdjson as follows:
 
-```c++
+```cpp
  auto doc = parser.iterate(padded_string_view(json_str, length, capacity));
 ```
 
 or simply
 
 
-```c++
+```cpp
  auto doc = parser.iterate(json_str, length, capacity);
 ```
 
@@ -89,7 +89,7 @@ Server Loops: Long-Running Processes and Memory Capacity
 The On-Demand approach also automatically expands its memory capacity when larger documents are parsed. However, for longer processes where very large files are processed (such as server loops), this capacity is not resized down. On-Demand also lets you adjust the maximal capacity that the parser can process:
 
 * You can set an upper bound (*max_capacity*) when construction the parser:
-```C++
+```cpp
     ondemand::parser parser(1000*1000);  // Never grows past documents > 1 MB
     auto doc = parser.iterate(json);
     for (web_request request : listen()) {
@@ -105,7 +105,7 @@ The On-Demand approach also automatically expands its memory capacity when large
 The capacity will grow as the parser encounters larger documents up to 1 MB.
 
 * You can also allocate a *fixed capacity* that will never grow:
-```C++
+```cpp
     ondemand::parser parser(1000*1000);
     parser.allocate(1000*1000)  // Fix the capacity to 1 MB
     auto doc = parser.iterate(json);

include/simdjson/concepts.h

@@ -143,6 +143,25 @@ concept container_but_not_string =
   std::ranges::input_range<T> && !string_like<T> && !concepts::string_view_keyed_map<T>;
 
 
+
+// Concept: Indexable container that is not a string or associative container
+// Accepts: std::vector, std::array, std::deque (have operator[], value_type, not string_like)
+// Rejects: std::string (string_like), std::list (no operator[]), std::map (has key_type)
+template<typename Container>
+concept indexable_container = requires {
+  typename Container::value_type;
+  requires !concepts::string_like<Container>;
+  requires !requires { typename Container::key_type; };  // Reject maps/sets
+  requires requires(Container& c, std::size_t i) {
+    { c[i] } -> std::convertible_to<typename Container::value_type>;
+  };
+};
+
+
+// Variable template to use with std::meta::substitute
+template<typename Container>
+constexpr bool indexable_container_v = indexable_container<Container>;
+
 } // namespace concepts
 
 

include/simdjson/dom/array.h

@@ -111,7 +111,7 @@ public:
   inline simdjson_result<element> at_pointer(std::string_view json_pointer) const noexcept;
 
   /**
-   * Recursive function which processes the json path of each child element
+   * Recursive function which processes the JSON path of each child element
    */
   inline void process_json_path_of_child_elements(std::vector<element>::iterator& current, std::vector<element>::iterator& end, const std::string_view& path_suffix, std::vector<element>& accumulator) const noexcept;
 
@@ -126,7 +126,7 @@ public:
    * JSONPath queries that trivially convertible to JSON Pointer queries: key
    * names and array indices.
    *
-   * https://datatracker.ietf.org/doc/html/draft-normington-jsonpath-00
+   * https://www.rfc-editor.org/rfc/rfc9535 (RFC 9535)
    *
    * @return The value associated with the given JSONPath expression, or:
    *         - INVALID_JSON_POINTER if the JSONPath to JSON Pointer conversion fails

include/simdjson/dom/document_stream.h

@@ -74,7 +74,7 @@ public:
   /**
    * Construct an uninitialized document_stream.
    *
-   *  ```c++
+   *  ```cpp
    *  document_stream docs;
    *  error = parser.parse_many(json).get(docs);
    *  ```

include/simdjson/dom/element.h

@@ -408,7 +408,7 @@ public:
    * JSONPath queries that trivially convertible to JSON Pointer queries: key
    * names and array indices.
    *
-   * https://datatracker.ietf.org/doc/html/draft-normington-jsonpath-00
+   * https://www.rfc-editor.org/rfc/rfc9535 (RFC 9535)
    *
    * @return The value associated with the given JSONPath expression, or:
    *         - INVALID_JSON_POINTER if the JSONPath to JSON Pointer conversion fails

include/simdjson/dom/object-inl.h

@@ -186,7 +186,7 @@ inline simdjson_result<std::vector<element>> object::at_path_with_wildcard(std::
   }
 
   if (i >= json_path.size() || (json_path[i] != '.' && json_path[i] != '[')) {
-    // expect json path to always start with $ but this isn't currently
+    // expect JSONPath expressions to always start with $ but this isn't currently
     // expected in jsonpathutil.h.
     return INVALID_JSON_POINTER;
   }

include/simdjson/dom/object.h

@@ -175,7 +175,7 @@ public:
   inline simdjson_result<element> at_pointer(std::string_view json_pointer) const noexcept;
 
   /**
-   * Recursive function which processes the json path of each child element
+   * Recursive function which processes the JSON path of each child element
    */
   inline void process_json_path_of_child_elements(std::vector<element>::iterator& current, std::vector<element>::iterator& end, const std::string_view& path_suffix, std::vector<element>& accumulator) const noexcept;
 
@@ -189,7 +189,7 @@ public:
    * JSONPath queries that trivially convertible to JSON Pointer queries: key
    * names and array indices.
    *
-   * https://datatracker.ietf.org/doc/html/draft-normington-jsonpath-00
+   * https://www.rfc-editor.org/rfc/rfc9535 (RFC 9535)
    *
    * @return The value associated with the given JSONPath expression, or:
    *         - INVALID_JSON_POINTER if the JSONPath to JSON Pointer conversion fails

include/simdjson/generic/ondemand/amalgamated.h

@@ -52,3 +52,6 @@
 #include "simdjson/generic/ondemand/json_string_builder-inl.h"
 #include "simdjson/generic/ondemand/json_builder.h"
 
+// JSON path accessor (compile-time) - must be after inline definitions
+#include "simdjson/generic/ondemand/compile_time_accessors.h"
+

include/simdjson/generic/ondemand/array.h

@@ -107,7 +107,7 @@ public:
    * JSONPath queries that trivially convertible to JSON Pointer queries: key
    * names and array indices.
    *
-   * https://datatracker.ietf.org/doc/html/draft-normington-jsonpath-00
+   * https://www.rfc-editor.org/rfc/rfc9535 (RFC 9535)
    *
    * @return The value associated with the given JSONPath expression, or:
    *         - INVALID_JSON_POINTER if the JSONPath to JSON Pointer conversion fails

include/simdjson/generic/ondemand/compile_time_accessors.h

@@ -0,0 +1,938 @@
+/**
+ * Compile-time JSON Path and JSON Pointer accessors using C++26 reflection (P2996)
+ *
+ * This file validates JSON paths/pointers against struct definitions at compile time
+ * and generates optimized accessor code with zero runtime overhead.
+ *
+ * ## How It Works
+ *
+ * **Compile Time**: Path is parsed, validated against struct, types are checked
+ * **Runtime**: Direct navigation with no parsing or validation overhead
+ *
+ * Example:
+ * ```cpp
+ * struct User { std::string name; std::vector<std::string> emails; };
+ *
+ * std::string email;
+ * path_accessor<User, ".emails[0]">::extract_field(doc, email);
+ *
+ * // Compile time validates:
+ * // 1. User has "emails" field
+ * // 2. "emails" is array-like
+ * // 3. Element type is std::string
+ * // 4. static_assert(^^std::string == ^^std::string)
+ *
+ * // Runtime just navigates:
+ * // doc.get_object().find_field("emails").get_array().at(0).get(email)
+ * ```
+ *
+ * ## Key Reflection APIs
+ *
+ * - `^^Type`: Reflect operator, converts type to std::meta::info
+ * - `std::meta::nonstatic_data_members_of(type)`: Get all fields of a struct
+ * - `std::meta::identifier_of(member)`: Get field name as string_view
+ * - `std::meta::type_of(member)`: Get reflected type of a field
+ * - `std::meta::is_array_type(type)`: Check if C-style array
+ * - `std::meta::remove_extent(array)`: Extract element type from array
+ * - `std::meta::members_of(type)`: Get all members including typedefs
+ * - `std::meta::is_type(member)`: Check if member is a type (vs field)
+ *
+ * All operations execute at compile time in consteval contexts.
+ */
+#ifndef SIMDJSON_GENERIC_ONDEMAND_COMPILE_TIME_ACCESSORS_H
+
+#ifndef SIMDJSON_CONDITIONAL_INCLUDE
+#define SIMDJSON_GENERIC_ONDEMAND_COMPILE_TIME_ACCESSORS_H
+
+#endif // SIMDJSON_CONDITIONAL_INCLUDE
+
+// Arguably, we should just check SIMDJSON_STATIC_REFLECTION since it
+// is unlikely that we will have reflection support without concepts support.
+#if SIMDJSON_SUPPORTS_CONCEPTS && SIMDJSON_STATIC_REFLECTION
+
+#include <string_view>
+#include <cstddef>
+#include <array>
+
+namespace simdjson {
+namespace SIMDJSON_IMPLEMENTATION {
+namespace ondemand {
+/***
+ * JSONPath implementation for compile-time access
+ * RFC 9535 JSONPath: Query Expressions for JSON, https://www.rfc-editor.org/rfc/rfc9535
+ */
+namespace json_path {
+
+// Note: value type must be fully defined before this header is included
+// This is ensured by including this in amalgamated.h after value-inl.h
+
+using ::simdjson::SIMDJSON_IMPLEMENTATION::ondemand::value;
+
+// Path step types
+enum class step_type {
+  field,        // .field_name or ["field_name"]
+  array_index   // [index]
+};
+
+// Represents a single step in a JSON path
+template<std::size_t N>
+struct path_step {
+  step_type type;
+  char key[N];  // Field name (empty for array indices)
+  std::size_t index;  // Array index (0 for field access)
+
+  constexpr path_step(step_type t, const char (&k)[N], std::size_t idx = 0)
+    : type(t), index(idx) {
+    for (std::size_t i = 0; i < N; ++i) {
+      key[i] = k[i];
+    }
+  }
+
+  constexpr std::string_view key_view() const {
+    return {key, N - 1};
+  }
+};
+
+// Helper to create field step
+template<std::size_t N>
+consteval auto make_field_step(const char (&name)[N]) {
+  return path_step<N>(step_type::field, name, 0);
+}
+
+// Helper to create array index step
+consteval auto make_index_step(std::size_t idx) {
+  return path_step<1>(step_type::array_index, "", idx);
+}
+
+// Parse state for compile-time JSON path parsing
+struct parse_result {
+  bool success;
+  std::size_t pos;
+  std::string_view error_msg;
+};
+
+// Compile-time JSON path parser
+// Supports subset: .field, ["field"], [index], nested combinations
+template<constevalutil::fixed_string Path>
+struct json_path_parser {
+  static constexpr std::string_view path_str = Path.view();
+
+  // Skip leading $ if present
+  static consteval std::size_t skip_root() {
+    if (!path_str.empty() && path_str[0] == '$') {
+      return 1;
+    }
+    return 0;
+  }
+
+  // Count the number of steps in the path at compile time
+  static consteval std::size_t count_steps() {
+    std::size_t count = 0;
+    std::size_t i = skip_root();
+
+    while (i < path_str.size()) {
+      if (path_str[i] == '.') {
+        // Field access: .field
+        ++i;
+        if (i >= path_str.size()) break;
+
+        // Skip field name
+        while (i < path_str.size() && path_str[i] != '.' && path_str[i] != '[') {
+          ++i;
+        }
+        ++count;
+      } else if (path_str[i] == '[') {
+        // Array or bracket notation
+        ++i;
+        if (i >= path_str.size()) break;
+
+        if (path_str[i] == '"' || path_str[i] == '\'') {
+          // Field access: ["field"] or ['field']
+          char quote = path_str[i];
+          ++i;
+          while (i < path_str.size() && path_str[i] != quote) {
+            ++i;
+          }
+          if (i < path_str.size()) ++i; // skip closing quote
+          if (i < path_str.size() && path_str[i] == ']') ++i;
+        } else {
+          // Array index: [0], [123]
+          while (i < path_str.size() && path_str[i] != ']') {
+            ++i;
+          }
+          if (i < path_str.size()) ++i; // skip ]
+        }
+        ++count;
+      } else {
+        ++i;
+      }
+    }
+
+    return count;
+  }
+
+  // Parse a field name at compile time
+  static consteval std::size_t parse_field_name(std::size_t start, char* out, std::size_t max_len) {
+    std::size_t len = 0;
+    std::size_t i = start;
+
+    while (i < path_str.size() && path_str[i] != '.' && path_str[i] != '[' && len < max_len - 1) {
+      out[len++] = path_str[i++];
+    }
+    out[len] = '\0';
+    return i;
+  }
+
+  // Parse an array index at compile time
+  static consteval std::pair<std::size_t, std::size_t> parse_array_index(std::size_t start) {
+    std::size_t index = 0;
+    std::size_t i = start;
+
+    while (i < path_str.size() && path_str[i] >= '0' && path_str[i] <= '9') {
+      index = index * 10 + (path_str[i] - '0');
+      ++i;
+    }
+
+    return {i, index};
+  }
+};
+
+// Compile-time path accessor generator
+template<typename T, constevalutil::fixed_string Path>
+struct path_accessor {
+  using value = ::simdjson::SIMDJSON_IMPLEMENTATION::ondemand::value;
+
+  static constexpr auto parser = json_path_parser<Path>();
+  static constexpr std::size_t num_steps = parser.count_steps();
+  static constexpr std::string_view path_view = Path.view();
+
+  // Compile-time accessor generation
+  // If T is a struct, validates the path at compile time
+  // If T is void, skips validation
+  template<typename DocOrValue>
+  static inline simdjson_result<value> access(DocOrValue& doc_or_val) noexcept {
+    // Validate path at compile time if T is a struct
+    if constexpr (std::is_class_v<T>) {
+      constexpr bool path_valid = validate_path();
+      static_assert(path_valid, "JSON path does not match struct definition");
+    }
+
+    // Parse the path at compile time to build access steps
+    return access_impl<parser.skip_root()>(doc_or_val.get_value());
+  }
+
+  // Extract value at path directly into target with compile-time type validation
+  // Example: std::string name; path_accessor<User, ".name">::extract_field(doc, name);
+  template<typename DocOrValue, typename FieldType>
+  static inline error_code extract_field(DocOrValue& doc_or_val, FieldType& target) noexcept {
+    static_assert(std::is_class_v<T>, "extract_field requires T to be a struct type for validation");
+
+    // Validate path exists in struct definition
+    constexpr bool path_valid = validate_path();
+    static_assert(path_valid, "JSON path does not match struct definition");
+
+    // Get the type at the end of the path
+    constexpr auto final_type = get_final_type();
+
+    // Verify target type matches the field type
+    static_assert(final_type == ^^FieldType, "Target type does not match the field type at the path");
+
+    // All validation done at compile time - just navigate and extract
+    auto json_value = access_impl<parser.skip_root()>(doc_or_val.get_value());
+    if (json_value.error()) return json_value.error();
+
+    return json_value.get(target);
+  }
+
+private:
+  // Get the final type by walking the path through the struct type
+  template<typename U = T>
+  static consteval std::enable_if_t<std::is_class_v<U>, std::meta::info> get_final_type() {
+    auto current_type = ^^T;
+    std::size_t i = parser.skip_root();
+
+    while (i < path_view.size()) {
+      if (path_view[i] == '.') {
+        // .field syntax
+        ++i;
+        std::size_t field_start = i;
+        while (i < path_view.size() && path_view[i] != '.' && path_view[i] != '[') {
+          ++i;
+        }
+
+        std::string_view field_name = path_view.substr(field_start, i - field_start);
+
+        auto members = std::meta::nonstatic_data_members_of(
+          current_type, std::meta::access_context::unchecked()
+        );
+
+        for (auto mem : members) {
+          if (std::meta::identifier_of(mem) == field_name) {
+            current_type = std::meta::type_of(mem);
+            break;
+          }
+        }
+
+      } else if (path_view[i] == '[') {
+        ++i;
+        if (i >= path_view.size()) break;
+
+        if (path_view[i] == '"' || path_view[i] == '\'') {
+          // ["field"] syntax
+          char quote = path_view[i];
+          ++i;
+          std::size_t field_start = i;
+          while (i < path_view.size() && path_view[i] != quote) {
+            ++i;
+          }
+
+          std::string_view field_name = path_view.substr(field_start, i - field_start);
+          if (i < path_view.size()) ++i; // skip quote
+          if (i < path_view.size() && path_view[i] == ']') ++i;
+
+          auto members = std::meta::nonstatic_data_members_of(
+            current_type, std::meta::access_context::unchecked()
+          );
+
+          for (auto mem : members) {
+            if (std::meta::identifier_of(mem) == field_name) {
+              current_type = std::meta::type_of(mem);
+              break;
+            }
+          }
+
+        } else {
+          // [index] syntax - extract element type
+          while (i < path_view.size() && path_view[i] >= '0' && path_view[i] <= '9') {
+            ++i;
+          }
+          if (i < path_view.size() && path_view[i] == ']') ++i;
+
+          current_type = get_element_type_reflected(current_type);
+        }
+      } else {
+        ++i;
+      }
+    }
+
+    return current_type;
+  }
+
+private:
+  // Walk path and extract directly into final field using compile-time reflection
+  template<std::meta::info CurrentType, std::size_t PathPos, typename TargetType>
+  static inline error_code extract_with_reflection(simdjson_result<value> current, TargetType& target_ref) noexcept {
+    if (current.error()) return current.error();
+
+    // Base case: end of path - extract into target
+    if constexpr (PathPos >= path_view.size()) {
+      return current.get(target_ref);
+    }
+    // Field access: .field_name
+    else if constexpr (path_view[PathPos] == '.') {
+      constexpr auto field_info = parse_next_field(PathPos);
+      constexpr std::string_view field_name = std::get<0>(field_info);
+      constexpr std::size_t next_pos = std::get<1>(field_info);
+
+      constexpr auto member_info = find_member_by_name(CurrentType, field_name);
+      static_assert(member_info != ^^void, "Field not found in struct");
+
+      constexpr auto member_type = std::meta::type_of(member_info);
+
+      auto obj_result = current.get_object();
+      if (obj_result.error()) return obj_result.error();
+      auto obj = obj_result.value_unsafe();
+      auto field_value = obj.find_field_unordered(field_name);
+
+      if constexpr (next_pos >= path_view.size()) {
+        return field_value.get(target_ref);
+      } else {
+        return extract_with_reflection<member_type, next_pos>(field_value, target_ref);
+      }
+    }
+    // Bracket notation: [index] or ["field"]
+    else if constexpr (path_view[PathPos] == '[') {
+      constexpr auto bracket_info = parse_bracket(PathPos);
+      constexpr bool is_field = std::get<0>(bracket_info);
+      constexpr std::size_t next_pos = std::get<2>(bracket_info);
+
+      if constexpr (is_field) {
+        constexpr std::string_view field_name = std::get<1>(bracket_info);
+        constexpr auto member_info = find_member_by_name(CurrentType, field_name);
+        static_assert(member_info != ^^void, "Field not found in struct");
+        constexpr auto member_type = std::meta::type_of(member_info);
+
+        auto obj_result = current.get_object();
+        if (obj_result.error()) return obj_result.error();
+        auto obj = obj_result.value_unsafe();
+        auto field_value = obj.find_field_unordered(field_name);
+
+        if constexpr (next_pos >= path_view.size()) {
+          return field_value.get(target_ref);
+        } else {
+          return extract_with_reflection<member_type, next_pos>(field_value, target_ref);
+        }
+      } else {
+        constexpr std::size_t index = std::get<3>(bracket_info);
+        constexpr auto elem_type = get_element_type_reflected(CurrentType);
+        static_assert(elem_type != ^^void, "Could not determine array element type");
+
+        auto arr_result = current.get_array();
+        if (arr_result.error()) return arr_result.error();
+        auto arr = arr_result.value_unsafe();
+        auto elem_value = arr.at(index);
+
+        if constexpr (next_pos >= path_view.size()) {
+          return elem_value.get(target_ref);
+        } else {
+          return extract_with_reflection<elem_type, next_pos>(elem_value, target_ref);
+        }
+      }
+    }
+    // Skip unexpected characters and continue
+    else {
+      return extract_with_reflection<CurrentType, PathPos + 1>(current, target_ref);
+    }
+  }
+
+  // Find member by name in reflected type
+  static consteval std::meta::info find_member_by_name(std::meta::info type_refl, std::string_view name) {
+    auto members = std::meta::nonstatic_data_members_of(type_refl, std::meta::access_context::unchecked());
+    for (auto mem : members) {
+      if (std::meta::identifier_of(mem) == name) {
+        return mem;
+      }
+    }
+  }
+
+  // Generate compile-time accessor code by walking the path
+  template<std::size_t PathPos>
+  static inline simdjson_result<value> access_impl(simdjson_result<value> current) noexcept {
+    if (current.error()) return current;
+
+    if constexpr (PathPos >= path_view.size()) {
+      return current;
+    } else if constexpr (path_view[PathPos] == '.') {
+      constexpr auto field_info = parse_next_field(PathPos);
+      constexpr std::string_view field_name = std::get<0>(field_info);
+      constexpr std::size_t next_pos = std::get<1>(field_info);
+
+      auto obj_result = current.get_object();
+      if (obj_result.error()) return obj_result.error();
+
+      auto obj = obj_result.value_unsafe();
+      auto next_value = obj.find_field_unordered(field_name);
+
+      return access_impl<next_pos>(next_value);
+
+    } else if constexpr (path_view[PathPos] == '[') {
+      constexpr auto bracket_info = parse_bracket(PathPos);
+      constexpr bool is_field = std::get<0>(bracket_info);
+      constexpr std::size_t next_pos = std::get<2>(bracket_info);
+
+      if constexpr (is_field) {
+        constexpr std::string_view field_name = std::get<1>(bracket_info);
+
+        auto obj_result = current.get_object();
+        if (obj_result.error()) return obj_result.error();
+
+        auto obj = obj_result.value_unsafe();
+        auto next_value = obj.find_field_unordered(field_name);
+
+        return access_impl<next_pos>(next_value);
+
+      } else {
+        constexpr std::size_t index = std::get<3>(bracket_info);
+
+        auto arr_result = current.get_array();
+        if (arr_result.error()) return arr_result.error();
+
+        auto arr = arr_result.value_unsafe();
+        auto next_value = arr.at(index);
+
+        return access_impl<next_pos>(next_value);
+      }
+    } else {
+      return access_impl<PathPos + 1>(current);
+    }
+  }
+
+  // Parse next field name
+  static consteval auto parse_next_field(std::size_t start) {
+    std::size_t i = start + 1;
+    std::size_t field_start = i;
+    while (i < path_view.size() && path_view[i] != '.' && path_view[i] != '[') {
+      ++i;
+    }
+    std::string_view field_name = path_view.substr(field_start, i - field_start);
+    return std::make_tuple(field_name, i);
+  }
+
+  // Parse bracket notation: returns (is_field, field_name, next_pos, index)
+  static consteval auto parse_bracket(std::size_t start) {
+    std::size_t i = start + 1; // skip '['
+
+    if (i < path_view.size() && (path_view[i] == '"' || path_view[i] == '\'')) {
+      // Field access
+      char quote = path_view[i];
+      ++i;
+      std::size_t field_start = i;
+      while (i < path_view.size() && path_view[i] != quote) {
+        ++i;
+      }
+      std::string_view field_name = path_view.substr(field_start, i - field_start);
+      if (i < path_view.size()) ++i; // skip closing quote
+      if (i < path_view.size() && path_view[i] == ']') ++i;
+
+      return std::make_tuple(true, field_name, i, std::size_t(0));
+    } else {
+      // Array index
+      std::size_t index = 0;
+      while (i < path_view.size() && path_view[i] >= '0' && path_view[i] <= '9') {
+        index = index * 10 + (path_view[i] - '0');
+        ++i;
+      }
+      if (i < path_view.size() && path_view[i] == ']') ++i;
+
+      return std::make_tuple(false, std::string_view{}, i, index);
+    }
+  }
+
+public:
+  // Check if reflected type is array-like (C-style array or indexable container)
+  // Uses reflection to test: 1) std::meta::is_array_type() for C arrays
+  //                          2) std::meta::substitute() to test concepts::indexable_container concept
+  static consteval bool is_array_like_reflected(std::meta::info type_reflection) {
+    if (std::meta::is_array_type(type_reflection)) {
+      return true;
+    }
+
+    if (std::meta::can_substitute(^^concepts::indexable_container_v, {type_reflection})) {
+      return std::meta::extract<bool>(std::meta::substitute(^^concepts::indexable_container_v, {type_reflection}));
+    }
+    return false;
+  }
+
+  // Extract element type from reflected array or container
+  // For C arrays: uses std::meta::remove_extent()
+  // For containers: finds value_type member using std::meta::members_of()
+  static consteval std::meta::info get_element_type_reflected(std::meta::info type_reflection) {
+    if (std::meta::is_array_type(type_reflection)) {
+      return std::meta::remove_extent(type_reflection);
+    }
+
+    auto members = std::meta::members_of(type_reflection, std::meta::access_context::unchecked());
+    for (auto mem : members) {
+      if (std::meta::is_type(mem)) {
+        auto name = std::meta::identifier_of(mem);
+        if (name == "value_type") {
+          return mem;
+        }
+      }
+    }
+    return ^^void;
+  }
+
+private:
+  // Check if type has member with given name
+  template<typename Type>
+  static consteval bool has_member(std::string_view member_name) {
+    constexpr auto members = std::meta::nonstatic_data_members_of(^^Type, std::meta::access_context::unchecked());
+    for (auto mem : members) {
+      if (std::meta::identifier_of(mem) == member_name) {
+        return true;
+      }
+    }
+    return false;
+  }
+
+  // Get type of member by name
+  template<typename Type>
+  static consteval auto get_member_type(std::string_view member_name) {
+    constexpr auto members = std::meta::nonstatic_data_members_of(^^Type, std::meta::access_context::unchecked());
+    for (auto mem : members) {
+      if (std::meta::identifier_of(mem) == member_name) {
+        return std::meta::type_of(mem);
+      }
+    }
+    return ^^void;
+  }
+
+  // Check if non-reflected type is array-like
+  template<typename Type>
+  static consteval bool is_container_type() {
+    using BaseType = std::remove_cvref_t<Type>;
+    if constexpr (requires { typename BaseType::value_type; }) {
+      return true;
+    }
+    if constexpr (std::is_array_v<BaseType>) {
+      return true;
+    }
+    return false;
+  }
+
+  // Extract element type from non-reflected container
+  template<typename Type>
+  using extract_element_type = std::conditional_t<
+    requires { typename std::remove_cvref_t<Type>::value_type; },
+    typename std::remove_cvref_t<Type>::value_type,
+    std::conditional_t<
+      std::is_array_v<std::remove_cvref_t<Type>>,
+      std::remove_extent_t<std::remove_cvref_t<Type>>,
+      void
+    >
+  >;
+
+  // Validate path matches struct definition
+  static consteval bool validate_path() {
+    if constexpr (!std::is_class_v<T>) {
+      return true;
+    }
+
+    auto current_type = ^^T;
+    std::size_t i = parser.skip_root();
+
+    while (i < path_view.size()) {
+      if (path_view[i] == '.') {
+        ++i;
+        std::size_t field_start = i;
+        while (i < path_view.size() && path_view[i] != '.' && path_view[i] != '[') {
+          ++i;
+        }
+
+        std::string_view field_name = path_view.substr(field_start, i - field_start);
+
+        bool found = false;
+        auto members = std::meta::nonstatic_data_members_of(current_type, std::meta::access_context::unchecked());
+
+        for (auto mem : members) {
+          if (std::meta::identifier_of(mem) == field_name) {
+            current_type = std::meta::type_of(mem);
+            found = true;
+            break;
+          }
+        }
+
+        if (!found) {
+          return false;
+        }
+
+      } else if (path_view[i] == '[') {
+        ++i;
+        if (i >= path_view.size()) return false;
+
+        if (path_view[i] == '"' || path_view[i] == '\'') {
+          char quote = path_view[i];
+          ++i;
+          std::size_t field_start = i;
+          while (i < path_view.size() && path_view[i] != quote) {
+            ++i;
+          }
+
+          std::string_view field_name = path_view.substr(field_start, i - field_start);
+          if (i < path_view.size()) ++i;
+          if (i < path_view.size() && path_view[i] == ']') ++i;
+
+          bool found = false;
+          auto members = std::meta::nonstatic_data_members_of(current_type, std::meta::access_context::unchecked());
+
+          for (auto mem : members) {
+            if (std::meta::identifier_of(mem) == field_name) {
+              current_type = std::meta::type_of(mem);
+              found = true;
+              break;
+            }
+          }
+
+          if (!found) {
+            return false;
+          }
+
+        } else {
+          while (i < path_view.size() && path_view[i] >= '0' && path_view[i] <= '9') {
+            ++i;
+          }
+
+          if (i < path_view.size() && path_view[i] == ']') ++i;
+
+          if (!is_array_like_reflected(current_type)) {
+            return false;
+          }
+
+          auto new_type = get_element_type_reflected(current_type);
+
+          if (new_type == ^^void) {
+            return false;
+          }
+
+          current_type = new_type;
+        }
+      } else {
+        ++i;
+      }
+    }
+
+    return true;
+  }
+};
+
+// Compile-time path accessor with validation
+template<typename T, constevalutil::fixed_string Path, typename DocOrValue>
+inline simdjson_result<::simdjson::SIMDJSON_IMPLEMENTATION::ondemand::value> at_path_compiled(DocOrValue& doc_or_val) noexcept {
+  using accessor = path_accessor<T, Path>;
+  return accessor::access(doc_or_val);
+}
+
+// Overload without type parameter (no validation)
+template<constevalutil::fixed_string Path, typename DocOrValue>
+inline simdjson_result<::simdjson::SIMDJSON_IMPLEMENTATION::ondemand::value> at_path_compiled(DocOrValue& doc_or_val) noexcept {
+  using accessor = path_accessor<void, Path>;
+  return accessor::access(doc_or_val);
+}
+
+// ============================================================================
+// JSON Pointer Compile-Time Support (RFC 6901)
+// ============================================================================
+
+// JSON Pointer parser: /field/0/nested (slash-separated)
+template<constevalutil::fixed_string Pointer>
+struct json_pointer_parser {
+  static constexpr std::string_view pointer_str = Pointer.view();
+
+  // Unescape token: ~0 -> ~, ~1 -> /
+  static consteval void unescape_token(std::string_view src, char* dest, std::size_t& out_len) {
+    out_len = 0;
+    for (std::size_t i = 0; i < src.size(); ++i) {
+      if (src[i] == '~' && i + 1 < src.size()) {
+        if (src[i + 1] == '0') {
+          dest[out_len++] = '~';
+          ++i;
+        } else if (src[i + 1] == '1') {
+          dest[out_len++] = '/';
+          ++i;
+        } else {
+          dest[out_len++] = src[i];
+        }
+      } else {
+        dest[out_len++] = src[i];
+      }
+    }
+  }
+
+  // Check if token is numeric
+  static consteval bool is_numeric(std::string_view token) {
+    if (token.empty()) return false;
+    if (token[0] == '0' && token.size() > 1) return false;
+    for (char c : token) {
+      if (c < '0' || c > '9') return false;
+    }
+    return true;
+  }
+
+  // Parse numeric token to index
+  static consteval std::size_t parse_index(std::string_view token) {
+    std::size_t result = 0;
+    for (char c : token) {
+      result = result * 10 + (c - '0');
+    }
+    return result;
+  }
+
+  // Count tokens in pointer
+  static consteval std::size_t count_tokens() {
+    if (pointer_str.empty() || pointer_str == "/") return 0;
+
+    std::size_t count = 0;
+    std::size_t pos = pointer_str[0] == '/' ? 1 : 0;
+
+    while (pos < pointer_str.size()) {
+      ++count;
+      std::size_t next_slash = pointer_str.find('/', pos);
+      if (next_slash == std::string_view::npos) break;
+      pos = next_slash + 1;
+    }
+
+    return count;
+  }
+
+  // Get Nth token
+  static consteval std::string_view get_token(std::size_t token_index) {
+    std::size_t pos = pointer_str[0] == '/' ? 1 : 0;
+    std::size_t current_token = 0;
+
+    while (current_token < token_index) {
+      std::size_t next_slash = pointer_str.find('/', pos);
+      pos = next_slash + 1;
+      ++current_token;
+    }
+
+    std::size_t token_end = pointer_str.find('/', pos);
+    if (token_end == std::string_view::npos) token_end = pointer_str.size();
+
+    return pointer_str.substr(pos, token_end - pos);
+  }
+};
+
+// JSON Pointer accessor
+template<typename T, constevalutil::fixed_string Pointer>
+struct pointer_accessor {
+  using parser = json_pointer_parser<Pointer>;
+  static constexpr std::string_view pointer_view = Pointer.view();
+  static constexpr std::size_t token_count = parser::count_tokens();
+
+  // Validate pointer against struct definition
+  static consteval bool validate_pointer() {
+    if constexpr (!std::is_class_v<T>) {
+      return true;
+    }
+
+    auto current_type = ^^T;
+    std::size_t pos = pointer_view[0] == '/' ? 1 : 0;
+
+    while (pos < pointer_view.size()) {
+      // Extract token up to next /
+      std::size_t token_end = pointer_view.find('/', pos);
+      if (token_end == std::string_view::npos) token_end = pointer_view.size();
+
+      std::string_view token = pointer_view.substr(pos, token_end - pos);
+
+      if (parser::is_numeric(token)) {
+        if (!path_accessor<T, Pointer>::is_array_like_reflected(current_type)) {
+          return false;
+        }
+        current_type = path_accessor<T, Pointer>::get_element_type_reflected(current_type);
+      } else {
+        bool found = false;
+        auto members = std::meta::nonstatic_data_members_of(current_type, std::meta::access_context::unchecked());
+
+        for (auto mem : members) {
+          if (std::meta::identifier_of(mem) == token) {
+            current_type = std::meta::type_of(mem);
+            found = true;
+            break;
+          }
+        }
+
+        if (!found) return false;
+      }
+
+      pos = token_end + 1;
+    }
+
+    return true;
+  }
+
+  // Recursive accessor
+  template<std::size_t TokenIndex>
+  static inline simdjson_result<value> access_impl(simdjson_result<value> current) noexcept {
+    if constexpr (TokenIndex >= token_count) {
+      return current;
+    } else {
+      constexpr std::string_view token = parser::get_token(TokenIndex);
+
+      if constexpr (parser::is_numeric(token)) {
+        constexpr std::size_t index = parser::parse_index(token);
+        auto arr = current.get_array().value_unsafe();
+        auto next_value = arr.at(index);
+        return access_impl<TokenIndex + 1>(next_value);
+      } else {
+        auto obj = current.get_object().value_unsafe();
+        auto next_value = obj.find_field_unordered(token);
+        return access_impl<TokenIndex + 1>(next_value);
+      }
+    }
+  }
+
+  // Access JSON value at pointer
+  template<typename DocOrValue>
+  static inline simdjson_result<value> access(DocOrValue& doc_or_val) noexcept {
+    if constexpr (std::is_class_v<T>) {
+      constexpr bool pointer_valid = validate_pointer();
+      static_assert(pointer_valid, "JSON Pointer does not match struct definition");
+    }
+
+    if (pointer_view.empty() || pointer_view == "/") {
+      if constexpr (requires { doc_or_val.get_value(); }) {
+        return doc_or_val.get_value();
+      } else {
+        return doc_or_val;
+      }
+    }
+
+    simdjson_result<value> current = doc_or_val.get_value();
+    return access_impl<0>(current);
+  }
+
+  // Extract value at pointer directly into target with type validation
+  template<typename DocOrValue, typename FieldType>
+  static inline error_code extract_field(DocOrValue& doc_or_val, FieldType& target) noexcept {
+    static_assert(std::is_class_v<T>, "extract_field requires T to be a struct type for validation");
+
+    constexpr bool pointer_valid = validate_pointer();
+    static_assert(pointer_valid, "JSON Pointer does not match struct definition");
+
+    constexpr auto final_type = get_final_type();
+    static_assert(final_type == ^^FieldType, "Target type does not match the field type at the pointer");
+
+    simdjson_result<value> current_value = doc_or_val.get_value();
+    auto json_value = access_impl<0>(current_value);
+    if (json_value.error()) return json_value.error();
+
+    return json_value.get(target);
+  }
+
+private:
+  // Get final type by walking pointer through struct
+  template<typename U = T>
+  static consteval std::enable_if_t<std::is_class_v<U>, std::meta::info> get_final_type() {
+    auto current_type = ^^T;
+    std::size_t pos = pointer_view[0] == '/' ? 1 : 0;
+
+    while (pos < pointer_view.size()) {
+      std::size_t token_end = pointer_view.find('/', pos);
+      if (token_end == std::string_view::npos) token_end = pointer_view.size();
+
+      std::string_view token = pointer_view.substr(pos, token_end - pos);
+
+      if (parser::is_numeric(token)) {
+        current_type = path_accessor<T, "">::get_element_type_reflected(current_type);
+      } else {
+        auto members = std::meta::nonstatic_data_members_of(current_type, std::meta::access_context::unchecked());
+
+        for (auto mem : members) {
+          if (std::meta::identifier_of(mem) == token) {
+            current_type = std::meta::type_of(mem);
+            break;
+          }
+        }
+      }
+
+      pos = token_end + 1;
+    }
+
+    return current_type;
+  }
+};
+
+// Compile-time JSON Pointer accessor with validation
+template<typename T, constevalutil::fixed_string Pointer, typename DocOrValue>
+inline simdjson_result<::simdjson::SIMDJSON_IMPLEMENTATION::ondemand::value> at_pointer_compiled(DocOrValue& doc_or_val) noexcept {
+  using accessor = pointer_accessor<T, Pointer>;
+  return accessor::access(doc_or_val);
+}
+
+// Overload without type parameter (no validation)
+template<constevalutil::fixed_string Pointer, typename DocOrValue>
+inline simdjson_result<::simdjson::SIMDJSON_IMPLEMENTATION::ondemand::value> at_pointer_compiled(DocOrValue& doc_or_val) noexcept {
+  using accessor = pointer_accessor<void, Pointer>;
+  return accessor::access(doc_or_val);
+}
+
+} // namespace json_path
+} // namespace ondemand
+} // namespace SIMDJSON_IMPLEMENTATION
+} // namespace simdjson
+
+#endif // SIMDJSON_SUPPORTS_CONCEPTS && SIMDJSON_STATIC_REFLECTION
+#endif // SIMDJSON_GENERIC_ONDEMAND_COMPILE_TIME_ACCESSORS_H
+

include/simdjson/generic/ondemand/document.h

@@ -407,7 +407,7 @@ public:
    * The following code reads z, then y, then x, and thus will not retrieve x or y if fed the
    * JSON `{ "x": 1, "y": 2, "z": 3 }`:
    *
-   * ```c++
+   * ```cpp
    * simdjson::ondemand::parser parser;
    * auto obj = parser.parse(R"( { "x": 1, "y": 2, "z": 3 } )"_padded);
    * double z = obj.find_field("z");
@@ -701,7 +701,7 @@ public:
    * JSONPath queries that trivially convertible to JSON Pointer queries: key
    * names and array indices.
    *
-   * https://datatracker.ietf.org/doc/html/draft-normington-jsonpath-00
+   * https://www.rfc-editor.org/rfc/rfc9535 (RFC 9535)
    *
    * Key values are matched exactly, without unescaping or Unicode normalization.
    * We do a byte-by-byte comparison. E.g.
@@ -734,7 +734,7 @@ public:
    * potentially improving performance by skipping unwanted fields.
    *
    * Example:
-   * ```c++
+   * ```cpp
    * struct Car {
    *   std::string make;
    *   std::string model;

include/simdjson/generic/ondemand/document_stream.h

@@ -81,7 +81,7 @@ public:
   /**
    * Construct an uninitialized document_stream.
    *
-   *  ```c++
+   *  ```cpp
    *  document_stream docs;
    *  auto error = parser.iterate_many(json).get(docs);
    *  ```

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

@@ -416,9 +416,9 @@ simdjson_inline void string_builder::append(number_type v) noexcept {
         pv = 0 - pv; // the 0 is for Microsoft
       }
       size_t dc = internal::digit_count(pv);
-      if (negative) {
-        buffer.get()[position++] = '-';
-      }
+      // by always writing the minus sign, we avoid the branch.
+      buffer.get()[position] = '-';
+      position += negative ? 1 : 0;
       char *write_pointer = buffer.get() + position + dc - 1;
       while (pv >= 100) {
         memcpy(write_pointer - 1, &internal::decimal_table[(pv % 100) * 2], 2);

include/simdjson/generic/ondemand/object.h

@@ -34,7 +34,7 @@ public:
    * The following code reads z, then y, then x, and thus will not retrieve x or y if fed the
    * JSON `{ "x": 1, "y": 2, "z": 3 }`:
    *
-   * ```c++
+   * ```cpp
    * simdjson::ondemand::parser parser;
    * auto obj = parser.parse(R"( { "x": 1, "y": 2, "z": 3 } )"_padded);
    * double z = obj.find_field("z");
@@ -243,7 +243,7 @@ public:
    * potentially improving performance by skipping unwanted fields.
    *
    * Example:
-   * ```c++
+   * ```cpp
    * struct Car {
    *   std::string make;
    *   std::string model;

include/simdjson/generic/ondemand/value.h

@@ -399,7 +399,7 @@ public:
    * The following code reads z, then y, then x, and thus will not retrieve x or y if fed the
    * JSON `{ "x": 1, "y": 2, "z": 3 }`:
    *
-   * ```c++
+   * ```cpp
    * simdjson::ondemand::parser parser;
    * auto obj = parser.parse(R"( { "x": 1, "y": 2, "z": 3 } )"_padded);
    * double z = obj.find_field("z");
@@ -772,7 +772,7 @@ public:
    * The following code reads z, then y, then x, and thus will not retrieve x or y if fed the
    * JSON `{ "x": 1, "y": 2, "z": 3 }`:
    *
-   * ```c++
+   * ```cpp
    * simdjson::ondemand::parser parser;
    * auto obj = parser.parse(R"( { "x": 1, "y": 2, "z": 3 } )"_padded);
    * double z = obj.find_field("z");

include/simdjson/simdjson_version.h

@@ -4,7 +4,7 @@
 #define SIMDJSON_SIMDJSON_VERSION_H
 
 /** The version of simdjson being used (major.minor.revision) */
-#define SIMDJSON_VERSION "4.0.7"
+#define SIMDJSON_VERSION "4.1.0"
 
 namespace simdjson {
 enum {
@@ -15,11 +15,11 @@ enum {
   /**
    * The minor version (major.MINOR.revision) of simdjson being used.
    */
-  SIMDJSON_VERSION_MINOR = 0,
+  SIMDJSON_VERSION_MINOR = 1,
   /**
    * The revision (major.minor.REVISION) of simdjson being used.
    */
-  SIMDJSON_VERSION_REVISION = 7
+  SIMDJSON_VERSION_REVISION = 0
 };
 } // namespace simdjson
 

singleheader/simdjson.cpp

@@ -1,4 +1,4 @@
-/* auto-generated on 2025-09-29 20:34:35 -0700. version 4.0.7 Do not edit! */
+/* auto-generated on 2025-10-27 16:52:41 -0400. version 4.1.0 Do not edit! */
 /* including simdjson.cpp:  */
 /* begin file simdjson.cpp */
 #define SIMDJSON_SRC_SIMDJSON_CPP
@@ -3030,6 +3030,25 @@ concept container_but_not_string =
   std::ranges::input_range<T> && !string_like<T> && !concepts::string_view_keyed_map<T>;
 
 
+
+// Concept: Indexable container that is not a string or associative container
+// Accepts: std::vector, std::array, std::deque (have operator[], value_type, not string_like)
+// Rejects: std::string (string_like), std::list (no operator[]), std::map (has key_type)
+template<typename Container>
+concept indexable_container = requires {
+  typename Container::value_type;
+  requires !concepts::string_like<Container>;
+  requires !requires { typename Container::key_type; };  // Reject maps/sets
+  requires requires(Container& c, std::size_t i) {
+    { c[i] } -> std::convertible_to<typename Container::value_type>;
+  };
+};
+
+
+// Variable template to use with std::meta::substitute
+template<typename Container>
+constexpr bool indexable_container_v = indexable_container<Container>;
+
 } // namespace concepts
 
 
@@ -5047,7 +5066,8 @@ namespace internal {
     { INCOMPLETE_ARRAY_OR_OBJECT, "INCOMPLETE_ARRAY_OR_OBJECT: JSON document ended early in the middle of an object or array. This is a fatal and unrecoverable error." },
     { SCALAR_DOCUMENT_AS_VALUE, "SCALAR_DOCUMENT_AS_VALUE: A JSON document made of a scalar (number, Boolean, null or string) is treated as a value. Use get_bool(), get_double(), etc. on the document instead. "},
     { OUT_OF_BOUNDS, "OUT_OF_BOUNDS: Attempt to access location outside of document."},
-    { TRAILING_CONTENT, "TRAILING_CONTENT: Unexpected trailing content in the JSON input."}
+    { TRAILING_CONTENT, "TRAILING_CONTENT: Unexpected trailing content in the JSON input."},
+    { OUT_OF_CAPACITY, "OUT_OF_CAPACITY: The capacity was exceeded, we cannot allocate enough memory."}
   }; // error_messages[]
 
 } // namespace internal

src/internal/error_tables.cpp

@@ -39,10 +39,11 @@ namespace internal {
     { INCOMPLETE_ARRAY_OR_OBJECT, "INCOMPLETE_ARRAY_OR_OBJECT: JSON document ended early in the middle of an object or array. This is a fatal and unrecoverable error." },
     { SCALAR_DOCUMENT_AS_VALUE, "SCALAR_DOCUMENT_AS_VALUE: A JSON document made of a scalar (number, Boolean, null or string) is treated as a value. Use get_bool(), get_double(), etc. on the document instead. "},
     { OUT_OF_BOUNDS, "OUT_OF_BOUNDS: Attempt to access location outside of document."},
-    { TRAILING_CONTENT, "TRAILING_CONTENT: Unexpected trailing content in the JSON input."}
+    { TRAILING_CONTENT, "TRAILING_CONTENT: Unexpected trailing content in the JSON input."},
+    { OUT_OF_CAPACITY, "OUT_OF_CAPACITY: The capacity was exceeded, we cannot allocate enough memory."}
   }; // error_messages[]
 
 } // namespace internal
 } // namespace simdjson
 
-#endif // SIMDJSON_SRC_ERROR_TABLES_CPP
+#endif // SIMDJSON_SRC_ERROR_TABLES_CPP

tests/ondemand/CMakeLists.txt

@@ -16,6 +16,9 @@ add_cpp_test(ondemand_error_tests                    LABELS ondemand acceptance
 add_cpp_test(ondemand_error_location_tests           LABELS ondemand acceptance per_implementation)
 add_cpp_test(ondemand_json_pointer_tests             LABELS ondemand acceptance per_implementation)
 add_cpp_test(ondemand_json_path_tests                LABELS ondemand acceptance per_implementation)
+add_cpp_test(compile_time_json_path_tests            LABELS ondemand acceptance per_implementation)
+add_cpp_test(compile_time_json_pointer_tests         LABELS ondemand acceptance per_implementation)
+add_cpp_test(compile_time_no_validation_tests        LABELS ondemand acceptance per_implementation)
 add_cpp_test(ondemand_key_string_tests               LABELS ondemand acceptance per_implementation)
 add_cpp_test(ondemand_misc_tests                     LABELS ondemand acceptance per_implementation)
 add_cpp_test(ondemand_number_tests                   LABELS ondemand acceptance per_implementation)

tests/ondemand/compile_time_json_path_tests.cpp

@@ -0,0 +1,255 @@
+#include "simdjson.h"
+#include "test_ondemand.h"
+#include <string>
+
+#if SIMDJSON_SUPPORTS_CONCEPTS && SIMDJSON_STATIC_REFLECTION
+
+using namespace simdjson;
+
+namespace compile_time_json_path_tests {
+
+// Test structures
+struct User {
+  std::string name;
+  int age;
+  std::string email;
+};
+
+struct Car {
+  std::string make;
+  std::string model;
+  int64_t year;
+  std::vector<double> tire_pressure;
+};
+
+// Nested struct types for testing deep nesting
+struct Location {
+  double latitude;
+  double longitude;
+};
+
+struct Address {
+  std::string street;
+  std::string city;
+  int zip;
+  Location location;  // Nested 2 levels deep
+};
+
+struct Person {
+  std::string name;
+  int age;
+  Address address;  // Nested struct
+  std::vector<std::string> emails;  // Array field
+};
+
+const padded_string TEST_USER_JSON = R"(
+{
+  "name": "John Doe",
+  "age": 30,
+  "email": "john@example.com"
+}
+)"_padded;
+
+const padded_string TEST_PERSON_JSON = R"(
+{
+  "name": "Jane Smith",
+  "age": 28,
+  "address": {
+    "street": "123 Main St",
+    "city": "Springfield",
+    "zip": 12345,
+    "location": {
+      "latitude": 42.1234,
+      "longitude": -71.5678
+    }
+  },
+  "emails": ["jane@example.com", "jane.smith@work.com"]
+}
+)"_padded;
+
+// ============================================================================
+// Tests for JSON Path Syntax (dot notation and brackets)
+// ============================================================================
+
+// Test 1: Nested struct with JSON Path syntax (2 levels: Person -> Address -> city)
+bool test_nested_struct_path() {
+  TEST_START();
+  ondemand::parser parser;
+  ondemand::document doc;
+  ASSERT_SUCCESS(parser.iterate(TEST_PERSON_JSON).get(doc));
+
+  std::string city;
+  using accessor = ondemand::json_path::path_accessor<Person, ".address.city">;
+  ASSERT_SUCCESS(accessor::extract_field(doc, city));
+  ASSERT_EQUAL(city, "Springfield");
+
+  TEST_SUCCEED();
+}
+
+// Test 2: Deep nested with bracket notation (3 levels)
+bool test_nested_struct_bracket_notation() {
+  TEST_START();
+  ondemand::parser parser;
+  ondemand::document doc;
+  ASSERT_SUCCESS(parser.iterate(TEST_PERSON_JSON).get(doc));
+
+  double longitude;
+  using accessor = ondemand::json_path::path_accessor<Person, "[\"address\"][\"location\"][\"longitude\"]">;
+  ASSERT_SUCCESS(accessor::extract_field(doc, longitude));
+  ASSERT_EQUAL(longitude, -71.5678);
+
+  TEST_SUCCEED();
+}
+
+// Test 3: Mixed dot and bracket notation on nested structs
+bool test_nested_struct_mixed_notation() {
+  TEST_START();
+  ondemand::parser parser;
+  ondemand::document doc;
+  ASSERT_SUCCESS(parser.iterate(TEST_PERSON_JSON).get(doc));
+
+  int zip;
+  using accessor = ondemand::json_path::path_accessor<Person, ".address[\"zip\"]">;
+  ASSERT_SUCCESS(accessor::extract_field(doc, zip));
+  ASSERT_EQUAL(zip, 12345);
+
+  TEST_SUCCEED();
+}
+
+// ============================================================================
+// Tests for extract_field() with JSON Path - Reflection-based direct extraction
+// ============================================================================
+
+// Test 4: extract_field simple string field (JSON Path dot notation)
+bool test_extract_field_path_simple() {
+  TEST_START();
+  ondemand::parser parser;
+  ondemand::document doc;
+  ASSERT_SUCCESS(parser.iterate(TEST_USER_JSON).get(doc));
+
+  std::string name;
+  using accessor = ondemand::json_path::path_accessor<User, ".name">;
+  ASSERT_SUCCESS(accessor::extract_field(doc, name));
+  ASSERT_EQUAL(name, "John Doe");
+
+  TEST_SUCCEED();
+}
+
+// Test 5: extract_field integer field (JSON Path dot notation)
+bool test_extract_field_path_integer() {
+  TEST_START();
+  ondemand::parser parser;
+  ondemand::document doc;
+  ASSERT_SUCCESS(parser.iterate(TEST_USER_JSON).get(doc));
+
+  int age;
+  using accessor = ondemand::json_path::path_accessor<User, ".age">;
+  ASSERT_SUCCESS(accessor::extract_field(doc, age));
+  ASSERT_EQUAL(age, 30);
+
+  TEST_SUCCEED();
+}
+
+// Test 6: extract_field bracket notation (JSON Path bracket notation)
+bool test_extract_field_path_bracket() {
+  TEST_START();
+  ondemand::parser parser;
+  ondemand::document doc;
+  ASSERT_SUCCESS(parser.iterate(TEST_USER_JSON).get(doc));
+
+  std::string email;
+  using accessor = ondemand::json_path::path_accessor<User, "[\"email\"]">;
+  ASSERT_SUCCESS(accessor::extract_field(doc, email));
+  ASSERT_EQUAL(email, "john@example.com");
+
+  TEST_SUCCEED();
+}
+
+// Test 7: JSON Path with nested field using dot notation
+bool test_path_nested_dot_notation() {
+  TEST_START();
+  ondemand::parser parser;
+  ondemand::document doc;
+  ASSERT_SUCCESS(parser.iterate(TEST_PERSON_JSON).get(doc));
+
+  std::string street;
+  using accessor = ondemand::json_path::path_accessor<Person, ".address.street">;
+  ASSERT_SUCCESS(accessor::extract_field(doc, street));
+  ASSERT_EQUAL(street, "123 Main St");
+
+  TEST_SUCCEED();
+}
+
+// Test 8: JSON Path with deep nested field (3 levels)
+bool test_path_deep_nested() {
+  TEST_START();
+  ondemand::parser parser;
+  ondemand::document doc;
+  ASSERT_SUCCESS(parser.iterate(TEST_PERSON_JSON).get(doc));
+
+  double latitude;
+  using accessor = ondemand::json_path::path_accessor<Person, ".address.location.latitude">;
+  ASSERT_SUCCESS(accessor::extract_field(doc, latitude));
+  ASSERT_EQUAL(latitude, 42.1234);
+
+  TEST_SUCCEED();
+}
+
+// Test 9: JSON Path with bracket notation for all levels
+bool test_path_all_bracket_notation() {
+  TEST_START();
+  ondemand::parser parser;
+  ondemand::document doc;
+  ASSERT_SUCCESS(parser.iterate(TEST_PERSON_JSON).get(doc));
+
+  std::string city;
+  using accessor = ondemand::json_path::path_accessor<Person, "[\"address\"][\"city\"]">;
+  ASSERT_SUCCESS(accessor::extract_field(doc, city));
+  ASSERT_EQUAL(city, "Springfield");
+
+  TEST_SUCCEED();
+}
+
+// Test 10: JSON Path mixed notation with integer field
+bool test_path_mixed_notation_integer() {
+  TEST_START();
+  ondemand::parser parser;
+  ondemand::document doc;
+  ASSERT_SUCCESS(parser.iterate(TEST_PERSON_JSON).get(doc));
+
+  int age;
+  using accessor = ondemand::json_path::path_accessor<Person, "[\"age\"]">;
+  ASSERT_SUCCESS(accessor::extract_field(doc, age));
+  ASSERT_EQUAL(age, 28);
+
+  TEST_SUCCEED();
+}
+
+} // namespace compile_time_json_path_tests
+
+#endif // SIMDJSON_SUPPORTS_CONCEPTS && SIMDJSON_STATIC_REFLECTION
+
+int main(int argc, char *argv[]) {
+  (void)argc;
+  (void)argv;
+#if SIMDJSON_SUPPORTS_CONCEPTS && SIMDJSON_STATIC_REFLECTION
+  std::cout << "Running compile-time JSON Path tests" << std::endl;
+
+  if (!compile_time_json_path_tests::test_nested_struct_path()) { return EXIT_FAILURE; }
+  if (!compile_time_json_path_tests::test_nested_struct_bracket_notation()) { return EXIT_FAILURE; }
+  if (!compile_time_json_path_tests::test_nested_struct_mixed_notation()) { return EXIT_FAILURE; }
+  if (!compile_time_json_path_tests::test_extract_field_path_simple()) { return EXIT_FAILURE; }
+  if (!compile_time_json_path_tests::test_extract_field_path_integer()) { return EXIT_FAILURE; }
+  if (!compile_time_json_path_tests::test_extract_field_path_bracket()) { return EXIT_FAILURE; }
+  if (!compile_time_json_path_tests::test_path_nested_dot_notation()) { return EXIT_FAILURE; }
+  if (!compile_time_json_path_tests::test_path_deep_nested()) { return EXIT_FAILURE; }
+  if (!compile_time_json_path_tests::test_path_all_bracket_notation()) { return EXIT_FAILURE; }
+  if (!compile_time_json_path_tests::test_path_mixed_notation_integer()) { return EXIT_FAILURE; }
+
+  std::cout << "All compile-time JSON Path tests passed!" << std::endl;
+  return EXIT_SUCCESS;
+#else
+  std::cout << "Compile-time JSON Path tests require C++26 reflection support" << std::endl;
+  return EXIT_SUCCESS;
+#endif
+}

tests/ondemand/compile_time_json_pointer_tests.cpp

@@ -0,0 +1,639 @@
+#include "simdjson.h"
+#include "test_ondemand.h"
+#include <string>
+
+#if SIMDJSON_SUPPORTS_CONCEPTS && SIMDJSON_STATIC_REFLECTION
+
+using namespace simdjson;
+
+namespace compile_time_json_pointer_tests {
+
+// Test structures
+struct User {
+  std::string name;
+  int age;
+  std::string email;
+};
+
+struct Car {
+  std::string make;
+  std::string model;
+  int64_t year;
+  std::vector<double> tire_pressure;
+};
+
+// Nested struct types for testing deep nesting
+struct Location {
+  double latitude;
+  double longitude;
+};
+
+struct Address {
+  std::string street;
+  std::string city;
+  int zip;
+  Location location;  // Nested 2 levels deep
+};
+
+struct Person {
+  std::string name;
+  int age;
+  Address address;  // Nested struct
+  std::vector<std::string> emails;  // Array field
+};
+
+const padded_string TEST_USER_JSON = R"(
+{
+  "name": "John Doe",
+  "age": 30,
+  "email": "john@example.com"
+}
+)"_padded;
+
+const padded_string TEST_CAR_JSON = R"(
+{
+  "make": "Toyota",
+  "model": "Camry",
+  "year": 2018,
+  "tire_pressure": [40.1, 39.9, 37.7, 40.4]
+}
+)"_padded;
+
+const padded_string TEST_NESTED_JSON = R"(
+{
+  "users": [
+    {
+      "name": "Alice",
+      "age": 25,
+      "email": "alice@example.com"
+    },
+    {
+      "name": "Bob",
+      "age": 35,
+      "email": "bob@example.com"
+    }
+  ],
+  "metadata": {
+    "count": 2,
+    "version": "1.0"
+  }
+}
+)"_padded;
+
+const padded_string TEST_ARRAY_JSON = R"(
+[
+  {"make": "Toyota", "model": "Camry", "year": 2018, "tire_pressure": [40.1, 39.9, 37.7, 40.4]},
+  {"make": "Kia", "model": "Soul", "year": 2012, "tire_pressure": [30.1, 31.0, 28.6, 28.7]},
+  {"make": "Toyota", "model": "Tercel", "year": 1999, "tire_pressure": [29.8, 30.0, 30.2, 30.5]}
+]
+)"_padded;
+
+const padded_string TEST_PERSON_JSON = R"(
+{
+  "name": "Jane Smith",
+  "age": 28,
+  "address": {
+    "street": "123 Main St",
+    "city": "Springfield",
+    "zip": 12345,
+    "location": {
+      "latitude": 42.1234,
+      "longitude": -71.5678
+    }
+  },
+  "emails": ["jane@example.com", "jane.smith@work.com"]
+}
+)"_padded;
+
+// Test 1: Simple field access
+bool test_simple_field() {
+  TEST_START();
+  ondemand::parser parser;
+  ondemand::document doc;
+  ASSERT_SUCCESS(parser.iterate(TEST_USER_JSON).get(doc));
+
+  auto result = ondemand::json_path::at_pointer_compiled<"/name">(doc);
+  ASSERT_SUCCESS(result.error());
+
+  std::string_view name;
+  ASSERT_SUCCESS(result.get_string().get(name));
+  ASSERT_EQUAL(name, "John Doe");
+
+  TEST_SUCCEED();
+}
+
+// Test 2: Integer field access
+bool test_integer_field() {
+  TEST_START();
+  ondemand::parser parser;
+  ondemand::document doc;
+  ASSERT_SUCCESS(parser.iterate(TEST_USER_JSON).get(doc));
+
+  auto result = ondemand::json_path::at_pointer_compiled<"/age">(doc);
+  ASSERT_SUCCESS(result.error());
+
+  int64_t age;
+  ASSERT_SUCCESS(result.get_int64().get(age));
+  ASSERT_EQUAL(age, 30);
+
+  TEST_SUCCEED();
+}
+
+// Test 3: Array index access
+bool test_array_index() {
+  TEST_START();
+  ondemand::parser parser;
+  ondemand::document doc;
+  ASSERT_SUCCESS(parser.iterate(TEST_CAR_JSON).get(doc));
+
+  auto result = ondemand::json_path::at_pointer_compiled<"/tire_pressure/1">(doc);
+  ASSERT_SUCCESS(result.error());
+
+  double pressure;
+  ASSERT_SUCCESS(result.get_double().get(pressure));
+  ASSERT_EQUAL(pressure, 39.9);
+
+  TEST_SUCCEED();
+}
+
+// Test 4: Nested field access
+bool test_nested_field() {
+  TEST_START();
+  ondemand::parser parser;
+  ondemand::document doc;
+  ASSERT_SUCCESS(parser.iterate(TEST_NESTED_JSON).get(doc));
+
+  auto result = ondemand::json_path::at_pointer_compiled<"/metadata/version">(doc);
+  ASSERT_SUCCESS(result.error());
+
+  std::string_view version;
+  ASSERT_SUCCESS(result.get_string().get(version));
+  ASSERT_EQUAL(version, "1.0");
+
+  TEST_SUCCEED();
+}
+
+// Test 5: Array of objects with nested path
+bool test_array_object_nested() {
+  TEST_START();
+  ondemand::parser parser;
+  ondemand::document doc;
+  ASSERT_SUCCESS(parser.iterate(TEST_NESTED_JSON).get(doc));
+
+  auto result = ondemand::json_path::at_pointer_compiled<"/users/0/name">(doc);
+  ASSERT_SUCCESS(result.error());
+
+  std::string_view name;
+  ASSERT_SUCCESS(result.get_string().get(name));
+  ASSERT_EQUAL(name, "Alice");
+
+  TEST_SUCCEED();
+}
+
+// Test 6: Root array access
+bool test_root_array() {
+  TEST_START();
+  ondemand::parser parser;
+  ondemand::document doc;
+  ASSERT_SUCCESS(parser.iterate(TEST_ARRAY_JSON).get(doc));
+
+  auto result = ondemand::json_path::at_pointer_compiled<"/1/make">(doc);
+  ASSERT_SUCCESS(result.error());
+
+  std::string_view make;
+  ASSERT_SUCCESS(result.get_string().get(make));
+  ASSERT_EQUAL(make, "Kia");
+
+  TEST_SUCCEED();
+}
+
+// Test 7: Deep nested array
+bool test_deep_nested_array() {
+  TEST_START();
+  ondemand::parser parser;
+  ondemand::document doc;
+  ASSERT_SUCCESS(parser.iterate(TEST_ARRAY_JSON).get(doc));
+
+  auto result = ondemand::json_path::at_pointer_compiled<"/0/tire_pressure/2">(doc);
+  ASSERT_SUCCESS(result.error());
+
+  double pressure;
+  ASSERT_SUCCESS(result.get_double().get(pressure));
+  ASSERT_EQUAL(pressure, 37.7);
+
+  TEST_SUCCEED();
+}
+
+// Test 8: Root pointer (empty or "/")
+bool test_root_pointer() {
+  TEST_START();
+  ondemand::parser parser;
+  ondemand::document doc;
+  ASSERT_SUCCESS(parser.iterate(TEST_USER_JSON).get(doc));
+
+  auto result = ondemand::json_path::at_pointer_compiled<"">(doc);
+  ASSERT_SUCCESS(result.error());
+
+  auto obj = result.get_object();
+  ASSERT_SUCCESS(obj.error());
+
+  TEST_SUCCEED();
+}
+
+// Test 9: First array element
+bool test_first_array_element() {
+  TEST_START();
+  ondemand::parser parser;
+  ondemand::document doc;
+  ASSERT_SUCCESS(parser.iterate(TEST_CAR_JSON).get(doc));
+
+  auto result = ondemand::json_path::at_pointer_compiled<"/tire_pressure/0">(doc);
+  ASSERT_SUCCESS(result.error());
+
+  double pressure;
+  ASSERT_SUCCESS(result.get_double().get(pressure));
+  ASSERT_EQUAL(pressure, 40.1);
+
+  TEST_SUCCEED();
+}
+
+// Test 10: Multiple indices in path
+bool test_multiple_indices() {
+  TEST_START();
+  ondemand::parser parser;
+  ondemand::document doc;
+  ASSERT_SUCCESS(parser.iterate(TEST_NESTED_JSON).get(doc));
+
+  auto result = ondemand::json_path::at_pointer_compiled<"/users/1/age">(doc);
+  ASSERT_SUCCESS(result.error());
+
+  int64_t age;
+  ASSERT_SUCCESS(result.get_int64().get(age));
+  ASSERT_EQUAL(age, 35);
+
+  TEST_SUCCEED();
+}
+
+// Test 11: Compare compile-time vs runtime pointer
+bool test_compile_vs_runtime() {
+  TEST_START();
+  ondemand::parser parser;
+  ondemand::document doc;
+  ASSERT_SUCCESS(parser.iterate(TEST_USER_JSON).get(doc));
+
+  // Compile-time version
+  auto compile_result = ondemand::json_path::at_pointer_compiled<"/name">(doc);
+  ASSERT_SUCCESS(compile_result.error());
+  std::string_view compile_name;
+  ASSERT_SUCCESS(compile_result.get_string().get(compile_name));
+
+  // Runtime version for comparison
+  ondemand::parser parser2;
+  ondemand::document doc2;
+  ASSERT_SUCCESS(parser2.iterate(TEST_USER_JSON).get(doc2));
+  auto runtime_result = doc2.at_pointer("/name");
+  ASSERT_SUCCESS(runtime_result.error());
+  std::string_view runtime_name;
+  ASSERT_SUCCESS(runtime_result.get_string().get(runtime_name));
+
+  // Should produce same result
+  ASSERT_EQUAL(compile_name, runtime_name);
+
+  TEST_SUCCEED();
+}
+
+// Test 12: Nested integer field
+bool test_nested_integer() {
+  TEST_START();
+  ondemand::parser parser;
+  ondemand::document doc;
+  ASSERT_SUCCESS(parser.iterate(TEST_NESTED_JSON).get(doc));
+
+  auto result = ondemand::json_path::at_pointer_compiled<"/metadata/count">(doc);
+  ASSERT_SUCCESS(result.error());
+
+  int64_t count;
+  ASSERT_SUCCESS(result.get_int64().get(count));
+  ASSERT_EQUAL(count, 2);
+
+  TEST_SUCCEED();
+}
+
+// Test 13: Last array element
+bool test_last_array_element() {
+  TEST_START();
+  ondemand::parser parser;
+  ondemand::document doc;
+  ASSERT_SUCCESS(parser.iterate(TEST_CAR_JSON).get(doc));
+
+  auto result = ondemand::json_path::at_pointer_compiled<"/tire_pressure/3">(doc);
+  ASSERT_SUCCESS(result.error());
+
+  double pressure;
+  ASSERT_SUCCESS(result.get_double().get(pressure));
+  ASSERT_EQUAL(pressure, 40.4);
+
+  TEST_SUCCEED();
+}
+
+// Test 14: Access second user's email
+bool test_second_user_email() {
+  TEST_START();
+  ondemand::parser parser;
+  ondemand::document doc;
+  ASSERT_SUCCESS(parser.iterate(TEST_NESTED_JSON).get(doc));
+
+  auto result = ondemand::json_path::at_pointer_compiled<"/users/1/email">(doc);
+  ASSERT_SUCCESS(result.error());
+
+  std::string_view email;
+  ASSERT_SUCCESS(result.get_string().get(email));
+  ASSERT_EQUAL(email, "bob@example.com");
+
+  TEST_SUCCEED();
+}
+
+// Test 15: Root array first element field
+bool test_root_array_first_field() {
+  TEST_START();
+  ondemand::parser parser;
+  ondemand::document doc;
+  ASSERT_SUCCESS(parser.iterate(TEST_ARRAY_JSON).get(doc));
+
+  auto result = ondemand::json_path::at_pointer_compiled<"/0/model">(doc);
+  ASSERT_SUCCESS(result.error());
+
+  std::string_view model;
+  ASSERT_SUCCESS(result.get_string().get(model));
+  ASSERT_EQUAL(model, "Camry");
+
+  TEST_SUCCEED();
+}
+
+// ============================================================================
+// Tests for Nested Struct Type Validation with Reflection
+// ============================================================================
+
+// Test 16: Deep nested field access (3 levels: Person -> Address -> Location -> latitude)
+bool test_nested_struct_deep_pointer() {
+  TEST_START();
+  ondemand::parser parser;
+  ondemand::document doc;
+  ASSERT_SUCCESS(parser.iterate(TEST_PERSON_JSON).get(doc));
+
+  double latitude;
+  using accessor = ondemand::json_path::pointer_accessor<Person, "/address/location/latitude">;
+  ASSERT_SUCCESS(accessor::extract_field(doc, latitude));
+  ASSERT_EQUAL(latitude, 42.1234);
+
+  TEST_SUCCEED();
+}
+
+// Test 17: Nested struct with int field (2 levels: Person -> Address -> zip)
+bool test_nested_struct_integer() {
+  TEST_START();
+  ondemand::parser parser;
+  ondemand::document doc;
+  ASSERT_SUCCESS(parser.iterate(TEST_PERSON_JSON).get(doc));
+
+  int zip;
+  using accessor = ondemand::json_path::pointer_accessor<Person, "/address/zip">;
+  ASSERT_SUCCESS(accessor::extract_field(doc, zip));
+  ASSERT_EQUAL(zip, 12345);
+
+  TEST_SUCCEED();
+}
+
+// Test 18: Nested struct with double field (3 levels deep)
+bool test_nested_struct_longitude() {
+  TEST_START();
+  ondemand::parser parser;
+  ondemand::document doc;
+  ASSERT_SUCCESS(parser.iterate(TEST_PERSON_JSON).get(doc));
+
+  double longitude;
+  using accessor = ondemand::json_path::pointer_accessor<Person, "/address/location/longitude">;
+  ASSERT_SUCCESS(accessor::extract_field(doc, longitude));
+  ASSERT_EQUAL(longitude, -71.5678);
+
+  TEST_SUCCEED();
+}
+
+// Test 19: Nested struct string field (2 levels)
+bool test_nested_struct_street() {
+  TEST_START();
+  ondemand::parser parser;
+  ondemand::document doc;
+  ASSERT_SUCCESS(parser.iterate(TEST_PERSON_JSON).get(doc));
+
+  std::string street;
+  using accessor = ondemand::json_path::pointer_accessor<Person, "/address/street">;
+  ASSERT_SUCCESS(accessor::extract_field(doc, street));
+  ASSERT_EQUAL(street, "123 Main St");
+
+  TEST_SUCCEED();
+}
+
+// ============================================================================
+// Compile-Time Error Tests (Documentation Only - These Should NOT Compile)
+// ============================================================================
+//
+// These tests demonstrate compile-time safety. If you uncomment them, they will
+// fail to compile with clear error messages.
+//
+// Example 1: Type mismatch - trying to extract string into int
+// bool test_compile_error_type_mismatch() {
+//   ondemand::parser parser;
+//   ondemand::document doc;
+//   parser.iterate(TEST_USER_JSON).get(doc);
+//
+//   int name;  // ERROR: name is std::string, not int!
+//   using accessor = ondemand::json_path::pointer_accessor<User, "/name">;
+//   accessor::extract_field(doc, name);
+//   // Compile error: "Target type does not match the field type at the pointer"
+//   // static_assert fails: ^^std::string != ^^int
+// }
+//
+// Example 2: Non-existent field
+// bool test_compile_error_invalid_field() {
+//   ondemand::parser parser;
+//   ondemand::document doc;
+//   parser.iterate(TEST_USER_JSON).get(doc);
+//
+//   std::string foo;
+//   using accessor = ondemand::json_path::pointer_accessor<User, "/nonexistent">;
+//   accessor::extract_field(doc, foo);
+//   // Compile error: "JSON Pointer does not match struct definition"
+//   // Field "nonexistent" not found in User struct
+// }
+//
+// Example 3: Wrong nested path
+// bool test_compile_error_wrong_nested_path() {
+//   ondemand::parser parser;
+//   ondemand::document doc;
+//   parser.iterate(TEST_PERSON_JSON).get(doc);
+//
+//   std::string foo;
+//   using accessor = ondemand::json_path::pointer_accessor<Person, "/address/invalid/field">;
+//   accessor::extract_field(doc, foo);
+//   // Compile error: "JSON Pointer does not match struct definition"
+//   // Field "invalid" not found in Address struct
+// }
+//
+// Example 4: Array index on non-array field
+// bool test_compile_error_array_on_scalar() {
+//   ondemand::parser parser;
+//   ondemand::document doc;
+//   parser.iterate(TEST_USER_JSON).get(doc);
+//
+//   std::string foo;
+//   using accessor = ondemand::json_path::pointer_accessor<User, "/name/0">;
+//   accessor::extract_field(doc, foo);
+//   // Compile error: "JSON Pointer does not match struct definition"
+//   // Can't use array index on std::string field
+// }
+//
+// Example 5: Deep nesting type mismatch
+// bool test_compile_error_deep_nesting_type_mismatch() {
+//   ondemand::parser parser;
+//   ondemand::document doc;
+//   parser.iterate(TEST_PERSON_JSON).get(doc);
+//
+//   int latitude;  // ERROR: latitude is double, not int!
+//   using accessor = ondemand::json_path::pointer_accessor<Person, "/address/location/latitude">;
+//   accessor::extract_field(doc, latitude);
+//   // Compile error: "Target type does not match the field type at the pointer"
+//   // static_assert fails: ^^double != ^^int
+// }
+
+// ============================================================================
+// Tests for extract_field() - Reflection-based direct extraction
+// ============================================================================
+
+// ============================================================================
+// Tests for extract_field() with JSON Pointer - Reflection-based direct extraction
+// ============================================================================
+
+// Test 20: extract_field simple string field (JSON Pointer)
+bool test_extract_field_pointer_simple() {
+  TEST_START();
+  ondemand::parser parser;
+  ondemand::document doc;
+  ASSERT_SUCCESS(parser.iterate(TEST_USER_JSON).get(doc));
+
+  std::string name;
+  using accessor = ondemand::json_path::pointer_accessor<User, "/name">;
+  ASSERT_SUCCESS(accessor::extract_field(doc, name));
+  ASSERT_EQUAL(name, "John Doe");
+
+  TEST_SUCCEED();
+}
+
+// Test 21: extract_field integer field (JSON Pointer)
+bool test_extract_field_pointer_integer() {
+  TEST_START();
+  ondemand::parser parser;
+  ondemand::document doc;
+  ASSERT_SUCCESS(parser.iterate(TEST_USER_JSON).get(doc));
+
+  int age;
+  using accessor = ondemand::json_path::pointer_accessor<User, "/age">;
+  ASSERT_SUCCESS(accessor::extract_field(doc, age));
+  ASSERT_EQUAL(age, 30);
+
+  TEST_SUCCEED();
+}
+
+// Test 22: extract_field email field (JSON Pointer)
+bool test_extract_field_pointer_email() {
+  TEST_START();
+  ondemand::parser parser;
+  ondemand::document doc;
+  ASSERT_SUCCESS(parser.iterate(TEST_USER_JSON).get(doc));
+
+  std::string email;
+  using accessor = ondemand::json_path::pointer_accessor<User, "/email">;
+  ASSERT_SUCCESS(accessor::extract_field(doc, email));
+  ASSERT_EQUAL(email, "john@example.com");
+
+  TEST_SUCCEED();
+}
+
+// Test 23: extract_field with Car struct (JSON Pointer)
+bool test_extract_field_pointer_car_make() {
+  TEST_START();
+  ondemand::parser parser;
+  ondemand::document doc;
+  ASSERT_SUCCESS(parser.iterate(TEST_CAR_JSON).get(doc));
+
+  std::string make;
+  using accessor = ondemand::json_path::pointer_accessor<Car, "/make">;
+  ASSERT_SUCCESS(accessor::extract_field(doc, make));
+  ASSERT_EQUAL(make, "Toyota");
+
+  TEST_SUCCEED();
+}
+
+// Test 24: extract_field with year (int64_t) (JSON Pointer)
+bool test_extract_field_pointer_car_year() {
+  TEST_START();
+  ondemand::parser parser;
+  ondemand::document doc;
+  ASSERT_SUCCESS(parser.iterate(TEST_CAR_JSON).get(doc));
+
+  int64_t year;
+  using accessor = ondemand::json_path::pointer_accessor<Car, "/year">;
+  ASSERT_SUCCESS(accessor::extract_field(doc, year));
+  ASSERT_EQUAL(year, 2018);
+
+  TEST_SUCCEED();
+}
+
+} // namespace compile_time_json_pointer_tests
+
+#endif // SIMDJSON_SUPPORTS_CONCEPTS && SIMDJSON_STATIC_REFLECTION
+
+int main(int argc, char *argv[]) {
+  (void)argc;
+  (void)argv;
+#if SIMDJSON_SUPPORTS_CONCEPTS && SIMDJSON_STATIC_REFLECTION
+  std::cout << "Running compile-time JSON Pointer tests" << std::endl;
+
+  if (!compile_time_json_pointer_tests::test_simple_field()) { return EXIT_FAILURE; }
+  if (!compile_time_json_pointer_tests::test_integer_field()) { return EXIT_FAILURE; }
+  if (!compile_time_json_pointer_tests::test_array_index()) { return EXIT_FAILURE; }
+  if (!compile_time_json_pointer_tests::test_nested_field()) { return EXIT_FAILURE; }
+  if (!compile_time_json_pointer_tests::test_array_object_nested()) { return EXIT_FAILURE; }
+  if (!compile_time_json_pointer_tests::test_root_array()) { return EXIT_FAILURE; }
+  if (!compile_time_json_pointer_tests::test_deep_nested_array()) { return EXIT_FAILURE; }
+  if (!compile_time_json_pointer_tests::test_root_pointer()) { return EXIT_FAILURE; }
+  if (!compile_time_json_pointer_tests::test_first_array_element()) { return EXIT_FAILURE; }
+  if (!compile_time_json_pointer_tests::test_multiple_indices()) { return EXIT_FAILURE; }
+  if (!compile_time_json_pointer_tests::test_compile_vs_runtime()) { return EXIT_FAILURE; }
+  if (!compile_time_json_pointer_tests::test_nested_integer()) { return EXIT_FAILURE; }
+  if (!compile_time_json_pointer_tests::test_last_array_element()) { return EXIT_FAILURE; }
+  if (!compile_time_json_pointer_tests::test_second_user_email()) { return EXIT_FAILURE; }
+  if (!compile_time_json_pointer_tests::test_root_array_first_field()) { return EXIT_FAILURE; }
+
+  // Test nested struct type validation with reflection (JSON Pointer syntax only)
+  std::cout << "\nRunning nested struct validation tests..." << std::endl;
+  if (!compile_time_json_pointer_tests::test_nested_struct_deep_pointer()) { return EXIT_FAILURE; }
+  if (!compile_time_json_pointer_tests::test_nested_struct_integer()) { return EXIT_FAILURE; }
+  if (!compile_time_json_pointer_tests::test_nested_struct_longitude()) { return EXIT_FAILURE; }
+  if (!compile_time_json_pointer_tests::test_nested_struct_street()) { return EXIT_FAILURE; }
+
+  // Test extract_field() API with JSON Pointer
+  std::cout << "\nRunning extract_field() with JSON Pointer..." << std::endl;
+  if (!compile_time_json_pointer_tests::test_extract_field_pointer_simple()) { return EXIT_FAILURE; }
+  if (!compile_time_json_pointer_tests::test_extract_field_pointer_integer()) { return EXIT_FAILURE; }
+  if (!compile_time_json_pointer_tests::test_extract_field_pointer_email()) { return EXIT_FAILURE; }
+  if (!compile_time_json_pointer_tests::test_extract_field_pointer_car_make()) { return EXIT_FAILURE; }
+  if (!compile_time_json_pointer_tests::test_extract_field_pointer_car_year()) { return EXIT_FAILURE; }
+
+  std::cout << "All compile-time JSON Pointer tests passed!" << std::endl;
+  return EXIT_SUCCESS;
+#else
+  std::cout << "Compile-time JSON Pointer tests require C++26 reflection support" << std::endl;
+  return EXIT_SUCCESS;
+#endif
+}

tests/ondemand/compile_time_no_validation_tests.cpp

@@ -0,0 +1,219 @@
+#include "simdjson.h"
+#include "test_ondemand.h"
+
+using namespace simdjson;
+
+#if SIMDJSON_SUPPORTS_CONCEPTS && SIMDJSON_STATIC_REFLECTION
+
+// Test compile-time accessors without struct type validation
+// These tests verify that the compile-time path parsing works even without
+// providing a struct type for validation
+namespace compile_time_no_validation_tests {
+
+const padded_string TEST_JSON = R"({
+  "name": "Alice",
+  "age": 30,
+  "address": {
+    "city": "Boston",
+    "zip": 12345
+  },
+  "scores": [95, 87, 92]
+})"_padded;
+
+// ============================================================================
+// JSON Pointer without validation
+// ============================================================================
+
+bool test_pointer_simple_field() {
+  TEST_START();
+  ondemand::parser parser;
+  auto doc = parser.iterate(TEST_JSON);
+
+  std::string_view name;
+  auto result = ondemand::json_path::at_pointer_compiled<"/name">(doc);
+  ASSERT_SUCCESS(result.get(name));
+  ASSERT_EQUAL(name, "Alice");
+
+  TEST_SUCCEED();
+}
+
+bool test_pointer_integer_field() {
+  TEST_START();
+  ondemand::parser parser;
+  auto doc = parser.iterate(TEST_JSON);
+
+  int64_t age;
+  auto result = ondemand::json_path::at_pointer_compiled<"/age">(doc);
+  ASSERT_SUCCESS(result.get(age));
+  ASSERT_EQUAL(age, 30);
+
+  TEST_SUCCEED();
+}
+
+bool test_pointer_nested_field() {
+  TEST_START();
+  ondemand::parser parser;
+  auto doc = parser.iterate(TEST_JSON);
+
+  std::string_view city;
+  auto result = ondemand::json_path::at_pointer_compiled<"/address/city">(doc);
+  ASSERT_SUCCESS(result.get(city));
+  ASSERT_EQUAL(city, "Boston");
+
+  TEST_SUCCEED();
+}
+
+bool test_pointer_nested_integer() {
+  TEST_START();
+  ondemand::parser parser;
+  auto doc = parser.iterate(TEST_JSON);
+
+  int64_t zip;
+  auto result = ondemand::json_path::at_pointer_compiled<"/address/zip">(doc);
+  ASSERT_SUCCESS(result.get(zip));
+  ASSERT_EQUAL(zip, 12345);
+
+  TEST_SUCCEED();
+}
+
+bool test_pointer_array_access() {
+  TEST_START();
+  ondemand::parser parser;
+  auto doc = parser.iterate(TEST_JSON);
+
+  int64_t score;
+  auto result = ondemand::json_path::at_pointer_compiled<"/scores/1">(doc);
+  ASSERT_SUCCESS(result.get(score));
+  ASSERT_EQUAL(score, 87);
+
+  TEST_SUCCEED();
+}
+
+// ============================================================================
+// JSON Path without validation
+// ============================================================================
+
+bool test_path_simple_field() {
+  TEST_START();
+  ondemand::parser parser;
+  auto doc = parser.iterate(TEST_JSON);
+
+  std::string_view name;
+  auto result = ondemand::json_path::at_path_compiled<".name">(doc);
+  ASSERT_SUCCESS(result.get(name));
+  ASSERT_EQUAL(name, "Alice");
+
+  TEST_SUCCEED();
+}
+
+bool test_path_nested_dot_notation() {
+  TEST_START();
+  ondemand::parser parser;
+  auto doc = parser.iterate(TEST_JSON);
+
+  std::string_view city;
+  auto result = ondemand::json_path::at_path_compiled<".address.city">(doc);
+  ASSERT_SUCCESS(result.get(city));
+  ASSERT_EQUAL(city, "Boston");
+
+  TEST_SUCCEED();
+}
+
+bool test_path_array_access() {
+  TEST_START();
+  ondemand::parser parser;
+  auto doc = parser.iterate(TEST_JSON);
+
+  int64_t score;
+  auto result = ondemand::json_path::at_path_compiled<".scores[1]">(doc);
+  ASSERT_SUCCESS(result.get(score));
+  ASSERT_EQUAL(score, 87);
+
+  TEST_SUCCEED();
+}
+
+bool test_path_bracket_notation() {
+  TEST_START();
+  ondemand::parser parser;
+  auto doc = parser.iterate(TEST_JSON);
+
+  int64_t age;
+  auto result = ondemand::json_path::at_path_compiled<"[\"age\"]">(doc);
+  ASSERT_SUCCESS(result.get(age));
+  ASSERT_EQUAL(age, 30);
+
+  TEST_SUCCEED();
+}
+
+bool test_path_mixed_notation() {
+  TEST_START();
+  ondemand::parser parser;
+  auto doc = parser.iterate(TEST_JSON);
+
+  int64_t zip;
+  auto result = ondemand::json_path::at_path_compiled<".address[\"zip\"]">(doc);
+  ASSERT_SUCCESS(result.get(zip));
+  ASSERT_EQUAL(zip, 12345);
+
+  TEST_SUCCEED();
+}
+
+bool test_path_all_bracket_notation() {
+  TEST_START();
+  ondemand::parser parser;
+  auto doc = parser.iterate(TEST_JSON);
+
+  std::string_view city;
+  auto result = ondemand::json_path::at_path_compiled<"[\"address\"][\"city\"]">(doc);
+  ASSERT_SUCCESS(result.get(city));
+  ASSERT_EQUAL(city, "Boston");
+
+  TEST_SUCCEED();
+}
+
+bool test_path_with_root_prefix() {
+  TEST_START();
+  ondemand::parser parser;
+  auto doc = parser.iterate(TEST_JSON);
+
+  std::string_view name;
+  auto result = ondemand::json_path::at_path_compiled<"$.name">(doc);
+  ASSERT_SUCCESS(result.get(name));
+  ASSERT_EQUAL(name, "Alice");
+
+  TEST_SUCCEED();
+}
+
+} // namespace compile_time_no_validation_tests
+
+#endif // SIMDJSON_SUPPORTS_CONCEPTS && SIMDJSON_STATIC_REFLECTION
+
+int main(int argc, char *argv[]) {
+  (void)argc;
+  (void)argv;
+#if SIMDJSON_SUPPORTS_CONCEPTS && SIMDJSON_STATIC_REFLECTION
+  std::cout << "Running compile-time accessor tests WITHOUT struct validation" << std::endl;
+
+  // JSON Pointer tests
+  if (!compile_time_no_validation_tests::test_pointer_simple_field()) { return EXIT_FAILURE; }
+  if (!compile_time_no_validation_tests::test_pointer_integer_field()) { return EXIT_FAILURE; }
+  if (!compile_time_no_validation_tests::test_pointer_nested_field()) { return EXIT_FAILURE; }
+  if (!compile_time_no_validation_tests::test_pointer_nested_integer()) { return EXIT_FAILURE; }
+  if (!compile_time_no_validation_tests::test_pointer_array_access()) { return EXIT_FAILURE; }
+
+  // JSON Path tests
+  if (!compile_time_no_validation_tests::test_path_simple_field()) { return EXIT_FAILURE; }
+  if (!compile_time_no_validation_tests::test_path_nested_dot_notation()) { return EXIT_FAILURE; }
+  if (!compile_time_no_validation_tests::test_path_array_access()) { return EXIT_FAILURE; }
+  if (!compile_time_no_validation_tests::test_path_bracket_notation()) { return EXIT_FAILURE; }
+  if (!compile_time_no_validation_tests::test_path_mixed_notation()) { return EXIT_FAILURE; }
+  if (!compile_time_no_validation_tests::test_path_all_bracket_notation()) { return EXIT_FAILURE; }
+  if (!compile_time_no_validation_tests::test_path_with_root_prefix()) { return EXIT_FAILURE; }
+
+  std::cout << "All compile-time accessor tests WITHOUT validation passed!" << std::endl;
+  return EXIT_SUCCESS;
+#else
+  std::cout << "Compile-time accessor tests require C++26 reflection support" << std::endl;
+  return EXIT_SUCCESS;
+#endif
+}