Do not force inlining of the recovery stubs with MSVC

f8ff0942b marked the stubs that stand in for error recovery with JSON_HEDLEY_ALWAYS_INLINE, which is __forceinline with MSVC. Visual Studio 2015 and 2017 do not inline them and warn (C4714), which /WX turns into an error on AppVeyor. The new internal macro JSON_INTERNAL_ALWAYS_INLINE forces inlining everywhere else (including clang-cl), and leaves the decision to MSVC. The MinGW objects keep their smaller section counts, as GCC and clang still inline the stubs. Signed-off-by: Niels Lohmann <mail@nlohmann.me>
Keep the MinGW test objects below the linker's section limit
2026-10-09 16:07:14 +00:00 · 2026-10-09 00:52:35 +02:00 · 2026-10-08 10:36:16 +02:00 · 2026-10-07 22:56:50 +02:00 · 2026-10-07 19:24:12 +02:00 · 2026-10-07 09:04:47 +02:00
109 changed files with 9113 additions and 5012 deletions
@@ -108,16 +108,11 @@ The tests are located in [`tests/src/unit-*.cpp`](https://github.com/nlohmann/js
 are structured along the features of the library or the nature of the tests. Usually, it should be clear from the
 context which existing file needs to be extended, and only very few cases require creating new test files.

-When fixing a bug, edit `unit-regression3.cpp` and add a section referencing the fixed issue. Tests that need C++17 or
-C++20 go into `unit-regression3-cpp17.cpp` or `unit-regression3-cpp20.cpp` instead, so the large file is not rebuilt
-for every C++ standard. `unit-regression2.cpp` holds the older tests; the two files exist because a single one grew
-large enough for the MinGW linker to fail relocating it, so please keep adding to the smaller file rather than growing
-the larger one.
-
-To keep compile times down, several test files are compiled together as one translation unit. This sets a few rules
-for test files, such as giving file-scope helpers file-specific names. See the README in the
-[`tests`](https://github.com/nlohmann/json/tree/develop/tests) folder for how the tests are built and what to keep in
-mind when adding them.
+When fixing a bug, edit `unit-regression3.cpp` and add a section referencing the fixed issue.
+`unit-regression2.cpp` holds the older tests; the two files exist because a single one grew large enough for the
+MinGW linker to fail relocating it, so please keep adding to the smaller file rather than growing the larger one.
+Regression tests that call `sax_parse` go into `unit-sax_parse.cpp` instead: every call instantiates the parser and
+the binary reader that recover from errors, which grows a test file considerably.

 #### Exceptions

@@ -31,51 +31,6 @@ jobs:
      - name: Build
        run: cmake --build build --target ci_test_gcc

-  ci_meson_install:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
-        with:
-          persist-credentials: false
-      - name: Get latest CMake and ninja
-        uses: lukka/get-cmake@fffaaafeea488556c2c12dad60690008bc1caacb # v4.4.2
-      - name: Check that Meson and pkg-config offer the CMake options
-        run: make check_build_options
-      - name: Install Meson
-        run: pip install meson
-      - name: Install with Meson
-        run: |
-          meson setup build-meson --prefix=${{ github.workspace }}/install
-          meson install -C build-meson
-      - name: Use the installed package with find_package
-        run: |
-          cmake -S tests/cmake_import/project -B build-import -DCMAKE_PREFIX_PATH=${{ github.workspace }}/install
-          cmake --build build-import
-      - name: Install with Meson and non-default options
-        run: |
-          meson setup build-meson-options --prefix=${{ github.workspace }}/install-options -DMultipleHeaders=true -DDiagnostics=true -DGlobalUDLs=false -DDisableTupleReferenceConversion=true -DStrictBinaryUTF8=true -DDeleteDeprecatedFunctions=true
-          meson install -C build-meson-options
-      - name: Check that the options reach the installed files
-        run: |
-          test -d install-options/include/nlohmann/detail
-          cflags=$(PKG_CONFIG_PATH=${{ github.workspace }}/install-options/share/pkgconfig pkg-config --cflags nlohmann_json)
-          echo "$cflags"
-          echo "$cflags" | grep -q -- '-DJSON_DIAGNOSTICS=1'
-          echo "$cflags" | grep -q -- '-DJSON_USE_GLOBAL_UDLS=0'
-          echo "$cflags" | grep -q -- '-DJSON_DISABLE_TUPLE_REFERENCE_CONVERSION=1'
-          echo "$cflags" | grep -q -- '-DJSON_STRICT_BINARY_UTF8=1'
-          echo "$cflags" | grep -q -- '-DJSON_DELETE_DEPRECATED_FUNCTIONS=1'
-          grep -q 'JSON_USE_GLOBAL_UDLS=0;JSON_DISABLE_TUPLE_REFERENCE_CONVERSION=1;JSON_DIAGNOSTICS=1' install-options/share/cmake/nlohmann_json/nlohmann_jsonTargets.cmake
-          grep -q 'JSON_STRICT_BINARY_UTF8=1;JSON_DELETE_DEPRECATED_FUNCTIONS=1' install-options/share/cmake/nlohmann_json/nlohmann_jsonTargets.cmake
-          cmake -S tests/cmake_import/project -B build-import-options -DCMAKE_PREFIX_PATH=${{ github.workspace }}/install-options
-          cmake --build build-import-options
-      - name: Install with Meson and the include directory outside the prefix
-        run: |
-          meson setup build-meson-split --prefix=${{ github.workspace }}/install-split --includedir=${{ github.workspace }}/install-split-dev/include
-          meson install -C build-meson-split
-          cmake -S tests/cmake_import/project -B build-import-split -DCMAKE_PREFIX_PATH=${{ github.workspace }}/install-split
-          cmake --build build-import-split
-
  ci_infer:
    runs-on: ubuntu-latest
    steps:
@@ -189,39 +189,7 @@ if (MSVC)
    )
 endif()

-# Install a pkg-config file, so other tools can find this. It carries the same
-# compile definitions as the target above.
-set(NLOHMANN_JSON_PKGCONFIG_CFLAGS "")
-if (NOT JSON_GlobalUDLs)
-    string(APPEND NLOHMANN_JSON_PKGCONFIG_CFLAGS " -DJSON_USE_GLOBAL_UDLS=0")
-endif()
-if (NOT JSON_ImplicitConversions)
-    string(APPEND NLOHMANN_JSON_PKGCONFIG_CFLAGS " -DJSON_USE_IMPLICIT_CONVERSIONS=0")
-endif()
-if (JSON_DisableEnumSerialization)
-    string(APPEND NLOHMANN_JSON_PKGCONFIG_CFLAGS " -DJSON_DISABLE_ENUM_SERIALIZATION=1")
-endif()
-if (JSON_DisableTupleReferenceConversion)
-    string(APPEND NLOHMANN_JSON_PKGCONFIG_CFLAGS " -DJSON_DISABLE_TUPLE_REFERENCE_CONVERSION=1")
-endif()
-if (JSON_Diagnostics)
-    string(APPEND NLOHMANN_JSON_PKGCONFIG_CFLAGS " -DJSON_DIAGNOSTICS=1")
-endif()
-if (JSON_Diagnostic_Positions)
-    string(APPEND NLOHMANN_JSON_PKGCONFIG_CFLAGS " -DJSON_DIAGNOSTIC_POSITIONS=1")
-endif()
-if (JSON_LegacyDiscardedValueComparison)
-    string(APPEND NLOHMANN_JSON_PKGCONFIG_CFLAGS " -DJSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON=1")
-endif()
-if (JSON_StrictNulHandling)
-    string(APPEND NLOHMANN_JSON_PKGCONFIG_CFLAGS " -DJSON_STRICT_NUL_HANDLING=1")
-endif()
-if (JSON_StrictBinaryUTF8)
-    string(APPEND NLOHMANN_JSON_PKGCONFIG_CFLAGS " -DJSON_STRICT_BINARY_UTF8=1")
-endif()
-if (JSON_DeleteDeprecatedFunctions)
-    string(APPEND NLOHMANN_JSON_PKGCONFIG_CFLAGS " -DJSON_DELETE_DEPRECATED_FUNCTIONS=1")
-endif()
+# Install a pkg-config file, so other tools can find this.
 configure_file(
    "${CMAKE_CURRENT_SOURCE_DIR}/cmake/pkg-config.pc.in"
    "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}.pc"
@@ -249,31 +249,9 @@ make BUILD.bazel

 The "Check amalgamation" workflow fails if the file is out of date.

-### `meson.build` and `meson_options.txt`
+### `meson.build`

-Meson build definitions suitable for use as a subproject ("wrap" in Meson terminology).
-
-Projects wishing to use the wrap can execute:
-```sh
-meson wrap install nlohmann_json
-```
-
-Which allows Meson to build from source when a system provided dependency isn't available.
-
-To build directly:
-```sh
-meson setup builddir
-ninja -C builddir
-```
-
-`meson_options.txt` defines the options, which mirror the CMake options that change the library's target (for example,
-`-DDiagnostics=true`). Meson requires this file next to `meson.build`, so it is also part of `include.zip`. `make check_build_options`
-([`tools/check_build_options`](tools/check_build_options/README.md)) checks in CI that both files and the pkg-config files
-stay in sync with the CMake options.
-
-When installing, `meson.build` installs the headers, a pkg-config file, and the CMake package config files, so that
-`find_package(nlohmann_json)` works. As Meson cannot generate `nlohmann_jsonTargets.cmake` itself, it is created from
-the template `cmake/nlohmann_jsonTargets.cmake.in`, which is only used by Meson.
+The build definition for the [Meson](https://mesonbuild.com) build system.

 ### `Package.swift`

@@ -1,4 +1,4 @@
-.PHONY: pretty clean ChangeLog.md release update_hedley update_hedley_undef BUILD.bazel natvis macro_builder_check check_build_options
+.PHONY: pretty clean ChangeLog.md release update_hedley update_hedley_undef BUILD.bazel natvis macro_builder_check

 ##########################################################################
 # configuration
@@ -127,10 +127,6 @@ macro_builder_check:
 	diff "$$TMPDIR/paste.hpp" "$$TMPDIR/paste_actual.hpp" || (echo "===================================================================\n  $(MACRO_SCOPE_HPP) (NLOHMANN_JSON_EXPAND..NLOHMANN_JSON_DOUBLE_PASTE63) is out of date!\n  Regenerate it, see tools/macro_builder/README.md.\n===================================================================" ; exit 1); \
 	diff "$$TMPDIR/type_body.hpp" "$$TMPDIR/type_body_actual.hpp" || (echo "===================================================================\n  $(MACRO_SCOPE_HPP) (NLOHMANN_JSON_TYPE_BODY) is out of date!\n  Regenerate it, see tools/macro_builder/README.md.\n===================================================================" ; exit 1)

-# check that the Meson build and the pkg-config files offer the options of the CMake target
-check_build_options:
-	python3 tools/check_build_options/check_build_options.py .
-
 # check if file single_include/nlohmann/json.hpp has been amalgamated from the nlohmann sources
 check-amalgamation:
 	@mv $(AMALGAMATED_FILE) $(AMALGAMATED_FILE)~
@@ -188,7 +184,7 @@ json.tar.xz:
 # We use `-X` to make the resulting ZIP file reproducible, see
 # <https://content.pivotal.io/blog/barriers-to-deterministic-reproducible-zip-files>.
 include.zip: BUILD.bazel
-	zip -9 --recurse-paths -X include.zip $(SRCS) $(AMALGAMATED_FILE) $(AMALGAMATED_FWD_FILE) $(AMALGAMATED_LITERALS_FILE) BUILD.bazel MODULE.bazel meson.build meson_options.txt LICENSE.MIT
+	zip -9 --recurse-paths -X include.zip $(SRCS) $(AMALGAMATED_FILE) $(AMALGAMATED_FWD_FILE) $(AMALGAMATED_LITERALS_FILE) BUILD.bazel MODULE.bazel meson.build LICENSE.MIT

 # Create the files for a release and add signatures and hashes.
 release: include.zip json.tar.xz
@@ -494,7 +494,7 @@ bool key(string_t& val);
 bool parse_error(std::size_t position, const std::string& last_token, const detail::exception& ex);
 ```

-The return value of each function determines whether parsing should proceed.
+The return value of each function determines whether parsing should proceed. For `parse_error`, returning `true` [recovers from the error](https://json.nlohmann.me/features/parsing/error_recovery/): the parser repairs the input and continues.

 To implement your own SAX handler, proceed as follows:

@@ -502,7 +502,7 @@ To implement your own SAX handler, proceed as follows:
 2. Create an object of your SAX interface class, e.g. `my_sax`.
 3. Call `bool json::sax_parse(input, &my_sax)`; where the first parameter can be any input like a string or an input stream and the second parameter is a pointer to your SAX interface.

-Note the `sax_parse` function only returns a `bool` indicating the result of the last executed SAX event. It does not return a  `json` value - it is up to you to decide what to do with the SAX events. Furthermore, no exceptions are thrown in case of a parse error -- it is up to you what to do with the exception object passed to your `parse_error` implementation. Internally, the SAX interface is used for the DOM parser (class `json_sax_dom_parser`) as well as the acceptor (`json_sax_acceptor`), see file [`json_sax.hpp`](https://github.com/nlohmann/json/blob/develop/include/nlohmann/detail/input/json_sax.hpp).
+Note the `sax_parse` function only returns a `bool` indicating whether the input was parsed without errors and no SAX event returned `false`. It does not return a  `json` value - it is up to you to decide what to do with the SAX events. Furthermore, no exceptions are thrown in case of a parse error -- it is up to you what to do with the exception object passed to your `parse_error` implementation. Internally, the SAX interface is used for the DOM parser (class `json_sax_dom_parser`) as well as the acceptor (`json_sax_acceptor`), see file [`json_sax.hpp`](https://github.com/nlohmann/json/blob/develop/include/nlohmann/detail/input/json_sax.hpp).

 ### STL-like access

@@ -871,11 +871,11 @@ add_custom_target(ci_icpx
 # The following tests are excluded as they trigger known nvc++ 25.5 defects (not
 # library bugs); see https://github.com/nlohmann/json for tracking. Only the
 # affected language-standard variants are excluded so coverage is otherwise kept:
-#   - test-comparison-cpp20_cpp20, test-comparison_legacy-cpp20_cpp20
+#   - test-comparison_cpp20, test-comparison_legacy_cpp20
 #         miscompiles cross-type/<=> comparison (e.g. `-17 <= null`)
 #   - test-constructor1_cpp11
 #         std::initializer_list lifetime bug -> SIGSEGV
-#   - test-deserialization-cpp20_cpp20
+#   - test-deserialization_cpp20
 #         mangles the UTF-8 u8"" string literal in the char8_t (C++20) section
 add_custom_target(ci_nvhpc
    COMMAND ${CMAKE_COMMAND}
@@ -887,7 +887,7 @@ add_custom_target(ci_nvhpc
    COMMAND ${CMAKE_COMMAND} --build ${PROJECT_BINARY_DIR}/build_nvhpc
    # the pipes are escaped so the surrounding shell passes them to ctest verbatim
    # instead of treating them as shell pipe operators
-    COMMAND cd ${PROJECT_BINARY_DIR}/build_nvhpc && ${CMAKE_CTEST_COMMAND} --parallel ${N} --exclude-regex "test-comparison-cpp20_cpp20\\|test-comparison_legacy-cpp20_cpp20\\|test-constructor1_cpp11\\|test-deserialization-cpp20_cpp20" --output-on-failure
+    COMMAND cd ${PROJECT_BINARY_DIR}/build_nvhpc && ${CMAKE_CTEST_COMMAND} --parallel ${N} --exclude-regex "test-comparison_cpp20\\|test-comparison_legacy_cpp20\\|test-constructor1_cpp11\\|test-deserialization_cpp20" --output-on-failure
    COMMENT "Compile and test with NVIDIA HPC SDK (nvc++)"
 )

@@ -1,42 +0,0 @@
-# Imported target for installations made with Meson (see meson.build).
-#
-# CMake installations generate this file with install(EXPORT ...). Meson cannot
-# do that, but as the library is header-only, the target only needs an include
-# directory, the C++ standard, and the compile definitions of the options that
-# differ from their defaults. Paths are computed relative to this file so that
-# the installation can be relocated (e.g., into a sysroot), unless includedir or
-# datadir is outside the prefix.
-
-if(TARGET @PROJECT_NAME@::@NLOHMANN_JSON_TARGET_NAME@)
-    return()
-endif()
-
-get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_DIR}/@NLOHMANN_JSON_CONFIG_TO_PREFIX@" ABSOLUTE)
-# As in CMake's generated file: avoid "//include" for an installation to "/".
-if(_IMPORT_PREFIX STREQUAL "/")
-    set(_IMPORT_PREFIX "")
-endif()
-
-add_library(@PROJECT_NAME@::@NLOHMANN_JSON_TARGET_NAME@ INTERFACE IMPORTED)
-set_target_properties(@PROJECT_NAME@::@NLOHMANN_JSON_TARGET_NAME@ PROPERTIES
-    INTERFACE_INCLUDE_DIRECTORIES "@NLOHMANN_JSON_INCLUDE_DIR@"
-)
-if(CMAKE_VERSION VERSION_LESS 3.8)
-    set_target_properties(@PROJECT_NAME@::@NLOHMANN_JSON_TARGET_NAME@ PROPERTIES
-        INTERFACE_COMPILE_FEATURES cxx_range_for
-    )
-else()
-    set_target_properties(@PROJECT_NAME@::@NLOHMANN_JSON_TARGET_NAME@ PROPERTIES
-        INTERFACE_COMPILE_FEATURES cxx_std_11
-    )
-endif()
-
-set(_NLOHMANN_JSON_COMPILE_DEFINITIONS "@NLOHMANN_JSON_COMPILE_DEFINITIONS@")
-if(_NLOHMANN_JSON_COMPILE_DEFINITIONS)
-    set_target_properties(@PROJECT_NAME@::@NLOHMANN_JSON_TARGET_NAME@ PROPERTIES
-        INTERFACE_COMPILE_DEFINITIONS "${_NLOHMANN_JSON_COMPILE_DEFINITIONS}"
-    )
-endif()
-
-unset(_NLOHMANN_JSON_COMPILE_DEFINITIONS)
-unset(_IMPORT_PREFIX)
@@ -4,4 +4,4 @@ includedir=${prefix}/@CMAKE_INSTALL_INCLUDEDIR@
 Name: @PROJECT_NAME@
 Description: JSON for Modern C++
 Version: @PROJECT_VERSION@
-Cflags: -I${includedir}@NLOHMANN_JSON_PKGCONFIG_CFLAGS@
+Cflags: -I${includedir}
@@ -109,55 +109,6 @@ function(_json_test_apply_test_properties test_target properties_target)
    endif()
 endfunction()

-# for internal use by _json_test_add_test() and _json_test_add_unity_batch():
-# registers the CTest test <test_name>_cpp<cxx_standard> (plus its Valgrind
-# variant), which runs the executable target <test_target> with the arguments
-# in ARGN, and applies the test properties of the test- and standard-specific
-# interface targets
-function(_json_test_register_test test_name test_target cxx_standard)
-    set(ctest_name ${test_name}_cpp${cxx_standard})
-
-    if (JSON_FastTests)
-        add_test(NAME ${ctest_name}
-            COMMAND ${test_target} ${DOCTEST_TEST_FILTER} ${ARGN}
-            WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
-        )
-    else()
-        add_test(NAME ${ctest_name}
-            COMMAND ${test_target} ${DOCTEST_TEST_FILTER} ${ARGN} --no-skip
-            WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
-        )
-    endif()
-    set_tests_properties(${ctest_name} PROPERTIES LABELS "all" FIXTURES_REQUIRED TEST_DATA)
-
-    # apply standard-specific test properties
-    if(TARGET _json_test_interface__cpp_${cxx_standard})
-        _json_test_apply_test_properties(${ctest_name} _json_test_interface__cpp_${cxx_standard})
-    endif()
-
-    # apply test-specific test properties
-    if(TARGET _json_test_interface_${test_name})
-        _json_test_apply_test_properties(${ctest_name} _json_test_interface_${test_name})
-    endif()
-
-    # apply test- and standard-specific test properties
-    if(TARGET _json_test_interface_${test_name}_cpp_${cxx_standard})
-        _json_test_apply_test_properties(${ctest_name}
-            _json_test_interface_${test_name}_cpp_${cxx_standard}
-        )
-    endif()
-
-    if(JSON_Valgrind)
-        add_test(NAME ${ctest_name}_valgrind
-            COMMAND ${memcheck_command} $<TARGET_FILE:${test_target}> ${DOCTEST_TEST_FILTER} ${ARGN}
-            WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
-        )
-        set_tests_properties(${ctest_name}_valgrind PROPERTIES
-            LABELS "valgrind" FIXTURES_REQUIRED TEST_DATA
-        )
-    endif()
-endfunction()
-
 # for internal use by json_test_add_test_for()
 function(_json_test_add_test test_name file main cxx_standard)
    set(test_target ${test_name}_cpp${cxx_standard})
@@ -192,7 +143,45 @@ function(_json_test_add_test test_name file main cxx_standard)
        )
    endif()

-    _json_test_register_test(${test_name} ${test_target} ${cxx_standard})
+    if (JSON_FastTests)
+        add_test(NAME ${test_target}
+            COMMAND ${test_target} ${DOCTEST_TEST_FILTER}
+            WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
+        )
+    else()
+        add_test(NAME ${test_target}
+            COMMAND ${test_target} ${DOCTEST_TEST_FILTER} --no-skip
+            WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
+        )
+    endif()
+    set_tests_properties(${test_target} PROPERTIES LABELS "all" FIXTURES_REQUIRED TEST_DATA)
+
+    # apply standard-specific test properties
+    if(TARGET _json_test_interface__cpp_${cxx_standard})
+        _json_test_apply_test_properties(${test_target} _json_test_interface__cpp_${cxx_standard})
+    endif()
+
+    # apply test-specific test properties
+    if(TARGET _json_test_interface_${test_name})
+        _json_test_apply_test_properties(${test_target} _json_test_interface_${test_name})
+    endif()
+
+    # apply test- and standard-specific test properties
+    if(TARGET _json_test_interface_${test_name}_cpp_${cxx_standard})
+        _json_test_apply_test_properties(${test_target}
+            _json_test_interface_${test_name}_cpp_${cxx_standard}
+        )
+    endif()
+
+    if(JSON_Valgrind)
+        add_test(NAME ${test_target}_valgrind
+            COMMAND ${memcheck_command} $<TARGET_FILE:${test_target}> ${DOCTEST_TEST_FILTER}
+            WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}
+        )
+        set_tests_properties(${test_target}_valgrind PROPERTIES
+            LABELS "valgrind" FIXTURES_REQUIRED TEST_DATA
+        )
+    endif()
 endfunction()

 #############################################################################
@@ -211,14 +200,6 @@ endfunction()
 # Use NAME <name> to override the filename-derived test name.
 # Use FORCE to create the test regardless of the file containing
 # JSON_HAS_CPP_<version_number>.
-#
-# Tests that depend on the C++ standard (e.g., because they use the macros
-# JSON_HAS_FILESYSTEM, JSON_HAS_RANGES, or JSON_HAS_THREE_WAY_COMPARISON)
-# should not make the whole of a large unit-foo.cpp be rebuilt for every
-# standard. Put them into a separate file unit-foo-cpp<NN>.cpp (see, e.g.,
-# unit-items-cpp17.cpp) which wraps its content in #ifdef JSON_HAS_CPP_<NN>.
-# Then, unit-foo.cpp itself contains no JSON_HAS_CPP_<NN> and is only built for
-# C++11.
 # Test targets are linked against <main>.
 # CXX_STANDARDS defaults to "11".
 #############################################################################
@@ -262,300 +243,6 @@ function(json_test_add_test_for file)
    endforeach()
 endfunction()

-# for internal use by json_test_add_unity_tests(): sets <result> to whether the
-# (absolute) <file> is built for <cxx_standard>; same rule as in
-# json_test_add_test_for(): C++11 always, others only if the file contains
-# JSON_HAS_CPP_<cxx_standard> or <force> is set
-function(_json_test_unity_applies file cxx_standard force result)
-    set(${result} TRUE PARENT_SCOPE)
-    if(NOT ("${cxx_standard}" STREQUAL 11 OR force))
-        file(READ ${file} file_content)
-        string(FIND "${file_content}" JSON_HAS_CPP_${cxx_standard} has_cpp_found)
-        if(${has_cpp_found} EQUAL -1)
-            set(${result} FALSE PARENT_SCOPE)
-        endif()
-    endif()
-endfunction()
-
-# for internal use by json_test_add_unity_tests(): creates the executable
-# test-unity-<batch_name>_cpp<cxx_standard> from the (absolute) source files
-# in ARGN, which are #include-d by a generated source file, and registers one
-# CTest test per source file that runs only the test cases of that file; if
-# <private> is true, the generated file defines JSON_TESTS_PRIVATE first
-function(_json_test_add_unity_batch batch_name cxx_standard main private)
-    set(batch_target test-unity-${batch_name}_cpp${cxx_standard})
-    set(batch_source ${PROJECT_BINARY_DIR}/tests/unity/${batch_target}.cpp)
-
-    set(batch_content "// generated by cmake/test.cmake; do not edit\n")
-    if(private)
-        string(APPEND batch_content "// at least one file of this batch needs access to private members of the library\n")
-        string(APPEND batch_content "#define JSON_TESTS_PRIVATE\n")
-    endif()
-    foreach(file ${ARGN})
-        string(APPEND batch_content "#include \"${file}\"\n")
-    endforeach()
-
-    # only touch the generated file if it changed to keep incremental builds incremental
-    set(old_content "")
-    if(EXISTS ${batch_source})
-        file(READ ${batch_source} old_content)
-    endif()
-    if(NOT "${old_content}" STREQUAL "${batch_content}")
-        file(WRITE ${batch_source} "${batch_content}")
-    endif()
-
-    add_executable(${batch_target} ${batch_source})
-    target_link_libraries(${batch_target} PRIVATE ${main})
-    set_target_properties(${batch_target} PROPERTIES
-        CXX_STANDARD ${cxx_standard}
-        CXX_STANDARD_REQUIRED ON
-    )
-    if(TARGET _json_test_interface__cpp_${cxx_standard})
-        target_link_libraries(${batch_target} PRIVATE _json_test_interface__cpp_${cxx_standard})
-    endif()
-
-    # rebuild the batch when one of its files changes, and show the files in IDEs;
-    # files that are also built standalone (VARIANT_FILES) are left out, as
-    # HEADER_FILE_ONLY is a per-file property and would also affect those targets
-    set_source_files_properties(${batch_source} PROPERTIES OBJECT_DEPENDS "${ARGN}")
-    foreach(file ${ARGN})
-        if(NOT file IN_LIST _json_test_unity_variant_files)
-            set_source_files_properties(${file} PROPERTIES HEADER_FILE_ONLY ON)
-            target_sources(${batch_target} PRIVATE ${file})
-        endif()
-    endforeach()
-
-    foreach(file ${ARGN})
-        get_filename_component(file_basename ${file} NAME_WE)
-        string(REGEX REPLACE "unit-(.+)" "test-\\1" test_name ${file_basename})
-
-        # run only the test cases defined in this file (and in the shared
-        # make_test_data_available.hpp if the file uses it)
-        file(READ ${file} file_content)
-        set(source_filter "--source-file=*${file_basename}.cpp")
-        string(FIND "${file_content}" make_test_data_available.hpp uses_test_data)
-        if(NOT ${uses_test_data} EQUAL -1)
-            string(APPEND source_filter ",*make_test_data_available.hpp")
-        endif()
-
-        _json_test_register_test(${test_name} ${batch_target} ${cxx_standard} "${source_filter}")
-    endforeach()
-endfunction()
-
-#############################################################################
-# json_test_add_unity_tests(
-#     FILES <files>...
-#     MAIN <main>
-#     [CXX_STANDARDS <version_number>...] [FORCE]
-#     [BATCH_SIZE <size>]
-#     [GROUPS <group>...]
-#     [VARIANT_FILES <files>...])
-#
-# Like calling json_test_add_test_for(<file> MAIN <main> ...) for each of the
-# <files>, but compiles several files together to speed up the build: for each
-# C++ standard, the files are split into batches of <size> files (default: 8)
-# and each batch is built as a single executable
-#
-#     test-unity-<pool><index>_cpp<version_number>
-#
-# whose generated source file #include-s the files of the batch (so they share
-# the template instantiations of the library). The tests are still named
-# test-foo_cpp<version_number>, one per file, but run the batch executable with
-# a doctest filter that selects the test cases of that file only.
-#
-# Files are only batched with files that agree on the macros defined before
-# the library is included: files that define at most JSON_TESTS_PRIVATE (or
-# macros derived from global compile definitions) form the pools "plain" and
-# "private". All other files are added with json_test_add_test_for() as usual,
-# as are files with test-specific build settings (see
-# json_test_set_test_options()) and the files listed in the explicit
-# exclusion list below.
-# Each <group> names a list variable json_test_unity_group_<group> of test file
-# stems (file names without "unit-" and ".cpp"). The batchable files of a group
-# are compiled together (regardless of BATCH_SIZE) as one executable
-#
-#     test-unity-<group>_cpp<version_number>
-#
-# so that related tests, which instantiate the same templates, share one
-# translation unit. A group may mix the pools "plain" and "private"; if any of
-# its files needs JSON_TESTS_PRIVATE, the whole group is built with it. Files
-# that cannot be batched stay standalone even if they are listed in a group.
-# Files in no group are batched by BATCH_SIZE as described above.
-# <files> in VARIANT_FILES are also built standalone with other settings, so
-# they are not marked as header-only sources of the batch.
-#############################################################################
-
-function(json_test_add_unity_tests)
-    cmake_parse_arguments(args "FORCE" "MAIN;BATCH_SIZE" "FILES;CXX_STANDARDS;VARIANT_FILES;GROUPS" ${ARGN})
-
-    if("${args_MAIN}" STREQUAL "")
-        message(FATAL_ERROR "Required argument MAIN <main> missing.")
-    endif()
-
-    if("${args_BATCH_SIZE}" STREQUAL "")
-        set(args_BATCH_SIZE 8)
-    endif()
-
-    if("${args_CXX_STANDARDS}" STREQUAL "")
-        set(args_CXX_STANDARDS 11)
-    endif()
-
-    if(args_FORCE)
-        set(force FORCE)
-    else()
-        set(force "")
-    endif()
-
-    set(_json_test_unity_variant_files "")
-    foreach(file ${args_VARIANT_FILES})
-        get_filename_component(file ${file} ABSOLUTE)
-        list(APPEND _json_test_unity_variant_files ${file})
-    endforeach()
-
-    # files that must not be merged into a batch: unit-32bit.cpp is only built
-    # for 32bit targets, and unit-no-macro-leak.cpp checks that including the
-    # library defines no unprefixed macro, which any other file would disturb
-    set(standalone_files unit-32bit.cpp unit-no-macro-leak.cpp)
-
-    set(harmless_macros "^(DOCTEST_.*|SKIP_TESTS_FOR_.*|JSON_TEST_DEPRECATED_FUNCTIONS_DELETED|JSON_TEST_STRICT_NUL_HANDLING_ENABLED|JSON_TEST_STRINGIZE)$")
-
-    # classify the files
-    set(plain_files "")
-    set(private_files "")
-    set(standalone_abs_files "")
-    foreach(file ${args_FILES})
-        get_filename_component(file_name ${file} NAME)
-        get_filename_component(file_basename ${file} NAME_WE)
-        string(REGEX REPLACE "unit-(.+)" "test-\\1" test_name ${file_basename})
-
-        set(batchable TRUE)
-        if(file_name IN_LIST standalone_files)
-            set(batchable FALSE)
-        endif()
-        if(TARGET _json_test_interface_${test_name})
-            set(batchable FALSE)
-        endif()
-        foreach(cxx_standard ${args_CXX_STANDARDS})
-            if(TARGET _json_test_interface_${test_name}_cpp_${cxx_standard})
-                set(batchable FALSE)
-            endif()
-        endforeach()
-
-        set(pool plain)
-        if(batchable)
-            # collect the macros (un)defined before the library is included
-            file(READ ${file} file_content)
-            string(FIND "${file_content}" "#include <nlohmann/" include_position)
-            if(NOT ${include_position} EQUAL -1)
-                string(SUBSTRING "${file_content}" 0 ${include_position} file_content)
-            endif()
-            string(REGEX MATCHALL "(^|\n)[ \t]*#[ \t]*(define|undef)[ \t]+[A-Za-z_0-9]+" directives "${file_content}")
-            foreach(directive ${directives})
-                string(REGEX REPLACE "^.*[ \t]([A-Za-z_0-9]+)$" "\\1" macro "${directive}")
-                if(macro MATCHES "${harmless_macros}")
-                    continue()
-                elseif("${macro}" STREQUAL JSON_TESTS_PRIVATE)
-                    set(pool private)
-                else()
-                    set(batchable FALSE)
-                endif()
-            endforeach()
-        endif()
-
-        get_filename_component(file_abs ${file} ABSOLUTE)
-        if(NOT batchable)
-            list(APPEND standalone_abs_files ${file_abs})
-            json_test_add_test_for(${file} MAIN ${args_MAIN} CXX_STANDARDS ${args_CXX_STANDARDS} ${force})
-            continue()
-        endif()
-        get_filename_component(file ${file} ABSOLUTE)
-        list(APPEND ${pool}_files ${file})
-    endforeach()
-
-    # resolve the explicit groups: group_<name>_files are the (absolute) files
-    # of the group, group_<name>_private tells whether one of them is private
-    set(grouped_files "")
-    foreach(group ${args_GROUPS})
-        if(NOT DEFINED json_test_unity_group_${group})
-            message(FATAL_ERROR "Unity test group '${group}' is not defined (json_test_unity_group_${group}).")
-        endif()
-        set(group_${group}_files "")
-        set(group_${group}_private FALSE)
-        foreach(stem ${json_test_unity_group_${group}})
-            # check against the source directory, because FILES may be filtered (JSON_TestShard)
-            get_filename_component(file ${CMAKE_CURRENT_SOURCE_DIR}/src/unit-${stem}.cpp ABSOLUTE)
-            if(NOT EXISTS ${file})
-                message(FATAL_ERROR "Unity test group '${group}' lists '${stem}', but ${file} does not exist.")
-            endif()
-            if(file IN_LIST grouped_files)
-                message(FATAL_ERROR "Unity test file unit-${stem}.cpp is listed in more than one group (second: '${group}').")
-            endif()
-            list(APPEND grouped_files ${file})
-
-            if(file IN_LIST standalone_abs_files)
-                message(STATUS "Unity test group '${group}': unit-${stem}.cpp cannot be batched and stays standalone")
-            elseif(file IN_LIST plain_files)
-                list(APPEND group_${group}_files ${file})
-                list(REMOVE_ITEM plain_files ${file})
-            elseif(file IN_LIST private_files)
-                list(APPEND group_${group}_files ${file})
-                list(REMOVE_ITEM private_files ${file})
-                set(group_${group}_private TRUE)
-            endif()
-        endforeach()
-    endforeach()
-
-    foreach(cxx_standard ${args_CXX_STANDARDS})
-        if(NOT compiler_supports_cpp_${cxx_standard})
-            continue()
-        endif()
-
-        # explicit groups: one batch per group
-        foreach(group ${args_GROUPS})
-            set(batch_files "")
-            foreach(file ${group_${group}_files})
-                _json_test_unity_applies(${file} ${cxx_standard} "${force}" applies)
-                if(applies)
-                    list(APPEND batch_files ${file})
-                endif()
-            endforeach()
-            if(batch_files)
-                _json_test_add_unity_batch(${group} ${cxx_standard} ${args_MAIN} ${group_${group}_private} ${batch_files})
-            endif()
-        endforeach()
-
-        # remaining files: batches of BATCH_SIZE files per pool
-        foreach(pool plain private)
-            set(is_private FALSE)
-            if(pool STREQUAL private)
-                set(is_private TRUE)
-            endif()
-
-            set(batch_files "")
-            set(batch_count 0)
-            set(batch_index 0)
-            foreach(file ${${pool}_files})
-                _json_test_unity_applies(${file} ${cxx_standard} "${force}" applies)
-                if(NOT applies)
-                    continue()
-                endif()
-
-                list(APPEND batch_files ${file})
-                math(EXPR batch_count "${batch_count} + 1")
-                if(batch_count EQUAL args_BATCH_SIZE)
-                    _json_test_add_unity_batch(${pool}${batch_index} ${cxx_standard} ${args_MAIN} ${is_private} ${batch_files})
-                    set(batch_files "")
-                    set(batch_count 0)
-                    math(EXPR batch_index "${batch_index} + 1")
-                endif()
-            endforeach()
-            if(batch_files)
-                _json_test_add_unity_batch(${pool}${batch_index} ${cxx_standard} ${args_MAIN} ${is_private} ${batch_files})
-            endif()
-        endforeach()
-    endforeach()
-endfunction()
-
 #############################################################################
 # json_test_should_build_32bit_test(
 #     <build_32bit_var> <build_32bit_only_var> <input>)
@@ -96,7 +96,9 @@ The SAX event lister must follow the interface of [`json_sax`](../json_sax/index

 ## Return value

-return value of the last processed SAX event
+`#!cpp true` if the input was parsed without errors and no SAX event returned `#!cpp false`; `#!cpp false` otherwise.
+In particular, the result is `#!cpp false` for input with errors, even if the SAX parser recovered from all of them
+(see [error recovery](../../features/parsing/error_recovery.md)).

 ## Exception safety

@@ -145,6 +147,7 @@ A UTF-8 byte order mark is silently ignored.
 - Added `ignore_trailing_commas` in version 3.13.0.
 - Added `tag_handler` in version 3.13.0.
 - Extended container support (1) to include types with lvalue-only ADL `begin`/`end` (matching `std::begin`/`std::end` semantics) in version 3.13.0.
+- Recovering from parse errors (see [`parse_error`](../json_sax/parse_error.md)) added in version 3.13.0.
 - Extended overload (2) to accept heterogeneous iterator+sentinel pairs (C++20 ranges support) in version 3.13.0.
 - `JSON_PRECISE_STREAM_POSITION` added in version 3.13.0 to optionally leave a `#!cpp std::istream` positioned right
  after the parsed value when `strict` is `#!cpp false`.
@@ -7,7 +7,8 @@ struct json_sax;

 This class describes the SAX interface used by [sax_parse](../basic_json/sax_parse.md). Each function is called in
 different situations while the input is parsed. The boolean return value informs the parser whether to continue
-processing the input.
+processing the input; for [`parse_error`](parse_error.md), it decides whether to
+[recover from the error](../../features/parsing/error_recovery.md).

 For instance, parsing the JSON text `{"a": [1, true]}` triggers the following callbacks, in order:

@@ -21,11 +21,18 @@ A parse error occurred.

 ## Return value

-Whether parsing should proceed (**must return `#!cpp false`**).
+Whether to recover from the error:
+
+- `#!cpp false` stops parsing.
+- `#!cpp true` recovers from the error: the error is repaired and parsing continues. If that is not possible, which
+  happens in the binary formats when the end of the item with the error is unknown, the value read so far is completed
+  and parsing stops. See [error recovery](../../features/parsing/error_recovery.md) for how errors are repaired.
+
+Either way, [`sax_parse`](../basic_json/sax_parse.md) returns `#!cpp false`.

 ## Examples

-??? example
+??? example "Example: (1) the SAX interface"

    The example below shows how the SAX interface is used.

@@ -39,12 +46,29 @@ Whether parsing should proceed (**must return `#!cpp false`**).
    --8<-- "examples/sax_parse.output"
    ```

+??? example "Example: (2) recovering from errors"
+
+    The example below shows how a SAX parser recovers from errors.
+
+    ```cpp
+    --8<-- "examples/sax_parse__error_recovery.cpp"
+    ```
+    
+    Output:
+    
+    ```
+    --8<-- "examples/sax_parse__error_recovery.output"
+    ```
+
 ## See also

 - [sax_parse](../basic_json/sax_parse.md) - SAX parser
 - [Parsing and Exceptions](../../features/parsing/parse_exceptions.md) - the article on handling parse errors without
  exceptions
+- [Error Recovery](../../features/parsing/error_recovery.md) - the article on recovering from parse errors

 ## Version history

 - Added in version 3.2.0.
+- Returning `#!cpp true` recovers from the error since version 3.13.0; before, parsing stopped, but the result of
+  [`sax_parse`](../basic_json/sax_parse.md) could be wrong.
@@ -67,7 +67,7 @@ By default, implicit conversions are enabled.
    `JSON_USE_IMPLICIT_CONVERSIONS` is defined to `0`:

    ```cpp
-    using wjson = nlohmann::json::with_string_t<std::wstring>;
+    using wjson = nlohmann::basic_json<std::map, std::vector, std::wstring>;

    void load(const nlohmann::json& j);

@@ -36,26 +36,13 @@ work items are tracked in the [GitHub milestones](https://github.com/nlohmann/js
 ## API stability

 Releases follow [semantic versioning](https://semver.org): a minor or patch release of version 3.x does not break code
-that uses the public API, unless that code opts in to a change with a macro as described [below](#version-40). In
-particular, a 3.x release does not:
+that uses the public API. In particular, a 3.x release does not:

- make breaking changes to the signature of a function: the types or order of its existing parameters, its return type,
-  its `noexcept` or `constexpr` specifier, or the const-ness of a member function. New parameters may be added if they
-  have a default value;
- remove or rename a function or class, or change the template parameters of a public class template;
+- change the signature of a function (its parameter types, return type, number of parameters, or the const-ness of a
+  member function);
+- remove or rename a function or class;
 - change which exceptions a function throws, or the [exception ids](../home/exceptions.md);
- change access specifiers, or change or remove existing default arguments. New default arguments may be added;
- change the JSON type that a valid input parses to, or the text that `dump()` produces for a valid value;
- accept input that was rejected before, or reject input that was accepted before;
- change the order in which the keys of an object are iterated. The default type sorts keys, and
-  [`ordered_json`](../api/ordered_json.md) keeps insertion order;
- change when iterators, pointers, or references are invalidated, or the state of a moved-from `basic_json`;
- add or remove implicit conversions from `basic_json`;
- change how `to_json` and `from_json` functions are found, or the behavior of
-  [`adl_serializer`](../api/adl_serializer/index.md);
- add pure virtual functions to the [`json_sax`](../api/json_sax/index.md) interface;
- remove, rename, renumber, or add enumerators of `value_t`;
- remove or rename a documented macro, CMake option, CMake target, or header, or change what a documented macro does.
+- change access specifiers or default arguments.

 Exceptions to these rules, for instance when fixing a bug requires changing the exception a function throws, are
 documented in the [release notes](../home/releases.md).
@@ -64,14 +51,13 @@ The following are **not** part of the public API and may change in any release,

 - The text of exception messages returned by `what()`. Use the [exception id](../home/exceptions.md) to tell errors
  apart.
- The ABI, including `sizeof(basic_json)` and the memory layout of its values. The
-  [versioned inline namespace](../features/namespace.md) turns mixing versions into a link error.
- The hash values returned by `std::hash` for `basic_json`. Numbers that compare equal still hash equally.
+- The ABI, including `sizeof(basic_json)` and the memory layout of its values. Recompile your code when you upgrade the
+  library. The [versioned inline namespace](../features/namespace.md) turns mixing versions into a link error.
 - Everything in namespace `nlohmann::detail`, and macros and type traits that are not documented in the
  [API reference](../api/basic_json/index.md).

-Breaking changes are only added behind a macro whose default keeps the 3.x behavior. See [Version 4.0](#version-40) and
-the [macro overview](../features/macros.md).
+Changes that would break the public API are only added behind a macro whose default keeps the 3.x behavior, see
+[Version 4.0](#version-40).

 ## Version 4.0

@@ -19,9 +19,25 @@ int main()
              << j.contains("/array/1"_json_pointer) << '\n'
              << j.contains("/array/-"_json_pointer) << '\n'
              << j.contains("/array/4"_json_pointer) << '\n'
-              << j.contains("/baz"_json_pointer) << '\n'
-              // an array index with a leading '0' is not found
-              << j.contains("/array/01"_json_pointer) << '\n'
-              // an array index that is not a number is not found
-              << j.contains("/array/one"_json_pointer) << std::endl;
+              << j.contains("/baz"_json_pointer) << std::endl;
+
+    try
+    {
+        // try to use an array index with leading '0'
+        j.contains("/array/01"_json_pointer);
+    }
+    catch (const json::parse_error& e)
+    {
+        std::cout << e.what() << '\n';
+    }
+
+    try
+    {
+        // try to use an array index that is not a number
+        j.contains("/array/one"_json_pointer);
+    }
+    catch (const json::parse_error& e)
+    {
+        std::cout << e.what() << '\n';
+    }
 }
@@ -5,5 +5,3 @@ true
 false
 false
 false
-false
-false
@@ -1,10 +1,11 @@
 #include <iostream>
+#include <map>

 #include <nlohmann/json.hpp>

 #include "custom_array_type.hpp"

-using custom_json = nlohmann::json::with_array_t<custom_array_type>;
+using custom_json = nlohmann::basic_json<std::map, custom_array_type>;

 int main()
 {
@@ -1,10 +1,16 @@
+#include <cstdint>
 #include <iostream>
+#include <map>
+#include <string>
+#include <vector>

 #include <nlohmann/json.hpp>

 #include "custom_binary_type.hpp"

-using custom_json = nlohmann::json::with_binary_t<custom_binary_type>;
+using custom_json = nlohmann::basic_json<std::map, std::vector, std::string, bool,
+      std::int64_t, std::uint64_t, double, std::allocator,
+      nlohmann::adl_serializer, custom_binary_type>;

 int main()
 {
@@ -1,11 +1,12 @@
 #include <iostream>
 #include <type_traits>
+#include <vector>

 #include <nlohmann/json.hpp>

 #include "custom_object_type.hpp"

-using custom_json = nlohmann::json::with_object_t<custom_object_type>;
+using custom_json = nlohmann::basic_json<custom_object_type, std::vector>;

 int main()
 {
@@ -1,10 +1,12 @@
 #include <iostream>
+#include <map>
+#include <vector>

 #include <nlohmann/json.hpp>

 #include "custom_string_type.hpp"

-using custom_json = nlohmann::json::with_string_t<custom_string_type>;
+using custom_json = nlohmann::basic_json<std::map, std::vector, custom_string_type>;

 int main()
 {
@@ -8,7 +8,7 @@ int main()
    try
    {
        // parsing input with a syntax error
-        json j = json::parse("[1,2,3,]");
+        json::parse("[1,2,3,]");
    }
    catch (const json::parse_error& e)
    {
@@ -0,0 +1,43 @@
+#include <iostream>
+#include <iomanip>
+#include <nlohmann/json.hpp>
+
+using json = nlohmann::json;
+
+// a SAX parser that creates a JSON value like json::parse does, but that
+// recovers from parse errors instead of stopping at the first one
+class recovering_parser : public nlohmann::detail::json_sax_dom_parser<json>
+{
+  public:
+    explicit recovering_parser(json& result)
+        : nlohmann::detail::json_sax_dom_parser<json>(result, false)
+    {}
+
+    bool parse_error(std::size_t position,
+                     const std::string& /*last_token*/,
+                     const json::exception& ex)
+    {
+        std::cout << "byte " << position << ": " << ex.what() << '\n';
+
+        // repair the input and continue
+        return true;
+    }
+};
+
+int main()
+{
+    // JSON text with several mistakes that ends too early
+    const std::string text = R"({
+    "name": "Hello World",
+    "tags": ["a" "b",],
+    "valid": tru,
+    "size": 1.,
+    "nested": {"x": 1)";
+
+    json result;
+    recovering_parser sax(result);
+    const bool valid = json::sax_parse(text, &sax);
+
+    std::cout << "\nvalid JSON: " << std::boolalpha << valid << '\n'
+              << std::setw(4) << result << std::endl;
+}
@@ -0,0 +1,19 @@
+byte 49: [json.exception.parse_error.101] parse error at line 3, column 20: syntax error while parsing array - unexpected string literal; expected ']'
+byte 51: [json.exception.parse_error.101] parse error at line 3, column 22: syntax error while parsing value - unexpected ']'; expected '[', '{', or a literal
+byte 70: [json.exception.parse_error.101] parse error at line 4, column 17: syntax error while parsing value - invalid literal; last read: '"valid": tru,'
+byte 86: [json.exception.parse_error.101] parse error at line 5, column 15: syntax error while parsing value - invalid number; expected digit after '.'; last read: '1.,'
+byte 109: [json.exception.parse_error.101] parse error at line 6, column 22: syntax error while parsing object - unexpected end of input; expected '}'
+
+valid JSON: false
+{
+    "name": "Hello World",
+    "nested": {
+        "x": 1
+    },
+    "size": 1,
+    "tags": [
+        "a",
+        "b"
+    ],
+    "valid": null
+}
@@ -0,0 +1,122 @@
+# Error Recovery
+
+By default, parsing stops at the first error. With the [SAX interface](sax_interface.md), you can instead ask the
+parser to *recover*: to repair the error and continue, so that you get as much as possible out of malformed input, for
+instance a file that was cut off, JSON edited by hand, or the output of a language model.
+
+## Recovering from errors
+
+The SAX parser's [`parse_error`](../../api/json_sax/parse_error.md) function is called for every error. Its return value
+decides what happens next:
+
+- `#!cpp false` stops parsing. This is what the SAX parsers of the library do, so [`parse`](../../api/basic_json/parse.md)
+  and [`accept`](../../api/basic_json/accept.md) never recover.
+- `#!cpp true` repairs the error and continues parsing.
+
+When recovering, the SAX parser still receives well-formed events: every `start_object` or `start_array` is followed by
+the matching `end_object` or `end_array`, and every `key` is followed by exactly one value. A SAX parser that creates a
+JSON value, such as the one in the example below, therefore gets a complete value. Parsing always ends, and
+[`sax_parse`](../../api/basic_json/sax_parse.md) returns `#!cpp false` for input that is not valid JSON, even if every
+error was repaired. Each token is reported at most once, and the SAX parser can stop at any error by returning
+`#!cpp false`.
+
+!!! example
+
+    The example below derives a SAX parser from the library's parser for `json` values (`json_sax_dom_parser`),
+    and recovers from all errors.
+
+    ```cpp
+    --8<-- "examples/sax_parse__error_recovery.cpp"
+    ```
+    
+    Output:
+    
+    ```
+    --8<-- "examples/sax_parse__error_recovery.output"
+    ```
+
+## How errors are repaired
+
+Each error is repaired with the smallest local edit: a missing separator is inserted, a stray token is removed, what can
+be read of a broken string or number is kept, and a value that cannot be read at all becomes `#!json null`.
+
+| Mistake                   | Repair                                                                         | Example                                  | Result                     |
+|---------------------------|--------------------------------------------------------------------------------|------------------------------------------|----------------------------|
+| missing `,` or `:`        | inserted                                                                       | `#!json [1 2]`, `#!json {"a" 1}`         | `[1,2]`, `{"a":1}`         |
+| missing value             | `#!json null` for an object key or between commas in an array                  | `#!json {"a":}`, `#!json [1,,2]`         | `{"a":null}`, `[1,null,2]` |
+| trailing comma            | removed                                                                        | `#!json [1,2,]`                          | `[1,2]`                    |
+| broken string             | invalid escapes and bytes are replaced (see below); a line break ends the string | `#!json ["a\qb"]`                        | `["aqb"]`                  |
+| broken number             | the longest valid beginning is kept                                            | `#!json [1., 2e+]`                       | `[1,2]`                    |
+| unreadable value          | `#!json null`                                                                  | `#!json [1, NaN, tru]`                   | `[1,null,null]`            |
+| number too large          | passed as infinity, together with its text                                     | `#!json [1e999]`                         | infinity (see below)       |
+| stray `:`                 | removed                                                                        | `#!json ["a":1]`                         | `["a",1]`                  |
+| member without a key      | skipped up to the next `,` or `}`                                              | `#!json {1:2, "b":3}`                    | `{"b":3}`                  |
+| wrong closing bracket     | closes the innermost array or object                                           | `#!json {"a":[1,2}, "b":3}`              | `{"a":[1,2],"b":3}`        |
+| input ends too early      | all open arrays and objects are closed                                         | `#!json {"a":[1,2`                       | `{"a":[1,2]}`              |
+| text before the value     | skipped                                                                        | `#!json )]}'{"a":1}`                     | `{"a":1}`                  |
+
+In a string, an unknown escape like `\q` stands for the escaped character (`q`), as in JavaScript. An invalid `\u`
+escape, a lone surrogate, and ill-formed UTF-8 are each replaced by U+FFFD (REPLACEMENT CHARACTER), and control
+characters are kept. A string without its closing quote ends at the next line break or at the end of the input.
+
+The input after the top-level value is not repaired: as without recovery, it is reported as an error, and parsing stops.
+
+## Binary formats
+
+The binary formats ([BJData](../binary_formats/bjdata.md), [BON8](../binary_formats/bon8.md),
+[BSON](../binary_formats/bson.md), [CBOR](../binary_formats/cbor.md), [MessagePack](../binary_formats/messagepack.md),
+and [UBJSON](../binary_formats/ubjson.md)) have no delimiters to find the next value by. So what can be repaired depends
+on whether the end of the item with the error is known, a distinction that
+[RFC 8949, Section 5.3](https://www.rfc-editor.org/rfc/rfc8949.html#section-5.3) makes for CBOR, too.
+
+If the item is complete, but cannot be passed on as it is, it is replaced, and parsing continues after it:
+
+| Mistake                                                             | Formats                 | Repair                                                                  |
+|---------------------------------------------------------------------|-------------------------|-------------------------------------------------------------------------|
+| tag, if `tag_handler` is `cbor_tag_handler_t::error` (the default)  | CBOR                    | ignored                                                                 |
+| simple value other than `false`, `true`, and `null`, like undefined | CBOR                    | `#!json null`                                                           |
+| number too large for a custom `number_float_t`, like `float`        | all                     | infinity                                                                |
+| character (`C`) that is not ASCII                                   | BJData, UBJSON          | U+FFFD                                                                  |
+| invalid high-precision number (`H`)                                 | BJData, UBJSON          | the longest valid beginning is kept, as for JSON text, or `#!json null` |
+| high-precision number too large                                     | BJData, UBJSON          | passed as infinity, together with its text                              |
+| object key that is not a string                                     | BON8, CBOR, MessagePack | the member is skipped                                                   |
+| element of a type the library does not read, like ObjectId or date  | BSON                    | `#!json null`                                                           |
+| string without its terminator                                       | BSON                    | kept                                                                    |
+| document whose size does not match its content                      | BSON                    | kept                                                                    |
+
+CBOR tags and simple values are repaired as [RFC 8949, Section 6.1](https://www.rfc-editor.org/rfc/rfc8949.html#section-6.1)
+suggests for converting CBOR to JSON. By default, [`sax_parse`](../../api/basic_json/sax_parse.md) reports every tag as
+an error; when recovering, tags are then ignored like with
+[`cbor_tag_handler_t::ignore`](../../api/basic_json/cbor_tag_handler_t.md). Strings that are not valid UTF-8 are no
+error: like [`from_cbor`](../../api/basic_json/from_cbor.md) and the other functions by default, `sax_parse` passes
+them on as they are.
+
+After any other error, the end of the item is unknown: the input ended, a byte is not a valid type marker, or a size
+cannot be right. Parsing then stops, and the value read so far is completed: a key that waits for its value gets
+`#!json null`, and all open arrays and objects are closed. This keeps everything before the error of an input that was
+cut off. The exception is BSON, which stores the size of every document: an element whose end is unknown gets
+`#!json null`, the rest of its document is skipped, and parsing continues after the document.
+
+## Limitations
+
+- A repair is a guess. For example, `#!json {"a" "b": 1}` could be meant as `#!json {"a": "b"}` or as
+  `#!json {"a": null, "b": 1}`; it is repaired to the former. Treat recovered values as a best effort, and check the
+  reported errors.
+- A closing bracket always closes the innermost array or object. If a bracket is missing rather than wrong, the
+  repair differs from the intention: `#!json {"a": {"b": [1, 2}, "c": 3}` is repaired to
+  `#!json {"a": {"b": [1, 2], "c": 3}}`, although `#!json {"a": {"b": [1, 2]}, "c": 3}` may have been meant.
+- Keys without quotes, and strings in single quotes, are not supported; such members are skipped.
+- In the binary formats, a member that is skipped because its key is not a string is lost, and so are the elements of a
+  BSON document after one whose end is unknown.
+- A number that is too large for `number_float_t` is passed as positive or negative infinity. The SAX parser's
+  `number_float` also gets the number's text, but a JSON value cannot store it, and
+  [`dump`](../../api/basic_json/dump.md) serializes infinity as `#!json null`.
+- When parsing is not strict (see [`sax_parse`](../../api/basic_json/sax_parse.md)), a repair may read parts of the
+  input after the value, for instance of the next value in a stream of concatenated values.
+
+## See also
+
+- [SAX interface](sax_interface.md) - implement a custom SAX handler
+- [`parse_error`](../../api/json_sax/parse_error.md) - the SAX event for parse errors
+- [`sax_parse`](../../api/basic_json/sax_parse.md) - generate SAX events
+- [parsing and exceptions](parse_exceptions.md) - control error handling
@@ -75,7 +75,7 @@ You can influence a DOM parse without switching to the SAX interface by passing
 When the input is not valid JSON, the `parse` function throws an exception by default. If exceptions are undesired or
 unavailable, the parser can instead return a discarded value, or [`accept`](../../api/basic_json/accept.md) can be used
 to only check whether an input is valid JSON. See [parsing and exceptions](parse_exceptions.md) for the available
-options.
+options. To get as much as possible out of malformed input, a SAX parser can [recover from errors](error_recovery.md).

 ## See also

@@ -86,4 +86,5 @@ options.
 - [parser callbacks](parser_callbacks.md) - influence the parsing by a callback function
 - [SAX interface](sax_interface.md) - implement a custom SAX handler
 - [parsing and exceptions](parse_exceptions.md) - control error handling
+- [error recovery](error_recovery.md) - get as much as possible out of malformed input
 - [parsing untrusted input](untrusted_input.md) - what to consider when parsing input from untrusted sources
@@ -64,7 +64,8 @@ bool parse_error(std::size_t position,
                 const json::exception& ex);
 ```

-The return value indicates whether the parsing should continue, so the function should usually return `#!cpp false`.
+The return value decides whether to stop parsing (`#!cpp false`) or to repair the error and continue
+(`#!cpp true`); see [error recovery](error_recovery.md) for the latter.

 ??? example "Example: report parse errors without exceptions"

@@ -60,7 +60,8 @@ bool key(string_t& val);
 bool parse_error(std::size_t position, const std::string& last_token, const json::exception& ex);
 ```

-The return value of each function determines whether parsing should proceed.
+The return value of each function determines whether parsing should proceed. For `parse_error`, returning
+`#!cpp true` [recovers from the error](error_recovery.md).

 To implement your own SAX handler, proceed as follows:

@@ -68,7 +69,7 @@ To implement your own SAX handler, proceed as follows:
 2. Create an object of your SAX interface class, e.g. `my_sax`.
 3. Call `#!cpp bool json::sax_parse(input, &my_sax);` where the first parameter can be any input like a string or an input stream and the second parameter is a pointer to your SAX interface.

-Note the `sax_parse` function only returns a `#!cpp bool` indicating the result of the last executed SAX event. It does not return `json` value - it is up to you to decide what to do with the SAX events. Furthermore, no exceptions are thrown in case of a parse error - it is up to you what to do with the exception object passed to your `parse_error` implementation. Internally, the SAX interface is used for the DOM parser (class `json_sax_dom_parser`) as well as the acceptor (`json_sax_acceptor`), see file `json_sax.hpp`.
+Note the `sax_parse` function only returns a `#!cpp bool` indicating whether the input was parsed without errors and no SAX event returned `#!cpp false`. It does not return `json` value - it is up to you to decide what to do with the SAX events. Furthermore, no exceptions are thrown in case of a parse error - it is up to you what to do with the exception object passed to your `parse_error` implementation. Internally, the SAX interface is used for the DOM parser (class `json_sax_dom_parser`) as well as the acceptor (`json_sax_acceptor`), see file `json_sax.hpp`.

 ## See also

@@ -351,8 +351,9 @@ The number types can be changed with template parameters.

    A `basic_json` type that uses `#!c long double` as floating-point type.

-    ```cpp hl_lines="1"
-    using json_ld = nlohmann::json::with_float_t<long double>;
+    ```cpp hl_lines="2"
+    using json_ld = nlohmann::basic_json<std::map, std::vector, std::string, bool,
+                                         std::int64_t, std::uint64_t, long double>;
    ```

    Note values should then be parsed with `json_ld::parse` rather than `json::parse` as the latter would parse
@@ -8,10 +8,6 @@ these requirements so they do not have to be discovered by trial and error. Each
 that are known to work for that parameter and the ones that do not, checked against Boost 1.83, Abseil 20250127.0,
 Folly, EASTL 3.21, `ankerl::unordered_dense`, `phmap`, `gtl`, `robin_hood`, `tsl::ordered_map`, and Qt 6.

-To change a single template parameter and keep the others, use the member alias templates
-[`with_*_t`](../../api/basic_json/with_t.md); for instance, `nlohmann::json::with_float_t<long double>` is `json` with
-`#!cpp long double` as [`number_float_t`](../../api/basic_json/number_float_t.md).
-
 ## How to read this page

 Requirements are split into two groups:
@@ -147,7 +143,7 @@ struct unordered_map_object
    using base_t::base_t;
 };

-using unordered_json = nlohmann::json::with_object_t<unordered_map_object>;
+using unordered_json = nlohmann::basic_json<unordered_map_object>;
 ```

 Whether `#!cpp std::unordered_map` can be instantiated at all depends on the standard library: `object_t` is formed
@@ -180,7 +176,7 @@ struct flat_hash_object
    using base_t::base_t;
 };

-using flat_hash_json = nlohmann::json::with_object_t<flat_hash_object>;
+using flat_hash_json = nlohmann::basic_json<flat_hash_object>;
 ```

 `absl::node_hash_map` keeps references to the mapped values valid across insertions; `absl::flat_hash_map` does not,
@@ -235,17 +235,6 @@ Build the unit tests against the [simdutf](https://github.com/simdutf/simdutf) U
 its version is set by the cache variable `JSON_SIMDUTF_VERSION`. This option is `OFF` by default. Depends on
 `JSON_BuildTests`.

-### `JSON_TestUnityBuild`
-
-Build the unit tests in batches of several test files per executable to speed up compilation: the files of a batch are
-compiled as one translation unit, so the template instantiations of the library are shared. Every test file still gets
-its own CTest test (e.g., `test-foo_cpp11`), which runs only the test cases of that file from the shared executable.
-This option is `ON` by default (and `OFF` with MinGW). Set it to `OFF` to get one executable per test file, e.g., when
-debugging a single file. The number of files per executable is set by the cache variable `JSON_TestUnityBatchSize`
-(default: `8`). Related test files (e.g., all binary formats) are grouped explicitly in `tests/CMakeLists.txt`; each
-group is compiled as one executable per C++ standard regardless of the batch size, and only the remaining files are
-batched by size. Depends on `JSON_BuildTests`.
-
 ### `JSON_Valgrind`

 Execute the test suite with [Valgrind](https://valgrind.org). This option is `OFF` by default. Depends on `JSON_BuildTests`.
@@ -116,7 +116,7 @@ function to use instead.
    === "Deprecated"
  
          ```cpp
-          using my_json = nlohmann::json::with_string_t<my_string_type>;
+          using my_json = nlohmann::basic_json<std::map, std::vector, my_string_type>;
          nlohmann::json_pointer<my_json> ptr("/foo/bar/1");
          ```
  
@@ -125,24 +125,10 @@ meson wrap install nlohmann_json
 Please see the Meson project for any issues regarding the packaging.

 The provided `meson.build` can also be used as an alternative to CMake for installing `nlohmann_json` system-wide in
-which case a [pkg-config](pkg-config.md) file and the CMake package config files are installed. To use it, have your build system require
-the `nlohmann_json` pkg-config dependency, or use [`find_package(nlohmann_json)`](cmake.md#external) in CMake. In Meson,
-it is preferred to use the [`dependency()`](https://mesonbuild.com/Reference-manual.html#dependency) object with a
-subproject fallback, rather than using the subproject directly.
-
-The options that change the library's configuration are available in Meson as well, named like the
-[CMake options](cmake.md#cmake-options) without the `JSON_` prefix: `MultipleHeaders`, `GlobalUDLs`,
-`ImplicitConversions`, `DisableEnumSerialization`, `DisableTupleReferenceConversion`, `Diagnostics`,
-`Diagnostic_Positions`, `LegacyDiscardedValueComparison`, `StrictNulHandling`, `StrictBinaryUTF8`, and
-`DeleteDeprecatedFunctions`. They have the same defaults as in CMake, except that
-`MultipleHeaders` is `false`. Set them with `-D` when setting up the build, or with the subproject name as prefix when
-the library is used as a subproject:
-
-```shell
-meson setup build -Dnlohmann_json:Diagnostics=true
-```
-
-The resulting compile definitions are part of the Meson dependency, the pkg-config file, and the CMake target.
+which case a [pkg-config](pkg-config.md) file is installed. To use it, have your build system require the
+`nlohmann_json` pkg-config dependency. In Meson, it is preferred to use the
+[`dependency()`](https://mesonbuild.com/Reference-manual.html#dependency) object with a subproject fallback, rather than
+using the subproject directly.

 ??? example "Example: Wrap"

@@ -88,6 +88,7 @@ nav:
      - features/performance.md
      - Parsing:
          - features/parsing/index.md
+          - features/parsing/error_recovery.md
          - features/parsing/json_lines.md
          - features/parsing/parse_exceptions.md
          - features/parsing/parser_callbacks.md
@@ -9,15 +9,12 @@
 #pragma once

 #include <cstdint> // uint64_t
-#if !defined(__SIZEOF_INT128__) && defined(_MSC_VER) && (defined(_M_X64) || defined(_M_ARM64))
-    #include <intrin0.h> // __umulh, _umul128
-#endif

 #include <nlohmann/detail/abi_macros.hpp>

 // Portable bit-level helpers for the number and string scanners. They use
-// compiler builtins or platform-specific intrinsics where available and plain
-// C++ otherwise, so they work regardless of byte order.
+// compiler builtins where available and plain C++ otherwise, so they need no
+// platform headers and work regardless of byte order.

 NLOHMANN_JSON_NAMESPACE_BEGIN
 namespace detail
@@ -55,12 +52,6 @@ inline uint128_parts full_multiplication(std::uint64_t a, std::uint64_t b) noexc
    __extension__ using uint128 = unsigned __int128;
    const uint128 r = static_cast<uint128>(a) * b;
    return {static_cast<std::uint64_t>(r), static_cast<std::uint64_t>(r >> 64u)};
-#elif defined(_MSC_VER) && defined(_M_X64)
-    std::uint64_t high = 0;
-    const std::uint64_t low = _umul128(a, b, &high);
-    return {low, high};
-#elif defined(_MSC_VER) && defined(_M_ARM64)
-    return {a * b, __umulh(a, b)};
 #else
    const std::uint64_t a_lo = a & 0xFFFFFFFFu;
    const std::uint64_t a_hi = a >> 32u;
@@ -132,7 +132,9 @@ struct json_sax
    @param[in] position    the position in the input where the error occurs
    @param[in] last_token  the last read token
    @param[in] ex          an exception object describing the error
-    @return whether parsing should proceed (must return false)
+    @return whether to recover from the error: false stops parsing; true
+            repairs the error and continues, or, if that is not possible,
+            stops after completing the value read so far
    */
    virtual bool parse_error(std::size_t position,
                             const std::string& last_token,
@@ -269,9 +271,12 @@ a pointer to the respective array or object for each recursion depth.
 After successful parsing, the value that is passed by reference to the
 constructor contains the parsed value.

-@tparam BasicJsonType  the JSON type
+@tparam BasicJsonType     the JSON type
+@tparam InputAdapterType  the input adapter of the lexer that can be passed to
+                          the constructor to record diagnostic positions; it
+                          does not matter if no lexer is passed
 */
-template<typename BasicJsonType, typename InputAdapterType>
+template<typename BasicJsonType, typename InputAdapterType = string_input_adapter_type>
 class json_sax_dom_parser
 {
  public:
@@ -518,7 +523,7 @@ class json_sax_dom_parser
    lexer_t* m_lexer_ref = nullptr;
 };

-template<typename BasicJsonType, typename InputAdapterType>
+template<typename BasicJsonType, typename InputAdapterType = string_input_adapter_type>
 class json_sax_dom_callback_parser
 {
  public:
@@ -10,7 +10,7 @@

 #include <array> // array
 #include <cstddef> // size_t
-#include <cstdint> // uint32_t
+#include <cstdint> // uint8_t, uint32_t
 #include <cstdio> // snprintf
 #include <initializer_list> // initializer_list
 #include <string> // char_traits, string
@@ -439,8 +439,16 @@ class lexer : public lexer_base<BasicJsonType>
                            if (0xD800 <= codepoint1 && codepoint1 <= 0xDBFF)
                            {
                                // expect next \uxxxx entry
-                                if (JSON_HEDLEY_LIKELY(get() == '\\' && get() == 'u'))
+                                if (JSON_HEDLEY_LIKELY(get() == '\\'))
                                {
+                                    if (JSON_HEDLEY_UNLIKELY(get() != 'u'))
+                                    {
+                                        // current is the character escaped by the backslash
+                                        error_message = "invalid string: surrogate U+D800..U+DBFF must be followed by U+DC00..U+DFFF";
+                                        string_error_resume = resume_kind::escaped_character;
+                                        return token_type::parse_error;
+                                    }
+
                                    const int codepoint2 = get_codepoint();

                                    if (JSON_HEDLEY_UNLIKELY(codepoint2 == -1))
@@ -465,7 +473,11 @@ class lexer : public lexer_base<BasicJsonType>
                                    }
                                    else
                                    {
+                                        // the second escape was read completely and is a
+                                        // code point of its own
                                        error_message = "invalid string: surrogate U+D800..U+DBFF must be followed by U+DC00..U+DFFF";
+                                        string_error_resume = resume_kind::after_escape;
+                                        string_error_codepoint = codepoint2;
                                        return token_type::parse_error;
                                    }
                                }
@@ -479,7 +491,9 @@ class lexer : public lexer_base<BasicJsonType>
                            {
                                if (JSON_HEDLEY_UNLIKELY(0xDC00 <= codepoint1 && codepoint1 <= 0xDFFF))
                                {
+                                    // the escape was read completely
                                    error_message = "invalid string: surrogate U+DC00..U+DFFF must follow U+D800..U+DBFF";
+                                    string_error_resume = resume_kind::after_escape;
                                    return token_type::parse_error;
                                }
                            }
@@ -2133,6 +2147,574 @@ scan_number_done:
        }
    }

+  public:
+    /////////////////////
+    // error recovery
+    /////////////////////
+
+    /*!
+    @brief make the best of the token that scan() rejected
+
+    Called by the parser after scan() returned token_type::parse_error and the
+    SAX parser asked to recover from the error (see #3989). Keeps what can be
+    read of the token and skips the rest:
+
+    - A string keeps its characters. An unknown escape stands for the escaped
+      character itself (as in JavaScript), an invalid Unicode escape and ill-formed
+      UTF-8 become U+FFFD, and a control character is kept. A line break or the
+      end of the input ends a string that lacks its closing quote.
+    - A number keeps its longest valid prefix, e.g. `1` for `1.` or `1e+`.
+    - A block comment that is not closed runs to the end of the input.
+    - Anything else is skipped.
+
+    The rest of an invalid token is skipped up to the next delimiter
+    (whitespace, a structural character, or a quote). A delimiter that the
+    invalid token consumed is returned to the input, so that the next scan()
+    reads it.
+
+    @return token_type::value_string or a number token type if a string or a
+            number could be read, token_type::end_of_input for a block comment
+            that is not closed, token_type::uninitialized otherwise
+    */
+    token_type recover_token()
+    {
+        const resume_kind resume = string_error_resume;
+        const int codepoint = string_error_codepoint;
+        string_error_resume = resume_kind::character;
+        string_error_codepoint = -1;
+
+        if (error_message_starts_with("invalid string"))
+        {
+            return recover_string(resume, codepoint);
+        }
+
+        if (error_message_starts_with("invalid number"))
+        {
+            return recover_number();
+        }
+
+        if (error_message_starts_with("invalid comment; missing"))
+        {
+            // the comment runs to the end of the input
+            return token_type::end_of_input;
+        }
+
+        skip_to_delimiter();
+        return token_type::uninitialized;
+    }
+
+    /*!
+    @brief return the token that scan() read last to the input, so that the
+           next scan() reads it again
+
+    Called by the parser when recovering from an error. The token must be a
+    single character (',', ':', '[', ']', '{', or '}') or the end of the
+    input, and scan() must have read it last.
+    */
+    void unget_token()
+    {
+        JSON_ASSERT(!next_unget);
+        unget();
+    }
+
+    /*!
+    @brief let the token string for the next error begin at the current character
+
+    The token string of an error reaches back to the beginning of the last
+    string or number. After an error, the parser calls this function so that
+    the next error does not report (and, with many errors, copy) everything
+    read since then.
+    */
+    void restart_token_string()
+    {
+        restart_token_string_impl(std::integral_constant<bool, lazy_token_string> {});
+    }
+
+  private:
+    /// how recover_string() continues after the error scan_string() reported
+    enum class resume_kind : std::uint8_t
+    {
+        /// current is the next character of the string (or the end of input)
+        character,
+        /// current is the character escaped by the preceding backslash
+        escaped_character,
+        /// current is the last character of a complete escape
+        after_escape
+    };
+
+    /// whether error_message begins with @a prefix
+    bool error_message_starts_with(const char* prefix) const noexcept
+    {
+        const char* message = error_message;
+        while (*prefix != '\0')
+        {
+            if (*message++ != *prefix++)
+            {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    /// whether current ends an invalid token (see recover_token())
+    bool current_is_delimiter() const noexcept
+    {
+        switch (current)
+        {
+            case ' ':
+            case '\t':
+            case '\n':
+            case '\r':
+            case '[':
+            case ']':
+            case '{':
+            case '}':
+            case ',':
+            case ':':
+            case '\"':
+#if !JSON_STRICT_NUL_HANDLING
+            case '\0':
+#endif
+            case char_traits<char_type>::eof():
+                return true;
+
+            case '/':
+                return ignore_comments;
+
+            default:
+                return false;
+        }
+    }
+
+    /// skip the rest of an invalid token and return its delimiter to the input
+    void skip_to_delimiter()
+    {
+        while (!current_is_delimiter())
+        {
+            get();
+        }
+
+        if (current != char_traits<char_type>::eof())
+        {
+            unget();
+        }
+    }
+
+    /// append U+FFFD REPLACEMENT CHARACTER to token_buffer
+    void add_replacement_character()
+    {
+        add(0xEF);
+        add(0xBF);
+        add(0xBD);
+    }
+
+    /// append the UTF-8 encoding of @a codepoint (not a surrogate) to token_buffer
+    void add_codepoint(const int codepoint)
+    {
+        JSON_ASSERT(0x00 <= codepoint && codepoint <= 0x10FFFF);
+        const auto cp = static_cast<unsigned int>(codepoint);
+        if (cp < 0x80)
+        {
+            add(static_cast<char_int_type>(cp));
+        }
+        else if (cp <= 0x7FF)
+        {
+            add(static_cast<char_int_type>(0xC0u | (cp >> 6u)));
+            add(static_cast<char_int_type>(0x80u | (cp & 0x3Fu)));
+        }
+        else if (cp <= 0xFFFF)
+        {
+            add(static_cast<char_int_type>(0xE0u | (cp >> 12u)));
+            add(static_cast<char_int_type>(0x80u | ((cp >> 6u) & 0x3Fu)));
+            add(static_cast<char_int_type>(0x80u | (cp & 0x3Fu)));
+        }
+        else
+        {
+            add(static_cast<char_int_type>(0xF0u | (cp >> 18u)));
+            add(static_cast<char_int_type>(0x80u | ((cp >> 12u) & 0x3Fu)));
+            add(static_cast<char_int_type>(0x80u | ((cp >> 6u) & 0x3Fu)));
+            add(static_cast<char_int_type>(0x80u | (cp & 0x3Fu)));
+        }
+    }
+
+    /// append a code point read from a Unicode escape; a surrogate becomes U+FFFD
+    void add_escaped_codepoint(const int codepoint)
+    {
+        if (0xD800 <= codepoint && codepoint <= 0xDFFF)
+        {
+            add_replacement_character();
+        }
+        else
+        {
+            add_codepoint(codepoint);
+        }
+    }
+
+    /*!
+    @brief remove an incomplete UTF-8 sequence from the end of token_buffer
+
+    next_byte_in_range() adds the bytes of a sequence as it checks them, so
+    when it rejects a byte, the beginning of the sequence is already in
+    token_buffer, which otherwise holds only complete sequences.
+
+    @return whether an incomplete sequence was removed
+    */
+    bool remove_incomplete_utf8_sequence()
+    {
+        std::size_t lead = token_buffer.size();
+        std::size_t continuation_bytes = 0;
+        while (lead > 0 && continuation_bytes < 3
+                && (static_cast<unsigned char>(token_buffer[lead - 1]) & 0xC0u) == 0x80u)
+        {
+            --lead;
+            ++continuation_bytes;
+        }
+        if (lead == 0)
+        {
+            return false;
+        }
+
+        const auto lead_byte = static_cast<unsigned char>(token_buffer[lead - 1]);
+        std::size_t expected = 0;
+        if (lead_byte >= 0xF0)
+        {
+            expected = 3;
+        }
+        else if (lead_byte >= 0xE0)
+        {
+            expected = 2;
+        }
+        else if (lead_byte >= 0xC0)
+        {
+            expected = 1;
+        }
+        if (continuation_bytes >= expected)
+        {
+            return false;
+        }
+
+        token_buffer.resize(lead - 1);
+        return true;
+    }
+
+    /*!
+    @brief read the UTF-8 sequence that begins with current, which is not ASCII
+    @return whether the next character must be read; false if current still
+            needs to be handled, because it does not belong to the sequence
+    */
+    bool recover_utf8_sequence()
+    {
+        // the number of continuation bytes and the range of the first one;
+        // see the ranges in scan_string()
+        std::size_t count = 0;
+        char_int_type low = 0x80;
+        char_int_type high = 0xBF;
+        if (current >= 0xC2 && current <= 0xDF)
+        {
+            count = 1;
+        }
+        else if (current >= 0xE0 && current <= 0xEF)
+        {
+            count = 2;
+            low = (current == 0xE0) ? 0xA0 : 0x80;
+            high = (current == 0xED) ? 0x9F : 0xBF;
+        }
+        else if (current >= 0xF0 && current <= 0xF4)
+        {
+            count = 3;
+            low = (current == 0xF0) ? 0x90 : 0x80;
+            high = (current == 0xF4) ? 0x8F : 0xBF;
+        }
+        else
+        {
+            // an ill-formed byte
+            add_replacement_character();
+            return true;
+        }
+
+        const std::size_t start = token_buffer.size();
+        add(current);
+        for (std::size_t i = 0; i < count; ++i)
+        {
+            get();
+            if (current < low || current > high)
+            {
+                token_buffer.resize(start);
+                add_replacement_character();
+                return false;
+            }
+            add(current);
+            low = 0x80;
+            high = 0xBF;
+        }
+        return true;
+    }
+
+    /*!
+    @brief read the low surrogate that must follow the high surrogate @a high
+    @return whether the next character must be read; false if current still
+            needs to be handled
+    */
+    bool recover_low_surrogate(int high)
+    {
+        while (true)
+        {
+            if (get() != '\\')
+            {
+                add_replacement_character();
+                return false;
+            }
+            if (get() != 'u')
+            {
+                add_replacement_character();
+                // not 'u', so this does not come back here
+                return recover_escape();
+            }
+
+            const int low = get_codepoint();
+            if (low == -1)
+            {
+                add_replacement_character();
+                return false;
+            }
+            if (0xDC00 <= low && low <= 0xDFFF)
+            {
+                add_codepoint(static_cast<int>((static_cast<unsigned int>(high) << 10u)
+                                               + static_cast<unsigned int>(low) - 0x35FDC00u));
+                return true;
+            }
+
+            // high has no low surrogate
+            add_replacement_character();
+            if (low < 0xD800 || low > 0xDBFF)
+            {
+                add_codepoint(low);
+                return true;
+            }
+            // another high surrogate
+            high = low;
+        }
+    }
+
+    /*!
+    @brief read the escape whose backslash was read; current is the escaped character
+    @return whether the next character must be read; false if current still
+            needs to be handled
+    */
+    bool recover_escape()
+    {
+        switch (current)
+        {
+            case '\"':
+                add('\"');
+                return true;
+            case '\\':
+                add('\\');
+                return true;
+            case '/':
+                add('/');
+                return true;
+            case 'b':
+                add('\b');
+                return true;
+            case 'f':
+                add('\f');
+                return true;
+            case 'n':
+                add('\n');
+                return true;
+            case 'r':
+                add('\r');
+                return true;
+            case 't':
+                add('\t');
+                return true;
+
+            case 'u':
+            {
+                const int codepoint = get_codepoint();
+                if (codepoint == -1)
+                {
+                    add_replacement_character();
+                    return false;
+                }
+                if (0xD800 <= codepoint && codepoint <= 0xDBFF)
+                {
+                    return recover_low_surrogate(codepoint);
+                }
+                add_escaped_codepoint(codepoint);
+                return true;
+            }
+
+            // an unknown escape stands for the escaped character
+            default:
+                return false;
+        }
+    }
+
+    /*!
+    @brief read the rest of a string after scan_string() rejected it
+
+    token_buffer holds what scan_string() read before the error. See
+    recover_token() for how errors are repaired.
+
+    @param[in] resume     how to continue, see resume_kind
+    @param[in] codepoint  for a high surrogate followed by an escape of another
+                          code point: that code point; -1 otherwise
+    */
+    token_type recover_string(const resume_kind resume, const int codepoint)
+    {
+        // whether the next character must be read before it can be handled
+        bool fetch = false;
+
+        if (error_message_starts_with("invalid string: surrogate")
+                || error_message_starts_with("invalid string: '\\u'")
+                || (error_message_starts_with("invalid string: ill-formed UTF-8")
+                    && remove_incomplete_utf8_sequence()))
+        {
+            add_replacement_character();
+        }
+
+        switch (resume)
+        {
+            case resume_kind::escaped_character:
+                fetch = recover_escape();
+                break;
+            case resume_kind::after_escape:
+                if (0xD800 <= codepoint && codepoint <= 0xDBFF)
+                {
+                    fetch = recover_low_surrogate(codepoint);
+                }
+                else
+                {
+                    if (codepoint != -1)
+                    {
+                        add_escaped_codepoint(codepoint);
+                    }
+                    fetch = true;
+                }
+                break;
+            case resume_kind::character:
+            default:
+                break;
+        }
+
+        while (true)
+        {
+            if (fetch)
+            {
+                get();
+            }
+            fetch = true;
+
+            switch (current)
+            {
+                case '\"':
+                // a line break or the end of the input ends a string that
+                // lacks its closing quote
+                case '\n':
+                case '\r':
+                case char_traits<char_type>::eof():
+                    return token_type::value_string;
+
+#if !JSON_STRICT_NUL_HANDLING
+                case '\0':
+                    // the end of the input, see scan()
+                    unget();
+                    return token_type::value_string;
+#endif
+
+                case '\\':
+                    get();
+                    fetch = recover_escape();
+                    break;
+
+                default:
+                    if (current < 0x80)
+                    {
+                        // including control characters
+                        add(current);
+                    }
+                    else
+                    {
+                        fetch = recover_utf8_sequence();
+                    }
+                    break;
+            }
+        }
+    }
+
+    /*!
+    @brief keep the longest valid prefix of a number that scan_number() rejected
+
+    token_buffer holds the characters scan_number() accepted before the error,
+    so the prefix ends at its last digit.
+    */
+    token_type recover_number()
+    {
+        // only size(), operator[], and resize() are used, which every string
+        // type the library supports provides
+        std::size_t length = token_buffer.size();
+        while (length != 0 && (token_buffer[length - 1] < '0' || token_buffer[length - 1] > '9'))
+        {
+            --length;
+        }
+        token_buffer.resize(length);
+
+        if (length == 0)
+        {
+            skip_to_delimiter();
+            return token_type::uninitialized;
+        }
+
+        if (decimal_point_position >= length)
+        {
+            decimal_point_position = std::string::npos;
+        }
+
+        std::size_t exponent = std::string::npos;
+        for (std::size_t i = 0; i < length; ++i)
+        {
+            if (token_buffer[i] == 'e' || token_buffer[i] == 'E')
+            {
+                exponent = i;
+                break;
+            }
+        }
+        const std::size_t mantissa_end = (exponent == std::string::npos) ? length : exponent;
+        token_type number_type = token_type::value_unsigned;
+        if (decimal_point_position != std::string::npos || exponent != std::string::npos)
+        {
+            number_type = token_type::value_float;
+        }
+        else if (token_buffer[0] == '-')
+        {
+            number_type = token_type::value_integer;
+        }
+
+        const token_type result = convert_number(number_type, mantissa_end);
+        skip_to_delimiter();
+        return result;
+    }
+
+    /// seekable adapter: the token string begins at current, which was consumed
+    void restart_token_string_impl(std::true_type /*lazy*/) noexcept
+    {
+        const std::size_t consumed = ia.get_consumed_count();
+        token_string_start = (consumed > 0 && current != char_traits<char_type>::eof()) ? consumed - 1 : consumed;
+    }
+
+    /// streaming adapter: the token string begins at current; a character
+    /// that was put back is copied again when it is read again
+    void restart_token_string_impl(std::false_type /*lazy*/)
+    {
+        token_string.clear();
+        if (!next_unget && current != char_traits<char_type>::eof())
+        {
+            token_string.push_back(char_traits<char_type>::to_char_type(current));
+        }
+    }
+
    /// input adapter
    InputAdapterType ia;

@@ -2172,6 +2754,13 @@ scan_number_done:
    /// a description of occurred lexer errors
    const char* error_message = "";

+    /// how recover_token() continues a string that scan_string() rejected;
+    /// set only on the error paths that need more than error_message
+    resume_kind string_error_resume = resume_kind::character;
+    /// the code point of the second escape when a high surrogate is followed
+    /// by an escape that is not a low surrogate; -1 otherwise
+    int string_error_codepoint = -1;
+
    // number values
    number_integer_t value_integer = 0;
    number_unsigned_t value_unsigned = 0;
@@ -139,26 +139,59 @@ class parser
    bool accept(const bool strict = true)
    {
        json_sax_acceptor<BasicJsonType> sax_acceptor;
-        return sax_parse(&sax_acceptor, strict);
+        return sax_parse_impl<false>(&sax_acceptor, strict);
    }

+    /*!
+    @brief public SAX interface
+
+    If the SAX parser's parse_error() returns true, the parser recovers from
+    the error: it repairs the input and continues (see #3989).
+
+    @param[in] sax     the SAX parser
+    @param[in] strict  whether to expect the last token to be EOF
+    @return whether the input was parsed without errors and no SAX event
+            returned false
+    */
    template<typename SAX>
    JSON_HEDLEY_NON_NULL(2)
    bool sax_parse(SAX* sax, const bool strict = true)
+    {
+        return sax_parse_impl<true>(sax, strict);
+    }
+
+  private:
+    /// what sax_parse_internal() does after an object key was expected
+    enum class next_step : std::uint8_t
+    {
+        /// stop parsing
+        stop,
+        /// parse a value that begins with last_token
+        parse_value,
+        /// evaluate the state of the innermost container, which reads
+        /// last_token again
+        evaluate_state
+    };
+
+    template<bool AllowRecovery, typename SAX>
+    JSON_HEDLEY_NON_NULL(2)
+    bool sax_parse_impl(SAX* sax, const bool strict)
    {
        (void)detail::is_sax_static_asserts<SAX, BasicJsonType> {};
-        const bool result = sax_parse_internal(sax);
+        const bool result = sax_parse_internal<AllowRecovery>(sax);

        if (result)
        {
            if (strict)
            {
-                // strict mode: next byte must be EOF
-                if (get_token() != token_type::end_of_input)
+                // strict mode: next byte must be EOF; after recovering from an
+                // error, the end of the input may already have been read
+                if (last_token != token_type::end_of_input && get_token() != token_type::end_of_input)
                {
-                    return sax->parse_error(m_lexer.get_position(),
-                                            m_lexer.get_token_string(),
-                                            parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_of_input, "value"), nullptr));
+                    // the value is complete, so there is nothing to recover
+                    static_cast<void>(report_error(sax, parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_of_input, "value"), nullptr),
+                                                   std::integral_constant<bool, AllowRecovery> {}));
+                    return false;
                }
            }
            else
@@ -169,10 +202,9 @@ class parser
            }
        }

-        return result;
+        return result && !error_reported;
    }

-  private:
    /*!
    @brief run a DOM SAX parser to completion and position the lexer

@@ -190,7 +222,7 @@ class parser
    template<typename DomSax>
    bool parse_dom(DomSax& sdp, const bool strict)
    {
-        sax_parse_internal(&sdp);
+        sax_parse_internal<false>(&sdp);

        if (strict)
        {
@@ -213,10 +245,20 @@ class parser
        return !sdp.is_errored();
    }

-    template<typename SAX>
+    /*!
+    @brief parse a JSON value and pass it to a SAX parser
+
+    @tparam AllowRecovery  whether to recover from an error if the SAX parser's
+                           parse_error() returns true; false for the SAX parsers
+                           of parse() and accept(), which never do, so that no
+                           code for recovering is generated for them
+    */
+    template<bool AllowRecovery, typename SAX>
    JSON_HEDLEY_NON_NULL(2)
    bool sax_parse_internal(SAX* sax)
    {
+        const std::integral_constant<bool, AllowRecovery> allow_recovery{};
+
        // stack to remember the hierarchy of structured values we are parsing
        // true = array; false = object
        std::vector<bool> states;
@@ -247,12 +289,18 @@ class parser
                            break;
                        }

-                        // parse key
+                        // remember we are now inside an object
+                        states.push_back(false);
+
+                        // parse key (the steps of parse_key(), which are
+                        // repeated here and below for speed)
                        if (JSON_HEDLEY_UNLIKELY(last_token != token_type::value_string))
                        {
-                            return sax->parse_error(m_lexer.get_position(),
-                                                    m_lexer.get_token_string(),
-                                                    parse_error::create(101, m_lexer.get_position(), exception_message(token_type::value_string, "object key"), nullptr));
+                            if (!continue_after(key_error(sax, allow_recovery, false), skip_to_state_evaluation))
+                            {
+                                return false;
+                            }
+                            continue;
                        }
                        if (JSON_HEDLEY_UNLIKELY(!sax->key(m_lexer.get_string())))
                        {
@@ -262,14 +310,13 @@ class parser
                        // parse separator (:)
                        if (JSON_HEDLEY_UNLIKELY(!get_token_expecting(token_type::name_separator)))
                        {
-                            return sax->parse_error(m_lexer.get_position(),
-                                                    m_lexer.get_token_string(),
-                                                    parse_error::create(101, m_lexer.get_position(), exception_message(token_type::name_separator, "object separator"), nullptr));
+                            if (!continue_after(key_error(sax, allow_recovery, true), skip_to_state_evaluation))
+                            {
+                                return false;
+                            }
+                            continue;
                        }

-                        // remember we are now inside an object
-                        states.push_back(false);
-
                        // parse values
                        get_token();
                        continue;
@@ -305,9 +352,11 @@ class parser

                        if (JSON_HEDLEY_UNLIKELY(!std::isfinite(res)))
                        {
-                            return sax->parse_error(m_lexer.get_position(),
-                                                    m_lexer.get_token_string(),
-                                                    out_of_range::create(406, concat("number overflow parsing '", m_lexer.get_token_string(), '\''), nullptr));
+                            if (!overflow_error(sax, res, allow_recovery))
+                            {
+                                return false;
+                            }
+                            break;
                        }

                        if (JSON_HEDLEY_UNLIKELY(!sax->number_float(res, m_lexer.get_string())))
@@ -375,23 +424,63 @@ class parser
                    case token_type::parse_error:
                    {
                        // using "uninitialized" to avoid an "expected" message
-                        return sax->parse_error(m_lexer.get_position(),
-                                                m_lexer.get_token_string(),
-                                                parse_error::create(101, m_lexer.get_position(), exception_message(token_type::uninitialized, "value"), nullptr));
+                        if (!report_error(sax, parse_error::create(101, m_lexer.get_position(), exception_message(token_type::uninitialized, "value"), nullptr), allow_recovery))
+                        {
+                            return false;
+                        }
+
+                        // recover: keep what can be read of the token
+                        recover_token(allow_recovery);
+                        if (last_token != token_type::uninitialized)
+                        {
+                            // a string or a number
+                            continue;
+                        }
+                        if (states.empty())
+                        {
+                            // look for the value after the garbage
+                            if (!skip_to_value(allow_recovery))
+                            {
+                                return false;
+                            }
+                            continue;
+                        }
+                        // nothing could be read
+                        if (JSON_HEDLEY_UNLIKELY(!sax->null()))
+                        {
+                            return false;
+                        }
+                        break;
                    }
                    case token_type::end_of_input:
                    {
                        if (JSON_HEDLEY_UNLIKELY(m_lexer.get_position().chars_read_total == 1))
                        {
-                            return sax->parse_error(m_lexer.get_position(),
-                                                    m_lexer.get_token_string(),
-                                                    parse_error::create(101, m_lexer.get_position(),
-                                                            "attempting to parse an empty input; check that your input string or stream contains the expected JSON", nullptr));
+                            // there is nothing to recover
+                            static_cast<void>(report_error(sax, parse_error::create(101, m_lexer.get_position(),
+                                                           "attempting to parse an empty input; check that your input string or stream contains the expected JSON", nullptr), allow_recovery));
+                            return false;
                        }

-                        return sax->parse_error(m_lexer.get_position(),
-                                                m_lexer.get_token_string(),
-                                                parse_error::create(101, m_lexer.get_position(), exception_message(token_type::literal_or_value, "value"), nullptr));
+                        if (!report_error(sax, parse_error::create(101, m_lexer.get_position(), exception_message(token_type::literal_or_value, "value"), nullptr), allow_recovery))
+                        {
+                            return false;
+                        }
+
+                        // recover: the input ends where a value is missing
+                        if (states.empty())
+                        {
+                            // there is no value
+                            return false;
+                        }
+                        if (!recover_missing_value(sax, states, allow_recovery))
+                        {
+                            return false;
+                        }
+                        // the state evaluation reads the token again
+                        unget_token(allow_recovery);
+                        skip_to_state_evaluation = true;
+                        continue;
                    }
                    case token_type::uninitialized:
                    case token_type::end_array:
@@ -401,9 +490,35 @@ class parser
                    case token_type::literal_or_value:
                    default: // the last token was unexpected
                    {
-                        return sax->parse_error(m_lexer.get_position(),
-                                                m_lexer.get_token_string(),
-                                                parse_error::create(101, m_lexer.get_position(), exception_message(token_type::literal_or_value, "value"), nullptr));
+                        if (!report_error(sax, parse_error::create(101, m_lexer.get_position(), exception_message(token_type::literal_or_value, "value"), nullptr), allow_recovery))
+                        {
+                            return false;
+                        }
+
+                        // recover
+                        if (states.empty())
+                        {
+                            // look for the value after the garbage
+                            if (!skip_to_value(allow_recovery))
+                            {
+                                return false;
+                            }
+                            continue;
+                        }
+                        if (last_token == token_type::name_separator)
+                        {
+                            // a stray ':'; the value may follow
+                            get_token();
+                            continue;
+                        }
+                        if (!recover_missing_value(sax, states, allow_recovery))
+                        {
+                            return false;
+                        }
+                        // the state evaluation reads the token again
+                        unget_token(allow_recovery);
+                        skip_to_state_evaluation = true;
+                        continue;
                    }
                }
            }
@@ -454,9 +569,30 @@ class parser
                    continue;
                }

-                return sax->parse_error(m_lexer.get_position(),
-                                        m_lexer.get_token_string(),
-                                        parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_array, "array"), nullptr));
+                if (!report_error(sax, parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_array, "array"), nullptr), allow_recovery))
+                {
+                    return false;
+                }
+
+                // recover
+                if (last_token == token_type::end_of_input)
+                {
+                    // the input ends inside the array
+                    return close_containers(sax, states, allow_recovery);
+                }
+                if (last_token == token_type::end_object)
+                {
+                    // a wrong closing bracket closes the innermost container
+                    if (JSON_HEDLEY_UNLIKELY(!sax->end_array()))
+                    {
+                        return false;
+                    }
+                    states.pop_back();
+                    skip_to_state_evaluation = true;
+                }
+                // otherwise, a missing ',' (or a stray ':', which value
+                // parsing drops): the next value begins here
+                continue;
            }

            // states.back() is false -> object
@@ -473,11 +609,12 @@ class parser
                    // parse key
                    if (JSON_HEDLEY_UNLIKELY(last_token != token_type::value_string))
                    {
-                        return sax->parse_error(m_lexer.get_position(),
-                                                m_lexer.get_token_string(),
-                                                parse_error::create(101, m_lexer.get_position(), exception_message(token_type::value_string, "object key"), nullptr));
+                        if (!continue_after(key_error(sax, allow_recovery, false), skip_to_state_evaluation))
+                        {
+                            return false;
+                        }
+                        continue;
                    }
-
                    if (JSON_HEDLEY_UNLIKELY(!sax->key(m_lexer.get_string())))
                    {
                        return false;
@@ -486,9 +623,11 @@ class parser
                    // parse separator (:)
                    if (JSON_HEDLEY_UNLIKELY(!get_token_expecting(token_type::name_separator)))
                    {
-                        return sax->parse_error(m_lexer.get_position(),
-                                                m_lexer.get_token_string(),
-                                                parse_error::create(101, m_lexer.get_position(), exception_message(token_type::name_separator, "object separator"), nullptr));
+                        if (!continue_after(key_error(sax, allow_recovery, true), skip_to_state_evaluation))
+                        {
+                            return false;
+                        }
+                        continue;
                    }

                    // parse values
@@ -516,12 +655,544 @@ class parser
                continue;
            }

-            return sax->parse_error(m_lexer.get_position(),
-                                    m_lexer.get_token_string(),
-                                    parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_object, "object"), nullptr));
+            if (!report_error(sax, parse_error::create(101, m_lexer.get_position(), exception_message(token_type::end_object, "object"), nullptr), allow_recovery))
+            {
+                return false;
+            }
+
+            // recover
+            if (last_token == token_type::end_of_input)
+            {
+                // the input ends inside the object
+                return close_containers(sax, states, allow_recovery);
+            }
+            if (last_token == token_type::end_array)
+            {
+                // a wrong closing bracket closes the innermost container
+                if (JSON_HEDLEY_UNLIKELY(!sax->end_object()))
+                {
+                    return false;
+                }
+                states.pop_back();
+                skip_to_state_evaluation = true;
+                continue;
+            }
+            if (!continue_after(recover_member(sax, allow_recovery), skip_to_state_evaluation))
+            {
+                return false;
+            }
        }
    }

+    /*!
+    @brief continue sax_parse_internal() after a recovery
+    @return whether to continue parsing
+    */
+    bool continue_after(const next_step step, bool& skip_to_state_evaluation)
+    {
+        if (step == next_step::evaluate_state)
+        {
+            // the state evaluation reads the token again
+            m_lexer.unget_token();
+            skip_to_state_evaluation = true;
+        }
+        return step != next_step::stop;
+    }
+
+    /// the parser for parse() and accept() never recovers: stop parsing
+    JSON_INTERNAL_ALWAYS_INLINE
+    static std::false_type continue_after(std::false_type /*step*/, bool& /*skip_to_state_evaluation*/) noexcept
+    {
+        return {};
+    }
+
+    /*!
+    @brief parse an object key and the name separator (:) after it
+
+    last_token is the token where the key is expected. sax_parse_internal()
+    repeats these steps rather than calling this function, which is used
+    when recovering from an error.
+
+    @return next_step::parse_value if the value follows, with last_token its
+            first token; next_step::evaluate_state if the object's state is
+            to be evaluated after recovering from an error; next_step::stop
+            to stop parsing
+    */
+    template<typename SAX>
+    next_step parse_key(SAX* sax)
+    {
+        const std::true_type allow_recovery{};
+
+        if (JSON_HEDLEY_UNLIKELY(last_token != token_type::value_string))
+        {
+            return key_error(sax, allow_recovery, false);
+        }
+
+        if (JSON_HEDLEY_UNLIKELY(!sax->key(m_lexer.get_string())))
+        {
+            return next_step::stop;
+        }
+
+        // parse separator (:)
+        if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::name_separator))
+        {
+            return key_error(sax, allow_recovery, true);
+        }
+
+        // the value begins with the next token
+        get_token();
+        return next_step::parse_value;
+    }
+
+    /*!
+    @brief report a number that is too large for number_float_t, and recover
+           from the error by passing the value on; the SAX parser gets the
+           number's text as well
+
+    This is a separate function, as reading other numbers is measurably
+    slower if the error is handled where they are read.
+
+    @param[in] sax    the SAX parser
+    @param[in] value  the value that is not finite
+    @return whether to continue parsing
+    */
+    template<typename SAX>
+    bool overflow_error(SAX* sax, const number_float_t value, std::true_type allow_recovery)
+    {
+        if (!report_error(sax, out_of_range::create(406, concat("number overflow parsing '", m_lexer.get_token_string(), '\''), nullptr), allow_recovery))
+        {
+            return false;
+        }
+        return sax->number_float(value, m_lexer.get_string());
+    }
+
+    /// @copydoc overflow_error
+    template<typename SAX>
+    JSON_INTERNAL_ALWAYS_INLINE
+    std::false_type overflow_error(SAX* sax, const number_float_t /*value*/, std::false_type allow_recovery)
+    {
+        return report_error(sax, out_of_range::create(406, concat("number overflow parsing '", m_lexer.get_token_string(), '\''), nullptr), allow_recovery);
+    }
+
+    /*!
+    @brief report a missing key, or a missing name separator (:) after the
+           key; the parser for parse() and accept() never recovers
+
+    @param[in] key_read  whether the key was read, so that the name separator
+                         is missing
+    @return std::false_type, see report_error()
+    */
+    template<typename SAX>
+    JSON_INTERNAL_ALWAYS_INLINE
+    std::false_type key_error(SAX* sax, std::false_type allow_recovery, const bool key_read)
+    {
+        return report_error(sax, parse_error::create(101, m_lexer.get_position(), key_read
+                            ? exception_message(token_type::name_separator, "object separator")
+                            : exception_message(token_type::value_string, "object key"), nullptr), allow_recovery);
+    }
+
+    /*!
+    @brief report a missing key, or a missing name separator (:) after the
+           key, and recover from it
+
+    @param[in] key_read  whether the key was read, so that the name separator
+                         is missing
+    */
+    template<typename SAX>
+    next_step key_error(SAX* sax, std::true_type allow_recovery, const bool key_read)
+    {
+        if (!key_read)
+        {
+            if (!report_error(sax, parse_error::create(101, m_lexer.get_position(), exception_message(token_type::value_string, "object key"), nullptr), allow_recovery))
+            {
+                return next_step::stop;
+            }
+            return recover_key(sax);
+        }
+
+        if (!report_error(sax, parse_error::create(101, m_lexer.get_position(), exception_message(token_type::name_separator, "object separator"), nullptr), allow_recovery))
+        {
+            return next_step::stop;
+        }
+        return recover_name_separator(sax);
+    }
+
+    /////////////////////
+    // error recovery
+    /////////////////////
+
+    /*
+    The functions below repair an error after the SAX parser's parse_error()
+    returned true (see #3989). Each mistake is repaired by the smallest local
+    edit: a missing ',' or ':' is inserted, a stray token is removed, what can
+    be read of an invalid string or number is kept (see
+    lexer::recover_token()), a missing value becomes null, a wrong closing
+    bracket closes the innermost container, and the end of the input closes
+    all of them. The events stay balanced, and every key() is followed by
+    exactly one value.
+
+    A repair hands a token to the state evaluation, by returning it to the
+    lexer (lexer::unget_token()) so that the state evaluation reads it again,
+    only if it is ',', ']', '}', or the end of the input. The state evaluation
+    hands a token to value or key parsing only if it is none of them, so a
+    token is never handed back and forth. Every other step reads a token or
+    closes a container, so parsing always ends.
+    */
+
+    /*!
+    @brief report an error to the SAX parser; the parser for parse() and
+           accept() never recovers
+
+    @return std::false_type rather than false: its value is known where the
+            function is called even if the call is not inlined, so the code
+            for recovering is not generated
+    */
+    template<typename SAX, typename Exception>
+    JSON_INTERNAL_ALWAYS_INLINE
+    std::false_type report_error(SAX* sax, const Exception& ex, std::false_type /*allow_recovery*/)
+    {
+        error_reported = true;
+        static_cast<void>(sax->parse_error(m_lexer.get_position(), m_lexer.get_token_string(), ex));
+        return {};
+    }
+
+    /*!
+    @brief report an error to the SAX parser
+    @return whether to recover from the error
+    */
+    template<typename SAX, typename Exception>
+    bool report_error(SAX* sax, const Exception& ex, std::true_type /*allow_recovery*/)
+    {
+        const std::size_t position = m_lexer.get_position().chars_read_total;
+        if (error_reported && position == last_error_position && last_token == last_error_token)
+        {
+            // a repair handed on the token of the error it repaired; the
+            // token was reported already, and the SAX parser asked to recover
+            return true;
+        }
+
+        error_reported = true;
+        last_error_position = position;
+        last_error_token = last_token;
+
+        if (!sax->parse_error(m_lexer.get_position(), m_lexer.get_token_string(), ex))
+        {
+            return false;
+        }
+
+        // the token string of the next error begins here
+        m_lexer.restart_token_string();
+        return true;
+    }
+
+    /*!
+    @brief keep what can be read of the token that the lexer rejected
+
+    The error was reported for the rejected token, so it is not reported again
+    for the token it is repaired to (see lexer::recover_token()).
+    */
+    token_type recover_token()
+    {
+        last_token = m_lexer.recover_token();
+        last_error_position = m_lexer.get_position().chars_read_total;
+        last_error_token = last_token;
+        return last_token;
+    }
+
+    // The functions below are called from sax_parse_internal() after an error
+    // was reported. The parser for parse() and accept() stopped there, so for
+    // it they are stubs: the code for recovering is then not even referenced,
+    // and unoptimized builds do not emit it either.
+
+    /// @copydoc recover_token()
+    JSON_INTERNAL_ALWAYS_INLINE
+    token_type recover_token(std::true_type /*allow_recovery*/)
+    {
+        return recover_token();
+    }
+
+    /// @copydoc recover_token()
+    JSON_INTERNAL_ALWAYS_INLINE
+    static std::false_type recover_token(std::false_type /*allow_recovery*/) noexcept
+    {
+        return {};
+    }
+
+    /// return the token that was read last to the lexer (see lexer::unget_token())
+    JSON_INTERNAL_ALWAYS_INLINE
+    void unget_token(std::true_type /*allow_recovery*/)
+    {
+        m_lexer.unget_token();
+    }
+
+    /// @copydoc unget_token(std::true_type)
+    JSON_INTERNAL_ALWAYS_INLINE
+    static void unget_token(std::false_type /*allow_recovery*/) noexcept {}
+
+    /// @copydoc skip_to_value
+    JSON_INTERNAL_ALWAYS_INLINE
+    static std::false_type skip_to_value(std::false_type /*allow_recovery*/) noexcept
+    {
+        return {};
+    }
+
+    /// @copydoc recover_missing_value
+    template<typename SAX>
+    JSON_INTERNAL_ALWAYS_INLINE
+    static std::false_type recover_missing_value(SAX* /*sax*/, const std::vector<bool>& /*states*/, std::false_type /*allow_recovery*/) noexcept
+    {
+        return {};
+    }
+
+    /// pass the end events of all open containers
+    template<typename SAX>
+    bool close_containers(SAX* sax, std::vector<bool>& states, std::true_type /*allow_recovery*/)
+    {
+        while (!states.empty())
+        {
+            const bool is_array = states.back();
+            states.pop_back();
+            if (JSON_HEDLEY_UNLIKELY(is_array ? !sax->end_array() : !sax->end_object()))
+            {
+                return false;
+            }
+        }
+        return true;
+    }
+
+    /// @copydoc close_containers
+    template<typename SAX>
+    JSON_INTERNAL_ALWAYS_INLINE
+    static std::false_type close_containers(SAX* /*sax*/, std::vector<bool>& /*states*/, std::false_type /*allow_recovery*/) noexcept
+    {
+        return {};
+    }
+
+    /*!
+    @brief read tokens until one begins a value, skipping everything before
+           the top-level value
+    @return whether a value begins with last_token
+    */
+    bool skip_to_value(std::true_type /*allow_recovery*/)
+    {
+        while (true)
+        {
+            switch (get_token())
+            {
+                case token_type::begin_array:
+                case token_type::begin_object:
+                case token_type::literal_false:
+                case token_type::literal_null:
+                case token_type::literal_true:
+                case token_type::value_float:
+                case token_type::value_integer:
+                case token_type::value_string:
+                case token_type::value_unsigned:
+                    return true;
+
+                case token_type::end_of_input:
+                    return false;
+
+                case token_type::parse_error:
+                    recover_token();
+                    if (last_token != token_type::uninitialized)
+                    {
+                        return true;
+                    }
+                    break;
+
+                case token_type::uninitialized:
+                case token_type::end_array:
+                case token_type::end_object:
+                case token_type::name_separator:
+                case token_type::value_separator:
+                case token_type::literal_or_value:
+                default:
+                    break;
+            }
+        }
+    }
+
+    /*!
+    @brief skip the rest of an object member that cannot be read
+
+    Reads tokens, beginning with last_token, until a ',', '}', or ']' that is
+    not inside a container that begins in the skipped tokens, or the end of
+    the input.
+    */
+    void skip_member()
+    {
+        std::size_t depth = 0;
+        while (true)
+        {
+            switch (last_token)
+            {
+                case token_type::begin_array:
+                case token_type::begin_object:
+                    ++depth;
+                    break;
+
+                case token_type::end_array:
+                case token_type::end_object:
+                    if (depth == 0)
+                    {
+                        return;
+                    }
+                    --depth;
+                    break;
+
+                case token_type::value_separator:
+                    if (depth == 0)
+                    {
+                        return;
+                    }
+                    break;
+
+                case token_type::end_of_input:
+                    return;
+
+                case token_type::parse_error:
+                    recover_token();
+                    break;
+
+                case token_type::uninitialized:
+                case token_type::literal_true:
+                case token_type::literal_false:
+                case token_type::literal_null:
+                case token_type::value_string:
+                case token_type::value_unsigned:
+                case token_type::value_integer:
+                case token_type::value_float:
+                case token_type::name_separator:
+                case token_type::literal_or_value:
+                default:
+                    break;
+            }
+            get_token();
+        }
+    }
+
+    /*!
+    @brief pass a value where it is missing
+
+    last_token is ',', ']', '}', or the end of the input, where a value was
+    expected. In an object, the key gets null; in an array, a ',' where a
+    value is missing stands for null (as in JavaScript), while an array that
+    ends there just ends.
+    */
+    template<typename SAX>
+    bool recover_missing_value(SAX* sax, const std::vector<bool>& states, std::true_type /*allow_recovery*/)
+    {
+        JSON_ASSERT(!states.empty());
+        if (!states.back() || last_token == token_type::value_separator)
+        {
+            return sax->null();
+        }
+        return true;
+    }
+
+    /// recover from a missing key; last_token is where it was expected
+    template<typename SAX>
+    next_step recover_key(SAX* sax)
+    {
+        switch (last_token)
+        {
+            case token_type::value_separator:
+            case token_type::end_object:
+            case token_type::end_array:
+            case token_type::end_of_input:
+                // no member: the object's state handles the token
+                return next_step::evaluate_state;
+
+            case token_type::parse_error:
+                recover_token();
+                if (last_token == token_type::value_string)
+                {
+                    // a key that could be repaired
+                    return parse_key(sax);
+                }
+                skip_member();
+                return next_step::evaluate_state;
+
+            case token_type::uninitialized:
+            case token_type::literal_true:
+            case token_type::literal_false:
+            case token_type::literal_null:
+            case token_type::value_string:
+            case token_type::value_unsigned:
+            case token_type::value_integer:
+            case token_type::value_float:
+            case token_type::begin_array:
+            case token_type::begin_object:
+            case token_type::name_separator:
+            case token_type::literal_or_value:
+            default:
+                // a member without a key
+                skip_member();
+                return next_step::evaluate_state;
+        }
+    }
+
+    /// recover from a missing name separator (:) after the key; last_token
+    /// is where it was expected
+    template<typename SAX>
+    next_step recover_name_separator(SAX* sax)
+    {
+        switch (last_token)
+        {
+            case token_type::value_separator:
+            case token_type::end_object:
+            case token_type::end_array:
+            case token_type::end_of_input:
+                // the value is missing as well
+                return sax->null() ? next_step::evaluate_state : next_step::stop;
+
+            case token_type::uninitialized:
+            case token_type::literal_true:
+            case token_type::literal_false:
+            case token_type::literal_null:
+            case token_type::value_string:
+            case token_type::value_unsigned:
+            case token_type::value_integer:
+            case token_type::value_float:
+            case token_type::begin_array:
+            case token_type::begin_object:
+            case token_type::name_separator:
+            case token_type::parse_error:
+            case token_type::literal_or_value:
+            default:
+                // a missing ':'; the value begins here
+                return next_step::parse_value;
+        }
+    }
+
+    /// recover from a token after an object member that is neither ',' nor
+    /// '}' (nor ']' or the end of the input, which the caller handles)
+    template<typename SAX>
+    next_step recover_member(SAX* sax, std::true_type /*allow_recovery*/)
+    {
+        if (last_token == token_type::parse_error)
+        {
+            recover_token();
+        }
+        if (last_token == token_type::value_string)
+        {
+            // a missing ','; the next key begins here
+            return parse_key(sax);
+        }
+        skip_member();
+        return next_step::evaluate_state;
+    }
+
+    /// the parser for parse() and accept() never recovers (and does not come
+    /// here, as report_error() returned false)
+    template<typename SAX>
+    JSON_INTERNAL_ALWAYS_INLINE
+    std::false_type recover_member(SAX* /*sax*/, std::false_type /*allow_recovery*/) const noexcept
+    {
+        return {};
+    }
+
    /// get next token from lexer
    token_type get_token()
    {
@@ -575,6 +1246,12 @@ class parser
    const bool allow_exceptions = true;
    /// whether trailing commas in objects and arrays should be ignored (true) or signaled as errors (false)
    const bool ignore_trailing_commas = false;
+    /// whether an error was reported to the SAX parser
+    bool error_reported = false;
+    /// the position of the last reported error
+    std::size_t last_error_position = 0;
+    /// the token of the last reported error
+    token_type last_error_token = token_type::uninitialized;
 };

 }  // namespace detail
@@ -199,6 +199,17 @@
    #define JSON_NO_UNIQUE_ADDRESS
 #endif

+// Inlines small functions even in unoptimized builds, so that they are not
+// emitted. The parsers for parse(), accept(), and from_*() use it for the
+// functions that stand in for the code recovering from errors (see #3989).
+// MSVC is left to decide, as it warns (C4714) where it does not inline a
+// __forceinline function.
+#if defined(_MSC_VER) && !defined(__clang__)
+    #define JSON_INTERNAL_ALWAYS_INLINE
+#else
+    #define JSON_INTERNAL_ALWAYS_INLINE JSON_HEDLEY_ALWAYS_INLINE
+#endif
+
 // Clang targeting MinGW does not survive the thread_local storage the copy
 // constructor uses to bound its descent: every test that copies a value
 // segfaults with clang 11.0.1 and clang 18.1.8, while the same tests pass with
@@ -19,6 +19,7 @@
 #undef NLOHMANN_CAN_CALL_STD_FUNC_IMPL
 #undef JSON_INLINE_VARIABLE
 #undef JSON_NO_UNIQUE_ADDRESS
+#undef JSON_INTERNAL_ALWAYS_INLINE
 #undef JSON_DISABLE_ENUM_SERIALIZATION
 #undef JSON_DISABLE_TUPLE_REFERENCE_CONVERSION

@@ -13,6 +13,7 @@
 #include <cstddef> // size_t
 #include <cstdint> // uint8_t, uint32_t
 #include <string> // string, to_string
+#include <utility> // move

 #include <nlohmann/detail/abi_macros.hpp>
 #include <nlohmann/detail/macro_scope.hpp>
@@ -149,7 +149,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    friend class ::nlohmann::detail::iter_impl;
    template<typename BasicJsonType, typename CharType, typename OutputSinkType>
    friend class ::nlohmann::detail::binary_writer;
-    template<typename BasicJsonType, typename InputType, typename SAX>
+    template<typename BasicJsonType, typename InputType, typename SAX, bool AllowRecovery>
    friend class ::nlohmann::detail::binary_reader;
    template<typename BasicJsonType, typename InputAdapterType>
    friend class ::nlohmann::detail::json_sax_dom_parser;
@@ -5689,7 +5689,7 @@ public:
        auto ia = detail::input_adapter(std::forward<InputType>(i));
        return format == input_format_t::json
               ? parser(std::move(ia), nullptr, true, ignore_comments, ignore_trailing_commas).sax_parse(sax, strict)
-               : detail::binary_reader<basic_json, decltype(ia), SAX>(std::move(ia), format).sax_parse(sax, strict, tag_handler);
+               : detail::binary_reader<basic_json, decltype(ia), SAX, true>(std::move(ia), format).sax_parse(sax, strict, tag_handler);
    }

    /// @brief generate SAX events (iterator pair, or iterator+sentinel pair for C++20 ranges support)
@@ -5707,7 +5707,7 @@ public:
        auto ia = detail::input_adapter(std::move(first), std::move(last));
        return format == input_format_t::json
               ? parser(std::move(ia), nullptr, true, ignore_comments, ignore_trailing_commas).sax_parse(sax, strict)
-               : detail::binary_reader<basic_json, decltype(ia), SAX>(std::move(ia), format).sax_parse(sax, strict, tag_handler);
+               : detail::binary_reader<basic_json, decltype(ia), SAX, true>(std::move(ia), format).sax_parse(sax, strict, tag_handler);
    }

    /// @brief generate SAX events
@@ -5746,7 +5746,7 @@ public:
               // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
               ? parser(std::move(ia), nullptr, true, ignore_comments, ignore_trailing_commas).sax_parse(sax, strict)
               // NOLINTNEXTLINE(hicpp-move-const-arg,performance-move-const-arg)
-               : detail::binary_reader<basic_json, decltype(ia), SAX>(std::move(ia), format).sax_parse(sax, strict, tag_handler);
+               : detail::binary_reader<basic_json, decltype(ia), SAX, true>(std::move(ia), format).sax_parse(sax, strict, tag_handler);
    }
 #endif
 #if defined(__clang__)
@@ -2,120 +2,24 @@ project('nlohmann_json',
    'cpp',
    version : '3.12.0',
    license : 'MIT',
-    meson_version : '>= 0.64',
-    default_options: ['cpp_std=c++11'],
 )

-if get_option('MultipleHeaders')
-    incdir = 'include'
-else
-    incdir = 'single_include'
-endif
-
-# The same compile definitions as the CMake target (see target_compile_definitions
-# in CMakeLists.txt): only an option that differs from its default adds one.
-json_defines = []
-if not get_option('GlobalUDLs')
-    json_defines += 'JSON_USE_GLOBAL_UDLS=0'
-endif
-if not get_option('ImplicitConversions')
-    json_defines += 'JSON_USE_IMPLICIT_CONVERSIONS=0'
-endif
-if get_option('DisableEnumSerialization')
-    json_defines += 'JSON_DISABLE_ENUM_SERIALIZATION=1'
-endif
-if get_option('DisableTupleReferenceConversion')
-    json_defines += 'JSON_DISABLE_TUPLE_REFERENCE_CONVERSION=1'
-endif
-if get_option('Diagnostics')
-    json_defines += 'JSON_DIAGNOSTICS=1'
-endif
-if get_option('Diagnostic_Positions')
-    json_defines += 'JSON_DIAGNOSTIC_POSITIONS=1'
-endif
-if get_option('LegacyDiscardedValueComparison')
-    json_defines += 'JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON=1'
-endif
-if get_option('StrictNulHandling')
-    json_defines += 'JSON_STRICT_NUL_HANDLING=1'
-endif
-if get_option('StrictBinaryUTF8')
-    json_defines += 'JSON_STRICT_BINARY_UTF8=1'
-endif
-if get_option('DeleteDeprecatedFunctions')
-    json_defines += 'JSON_DELETE_DEPRECATED_FUNCTIONS=1'
-endif
-
-cpp_args = []
-foreach define : json_defines
-    cpp_args += '-D' + define
-endforeach
-
 nlohmann_json_dep = declare_dependency(
-    compile_args: cpp_args,
-    include_directories: include_directories(incdir)
+    include_directories: include_directories('single_include')
 )
-meson.override_dependency('nlohmann_json', nlohmann_json_dep)

-# The multi-header version under the name earlier versions of this file used
 nlohmann_json_multiple_headers = declare_dependency(
-    compile_args: cpp_args,
    include_directories: include_directories('include')
 )

 if not meson.is_subproject()
-    install_subdir(
-        incdir / 'nlohmann',
-        install_dir: get_option('includedir'),
-        install_tag: 'devel',
-    )
+install_headers('single_include/nlohmann/json.hpp', subdir: 'nlohmann')
+install_headers('single_include/nlohmann/json_fwd.hpp', subdir: 'nlohmann')
+install_headers('single_include/nlohmann/json_literals.hpp', subdir: 'nlohmann')

-    pkgc = import('pkgconfig')
-    pkgc.generate(name: 'nlohmann_json',
-        version: meson.project_version(),
-        description: 'JSON for Modern C++',
-        extra_cflags: cpp_args,
-        install_dir: get_option('datadir') / 'pkgconfig',
-    )
-
-    # CMake package config files, so that find_package(nlohmann_json) works. The
-    # include directory is given relative to the config files, so that the
-    # installation can be relocated. This is not possible if includedir or datadir
-    # is an absolute path outside the prefix (e.g., with the separate outputs of
-    # Nix); then the absolute include directory is used, as CMake does.
-    fs = import('fs')
-    cmake_install_dir = get_option('datadir') / 'cmake' / meson.project_name()
-    cmake_to_prefix = []
-    if fs.is_absolute(get_option('includedir')) or fs.is_absolute(cmake_install_dir)
-        cmake_include_dir = (get_option('prefix') / get_option('includedir')).replace('\\', '/')
-    else
-        foreach component : cmake_install_dir.split('/')
-            cmake_to_prefix += '..'
-        endforeach
-        cmake_include_dir = '${_IMPORT_PREFIX}/' + get_option('includedir')
-    endif
-
-    cmake_conf = configuration_data()
-    cmake_conf.set('PROJECT_NAME', meson.project_name())
-    cmake_conf.set('PROJECT_VERSION', meson.project_version())
-    cmake_conf.set('PROJECT_VERSION_MAJOR', meson.project_version().split('.')[0])
-    cmake_conf.set('NLOHMANN_JSON_TARGET_NAME', meson.project_name())
-    cmake_conf.set('NLOHMANN_JSON_TARGETS_EXPORT_NAME', meson.project_name() + 'Targets')
-    cmake_conf.set('NLOHMANN_JSON_INCLUDE_DIR', cmake_include_dir)
-    cmake_conf.set('NLOHMANN_JSON_CONFIG_TO_PREFIX', '/'.join(cmake_to_prefix))
-    cmake_conf.set('NLOHMANN_JSON_COMPILE_DEFINITIONS', ';'.join(json_defines))
-
-    foreach cmake_file : [
-        ['cmake/config.cmake.in', 'nlohmann_jsonConfig.cmake'],
-        ['cmake/nlohmann_jsonConfigVersion.cmake.in', 'nlohmann_jsonConfigVersion.cmake'],
-        ['cmake/nlohmann_jsonTargets.cmake.in', 'nlohmann_jsonTargets.cmake'],
-    ]
-        configure_file(
-            input: cmake_file[0],
-            output: cmake_file[1],
-            configuration: cmake_conf,
-            format: 'cmake@',
-            install_dir: cmake_install_dir,
-        )
-    endforeach
+pkgc = import('pkgconfig')
+pkgc.generate(name: 'nlohmann_json',
+    version: meson.project_version(),
+    description: 'JSON for Modern C++'
+)
 endif
@@ -1,66 +0,0 @@
-option(
-    'MultipleHeaders',
-    type: 'boolean',
-    value: false,
-    description: 'Use non-amalgamated version of the library',
-)
-option(
-    'GlobalUDLs',
-    type: 'boolean',
-    value: true,
-    description: 'Place user-defined string literals in the global namespace',
-)
-option(
-    'ImplicitConversions',
-    type: 'boolean',
-    value: true,
-    description: 'Enable implicit conversions',
-)
-option(
-    'DisableEnumSerialization',
-    type: 'boolean',
-    value: false,
-    description: 'Disable default integer enum serialization',
-)
-option(
-    'DisableTupleReferenceConversion',
-    type: 'boolean',
-    value: false,
-    description: 'Disable conversion from a one-element tuple of a JSON reference',
-)
-option(
-    'Diagnostics',
-    type: 'boolean',
-    value: false,
-    description: 'Use extended diagnostic messages',
-)
-option(
-    'Diagnostic_Positions',
-    type: 'boolean',
-    value: false,
-    description: 'Enable diagnostic positions',
-)
-option(
-    'LegacyDiscardedValueComparison',
-    type: 'boolean',
-    value: false,
-    description: 'Enable legacy discarded value comparison',
-)
-option(
-    'StrictNulHandling',
-    type: 'boolean',
-    value: false,
-    description: 'Enable strict NUL-byte handling',
-)
-option(
-    'StrictBinaryUTF8',
-    type: 'boolean',
-    value: false,
-    description: 'Enable UTF-8 checks in the CBOR, UBJSON, BJData, and BSON writers',
-)
-option(
-    'DeleteDeprecatedFunctions',
-    type: 'boolean',
-    value: false,
-    description: 'Delete the deprecated functions instead of only deprecating them',
-)
@@ -47,6 +47,7 @@ inline namespace json_literals
 namespace detail
 {
    using NLOHMANN_JSON_NAMESPACE::detail::json_sax_dom_callback_parser;
+    using NLOHMANN_JSON_NAMESPACE::detail::json_sax_dom_parser;
    using NLOHMANN_JSON_NAMESPACE::detail::unknown_size;
 } // namespace detail

@@ -2,14 +2,12 @@ cmake_minimum_required(VERSION 3.13...4.0)

 option(JSON_Valgrind    "Execute test suite with Valgrind." OFF)
 option(JSON_FastTests   "Skip expensive/slow tests." OFF)
-option(JSON_TestUnityBuild "Build the unit tests in batches of several files per executable to speed up compilation." ON)
 option(JSON_TestSimdutf "Build the unit tests against the simdutf UTF-8 validation backend." OFF)

 set(JSON_SIMDUTF_VERSION 9.1.0 CACHE STRING "The simdutf version used by JSON_TestSimdutf.")

 set(JSON_32bitTest     AUTO CACHE STRING "Enable the 32bit unit test (ON/OFF/AUTO/ONLY).")
 set(JSON_TestStandards "" CACHE STRING "The list of standards to test explicitly.")
-set(JSON_TestUnityBatchSize 8 CACHE STRING "The number of unit test files compiled into one executable with JSON_TestUnityBuild.")
 set(JSON_TestShard     "" CACHE STRING "Build only a part of the unit tests, given as <index>/<count> (e.g. 0/2), to split them across CI jobs with a time limit.")

 # using an env var, since this will also affect targets executing cmake (such as "ci_test_compiler_default")
@@ -22,11 +20,6 @@ endif()

 include(test)

-# MinGW's GNU ld hits section and relocation limits with the large merged translation units
-if(MINGW)
-    set(JSON_TestUnityBuild OFF)
-endif()
-
 #############################################################################
 # override standard support
 #############################################################################
@@ -145,8 +138,7 @@ json_test_set_test_options(test-disabled_exceptions
 # only the #972 regression test needs thirdparty/fifo_map on its include path
 json_test_set_test_options(test-regression1 LINK_LIBRARIES fifo_map_include)

-# Regression test for GCC's false -Warray-bounds error with JSON_DIAGNOSTICS (#5742, fixed in #5585). It only
-# showed up when optimizing, so build this test with -O3 and the warning as an error.
+# GCC's false -Warray-bounds error with JSON_DIAGNOSTICS only shows up when optimizing (#5742).
 # -O3 makes the optimizer-driven warnings of the ci_test_gcc flag set (-Winline,
 # -Wsuggest-attribute=...) fire on the library's inline functions; they are not
 # what this test checks, so turn them off for it.
@@ -329,28 +321,9 @@ if(NOT "${JSON_TestShard}" STREQUAL "")
    message(STATUS "Test shard ${JSON_TestShard}: ${shard_file_count} of ${test_file_count} unit test files")
 endif()

-# Explicit groups of test files (file names without "unit-" and ".cpp") for
-# JSON_TestUnityBuild: all files of a group are compiled into one translation
-# unit per C++ standard, so that related tests share their template
-# instantiations (all binary formats instantiate the same readers and
-# writers). Only add a group where this was measured to pay off: grouping
-# files that share little just creates one slow translation unit. Files in no
-# group are batched alphabetically by JSON_TestUnityBatchSize.
-set(json_test_unity_groups binary)
-set(json_test_unity_group_binary binary_formats binary_utf8_error_handler binary_writer_sinks bjdata bon8 bon8-cpp17 bson byte_container_with_subtype cbor msgpack msgpack-cpp17 ubjson)
-
-if(JSON_TestUnityBuild)
-    message(STATUS "Building the unit tests in batches of ${JSON_TestUnityBatchSize} files (JSON_TestUnityBuild)")
-    json_test_add_unity_tests(FILES ${files} MAIN test_main CXX_STANDARDS ${test_cxx_standards} ${test_force}
-        BATCH_SIZE ${JSON_TestUnityBatchSize}
-        GROUPS ${json_test_unity_groups}
-        VARIANT_FILES src/unit-comparison.cpp src/unit-comparison-cpp20.cpp src/unit-class_parser.cpp src/unit-diagnostic-positions.cpp
-    )
-else()
-    foreach(file ${files})
-        json_test_add_test_for(${file} MAIN test_main CXX_STANDARDS ${test_cxx_standards} ${test_force})
-    endforeach()
-endif()
+foreach(file ${files})
+    json_test_add_test_for(${file} MAIN test_main CXX_STANDARDS ${test_cxx_standards} ${test_force})
+endforeach()

 # tests/src/unit-no-macro-leak.cpp #include-s the generated leak-check file,
 # so its test targets must be built after generate_hedley_undef_checks.
@@ -376,13 +349,6 @@ json_test_add_test_for(src/unit-comparison.cpp
    NAME test-comparison_legacy
    MAIN test_main CXX_STANDARDS ${test_cxx_standards} ${test_force}
 )
-json_test_set_test_options(test-comparison_legacy-cpp20
-    COMPILE_DEFINITIONS JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON=1
-)
-json_test_add_test_for(src/unit-comparison-cpp20.cpp
-    NAME test-comparison_legacy-cpp20
-    MAIN test_main CXX_STANDARDS ${test_cxx_standards} ${test_force}
-)

 # test the parser again with JSON_DIAGNOSTIC_POSITIONS enabled
 json_test_set_test_options(test-class_parser_diagnostic_positions
@@ -1,92 +0,0 @@
-# Unit tests
-
-The unit tests are in [`src/unit-*.cpp`](src) and use [doctest](https://github.com/doctest/doctest). Each file becomes
-one CTest test per C++ standard it is built for, named after the file: `src/unit-foo.cpp` becomes `test-foo_cpp11`.
-
-## Build and run
-
-```sh
-cmake -S . -B build -DJSON_BuildTests=ON
-cmake --build build -j 10
-ctest --test-dir build -j 10
-```
-
-The [CMake options](../docs/mkdocs/docs/integration/cmake.md) starting with `JSON_Test` (and `JSON_FastTests`,
-`JSON_Valgrind`) control the test build. The most relevant ones:
-
- `JSON_TestStandards`: build every test file for the given standards, e.g., `-DJSON_TestStandards=17`. By default,
-  a file is built for C++11 and for each standard whose `JSON_HAS_CPP_<N>` macro it mentions (see below).
- `JSON_TestUnityBuild`: compile several test files together (see below). Set it to `OFF` to get one executable per
-  test file, e.g., to debug a single test in a debugger.
- `JSON_TestShard`: build only a part of the test files, e.g., `-DJSON_TestShard=0/2`.
-
-To run the tests of one file only, run its CTest test, e.g., `ctest --test-dir build -R test-foo_cpp11`.
-
-## How test files are built
-
-Two mechanisms keep the compile time down. Both are automatic, but they set a few rules for test files.
-
-### C++ standards
-
-A test file is built for a C++ standard beyond C++11 if its text contains `JSON_HAS_CPP_<N>`, for instance in
-`#ifdef JSON_HAS_CPP_17`, or in a comment `// JSON_HAS_CPP_17` next to code that needs a macro only defined for that
-standard, such as `JSON_HAS_FILESYSTEM`. Then the *whole file* is compiled again for that standard.
-
-So that this does not happen for the large files, tests that need C++14, C++17, or C++20 go into a separate file
-`src/unit-<name>-cpp<N>.cpp` (e.g., [`src/unit-regression3-cpp17.cpp`](src/unit-regression3-cpp17.cpp)), whose body
-is wrapped in `#ifdef JSON_HAS_CPP_<N>`. The main file `src/unit-<name>.cpp` must not mention `JSON_HAS_CPP_<N>` at
-all, not even in a comment, so it is built for C++11 only. The CI jobs `ci_test_*_cxx<N>` still build every test file
-for every standard.
-
-### Unity build
-
-With `JSON_TestUnityBuild` (`ON` by default, `OFF` with MinGW), CMake compiles several test files as one translation
-unit, so they share the template instantiations of the library. CMake generates `build/tests/unity/test-unity-*.cpp`,
-which `#include` the test files of a batch. Every test file still gets its own CTest test, which runs the batch
-executable with `--source-file=*unit-foo.cpp`, so only the test cases of that file run.
-
-CMake decides from the macros a file defines *before* including `<nlohmann/json.hpp>`:
-
-| Macros defined before the include                                                         | Built as                          |
-|-------------------------------------------------------------------------------------------|-----------------------------------|
-| none (or only `SKIP_TESTS_FOR_*` and similar macros derived from global definitions)      | batch with the other plain files  |
-| only `JSON_TESTS_PRIVATE`                                                                 | batch with the other such files   |
-| any library configuration macro (`JSON_DIAGNOSTICS`, `JSON_NO_IO`, `JSON_ASSERT`, ...)    | its own executable                |
-
-Files with test-specific build options (`json_test_set_test_options(test-foo ...)` in
-[`CMakeLists.txt`](CMakeLists.txt)) also get their own executable. The batchable files are split alphabetically into
-batches of `JSON_TestUnityBatchSize` files, except for explicit groups of related files: `json_test_unity_group_binary`
-compiles all binary-format tests together, because they share the binary readers and writers. Only add a group if it
-measurably pays off; files that share little just make one slow translation unit.
-
-## Rules for test files
-
-Because the files of a batch share one translation unit, a test file must not affect the files that follow it:
-
-1. **Give file-scope helpers file-specific names.** An anonymous namespace does not help, as the batch is one
-   translation unit. Use a name such as `my_allocator_2982`, or wrap the helpers in a namespace named after the file
-   (e.g., `namespace unit_comparison_detail`). Clashes show up as compile errors.
-2. **Do not `#undef` library macros**, such as `JSON_HAS_CPP_17`, at the end of a file: this silently disables the tests
-   that depend on them in the later files of the batch. `#undef` macros you define yourself after including the library.
-3. **Put version-dependent tests into `unit-<name>-cpp<N>.cpp`** (see [C++ standards](#c-standards)).
-4. **Define test cases in the `.cpp` file itself.** The batch executable selects the tests of a file by its name, so a
-   `TEST_CASE` in a shared header is not run. The only exception is the test case in
-   [`src/make_test_data_available.hpp`](src/make_test_data_available.hpp), which CMake handles explicitly.
-
-To check a new file for clashes with all others at once, build with `-DJSON_TestUnityBatchSize=1000`, which puts all
-batchable files of a kind into one translation unit.
-
-## Where to add tests
-
-Tests are structured along the features of the library. Usually, an existing file is the right place:
-
- For a bug fix, add a section referencing the issue to [`src/unit-regression3.cpp`](src/unit-regression3.cpp), or to
-  [`src/unit-regression3-cpp17.cpp`](src/unit-regression3-cpp17.cpp) /
-  [`src/unit-regression3-cpp20.cpp`](src/unit-regression3-cpp20.cpp) if the test needs C++17 / C++20.
-  [`src/unit-regression2.cpp`](src/unit-regression2.cpp) holds older tests and should not grow further.
- When testing exceptions, use `CHECK_THROWS_WITH_AS`, which also checks the `what()` message.
-
-A new file `src/unit-<name>.cpp` is picked up automatically when CMake runs again; no change to `CMakeLists.txt` is
-needed.
-
-See also [`fuzzing.md`](fuzzing.md) for fuzz testing.
@@ -47,6 +47,10 @@ dumps is stable under exactly the same values that break operator==.
 The unit tests run the same checks on a fixed corpus (see the "BJData round-trip
 invariants" test case), so keep both in sync.

+Furthermore, it reads data with a SAX parser that recovers from every error
+and checks that the events are balanced, that reading ends, and that it
+reports an error exactly when from_bjdata() fails (see #3989).
+
 The provided function `LLVMFuzzerTestOneInput` can be used in different fuzzer
 drivers.
 */
@@ -59,6 +63,8 @@ drivers.
    #error "the fuzzer drivers must be built without NDEBUG"
 #endif

+#include "fuzzer-recovering_checker.hpp"
+
 using json = nlohmann::json;

 // compares dumps rather than values, because NaN != NaN; keep writes strings
@@ -78,6 +84,9 @@ static bool is_value_stable(const json& lhs, const json& rhs)
 // see http://llvm.org/docs/LibFuzzer.html
 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
 {
+    // recover from all errors, reading from memory and from a stream
+    const bool recovered_without_errors = check_recovering_parse(data, size, json::input_format_t::bjdata).errors == 0;
+
    std::vector<uint8_t> const vec1(data, data + size);

    // step 0: parse input without exceptions; a parse error must then be
@@ -110,6 +119,9 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
        // without exceptions, the same input must give the same value
        assert(!noexcept_threw && !j_noexcept.is_discarded() && same_value(j_noexcept, j1));

+        // the recovering parser must not have reported an error either
+        assert(recovered_without_errors);
+
        try
        {
            // step 2.1: round trip without adding size annotations to container types
@@ -143,6 +155,7 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
    {
        // parse errors are ok, because input may be random bytes
        assert(parsed || noexcept_threw || j_noexcept.is_discarded());
+        assert(parsed || !recovered_without_errors);
    }
    catch (const json::type_error&)
    {
@@ -153,6 +166,7 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
    {
        // out of range errors may happen if provided sizes are excessive
        assert(parsed || noexcept_threw || j_noexcept.is_discarded());
+        assert(parsed || !recovered_without_errors);
    }

    // return 0 - non-zero return values are reserved for future use
@@ -21,6 +21,10 @@ It also checks that reading the data from a stream, which reads strings byte by
 byte, gives the same value or error as reading it from contiguous memory, which
 copies strings in bulk.

+Furthermore, it reads data with a SAX parser that recovers from every error
+and checks that the events are balanced, that reading ends, and that it
+reports an error exactly when from_bon8() fails (see #3989).
+
 The provided function `LLVMFuzzerTestOneInput` can be used in different fuzzer
 drivers.
 */
@@ -34,6 +38,8 @@ drivers.
    #error "the fuzzer drivers must be built without NDEBUG"
 #endif

+#include "fuzzer-recovering_checker.hpp"
+
 using json = nlohmann::json;

 // compares dumps rather than values, because NaN != NaN; keep writes strings
@@ -64,6 +70,9 @@ std::string read_bon8(InputType&& input)
 // see http://llvm.org/docs/LibFuzzer.html
 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
 {
+    // recover from all errors, reading from memory and from a stream
+    const bool recovered_without_errors = check_recovering_parse(data, size, json::input_format_t::bon8).errors == 0;
+
    // contiguous and stream input must be read alike
    {
        std::istringstream stream(std::string(reinterpret_cast<const char*>(data), size));
@@ -102,6 +111,9 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
        // without exceptions, the same input must give the same value
        assert(!noexcept_threw && !j_noexcept.is_discarded() && same_value(j_noexcept, j1));

+        // the recovering parser must not have reported an error either
+        assert(recovered_without_errors);
+
        try
        {
            // step 2: round trip
@@ -123,6 +135,7 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
    {
        // parse errors are ok, because input may be random bytes
        assert(parsed || noexcept_threw || j_noexcept.is_discarded());
+        assert(parsed || !recovered_without_errors);
    }
    catch (const json::type_error&)
    {
@@ -133,6 +146,7 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
    {
        // out of range errors may happen if provided sizes are excessive
        assert(parsed || noexcept_threw || j_noexcept.is_discarded());
+        assert(parsed || !recovered_without_errors);
    }

    // return 0 - non-zero return values are reserved for future use
@@ -17,6 +17,10 @@ array data, it performs the following steps:
 - j2 = from_bson(vec)
 - assert(to_bson(j2) == vec)

+Furthermore, it reads data with a SAX parser that recovers from every error
+and checks that the events are balanced, that reading ends, and that it
+reports an error exactly when from_bson() fails (see #3989).
+
 The provided function `LLVMFuzzerTestOneInput` can be used in different fuzzer
 drivers.
 */
@@ -29,6 +33,8 @@ drivers.
    #error "the fuzzer drivers must be built without NDEBUG"
 #endif

+#include "fuzzer-recovering_checker.hpp"
+
 using json = nlohmann::json;

 // compares dumps rather than values, because NaN != NaN; keep writes strings
@@ -41,6 +47,9 @@ static bool same_value(const json& lhs, const json& rhs)
 // see http://llvm.org/docs/LibFuzzer.html
 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
 {
+    // recover from all errors, reading from memory and from a stream
+    const bool recovered_without_errors = check_recovering_parse(data, size, json::input_format_t::bson).errors == 0;
+
    std::vector<uint8_t> const vec1(data, data + size);

    // step 0: parse input without exceptions; a parse error must then be
@@ -73,6 +82,9 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
        // without exceptions, the same input must give the same value
        assert(!noexcept_threw && !j_noexcept.is_discarded() && same_value(j_noexcept, j1));

+        // the recovering parser must not have reported an error either
+        assert(recovered_without_errors);
+
        try
        {
            // step 2: round trip
@@ -94,6 +106,7 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
    {
        // parse errors are ok, because input may be random bytes
        assert(parsed || noexcept_threw || j_noexcept.is_discarded());
+        assert(parsed || !recovered_without_errors);
    }
    catch (const json::type_error&)
    {
@@ -104,6 +117,7 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
    {
        // out of range errors can occur during parsing, too
        assert(parsed || noexcept_threw || j_noexcept.is_discarded());
+        assert(parsed || !recovered_without_errors);
    }

    // return 0 - non-zero return values are reserved for future use
@@ -17,6 +17,10 @@ array data, it performs the following steps:
 - j2 = from_cbor(vec)
 - assert(to_cbor(j2) == vec)

+Furthermore, it reads data with a SAX parser that recovers from every error
+and checks that the events are balanced, that reading ends, and that it
+reports an error exactly when from_cbor() fails (see #3989).
+
 The provided function `LLVMFuzzerTestOneInput` can be used in different fuzzer
 drivers.
 */
@@ -29,6 +33,8 @@ drivers.
    #error "the fuzzer drivers must be built without NDEBUG"
 #endif

+#include "fuzzer-recovering_checker.hpp"
+
 using json = nlohmann::json;

 // compares dumps rather than values, because NaN != NaN; keep writes strings
@@ -41,6 +47,9 @@ static bool same_value(const json& lhs, const json& rhs)
 // see http://llvm.org/docs/LibFuzzer.html
 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
 {
+    // recover from all errors, reading from memory and from a stream
+    const bool recovered_without_errors = check_recovering_parse(data, size, json::input_format_t::cbor).errors == 0;
+
    std::vector<uint8_t> const vec1(data, data + size);

    // step 0: parse input without exceptions; a parse error must then be
@@ -73,6 +82,9 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
        // without exceptions, the same input must give the same value
        assert(!noexcept_threw && !j_noexcept.is_discarded() && same_value(j_noexcept, j1));

+        // the recovering parser must not have reported an error either
+        assert(recovered_without_errors);
+
        try
        {
            // step 2: round trip
@@ -94,6 +106,7 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
    {
        // parse errors are ok, because input may be random bytes
        assert(parsed || noexcept_threw || j_noexcept.is_discarded());
+        assert(parsed || !recovered_without_errors);
    }
    catch (const json::type_error&)
    {
@@ -104,6 +117,7 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
    {
        // out of range errors can occur during parsing, too
        assert(parsed || noexcept_threw || j_noexcept.is_discarded());
+        assert(parsed || !recovered_without_errors);
    }

    // return 0 - non-zero return values are reserved for future use
@@ -18,6 +18,10 @@ array data, it performs the following steps:
 - s2 = serialize(j2)
 - assert(s1 == s2)

+Furthermore, it parses data with a SAX parser that recovers from every error
+and checks that the events are balanced, that parsing ends, and that valid
+input is parsed without errors (see #3989).
+
 The provided function `LLVMFuzzerTestOneInput` can be used in different fuzzer
 drivers.
 */
@@ -30,6 +34,8 @@ drivers.
    #error "the fuzzer drivers must be built without NDEBUG"
 #endif

+#include "fuzzer-recovering_checker.hpp"
+
 using json = nlohmann::json;

 // compares dumps rather than values, because NaN != NaN; keep writes strings
@@ -42,6 +48,13 @@ static bool same_value(const json& lhs, const json& rhs)
 // see http://llvm.org/docs/LibFuzzer.html
 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
 {
+    // recover from all errors, reading from memory and from a stream
+    {
+        const auto checker = check_recovering_parse(data, size, json::input_format_t::json);
+        assert(checker.events <= (4 * size) + 4);
+        assert((checker.errors == 0) == json::accept(data, data + size));
+    }
+
    // step 0: parse input without exceptions; a parse error must then be
    // reported as a discarded value, never thrown
    json j_noexcept;
@@ -17,6 +17,10 @@ array data, it performs the following steps:
 - j2 = from_msgpack(vec)
 - assert(to_msgpack(j2) == vec)

+Furthermore, it reads data with a SAX parser that recovers from every error
+and checks that the events are balanced, that reading ends, and that it
+reports an error exactly when from_msgpack() fails (see #3989).
+
 The provided function `LLVMFuzzerTestOneInput` can be used in different fuzzer
 drivers.
 */
@@ -29,6 +33,8 @@ drivers.
    #error "the fuzzer drivers must be built without NDEBUG"
 #endif

+#include "fuzzer-recovering_checker.hpp"
+
 using json = nlohmann::json;

 // compares dumps rather than values, because NaN != NaN; keep writes strings
@@ -41,6 +47,9 @@ static bool same_value(const json& lhs, const json& rhs)
 // see http://llvm.org/docs/LibFuzzer.html
 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
 {
+    // recover from all errors, reading from memory and from a stream
+    const bool recovered_without_errors = check_recovering_parse(data, size, json::input_format_t::msgpack).errors == 0;
+
    std::vector<uint8_t> const vec1(data, data + size);

    // step 0: parse input without exceptions; a parse error must then be
@@ -73,6 +82,9 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
        // without exceptions, the same input must give the same value
        assert(!noexcept_threw && !j_noexcept.is_discarded() && same_value(j_noexcept, j1));

+        // the recovering parser must not have reported an error either
+        assert(recovered_without_errors);
+
        try
        {
            // step 2: round trip
@@ -94,6 +106,7 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
    {
        // parse errors are ok, because input may be random bytes
        assert(parsed || noexcept_threw || j_noexcept.is_discarded());
+        assert(parsed || !recovered_without_errors);
    }
    catch (const json::type_error&)
    {
@@ -104,6 +117,7 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
    {
        // out of range errors may happen if provided sizes are excessive
        assert(parsed || noexcept_threw || j_noexcept.is_discarded());
+        assert(parsed || !recovered_without_errors);
    }

    // return 0 - non-zero return values are reserved for future use
@@ -26,6 +26,10 @@ array data, it performs the following steps:
 The unit tests run the same checks on a fixed corpus (see the "UBJSON round-trip
 invariants" test case), so keep both in sync.

+Furthermore, it reads data with a SAX parser that recovers from every error
+and checks that the events are balanced, that reading ends, and that it
+reports an error exactly when from_ubjson() fails (see #3989).
+
 The provided function `LLVMFuzzerTestOneInput` can be used in different fuzzer
 drivers.
 */
@@ -38,6 +42,8 @@ drivers.
    #error "the fuzzer drivers must be built without NDEBUG"
 #endif

+#include "fuzzer-recovering_checker.hpp"
+
 using json = nlohmann::json;

 // compares dumps rather than values, because NaN != NaN; keep writes strings
@@ -50,6 +56,9 @@ static bool same_value(const json& lhs, const json& rhs)
 // see http://llvm.org/docs/LibFuzzer.html
 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
 {
+    // recover from all errors, reading from memory and from a stream
+    const bool recovered_without_errors = check_recovering_parse(data, size, json::input_format_t::ubjson).errors == 0;
+
    std::vector<uint8_t> const vec1(data, data + size);

    // step 0: parse input without exceptions; a parse error must then be
@@ -82,6 +91,9 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
        // without exceptions, the same input must give the same value
        assert(!noexcept_threw && !j_noexcept.is_discarded() && same_value(j_noexcept, j1));

+        // the recovering parser must not have reported an error either
+        assert(recovered_without_errors);
+
        try
        {
            // step 2.1: round trip without adding size annotations to container types
@@ -113,6 +125,7 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
    {
        // parse errors are ok, because input may be random bytes
        assert(parsed || noexcept_threw || j_noexcept.is_discarded());
+        assert(parsed || !recovered_without_errors);
    }
    catch (const json::type_error&)
    {
@@ -123,6 +136,7 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
    {
        // out of range errors may happen if provided sizes are excessive
        assert(parsed || noexcept_threw || j_noexcept.is_discarded());
+        assert(parsed || !recovered_without_errors);
    }

    // return 0 - non-zero return values are reserved for future use
@@ -0,0 +1,154 @@
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  JSON for Modern C++ (supporting code)
+// |  |  |__   |  |  | | | |  version 3.12.0
+// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
+//
+// SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
+// SPDX-License-Identifier: MIT
+
+#pragma once
+
+#include <cassert>
+#include <cstddef>
+#include <cstdint>
+#include <sstream>
+#include <string>
+#include <vector>
+#include <nlohmann/json.hpp>
+
+namespace
+{
+// a SAX parser that recovers from every error and checks that the events are
+// balanced and that every key is followed by exactly one value
+class recovering_checker : public nlohmann::json_sax<nlohmann::json>
+{
+  public:
+    bool null() override
+    {
+        return value();
+    }
+
+    bool boolean(bool /*val*/) override
+    {
+        return value();
+    }
+
+    bool number_integer(number_integer_t /*val*/) override
+    {
+        return value();
+    }
+
+    bool number_unsigned(number_unsigned_t /*val*/) override
+    {
+        return value();
+    }
+
+    bool number_float(number_float_t /*val*/, const string_t& /*s*/) override
+    {
+        return value();
+    }
+
+    bool string(string_t& /*val*/) override
+    {
+        return value();
+    }
+
+    bool binary(binary_t& /*val*/) override
+    {
+        return value();
+    }
+
+    bool start_object(std::size_t /*elements*/) override
+    {
+        value();
+        stack.push_back('o');
+        return true;
+    }
+
+    bool key(string_t& /*val*/) override
+    {
+        ++events;
+        assert(!stack.empty() && stack.back() == 'o');
+        stack.back() = 'v';
+        return true;
+    }
+
+    bool end_object() override
+    {
+        ++events;
+        assert(!stack.empty() && stack.back() == 'o');
+        stack.pop_back();
+        return true;
+    }
+
+    bool start_array(std::size_t /*elements*/) override
+    {
+        value();
+        stack.push_back('a');
+        return true;
+    }
+
+    bool end_array() override
+    {
+        ++events;
+        assert(!stack.empty() && stack.back() == 'a');
+        stack.pop_back();
+        return true;
+    }
+
+    bool parse_error(std::size_t /*position*/, const std::string& /*last_token*/, const nlohmann::detail::exception& /*ex*/) override
+    {
+        ++errors;
+        return true;
+    }
+
+    bool complete() const
+    {
+        return stack.empty();
+    }
+
+    std::size_t events = 0;
+    std::size_t errors = 0;
+
+  private:
+    bool value()
+    {
+        ++events;
+        if (!stack.empty())
+        {
+            // an array element, or the value of a key
+            assert(stack.back() != 'o');
+            if (stack.back() == 'v')
+            {
+                stack.back() = 'o';
+            }
+        }
+        return true;
+    }
+
+    // 'a' for an array, 'o' for an object that expects a key, 'v' for an
+    // object that expects the value of a key
+    std::vector<char> stack {}; // NOLINT(readability-redundant-member-init)
+};
+
+/// parses @a data with a recovering_checker from memory and from a stream,
+/// checks that both see the same, that the events are balanced, and that the
+/// number of errors is bounded, and returns the checker (see #3989)
+inline recovering_checker check_recovering_parse(const std::uint8_t* data, const std::size_t size, const nlohmann::json::input_format_t format)
+{
+    recovering_checker checker;
+    const bool ok = nlohmann::json::sax_parse(data, data + size, &checker, format);
+    assert(checker.complete());
+    assert(checker.errors <= size + 1);
+    assert(ok == (checker.errors == 0));
+
+    std::istringstream stream(std::string(reinterpret_cast<const char*>(data), size));
+    recovering_checker stream_checker;
+    assert(nlohmann::json::sax_parse(stream, &stream_checker, format) == ok);
+    assert(stream_checker.complete());
+    assert(stream_checker.events == checker.events);
+    assert(stream_checker.errors == checker.errors);
+
+    return checker;
+}
+} // namespace
@@ -1,98 +0,0 @@
-//     __ _____ _____ _____
-//  __|  |   __|     |   | |  JSON for Modern C++ (supporting code)
-// |  |  |__   |  |  | | | |  version 3.12.0
-// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
-//
-// SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
-// SPDX-License-Identifier: MIT
-
-// This file contains the C++17-only part of unit-allocator.cpp (std::string_view key
-// lookup with a failing allocator). It is kept in a separate translation unit so the (much
-// larger) unit-allocator.cpp is built for C++11 only and not rebuilt for every C++
-// standard.
-
-#include "doctest_compatibility.h"
-
-#include <nlohmann/json.hpp>
-
-#ifdef JSON_HAS_CPP_17
-#include <memory>
-#include <new>
-#include <string_view>
-#include <utility>
-
-namespace
-{
-bool next_construct_fails_cpp17 = false;
-bool next_destroy_fails_cpp17 = false;
-bool next_deallocate_fails_cpp17 = false;
-
-template<class T>
-struct my_allocator_cpp17 : std::allocator<T>
-{
-    using std::allocator<T>::allocator;
-
-    template<class... Args>
-    void construct(T* p, Args&& ... args)
-    {
-        if (next_construct_fails_cpp17)
-        {
-            next_construct_fails_cpp17 = false;
-            throw std::bad_alloc();
-        }
-
-        ::new (reinterpret_cast<void*>(p)) T(std::forward<Args>(args)...);
-    }
-
-    void deallocate(T* p, std::size_t n)
-    {
-        if (next_deallocate_fails_cpp17)
-        {
-            next_deallocate_fails_cpp17 = false;
-            throw std::bad_alloc();
-        }
-
-        std::allocator<T>::deallocate(p, n);
-    }
-
-    void destroy(T* p)
-    {
-        if (next_destroy_fails_cpp17)
-        {
-            next_destroy_fails_cpp17 = false;
-            throw std::bad_alloc();
-        }
-
-        static_cast<void>(p); // fix MSVC's C4100 warning
-        p->~T();
-    }
-
-    template <class U>
-    struct rebind
-    {
-        using other = my_allocator_cpp17<U>;
-    };
-};
-} // namespace
-
-// the no-exceptions CI job skips every CHECK_THROWS_AS, which would leave
-// next_construct_fails_cpp17 set for the next allocation outside a check
-#if !defined(JSON_NOEXCEPTION)
-TEST_CASE("a failed allocation leaves the value unchanged (C++17)")
-{
-    // create JSON type using the throwing allocator
-    using my_json = nlohmann::json::with_allocator_t<my_allocator_cpp17>;
-
-    SECTION("turning a null value into an array or object")
-    {
-        my_json j;
-
-        next_construct_fails_cpp17 = true;
-        CHECK_THROWS_AS(j[std::string_view("key")], std::bad_alloc&);
-        CHECK(j.is_null());
-
-        next_construct_fails_cpp17 = false;
-    }
-}
-#endif
-#endif
@@ -1,115 +0,0 @@
-//     __ _____ _____ _____
-//  __|  |   __|     |   | |  JSON for Modern C++ (supporting code)
-// |  |  |__   |  |  | | | |  version 3.12.0
-// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
-//
-// SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
-// SPDX-License-Identifier: MIT
-
-// This file contains the C++20-only part of unit-allocator.cpp (creating a value from a
-// std::ranges view with a failing allocator). It is kept in a separate translation unit so
-// the (much larger) unit-allocator.cpp is built for C++11 only and not rebuilt for every
-// C++ standard.
-
-#include "doctest_compatibility.h"
-
-#include <nlohmann/json.hpp>
-
-#ifdef JSON_HAS_CPP_20
-#if JSON_HAS_RANGES
-    #include <ranges>
-#endif
-
-#include <memory>
-#include <new>
-#include <utility>
-#include <vector>
-
-namespace
-{
-bool next_construct_fails_cpp20 = false;
-bool next_destroy_fails_cpp20 = false;
-bool next_deallocate_fails_cpp20 = false;
-
-template<class T>
-struct my_allocator_cpp20 : std::allocator<T>
-{
-    using std::allocator<T>::allocator;
-
-    template<class... Args>
-    void construct(T* p, Args&& ... args)
-    {
-        if (next_construct_fails_cpp20)
-        {
-            next_construct_fails_cpp20 = false;
-            throw std::bad_alloc();
-        }
-
-        ::new (reinterpret_cast<void*>(p)) T(std::forward<Args>(args)...);
-    }
-
-    void deallocate(T* p, std::size_t n)
-    {
-        if (next_deallocate_fails_cpp20)
-        {
-            next_deallocate_fails_cpp20 = false;
-            throw std::bad_alloc();
-        }
-
-        std::allocator<T>::deallocate(p, n);
-    }
-
-    void destroy(T* p)
-    {
-        if (next_destroy_fails_cpp20)
-        {
-            next_destroy_fails_cpp20 = false;
-            throw std::bad_alloc();
-        }
-
-        static_cast<void>(p); // fix MSVC's C4100 warning
-        p->~T();
-    }
-
-    template <class U>
-    struct rebind
-    {
-        using other = my_allocator_cpp20<U>;
-    };
-};
-} // namespace
-
-// the no-exceptions CI job skips every CHECK_THROWS_AS, which would leave
-// next_construct_fails_cpp20 set for the next allocation outside a check
-#if !defined(JSON_NOEXCEPTION)
-TEST_CASE("a failed allocation leaves the value unchanged (C++20)")
-{
-    // create JSON type using the throwing allocator
-    using my_json = nlohmann::json::with_allocator_t<my_allocator_cpp20>;
-
-    // With iterator debugging, VS 2015's containers construct a proxy with the
-    // allocator in constructors that cannot report its failure, so a failing
-    // allocator crashes this section there (SIGSEGV with VS 2015 Debug x86).
-#if !(defined(_MSC_VER) && _MSC_VER < 1910 && defined(_ITERATOR_DEBUG_LEVEL) && _ITERATOR_DEBUG_LEVEL > 0)
-    SECTION("converting into an existing value")
-    {
-        // to_json replaces the value it is given; the old one must survive a
-        // failed creation of the new one
-        my_json j = "old";
-
-#if JSON_HAS_RANGES && !defined(__MINGW32__)
-        const std::vector<int> numbers = {1, 2};
-        next_construct_fails_cpp20 = true;
-        CHECK_THROWS_AS(nlohmann::to_json(j, numbers | std::views::filter([](int /*unused*/)
-        {
-            return true;
-        })), std::bad_alloc&);
-        CHECK(j == "old");
-#endif
-
-        next_construct_fails_cpp20 = false;
-    }
-#endif
-}
-#endif
-#endif
@@ -13,6 +13,9 @@
 using nlohmann::json;

 #include <valarray>
+#if JSON_HAS_RANGES
+    #include <ranges>
+#endif

 namespace
 {
@@ -367,7 +370,14 @@ TEST_CASE("copy of a deeply nested value survives a failing allocation (#5640)")
 #if !(defined(_ITERATOR_DEBUG_LEVEL) && _ITERATOR_DEBUG_LEVEL > 0)
    SECTION("std::map-backed object_t")
    {
-        using bad_alloc_json = nlohmann::json::with_allocator_t<nth_alloc_fails_allocator>;
+        using bad_alloc_json = nlohmann::basic_json<std::map,
+              std::vector,
+              std::string,
+              bool,
+              std::int64_t,
+              std::uint64_t,
+              double,
+              nth_alloc_fails_allocator>;

        check_deep_copy_survives_failing_allocation<bad_alloc_json>(false);
        check_deep_copy_survives_failing_allocation<bad_alloc_json>(true);
@@ -375,7 +385,14 @@ TEST_CASE("copy of a deeply nested value survives a failing allocation (#5640)")

    SECTION("ordered_map-backed object_t")
    {
-        using bad_alloc_ordered_json = nlohmann::ordered_json::with_allocator_t<nth_alloc_fails_allocator>;
+        using bad_alloc_ordered_json = nlohmann::basic_json<nlohmann::ordered_map,
+              std::vector,
+              std::string,
+              bool,
+              std::int64_t,
+              std::uint64_t,
+              double,
+              nth_alloc_fails_allocator>;

        check_deep_copy_survives_failing_allocation<bad_alloc_ordered_json>(false);
        check_deep_copy_survives_failing_allocation<bad_alloc_ordered_json>(true);
@@ -433,7 +450,14 @@ struct scratch_counting_allocator : std::allocator<T>

 TEST_CASE("deep copy uses the provided allocator")
 {
-    using counting_json = nlohmann::json::with_allocator_t<scratch_counting_allocator>;
+    using counting_json = nlohmann::basic_json<std::map,
+          std::vector,
+          std::string,
+          bool,
+          std::int64_t,
+          std::uint64_t,
+          double,
+          scratch_counting_allocator>;

    // deeper than the 128 levels the copy constructor descends into, so the
    // innermost objects are copied by the iterative deep copy
@@ -492,7 +516,14 @@ TEST_CASE("converting a deeply nested value from another specialization fails cl
    // the allocator in noexcept constructors, so a failing construction crashes
    // the program there instead of throwing std::bad_alloc. Nothing to check.
 #if !(defined(_MSC_VER) && _MSC_VER < 1910 && defined(_ITERATOR_DEBUG_LEVEL) && _ITERATOR_DEBUG_LEVEL > 0)
-    using countdown_json = nlohmann::json::with_allocator_t<countdown_allocator>;
+    using countdown_json = nlohmann::basic_json<std::map,
+          std::vector,
+          std::string,
+          bool,
+          std::int64_t,
+          std::uint64_t,
+          double,
+          countdown_allocator>;

    // deeper than the 128 levels the converting constructor descends into, so
    // that failures land on both sides of the bound - or, built with
@@ -600,7 +631,14 @@ TEST_CASE("destructor performs no allocation, only deallocation")
    // Since that stack could itself throw bad_alloc from inside the
    // noexcept destructor (#5135), destroy() no longer allocates anything:
    // it only ever frees what is already there.
-    using counting_json = nlohmann::json::with_allocator_t<counting_allocator>;
+    using counting_json = nlohmann::basic_json<std::map,
+          std::vector,
+          std::string,
+          bool,
+          std::int64_t,
+          std::uint64_t,
+          double,
+          counting_allocator>;

    SECTION("array")
    {
@@ -645,7 +683,14 @@ TEST_CASE("destructor performs no allocation, only deallocation")
 TEST_CASE("a failed allocation leaves the value unchanged")
 {
    // create JSON type using the throwing allocator
-    using my_json = nlohmann::json::with_allocator_t<my_allocator>;
+    using my_json = nlohmann::basic_json<std::map,
+          std::vector,
+          std::string,
+          bool,
+          std::int64_t,
+          std::uint64_t,
+          double,
+          my_allocator>;

    // Each of these creates a string, array, object, or binary value. The
    // value must be created before the type is changed: otherwise, a failed
@@ -681,6 +726,12 @@ TEST_CASE("a failed allocation leaves the value unchanged")
        CHECK_THROWS_AS(j["key"], std::bad_alloc&);
        CHECK(j.is_null());

+#ifdef JSON_HAS_CPP_17
+        next_construct_fails = true;
+        CHECK_THROWS_AS(j[std::string_view("key")], std::bad_alloc&);
+        CHECK(j.is_null());
+#endif
+
        next_construct_fails = true;
        CHECK_THROWS_AS(j.push_back(my_json(1)), std::bad_alloc&);
        CHECK(j.is_null());
@@ -778,6 +829,16 @@ TEST_CASE("a failed allocation leaves the value unchanged")
        CHECK_THROWS_AS(nlohmann::to_json(j, std::valarray<int> {1, 2}), std::bad_alloc&);
        CHECK(j == "old");

+#if JSON_HAS_RANGES && !defined(__MINGW32__)
+        const std::vector<int> numbers = {1, 2};
+        next_construct_fails = true;
+        CHECK_THROWS_AS(nlohmann::to_json(j, numbers | std::views::filter([](int /*unused*/)
+        {
+            return true;
+        })), std::bad_alloc&);
+        CHECK(j == "old");
+#endif
+
        next_construct_fails = false;
        nlohmann::to_json(j, std::vector<int> {1, 2});
        CHECK(j == my_json({1, 2}));
@@ -415,6 +415,46 @@ TEST_CASE("alternative string type")
        CHECK(j2.dump() == R"({"/foo/0":"bar","/foo/1":"baz"})");
    }

+    SECTION("error recovery")
+    {
+        // a SAX parser that recovers from every error (see #3989)
+        struct recovering_parser : nlohmann::detail::json_sax_dom_parser<alt_json>
+        {
+            explicit recovering_parser(alt_json& j)
+                : nlohmann::detail::json_sax_dom_parser<alt_json>(j, false)
+            {}
+
+            // sax_parse() calls the SAX parser's own parse_error(), so hiding
+            // the one of the base class is what recovering takes
+            // NOLINTNEXTLINE(bugprone-derived-method-shadowing-base-method)
+            bool parse_error(std::size_t /*unused*/, const std::string& /*unused*/, const nlohmann::detail::exception& /*unused*/)
+            {
+                ++errors;
+                return true;
+            }
+
+            std::size_t errors = 0;
+        };
+
+        alt_json j;
+        recovering_parser sax(j);
+        // not inside CHECK(): MSVC reads the escape in a stringized raw string
+        const std::string input = R"([1., "a\qb", tru, {"k" 2}])";
+        CHECK(!alt_json::sax_parse(input, &sax));
+        CHECK(sax.errors == 4);
+        CHECK(j.dump() == R"([1,"aqb",null,{"k":2}])");
+
+        // a UBJSON high-precision number, a CBOR key that is not a string
+        alt_json u;
+        recovering_parser ubjson_sax(u);
+        CHECK(!alt_json::sax_parse(std::vector<std::uint8_t> {'[', 'H', 'i', 2, '1', '.', ']'}, &ubjson_sax, alt_json::input_format_t::ubjson));
+        CHECK(u.dump() == "[1]");
+        alt_json c;
+        recovering_parser cbor_sax(c);
+        CHECK(!alt_json::sax_parse(std::vector<std::uint8_t> {0xA2, 0x01, 0x02, 0x61, 'a', 0x03}, &cbor_sax, alt_json::input_format_t::cbor));
+        CHECK(c.dump() == R"({"a":3})");
+    }
+
    SECTION("conversion between basic_json specializations (#2649)")
    {
        // explicit conversions are always possible
@@ -237,7 +237,7 @@ namespace
 // the binary formats as function pointers for "Binary formats with narrow number types";
 // named functions rather than lambdas, because clang 3.5 cannot convert a lambda
 // to a function pointer in the braced initializer of the format table
-using narrow_json = nlohmann::json::with_integers_t<std::int32_t, std::uint32_t>::with_float_t<float>;
+using narrow_json = nlohmann::basic_json<std::map, std::vector, std::string, bool, std::int32_t, std::uint32_t, float>;
 using bytes = std::vector<std::uint8_t>;

 bytes encode_cbor(const json& j)
@@ -1,60 +0,0 @@
-//     __ _____ _____ _____
-//  __|  |   __|     |   | |  JSON for Modern C++ (supporting code)
-// |  |  |__   |  |  | | | |  version 3.12.0
-// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
-//
-// SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
-// SPDX-License-Identifier: MIT
-
-// This file contains the C++17-only part of unit-bon8.cpp (BON8 with std::byte
-// containers). It is kept in a separate translation unit so the (much larger) unit-
-// bon8.cpp is built for C++11 only and not rebuilt for every C++ standard.
-
-#include "doctest_compatibility.h"
-
-#include <nlohmann/json.hpp>
-using nlohmann::json;
-
-#ifdef JSON_HAS_CPP_17
-#include <cstddef>
-#include <cstdint>
-#include <vector>
-
-TEST_CASE("BON8 with std::byte")
-{
-    SECTION("vector roundtrip")
-    {
-        const json original =
-        {
-            {"name", "test"},
-            {"value", 42},
-            {"array", {1, 2, 3}}
-        };
-
-        const std::vector<uint8_t> temp = json::to_bon8(original);
-        std::vector<std::byte> bon8_data(temp.size());
-        for (size_t i = 0; i < temp.size(); ++i)
-        {
-            bon8_data[i] = std::byte(temp[i]);
-        }
-
-        json from_bytes;
-        CHECK_NOTHROW(from_bytes = json::from_bon8(bon8_data));
-        CHECK(from_bytes == original);
-    }
-
-    SECTION("empty vector")
-    {
-        const std::vector<std::byte> empty_data;
-        CHECK_THROWS_WITH_AS([&]()
-        {
-            [[maybe_unused]] auto result = json::from_bon8(empty_data);
-            return true;
-        }
-        (),
-        "[json.exception.parse_error.110] parse error at byte 1: syntax error while parsing BON8 value: unexpected end of input",
-        json::parse_error&);
-    }
-}
-
-#endif
@@ -1052,3 +1052,41 @@ TEST_CASE("issue #5648 - from_bon8(ptr, len) must read len bytes, not treat ptr
 #endif
 }

+#ifdef JSON_HAS_CPP_17
+TEST_CASE("BON8 with std::byte")
+{
+    SECTION("vector roundtrip")
+    {
+        const json original =
+        {
+            {"name", "test"},
+            {"value", 42},
+            {"array", {1, 2, 3}}
+        };
+
+        const std::vector<uint8_t> temp = json::to_bon8(original);
+        std::vector<std::byte> bon8_data(temp.size());
+        for (size_t i = 0; i < temp.size(); ++i)
+        {
+            bon8_data[i] = std::byte(temp[i]);
+        }
+
+        json from_bytes;
+        CHECK_NOTHROW(from_bytes = json::from_bon8(bon8_data));
+        CHECK(from_bytes == original);
+    }
+
+    SECTION("empty vector")
+    {
+        const std::vector<std::byte> empty_data;
+        CHECK_THROWS_WITH_AS([&]()
+        {
+            [[maybe_unused]] auto result = json::from_bon8(empty_data);
+            return true;
+        }
+        (),
+        "[json.exception.parse_error.110] parse error at byte 1: syntax error while parsing BON8 value: unexpected end of input",
+        json::parse_error&);
+    }
+}
+#endif
@@ -17,7 +17,6 @@ using nlohmann::json;
 #include <cstdint> // uint32_t, uint64_t
 #include <cstdlib> // strtod
 #include <cstring> // memcpy
-#include <limits> // numeric_limits
 #include <sstream> // stringstream
 #include <string> // string
 #include <utility> // pair
@@ -892,39 +891,8 @@ TEST_CASE("Eisel-Lemire float conversion")

    SECTION("128-bit products and leading zeros")
    {
-        const auto check_product = [](std::uint64_t a, std::uint64_t b)
-        {
-            const auto product = nlohmann::detail::full_multiplication(a, b);
-            CHECK(big_from(product.high, product.low) == big_mul(big_from(0, a), big_from(0, b)));
-        };
-
-        const std::uint64_t max = (std::numeric_limits<std::uint64_t>::max)();
-        const std::array<std::pair<std::uint64_t, std::uint64_t>, 13> edge_cases =
-        {
-            {
-                {0, 0},
-                {0, 1},
-                {1, 1},
-                {1, max},
-                {0xFFFFFFFFu, 0x100000000u},
-                {0x100000000u, 0x100000000u},
-                {0x100000001u, 0x100000001u},
-                {max, max},
-                {max, 2},
-                {0xFFFFFFFF00000000u, 0x100000001u},
-                {0x100000001u, 0xFFFFFFFF00000000u},
-                {max, 1},
-                {2, max},
-            }
-        };
-
-        for (const auto& test : edge_cases)
-        {
-            check_product(test.first, test.second);
-        }
-
        // whichever implementation the compiler gets (with or without a
-        // 128-bit integer type or a builtin / intrinsic)
+        // 128-bit integer type or a builtin)
        std::uint64_t state = 42;
        for (int i = 0; i < 10000; ++i)
        {
@@ -933,7 +901,8 @@ TEST_CASE("Eisel-Lemire float conversion")
            state ^= state << 17u;
            const std::uint64_t a = state;
            const std::uint64_t b = (state * 0x9E3779B97F4A7C15u) >> (i % 64);
-            check_product(a, b);
+            const auto product = nlohmann::detail::full_multiplication(a, b);
+            CHECK(big_from(product.high, product.low) == big_mul(big_from(0, a), big_from(0, b)));

            const int k = i % 64;
            const std::uint64_t x = (std::uint64_t{1} << k) | (a & ((std::uint64_t{1} << k) - 1));
@@ -143,11 +143,13 @@ class SaxEventLogger
    {
        errored = true;
        events.push_back("parse_error(" + std::to_string(position) + ")");
-        return false;
+        return recover;
    }

    std::vector<std::string> events {}; // NOLINT(readability-redundant-member-init)
    bool errored = false;
+    /// whether parse_error() asks the parser to recover from the error (see #3989)
+    bool recover = false;
 };

 class SaxCountdown : public nlohmann::json::json_sax_t
@@ -3026,3 +3028,583 @@ TEST_CASE("diagnostic positions: value lifetime, input adapters, and SAX")
    }
 }
 #endif
+
+namespace
+{
+/// builds a value like json::parse(), but asks the parser to recover from
+/// errors (see #3989), and checks that the events it receives are balanced
+class RecoveringDomParser
+{
+  public:
+    explicit RecoveringDomParser(json& j, std::size_t max_errors_ = static_cast<std::size_t>(-1))
+        : dom(j, false)
+        , max_errors(max_errors_)
+    {}
+
+    bool null()
+    {
+        value();
+        return dom.null();
+    }
+
+    bool boolean(bool val)
+    {
+        value();
+        return dom.boolean(val);
+    }
+
+    bool number_integer(json::number_integer_t val)
+    {
+        value();
+        return dom.number_integer(val);
+    }
+
+    bool number_unsigned(json::number_unsigned_t val)
+    {
+        value();
+        return dom.number_unsigned(val);
+    }
+
+    bool number_float(json::number_float_t val, const std::string& s)
+    {
+        value();
+        return dom.number_float(val, s);
+    }
+
+    bool string(std::string& val)
+    {
+        value();
+        return dom.string(val);
+    }
+
+    bool binary(json::binary_t& val)
+    {
+        value();
+        return dom.binary(val);
+    }
+
+    bool start_object(std::size_t elements)
+    {
+        value();
+        stack.push_back('o');
+        return dom.start_object(elements);
+    }
+
+    bool key(std::string& val)
+    {
+        ++events;
+        if (stack.empty() || stack.back() != 'o')
+        {
+            well_formed = false;
+            return false;
+        }
+        stack.back() = 'v';
+        return dom.key(val);
+    }
+
+    bool end_object()
+    {
+        ++events;
+        if (stack.empty() || stack.back() != 'o')
+        {
+            well_formed = false;
+            return false;
+        }
+        stack.pop_back();
+        return dom.end_object();
+    }
+
+    bool start_array(std::size_t elements)
+    {
+        value();
+        stack.push_back('a');
+        return dom.start_array(elements);
+    }
+
+    bool end_array()
+    {
+        ++events;
+        if (stack.empty() || stack.back() != 'a')
+        {
+            well_formed = false;
+            return false;
+        }
+        stack.pop_back();
+        return dom.end_array();
+    }
+
+    bool parse_error(std::size_t /*unused*/, const std::string& /*unused*/, const json::exception& ex)
+    {
+        errors.emplace_back(ex.what());
+        return errors.size() < max_errors;
+    }
+
+    /// whether the events were balanced and every key was followed by a value
+    bool balanced() const
+    {
+        return well_formed && stack.empty();
+    }
+
+    /// builds the value
+    nlohmann::detail::json_sax_dom_parser<json> dom;
+    std::vector<std::string> errors {}; // NOLINT(readability-redundant-member-init)
+    std::size_t events = 0;
+    /// the open containers: 'a' for an array, 'o' for an object that expects
+    /// a key, 'v' for an object that expects the value of a key
+    std::vector<char> stack {}; // NOLINT(readability-redundant-member-init)
+    bool well_formed = true;
+    std::size_t max_errors;
+
+  private:
+    /// a value is passed: it is an array element, or the value of a key
+    void value()
+    {
+        ++events;
+        if (!stack.empty())
+        {
+            if (stack.back() == 'v')
+            {
+                stack.back() = 'o';
+            }
+            else if (stack.back() == 'o')
+            {
+                // a value without a key
+                well_formed = false;
+            }
+        }
+    }
+
+};
+
+struct RecoveryResult
+{
+    json value;
+    std::vector<std::string> errors;
+    std::size_t events;
+    bool ok;
+    bool balanced;
+};
+
+template<typename InputType>
+RecoveryResult parse_recovering(InputType&& input, const bool strict = true,
+                                const bool ignore_comments = false, const bool ignore_trailing_commas = false)
+{
+    json j;
+    RecoveringDomParser sax(j);
+    const bool ok = json::sax_parse(std::forward<InputType>(input), &sax, json::input_format_t::json,
+                                    strict, ignore_comments, ignore_trailing_commas);
+    return {j, sax.errors, sax.events, ok, sax.balanced()};
+}
+
+/// stops after a number of events, but recovers from errors
+class RecoveringCountdown : public SaxCountdown
+{
+  public:
+    using SaxCountdown::SaxCountdown;
+
+    bool parse_error(std::size_t /*position*/, const std::string& /*last_token*/, const json::exception& /*ex*/) override
+    {
+        return true;
+    }
+};
+
+/// a repaired input: the value it is repaired to, and the number of errors
+struct Repair
+{
+    const char* input;
+    const char* expected;
+    std::size_t errors;
+};
+} // namespace
+
+TEST_CASE("parser error recovery (#3989)")
+{
+    SECTION("repairs")
+    {
+        const std::vector<Repair> repairs =
+        {
+            // a missing separator is inserted
+            {"[1 2]", "[1,2]", 1},
+            {R"({"a":1 "b":2})", R"({"a":1,"b":2})", 1},
+            {R"({"a" 1})", R"({"a":1})", 1},
+            {"[1 tru 2]", "[1,null,2]", 2},
+            {R"({"a" "b": 1})", R"({"a":"b"})", 2},
+
+            // a missing value is null in an object; in an array, a ',' stands
+            // for null, while an array that ends there just ends
+            {R"({"a":})", R"({"a":null})", 1},
+            {R"({"a"})", R"({"a":null})", 1},
+            {R"({"a","b":1})", R"({"a":null,"b":1})", 1},
+            {"[1,,2]", "[1,null,2]", 1},
+            {"[,1]", "[null,1]", 1},
+            {"[1,]", "[1]", 1},
+            {"[1,2,3,]", "[1,2,3]", 1},
+            {R"({"a":1,})", R"({"a":1})", 1},
+
+            // a broken string keeps what can be read
+            {R"(["a\qb"])", R"(["aqb"])", 1},
+            {R"({"na\me":1})", R"({"name":1})", 1},
+            {"[\"\xFF\"]", R"(["\uFFFD"])", 1},
+            {"[\"a\xC3(\"]", R"(["a\uFFFD("])", 1},
+            {"[\"\xE2\x82\"]", R"(["\uFFFD"])", 1},
+            {"[\"\xC3\\\\\", 1]", R"(["\uFFFD\\",1])", 1},
+            {R"(["\u12"])", R"(["\uFFFD"])", 1},
+            {R"(["\u12G4"])", R"(["\uFFFDG4"])", 1},
+            {R"(["\uDC00x"])", R"(["\uFFFDx"])", 1},
+            {R"(["\uD800x"])", R"(["\uFFFDx"])", 1},
+            {R"(["\uD800\u0041"])", R"(["\uFFFDA"])", 1},
+            {R"(["\uD800\uD800\uDC00"])", R"(["\uFFFD\uD800\uDC00"])", 1},
+            {R"(["\uD800\uD800\uD800x"])", R"(["\uFFFD\uFFFD\uFFFDx"])", 1},
+            {
+                R"(["\uD800\"x", 1])", R"(["\uFFFD\"x",1])", 1
+            },
+            {R"(["\uD800\q"])", R"(["\uFFFDq"])", 1},
+            {"[\"a\tb\"]", R"(["a\tb"])", 1},
+            {R"(["a\qb\u0041\x"])", R"(["aqbAx"])", 1},
+
+            // a broken number keeps its longest valid prefix
+            {"[1.]", "[1]", 1},
+            {"[-2.]", "[-2]", 1},
+            {"[1.5e]", "[1.5]", 1},
+            {"[1e+]", "[1]", 1},
+            {"[1.x2, 3]", "[1,3]", 1},
+
+            // what cannot be read at all is null
+            {"[1,NaN,3]", "[1,null,3]", 1},
+            {"[tru]", "[null]", 1},
+            {"[-]", "[null]", 1},
+            {R"({"a":Infinity})", R"({"a":null})", 1},
+
+            // a stray token is dropped
+            {"[:1]", "[1]", 1},
+            {R"(["a":1])", R"(["a",1])", 1},
+            {R"({"a"::1})", R"({"a":1})", 1},
+
+            // a member that cannot be read is skipped
+            {R"({1:2,"b":3})", R"({"b":3})", 1},
+            {R"({"a":1 2})", R"({"a":1})", 1},
+            {R"({,"a":1})", R"({"a":1})", 1},
+            {R"({"a":1,,"b":2})", R"({"a":1,"b":2})", 1},
+            {"{a:1}", "{}", 1},
+            {R"({"a":1 [1,{"b":2}], "c":3})", R"({"a":1,"c":3})", 1},
+            {R"([{1}, "a"])", R"([{},"a"])", 1},
+
+            // a wrong closing bracket closes the innermost container
+            {R"({"a":[1,2}, "b":3})", R"({"a":[1,2],"b":3})", 1},
+            {R"([{"a":1], 2])", R"([{"a":1},2])", 1},
+            {"{]", "{}", 1},
+            {"[}", "[]", 1},
+
+            // the end of the input closes all containers
+            {R"({"a":[1,2)", R"({"a":[1,2]})", 1},
+            {"[", "[]", 1},
+            {"{", "{}", 1},
+            {R"({"a")", R"({"a":null})", 1},
+            {R"({"a":)", R"({"a":null})", 1},
+            {"[1,", "[1]", 1},
+            {"[[[1", "[[[1]]]", 1},
+            {
+                R"(["abc)", R"(["abc"])", 2
+            },
+            {"[1,tr", "[1,null]", 2},
+            {"\"abc", "\"abc\"", 1},
+            {"[\"ab\ncd\"]", R"(["ab",null,"]"])", 4},
+
+            // what comes before the top-level value is skipped
+            {")]}'\n{\"a\":1}", R"({"a":1})", 1},
+            {R"(data: {"a":1})", R"({"a":1})", 1},
+            {"\xEF\xBB[1]", "[1]", 1},
+
+            // what comes after it is an error that ends parsing
+            {R"({"a":1}})", R"({"a":1})", 1},
+            {"[1}]", "[1]", 2},
+            {"[1] [2]", "[1]", 1},
+        };
+
+        for (const auto& repair : repairs)
+        {
+            CAPTURE(repair.input)
+            const auto result = parse_recovering(std::string(repair.input));
+            CHECK(!result.ok);
+            CHECK(result.balanced);
+            CHECK(result.value == json::parse(repair.expected));
+            CHECK(result.errors.size() == repair.errors);
+        }
+    }
+
+    SECTION("number overflow")
+    {
+        const auto result = parse_recovering(std::string("[1e999,-1e999]"));
+        CHECK(!result.ok);
+        CHECK(result.balanced);
+        CHECK(result.errors.size() == 2);
+        CHECK(result.errors[0] == "[json.exception.out_of_range.406] number overflow parsing '1e999'");
+        REQUIRE(result.value.size() == 2);
+        CHECK(result.value[0].is_number_float());
+        CHECK(result.value[0].get<double>() == std::numeric_limits<double>::infinity());
+        CHECK(result.value[1].get<double>() == -std::numeric_limits<double>::infinity());
+
+        // the SAX parser gets the number's text
+        SaxEventLogger logger;
+        logger.recover = true;
+        CHECK(!json::sax_parse("1e999", &logger));
+        CHECK(logger.events == std::vector<std::string>({"parse_error(5)", "number_float(1e999)"}));
+    }
+
+    SECTION("nothing to recover")
+    {
+        for (const std::string s :
+                {
+                    "", "   ", "]", "tru", "NaN", ",:", "/* comment"
+                })
+        {
+            CAPTURE(s)
+            const auto result = parse_recovering(s, true, true);
+            CHECK(!result.ok);
+            CHECK(result.balanced);
+            CHECK(result.events == 0);
+            CHECK(result.value == nullptr);
+            CHECK(result.errors.size() == 1);
+        }
+    }
+
+    SECTION("error messages")
+    {
+        // the first error is reported as without recovery
+        for (const std::string s :
+                {
+                    "[1 2]", R"({"a":1 "b":2})", R"({"a" 1})", R"({"a":})", "[1,]", "[1.]",
+                    R"(["a\qb"])", "[1e999]", "{1:2}", R"({"a":[1,2}})", "[1,", "[1] [2]", "{a:1}"
+                })
+        {
+            CAPTURE(s)
+            const auto result = parse_recovering(s);
+            REQUIRE(!result.errors.empty());
+            json _;
+            CHECK_THROWS_WITH_STD_STR(_ = json::parse(s), result.errors.front());
+        }
+
+        // the token of an error begins where the previous error was
+        const auto result = parse_recovering(std::string("[tru, fals, nul]"));
+        CHECK(result.errors == std::vector<std::string>(
+        {
+            "[json.exception.parse_error.101] parse error at line 1, column 5: syntax error while parsing value - invalid literal; last read: '[tru,'",
+            "[json.exception.parse_error.101] parse error at line 1, column 11: syntax error while parsing value - invalid literal; last read: ', fals,'",
+            "[json.exception.parse_error.101] parse error at line 1, column 16: syntax error while parsing value - invalid literal; last read: ', nul]'"
+        }));
+        CHECK(result.value == json::parse("[null,null,null]"));
+    }
+
+    SECTION("events")
+    {
+        // see #4522
+        SaxEventLogger logger;
+        logger.recover = true;
+        CHECK(!json::sax_parse(R"([{1}, "a"])", &logger));
+        CHECK(logger.events == std::vector<std::string>(
+        {
+            "start_array()", "start_object()", "parse_error(3)", "end_object()", "string(a)", "end_array()"
+        }));
+    }
+
+    SECTION("options")
+    {
+        SECTION("strict")
+        {
+            const auto result = parse_recovering(std::string("[1 2] [3]"), false);
+            CHECK(!result.ok);
+            CHECK(result.value == json::parse("[1,2]"));
+            CHECK(result.errors.size() == 1);
+        }
+
+        SECTION("ignore_trailing_commas")
+        {
+            for (const std::string s :
+                    {
+                        "[1,]", R"({"a":1,})", "[[1,],]"
+                    })
+            {
+                CAPTURE(s)
+                const auto result = parse_recovering(s, true, false, true);
+                CHECK(result.ok);
+                CHECK(result.errors.empty());
+            }
+
+            auto result = parse_recovering(std::string("[1,,]"), true, false, true);
+            CHECK(result.value == json::parse("[1,null]"));
+            CHECK(result.errors.size() == 1);
+
+            result = parse_recovering(std::string(R"({"a":1,,})"), true, false, true);
+            CHECK(result.value == json::parse(R"({"a":1})"));
+            CHECK(result.errors.size() == 1);
+        }
+
+        SECTION("ignore_comments")
+        {
+            auto result = parse_recovering(std::string("[1 /* one */ 2]"), true, true);
+            CHECK(result.value == json::parse("[1,2]"));
+            CHECK(result.errors.size() == 1);
+
+            // a comment that is not closed runs to the end of the input, which
+            // is not reported again
+            result = parse_recovering(std::string("[1, 2 /* unterminated"), true, true);
+            CHECK(result.balanced);
+            CHECK(result.value == json::parse("[1,2]"));
+            CHECK(result.errors.size() == 1);
+
+            // a '/' that does not begin a comment is garbage
+            result = parse_recovering(std::string("[1, /x, 2]"), true, true);
+            CHECK(result.balanced);
+            CHECK(result.value == json::parse("[1,null,2]"));
+            CHECK(result.errors.size() == 1);
+        }
+    }
+
+    SECTION("null bytes")
+    {
+        // a null byte ends the input, unless JSON_STRICT_NUL_HANDLING is set
+        const auto result = parse_recovering(std::string("[1,\0x", 5));
+        CHECK(result.balanced);
+        CHECK(!result.ok);
+#ifdef JSON_TEST_STRICT_NUL_HANDLING_ENABLED
+        CHECK(result.value == json::parse("[1,null]"));
+#else
+        CHECK(result.value == json::parse("[1]"));
+        CHECK(result.errors.size() == 1);
+#endif
+
+        const auto in_string = parse_recovering(std::string("[\"a\0b\"]", 7));
+        CHECK(in_string.balanced);
+#ifdef JSON_TEST_STRICT_NUL_HANDLING_ENABLED
+        CHECK(in_string.value == json::array({std::string("a\0b", 3)}));
+#else
+        CHECK(in_string.value == json::parse(R"(["a"])"));
+#endif
+    }
+
+    SECTION("the SAX parser stops recovering")
+    {
+        json j;
+        RecoveringDomParser sax(j, 2);
+        CHECK(!json::sax_parse("[1 2 3 4 5]", &sax));
+        CHECK(sax.errors.size() == 2);
+
+        // an error at a delimiter that an invalid token consumed is reported
+        // to the SAX parser, too
+        json j2;
+        RecoveringDomParser sax2(j2, 2);
+        CHECK(!json::sax_parse("[tru}, 1]", &sax2));
+        CHECK(sax2.errors.size() == 2);
+    }
+
+    SECTION("an event stops parsing during a repair")
+    {
+        // start_object() and key() are passed, then null() for the missing
+        // value returns false
+        RecoveringCountdown countdown(2);
+        CHECK(!json::sax_parse(R"({"a":})", &countdown));
+
+        // the end of the input: end_array() for the second array returns false
+        RecoveringCountdown countdown2(4);
+        CHECK(!json::sax_parse("[[1", &countdown2));
+    }
+
+    SECTION("input adapters")
+    {
+        // the lexer reads contiguous and streaming input differently, and it
+        // puts back a character that ended an invalid token
+        for (const std::string s :
+                {
+                    "[1 2]", "[tru}, 1]", R"({"a" "b\q", "c":[1.x, 2}})", "[\"\xFF\xC3(\", -, 1e+]", "{a:1,\"b\":2", ")]}' [1]"
+                })
+        {
+            CAPTURE(s)
+            const auto reference = parse_recovering(s);
+            CHECK(reference.balanced);
+
+            const auto from_c_string = parse_recovering(s.c_str());
+            CHECK(from_c_string.value == reference.value);
+            CHECK(from_c_string.errors == reference.errors);
+
+            const std::list<char> l(s.begin(), s.end());
+            json j;
+            RecoveringDomParser sax(j);
+            CHECK(!json::sax_parse(l.begin(), l.end(), &sax));
+            CHECK(j == reference.value);
+            CHECK(sax.errors == reference.errors);
+
+            std::istringstream ss(s);
+            const auto from_stream = parse_recovering(ss);
+            CHECK(from_stream.value == reference.value);
+            CHECK(from_stream.errors == reference.errors);
+        }
+    }
+
+    SECTION("long runs of errors")
+    {
+        // no error may copy all the input read before it
+        const auto closing = parse_recovering("[" + std::string(100000, '}'));
+        CHECK(closing.balanced);
+        CHECK(closing.value == json::array());
+
+        const auto garbage = parse_recovering("[" + std::string(100000, 'x') + "]");
+        CHECK(garbage.balanced);
+        CHECK(garbage.errors.size() == 1);
+
+        const auto commas = parse_recovering("{" + std::string(100000, ',') + "}");
+        CHECK(commas.balanced);
+        CHECK(commas.value == json::object());
+    }
+
+    SECTION("mutations of valid input")
+    {
+        // whatever the input, the events are balanced, every error is reported
+        // at most once, and valid input is parsed as usual
+        const std::vector<std::string> documents =
+        {
+            R"({"name": "value", "list": [1, -2.5, true, null, {"x": [[]]}], "e": "\u00e9"})",
+            R"([{"a": [1, 2, {"b": "c"}]}, [], {}, "\ud83d\ude00", 1e10])",
+            "{\"\xC3\xA9\": \"\xF0\x9F\x98\x80\"}",
+            R"(  {"k" : [ "v" , 0 ] }  )",
+        };
+        // each character that can be inserted, including a null byte
+        const std::string insertions("[]{},:\"x\\\0\xFF", 11);
+
+        std::vector<std::string> inputs;
+        for (const auto& doc : documents)
+        {
+            for (std::size_t i = 0; i <= doc.size(); ++i)
+            {
+                inputs.push_back(doc.substr(0, i));
+                if (i < doc.size())
+                {
+                    inputs.push_back(doc.substr(0, i) + doc.substr(i + 1));
+                }
+                for (const char c : insertions)
+                {
+                    inputs.push_back(doc.substr(0, i) + c + doc.substr(i));
+                }
+            }
+        }
+
+        for (const auto& s : inputs)
+        {
+            CAPTURE(s)
+            const auto result = parse_recovering(s);
+            CHECK(result.balanced);
+            CHECK(result.errors.size() <= s.size() + 1);
+            CHECK(result.events <= (4 * s.size()) + 4);
+            if (json::accept(s))
+            {
+                CHECK(result.ok);
+                CHECK(result.errors.empty());
+                CHECK(result.value == json::parse(s));
+            }
+            else
+            {
+                CHECK(!result.ok);
+                CHECK(!result.errors.empty());
+            }
+        }
+    }
+}
@@ -1,496 +0,0 @@
-//     __ _____ _____ _____
-//  __|  |   __|     |   | |  JSON for Modern C++ (supporting code)
-// |  |  |__   |  |  | | | |  version 3.12.0
-// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
-//
-// SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
-// SPDX-License-Identifier: MIT
-
-// This file contains the C++20-only part of unit-comparison.cpp (tests of operator<=> and
-// other three-way comparison specific behavior). It is kept in a separate translation unit
-// so the (much larger) unit-comparison.cpp is built for C++11 only and not rebuilt for
-// every C++ standard.
-
-#include "doctest_compatibility.h"
-
-#include <nlohmann/json.hpp>
-using nlohmann::json;
-
-#ifdef JSON_HAS_CPP_20
-#if JSON_HAS_THREE_WAY_COMPARISON
-#include <cmath>
-#include <compare>
-#include <cstddef>
-#include <limits>
-#include <string>
-#include <utility>
-#include <vector>
-
-// this can be replaced with the doctest stl extension header in version 2.5
-namespace doctest
-{
-template<> struct StringMaker<std::partial_ordering>
-{
-    static String convert(const std::partial_ordering& order)
-    {
-        if (order == std::partial_ordering::less)
-        {
-            return "std::partial_ordering::less";
-        }
-        if (order == std::partial_ordering::equivalent)
-        {
-            return "std::partial_ordering::equivalent";
-        }
-        if (order == std::partial_ordering::greater)
-        {
-            return "std::partial_ordering::greater";
-        }
-        if (order == std::partial_ordering::unordered)
-        {
-            return "std::partial_ordering::unordered";
-        }
-        return "{?}";
-    }
-};
-} // namespace doctest
-
-TEST_CASE("lexicographical comparison operators (C++20)")
-{
-    constexpr auto f_ = false;
-    constexpr auto _t = true;
-    constexpr auto nan = std::numeric_limits<json::number_float_t>::quiet_NaN();
-    constexpr auto lt = std::partial_ordering::less;
-    constexpr auto gt = std::partial_ordering::greater;
-    constexpr auto eq = std::partial_ordering::equivalent;
-    constexpr auto un = std::partial_ordering::unordered;
-
-    INFO("using 3-way comparison");
-
-#if JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON
-    INFO("using legacy comparison");
-#endif
-
-    SECTION("types")
-    {
-        std::vector<json::value_t> j_types =
-        {
-            json::value_t::null,
-            json::value_t::boolean,
-            json::value_t::number_integer,
-            json::value_t::number_unsigned,
-            json::value_t::number_float,
-            json::value_t::object,
-            json::value_t::array,
-            json::value_t::string,
-            json::value_t::binary,
-            json::value_t::discarded
-        };
-
-        std::vector<std::vector<bool>> expected_lt =
-        {
-            //0   1   2   3   4   5   6   7   8   9
-            {f_, _t, _t, _t, _t, _t, _t, _t, _t, f_}, //  0
-            {f_, f_, _t, _t, _t, _t, _t, _t, _t, f_}, //  1
-            {f_, f_, f_, f_, f_, _t, _t, _t, _t, f_}, //  2
-            {f_, f_, f_, f_, f_, _t, _t, _t, _t, f_}, //  3
-            {f_, f_, f_, f_, f_, _t, _t, _t, _t, f_}, //  4
-            {f_, f_, f_, f_, f_, f_, _t, _t, _t, f_}, //  5
-            {f_, f_, f_, f_, f_, f_, f_, _t, _t, f_}, //  6
-            {f_, f_, f_, f_, f_, f_, f_, f_, _t, f_}, //  7
-            {f_, f_, f_, f_, f_, f_, f_, f_, f_, f_}, //  8
-            {f_, f_, f_, f_, f_, f_, f_, f_, f_, f_}, //  9
-        };
-
-        SECTION("comparison: less")
-        {
-            for (size_t i = 0; i < j_types.size(); ++i)
-            {
-                for (size_t j = 0; j < j_types.size(); ++j)
-                {
-                    CAPTURE(i)
-                    CAPTURE(j)
-                    // check precomputed values
-                    CHECK((j_types[i] < j_types[j]) == expected_lt[i][j]);
-                }
-            }
-        }
-
-        SECTION("comparison: 3-way")
-        {
-            // doctest runs the REQUIRE in the test case body once per leaf section; keep it
-            // here to run it as often as before the 3-way sections moved from unit-comparison.cpp
-            REQUIRE(std::isnan(nan));
-
-            std::vector<std::vector<std::partial_ordering>> expected =
-            {
-                //0   1   2   3   4   5   6   7   8   9
-                {eq, lt, lt, lt, lt, lt, lt, lt, lt, un}, //  0
-                {gt, eq, lt, lt, lt, lt, lt, lt, lt, un}, //  1
-                {gt, gt, eq, eq, eq, lt, lt, lt, lt, un}, //  2
-                {gt, gt, eq, eq, eq, lt, lt, lt, lt, un}, //  3
-                {gt, gt, eq, eq, eq, lt, lt, lt, lt, un}, //  4
-                {gt, gt, gt, gt, gt, eq, lt, lt, lt, un}, //  5
-                {gt, gt, gt, gt, gt, gt, eq, lt, lt, un}, //  6
-                {gt, gt, gt, gt, gt, gt, gt, eq, lt, un}, //  7
-                {gt, gt, gt, gt, gt, gt, gt, gt, eq, un}, //  8
-                {un, un, un, un, un, un, un, un, un, un}, //  9
-            };
-
-            // check expected partial_ordering against expected boolean
-            REQUIRE(expected.size() == expected_lt.size());
-            for (size_t i = 0; i < expected.size(); ++i)
-            {
-                REQUIRE(expected[i].size() == expected_lt[i].size());
-                for (size_t j = 0; j < expected[i].size(); ++j)
-                {
-                    CAPTURE(i)
-                    CAPTURE(j)
-                    CHECK(std::is_lt(expected[i][j]) == expected_lt[i][j]);
-                }
-            }
-
-            // check 3-way comparison against expected partial_ordering
-            REQUIRE(expected.size() == j_types.size());
-            for (size_t i = 0; i < j_types.size(); ++i)
-            {
-                REQUIRE(expected[i].size() == j_types.size());
-                for (size_t j = 0; j < j_types.size(); ++j)
-                {
-                    CAPTURE(i)
-                    CAPTURE(j)
-                    CHECK((j_types[i] <=> j_types[j]) == expected[i][j]); // *NOPAD*
-                }
-            }
-        }
-    }
-
-    SECTION("values")
-    {
-        json j_values =
-        {
-            nullptr, nullptr,                                              // 0 1
-            -17, 42,                                                       // 2 3
-            8u, 13u,                                                       // 4 5
-            3.14159, 23.42,                                                // 6 7
-            nan, nan,                                                      // 8 9
-            "foo", "bar",                                                  // 10 11
-            true, false,                                                   // 12 13
-            {1, 2, 3}, {"one", "two", "three"},                            // 14 15
-            {{"first", 1}, {"second", 2}}, {{"a", "A"}, {"b", {"B"}}},     // 16 17
-            json::binary({1, 2, 3}), json::binary({1, 2, 4}),              // 18 19
-            json(json::value_t::discarded), json(json::value_t::discarded) // 20 21
-        };
-
-        std::vector<std::vector<bool>> expected_eq =
-        {
-            //0   1   2   3   4   5   6   7   8   9  10  11  12  13  14  15  16  17  18  19  20  21
-            {_t, _t, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_}, //  0
-            {_t, _t, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_}, //  1
-            {f_, f_, _t, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_}, //  2
-            {f_, f_, f_, _t, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_}, //  3
-            {f_, f_, f_, f_, _t, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_}, //  4
-            {f_, f_, f_, f_, f_, _t, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_}, //  5
-            {f_, f_, f_, f_, f_, f_, _t, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_}, //  6
-            {f_, f_, f_, f_, f_, f_, f_, _t, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_}, //  7
-            {f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_}, //  8
-            {f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_}, //  9
-            {f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, _t, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_}, // 10
-            {f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, _t, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_}, // 11
-            {f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, _t, f_, f_, f_, f_, f_, f_, f_, f_, f_}, // 12
-            {f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, _t, f_, f_, f_, f_, f_, f_, f_, f_}, // 13
-            {f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, _t, f_, f_, f_, f_, f_, f_, f_}, // 14
-            {f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, _t, f_, f_, f_, f_, f_, f_}, // 15
-            {f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, _t, f_, f_, f_, f_, f_}, // 16
-            {f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, _t, f_, f_, f_, f_}, // 17
-            {f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, _t, f_, f_, f_}, // 18
-            {f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, _t, f_, f_}, // 19
-            {f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_}, // 20
-            {f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_}, // 21
-        };
-
-        std::vector<std::vector<bool>> expected_lt =
-        {
-            //0   1   2   3   4   5   6   7   8   9  10  11  12  13  14  15  16  17  18  19  20  21
-            {f_, f_, _t, _t, _t, _t, _t, _t, _t, _t, _t, _t, _t, _t, _t, _t, _t, _t, _t, _t, f_, f_}, //  0
-            {f_, f_, _t, _t, _t, _t, _t, _t, _t, _t, _t, _t, _t, _t, _t, _t, _t, _t, _t, _t, f_, f_}, //  1
-            {f_, f_, f_, _t, _t, _t, _t, _t, f_, f_, _t, _t, f_, f_, _t, _t, _t, _t, _t, _t, f_, f_}, //  2
-            {f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, _t, _t, f_, f_, _t, _t, _t, _t, _t, _t, f_, f_}, //  3
-            {f_, f_, f_, _t, f_, _t, f_, _t, f_, f_, _t, _t, f_, f_, _t, _t, _t, _t, _t, _t, f_, f_}, //  4
-            {f_, f_, f_, _t, f_, f_, f_, _t, f_, f_, _t, _t, f_, f_, _t, _t, _t, _t, _t, _t, f_, f_}, //  5
-            {f_, f_, f_, _t, _t, _t, f_, _t, f_, f_, _t, _t, f_, f_, _t, _t, _t, _t, _t, _t, f_, f_}, //  6
-            {f_, f_, f_, _t, f_, f_, f_, f_, f_, f_, _t, _t, f_, f_, _t, _t, _t, _t, _t, _t, f_, f_}, //  7
-            {f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, _t, _t, f_, f_, _t, _t, _t, _t, _t, _t, f_, f_}, //  8
-            {f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, _t, _t, f_, f_, _t, _t, _t, _t, _t, _t, f_, f_}, //  9
-            {f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, _t, _t, f_, f_}, // 10
-            {f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, _t, f_, f_, f_, f_, f_, f_, f_, _t, _t, f_, f_}, // 11
-            {f_, f_, _t, _t, _t, _t, _t, _t, _t, _t, _t, _t, f_, f_, _t, _t, _t, _t, _t, _t, f_, f_}, // 12
-            {f_, f_, _t, _t, _t, _t, _t, _t, _t, _t, _t, _t, _t, f_, _t, _t, _t, _t, _t, _t, f_, f_}, // 13
-            {f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, _t, _t, f_, f_, f_, _t, f_, f_, _t, _t, f_, f_}, // 14
-            {f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, _t, _t, f_, f_, f_, f_, f_, f_, _t, _t, f_, f_}, // 15
-            {f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, _t, _t, f_, f_, _t, _t, f_, f_, _t, _t, f_, f_}, // 16
-            {f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, _t, _t, f_, f_, _t, _t, _t, f_, _t, _t, f_, f_}, // 17
-            {f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, _t, f_, f_}, // 18
-            {f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_}, // 19
-            {f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_}, // 20
-            {f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_, f_}, // 21
-        };
-
-        SECTION("signed/unsigned mixed comparison above INT64_MAX")
-        {
-            const json above_int64_max = static_cast<std::uint64_t>((std::numeric_limits<std::int64_t>::max)()) + 1ULL;
-            const json max_uint64 = (std::numeric_limits<std::uint64_t>::max)();
-            const json negative_one = -1;
-            const json one = 1;
-            const json max_int64 = (std::numeric_limits<std::int64_t>::max)();
-
-            CHECK((negative_one <=> above_int64_max) == std::partial_ordering::less); // *NOPAD*
-            CHECK((above_int64_max <=> negative_one) == std::partial_ordering::greater); // *NOPAD*
-            CHECK((negative_one <=> max_uint64) == std::partial_ordering::less); // *NOPAD*
-            CHECK((max_uint64 <=> negative_one) == std::partial_ordering::greater); // *NOPAD*
-            CHECK((one <=> above_int64_max) == std::partial_ordering::less); // *NOPAD*
-            CHECK((above_int64_max <=> one) == std::partial_ordering::greater); // *NOPAD*
-            CHECK((max_int64 <=> above_int64_max) == std::partial_ordering::less); // *NOPAD*
-            CHECK((above_int64_max <=> max_int64) == std::partial_ordering::greater); // *NOPAD*
-        }
-
-        SECTION("integer/float mixed comparison is exact")
-        {
-            // Widening the integer to a double loses precision past the
-            // mantissa, so 2^63-2 and 2^63-1 both used to compare equal to the
-            // double 2^63 while differing from each other. That makes equality
-            // intransitive and the ordering not a strict weak ordering.
-            const json below_two_63 = static_cast<std::int64_t>(9223372036854775806LL);
-            const json max_int64 = (std::numeric_limits<std::int64_t>::max)();
-            const json two_63 = 9223372036854775808.0;
-
-            // the same past the unsigned range
-            const json max_uint64 = (std::numeric_limits<std::uint64_t>::max)();
-            const json two_64 = 18446744073709551616.0;
-
-            CHECK((max_int64 <=> two_63) == std::partial_ordering::less); // *NOPAD*
-            CHECK((two_63 <=> max_int64) == std::partial_ordering::greater); // *NOPAD*
-            CHECK((below_two_63 <=> max_int64) == std::partial_ordering::less); // *NOPAD*
-            CHECK((max_uint64 <=> two_64) == std::partial_ordering::less); // *NOPAD*
-            CHECK((json(1) <=> json(1.0)) == std::partial_ordering::equivalent); // *NOPAD*
-            CHECK((json(1) <=> json(nan)) == std::partial_ordering::unordered); // *NOPAD*
-        }
-
-        SECTION("comparison: 3-way")
-        {
-            // doctest runs the REQUIRE in the test case body once per leaf section; keep it
-            // here to run it as often as before the 3-way sections moved from unit-comparison.cpp
-            REQUIRE(std::isnan(nan));
-
-            std::vector<std::vector<std::partial_ordering>> expected =
-            {
-                //0   1   2   3   4   5   6   7   8   9  10  11  12  13  14  15  16  17  18  19  20  21
-                {eq, eq, lt, lt, lt, lt, lt, lt, lt, lt, lt, lt, lt, lt, lt, lt, lt, lt, lt, lt, un, un}, //  0
-                {eq, eq, lt, lt, lt, lt, lt, lt, lt, lt, lt, lt, lt, lt, lt, lt, lt, lt, lt, lt, un, un}, //  1
-                {gt, gt, eq, lt, lt, lt, lt, lt, un, un, lt, lt, gt, gt, lt, lt, lt, lt, lt, lt, un, un}, //  2
-                {gt, gt, gt, eq, gt, gt, gt, gt, un, un, lt, lt, gt, gt, lt, lt, lt, lt, lt, lt, un, un}, //  3
-                {gt, gt, gt, lt, eq, lt, gt, lt, un, un, lt, lt, gt, gt, lt, lt, lt, lt, lt, lt, un, un}, //  4
-                {gt, gt, gt, lt, gt, eq, gt, lt, un, un, lt, lt, gt, gt, lt, lt, lt, lt, lt, lt, un, un}, //  5
-                {gt, gt, gt, lt, lt, lt, eq, lt, un, un, lt, lt, gt, gt, lt, lt, lt, lt, lt, lt, un, un}, //  6
-                {gt, gt, gt, lt, gt, gt, gt, eq, un, un, lt, lt, gt, gt, lt, lt, lt, lt, lt, lt, un, un}, //  7
-                {gt, gt, un, un, un, un, un, un, un, un, lt, lt, gt, gt, lt, lt, lt, lt, lt, lt, un, un}, //  8
-                {gt, gt, un, un, un, un, un, un, un, un, lt, lt, gt, gt, lt, lt, lt, lt, lt, lt, un, un}, //  9
-                {gt, gt, gt, gt, gt, gt, gt, gt, gt, gt, eq, gt, gt, gt, gt, gt, gt, gt, lt, lt, un, un}, // 10
-                {gt, gt, gt, gt, gt, gt, gt, gt, gt, gt, lt, eq, gt, gt, gt, gt, gt, gt, lt, lt, un, un}, // 11
-                {gt, gt, lt, lt, lt, lt, lt, lt, lt, lt, lt, lt, eq, gt, lt, lt, lt, lt, lt, lt, un, un}, // 12
-                {gt, gt, lt, lt, lt, lt, lt, lt, lt, lt, lt, lt, lt, eq, lt, lt, lt, lt, lt, lt, un, un}, // 13
-                {gt, gt, gt, gt, gt, gt, gt, gt, gt, gt, lt, lt, gt, gt, eq, lt, gt, gt, lt, lt, un, un}, // 14
-                {gt, gt, gt, gt, gt, gt, gt, gt, gt, gt, lt, lt, gt, gt, gt, eq, gt, gt, lt, lt, un, un}, // 15
-                {gt, gt, gt, gt, gt, gt, gt, gt, gt, gt, lt, lt, gt, gt, lt, lt, eq, gt, lt, lt, un, un}, // 16
-                {gt, gt, gt, gt, gt, gt, gt, gt, gt, gt, lt, lt, gt, gt, lt, lt, lt, eq, lt, lt, un, un}, // 17
-                {gt, gt, gt, gt, gt, gt, gt, gt, gt, gt, gt, gt, gt, gt, gt, gt, gt, gt, eq, lt, un, un}, // 18
-                {gt, gt, gt, gt, gt, gt, gt, gt, gt, gt, gt, gt, gt, gt, gt, gt, gt, gt, gt, eq, un, un}, // 19
-                {un, un, un, un, un, un, un, un, un, un, un, un, un, un, un, un, un, un, un, un, un, un}, // 20
-                {un, un, un, un, un, un, un, un, un, un, un, un, un, un, un, un, un, un, un, un, un, un}, // 21
-            };
-
-            // check expected partial_ordering against expected booleans
-            REQUIRE(expected.size() == expected_eq.size());
-            REQUIRE(expected.size() == expected_lt.size());
-            for (size_t i = 0; i < expected.size(); ++i)
-            {
-                REQUIRE(expected[i].size() == expected_eq[i].size());
-                REQUIRE(expected[i].size() == expected_lt[i].size());
-                for (size_t j = 0; j < expected[i].size(); ++j)
-                {
-                    CAPTURE(i)
-                    CAPTURE(j)
-                    CHECK(std::is_eq(expected[i][j]) == expected_eq[i][j]);
-                    CHECK(std::is_lt(expected[i][j]) == expected_lt[i][j]);
-                    if (std::is_gt(expected[i][j]))
-                    {
-                        CHECK((!expected_eq[i][j] && !expected_lt[i][j]));
-                    }
-                }
-            }
-
-            // check that two values compare according to their expected ordering
-            REQUIRE(expected.size() == j_values.size());
-            for (size_t i = 0; i < j_values.size(); ++i)
-            {
-                REQUIRE(expected[i].size() == j_values.size());
-                for (size_t j = 0; j < j_values.size(); ++j)
-                {
-                    CAPTURE(i)
-                    CAPTURE(j)
-                    CHECK((j_values[i] <=> j_values[j]) == expected[i][j]); // *NOPAD*
-                }
-            }
-        }
-    }
-
-}
-
-TEST_CASE("regression #3868 - heterogeneous comparisons compile under C++20 (P2468R2)")
-{
-    // Issue #3868: operator!= was preventing compiler from synthesizing reversed
-    // operator== candidates under C++20's P2468R2 rewritten candidate rules.
-    // Verify that heterogeneous comparisons now work.
-
-    SECTION("string vs json")
-    {
-        std::string s = "string";
-        json j = "string";
-        CHECK(s == j);
-        CHECK(j == s);
-        CHECK_FALSE(s != j);
-        CHECK_FALSE(j != s);
-    }
-
-    SECTION("other heterogeneous types")
-    {
-        int i = 42;
-        json j = 42;
-        CHECK(i == j);
-        CHECK(j == i);
-        CHECK_FALSE(i != j);
-        CHECK_FALSE(j != i);
-    }
-}
-
-#if JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON
-TEST_CASE("regression #5665 - scalar <= discarded and scalar >= discarded in C++20 legacy mode")
-{
-    // Issue #5665: with a scalar on the left-hand side, <= and >= only had the
-    // candidate rewritten from operator<=>, which does not emulate the legacy
-    // discarded-value behavior. Check that scalar-on-the-left now matches the
-    // other three operand orders.
-    const json discarded(json::value_t::discarded);
-    const json one = 1;
-
-    CHECK(discarded <= 1);
-    CHECK(discarded >= 1);
-    CHECK(one <= discarded);
-    CHECK(one >= discarded);
-    CHECK(1 <= discarded);
-    CHECK(1 >= discarded);
-    CHECK(1.5 <= discarded);
-    CHECK(1.5 >= discarded);
-}
-
-#endif
-
-TEST_CASE("containers are compared element by element (C++20)")
-{
-    // Containers nested deeper than a bound are compared without the call
-    // stack, by code of their own; every relation is checked both at the top
-    // level and below that bound.
-    const auto deep = [](const json & j, const std::size_t depth)
-    {
-        json result = j;
-        for (std::size_t i = 0; i < depth; ++i)
-        {
-            result = json::array({std::move(result)});
-        }
-        return result;
-    };
-
-    for (const std::size_t depth : std::vector<std::size_t> {0, 200})
-    {
-        CAPTURE(depth)
-
-        // objects with different keys
-        {
-            const json a = deep({{"a", 1}}, depth);
-            const json b = deep({{"b", 1}}, depth);
-            CHECK((a <=> b) == std::partial_ordering::less); // *NOPAD*
-            CHECK((b <=> a) == std::partial_ordering::greater); // *NOPAD*
-            CHECK((a <=> a) == std::partial_ordering::equivalent); // *NOPAD*
-        }
-
-        // a container that is a prefix of the other one
-        {
-            // the one that runs out of elements first is the smaller one
-            const json shorter = deep({1}, depth);
-            const json longer = deep({1, 2}, depth);
-
-            const json smaller_object = deep({{"a", 1}}, depth);
-            const json larger_object = deep({{"a", 1}, {"b", 2}}, depth);
-            CHECK((shorter <=> longer) == std::partial_ordering::less); // *NOPAD*
-            CHECK((longer <=> shorter) == std::partial_ordering::greater); // *NOPAD*
-        }
-
-        // elements that cannot be ordered
-        {
-            const double nan = std::numeric_limits<double>::quiet_NaN();
-            const json lhs = deep({nan, 1}, depth);
-            const json rhs = deep({nan, 2}, depth);
-            // operator<=> stops there, as std::lexicographical_compare_three_way
-            // does, and operator< is derived from it
-            CHECK((lhs <=> rhs) == std::partial_ordering::unordered); // *NOPAD*
-            CHECK_FALSE(lhs < rhs);
-        }
-    }
-}
-
-TEST_CASE("operator<=> of binary values with a different subtype does not depend on nesting depth")
-{
-    // #5654: std::vector<std::uint8_t>::operator<=>, which the binary type's
-    // own operator<=> uses, ignores the subtype that operator== checks. So a
-    // pair of binary values with the same bytes but a different subtype is
-    // unequal, yet <=>-equivalent - the same inconsistency between == and <=>
-    // that a NaN has. Within the nesting bound, an array compares itself
-    // with std::vector's own operator<=>, which treats an equivalent pair as
-    // undecided and lets the next element decide, same as
-    // std::lexicographical_compare_three_way does. Past the bound,
-    // compare_iteratively<true>() takes over and must classify the pair the
-    // same way, or the result of operator<=> - and of <, which C++20 derives
-    // from it - depends on how deeply the values are nested.
-    const json a = json::array({json::binary({1}, 1), 1});
-    const json b = json::array({json::binary({1}, 2), 2});
-
-    // the root inconsistency: unequal, yet <=>-equivalent
-    CHECK_FALSE(a[0] == b[0]);
-    CHECK((a[0] <=> b[0]) == std::partial_ordering::equivalent); // *NOPAD*
-
-    const auto deep = [](const json & j, const std::size_t depth)
-    {
-        json result = j;
-        for (std::size_t i = 0; i < depth; ++i)
-        {
-            result = json::array({std::move(result)});
-        }
-        return result;
-    };
-
-    // 127 levels stay within nesting_depth_limit() (128); 128 and 200 do not,
-    // and must still agree with the levels that do
-    for (const std::size_t depth : std::vector<std::size_t> {0, 127, 128, 200})
-    {
-        CAPTURE(depth)
-        const json x = deep(a, depth);
-        const json y = deep(b, depth);
-        CHECK((x <=> y) == std::partial_ordering::less); // *NOPAD*
-        CHECK((y <=> x) == std::partial_ordering::greater); // *NOPAD*
-        CHECK(x < y);
-        CHECK(y > x);
-        CHECK_FALSE(y < x);
-    }
-}
-
-#endif // JSON_HAS_THREE_WAY_COMPARISON
-#endif
@@ -6,11 +6,12 @@
 // SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
 // SPDX-License-Identifier: MIT

-// cmake/test.cmake builds a unit test with C++ standards beyond C++11 only if the
-// source file mentions the corresponding version macro. To avoid rebuilding this
-// large file for every standard, tests that depend on the standard version (e.g.,
-// those using JSON_HAS_FILESYSTEM, JSON_HAS_RANGES, or JSON_HAS_THREE_WAY_COMPARISON)
-// go into a separate file unit-comparison-cpp<NN>.cpp. This file stays C++11-only.
+// cmake/test.cmake selects the C++ standard versions with which to build a
+// unit test based on the presence of JSON_HAS_CPP_<VERSION> macros.
+// When using macros that are only defined for particular versions of the standard
+// (e.g., JSON_HAS_FILESYSTEM for C++17 and up), please mention the corresponding
+// version macro in a comment close by, like this:
+// JSON_HAS_CPP_<VERSION> (do not remove; see note at top of file)

 #include "doctest_compatibility.h"

@@ -27,6 +28,37 @@
 #include <nlohmann/json.hpp>
 using nlohmann::json;

+#if JSON_HAS_THREE_WAY_COMPARISON
+// this can be replaced with the doctest stl extension header in version 2.5
+namespace doctest
+{
+template<> struct StringMaker<std::partial_ordering>
+{
+    static String convert(const std::partial_ordering& order)
+    {
+        if (order == std::partial_ordering::less)
+        {
+            return "std::partial_ordering::less";
+        }
+        if (order == std::partial_ordering::equivalent)
+        {
+            return "std::partial_ordering::equivalent";
+        }
+        if (order == std::partial_ordering::greater)
+        {
+            return "std::partial_ordering::greater";
+        }
+        if (order == std::partial_ordering::unordered)
+        {
+            return "std::partial_ordering::unordered";
+        }
+        return "{?}";
+    }
+};
+} // namespace doctest
+
+#endif
+
 namespace
 {
 // helper function to check std::less<json::value_t>
@@ -43,6 +75,16 @@ TEST_CASE("lexicographical comparison operators")
    constexpr auto f_ = false;
    constexpr auto _t = true;
    constexpr auto nan = std::numeric_limits<json::number_float_t>::quiet_NaN();
+#if JSON_HAS_THREE_WAY_COMPARISON
+    constexpr auto lt = std::partial_ordering::less;
+    constexpr auto gt = std::partial_ordering::greater;
+    constexpr auto eq = std::partial_ordering::equivalent;
+    constexpr auto un = std::partial_ordering::unordered;
+#endif
+
+#if JSON_HAS_THREE_WAY_COMPARISON
+    INFO("using 3-way comparison");
+#endif

 #if JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON
    INFO("using legacy comparison");
@@ -93,13 +135,62 @@ TEST_CASE("lexicographical comparison operators")
                    CAPTURE(i)
                    CAPTURE(j)
                    // check precomputed values
-#if !JSON_HAS_THREE_WAY_COMPARISON
+#if JSON_HAS_THREE_WAY_COMPARISON
+                    // JSON_HAS_CPP_20 (do not remove; see note at top of file)
+                    CHECK((j_types[i] < j_types[j]) == expected_lt[i][j]);
+#else
                    CHECK(operator<(j_types[i], j_types[j]) == expected_lt[i][j]);
 #endif
                    CHECK(f(j_types[i], j_types[j]) == expected_lt[i][j]);
                }
            }
        }
+#if JSON_HAS_THREE_WAY_COMPARISON
+        // JSON_HAS_CPP_20 (do not remove; see note at top of file)
+        SECTION("comparison: 3-way")
+        {
+            std::vector<std::vector<std::partial_ordering>> expected =
+            {
+                //0   1   2   3   4   5   6   7   8   9
+                {eq, lt, lt, lt, lt, lt, lt, lt, lt, un}, //  0
+                {gt, eq, lt, lt, lt, lt, lt, lt, lt, un}, //  1
+                {gt, gt, eq, eq, eq, lt, lt, lt, lt, un}, //  2
+                {gt, gt, eq, eq, eq, lt, lt, lt, lt, un}, //  3
+                {gt, gt, eq, eq, eq, lt, lt, lt, lt, un}, //  4
+                {gt, gt, gt, gt, gt, eq, lt, lt, lt, un}, //  5
+                {gt, gt, gt, gt, gt, gt, eq, lt, lt, un}, //  6
+                {gt, gt, gt, gt, gt, gt, gt, eq, lt, un}, //  7
+                {gt, gt, gt, gt, gt, gt, gt, gt, eq, un}, //  8
+                {un, un, un, un, un, un, un, un, un, un}, //  9
+            };
+
+            // check expected partial_ordering against expected boolean
+            REQUIRE(expected.size() == expected_lt.size());
+            for (size_t i = 0; i < expected.size(); ++i)
+            {
+                REQUIRE(expected[i].size() == expected_lt[i].size());
+                for (size_t j = 0; j < expected[i].size(); ++j)
+                {
+                    CAPTURE(i)
+                    CAPTURE(j)
+                    CHECK(std::is_lt(expected[i][j]) == expected_lt[i][j]);
+                }
+            }
+
+            // check 3-way comparison against expected partial_ordering
+            REQUIRE(expected.size() == j_types.size());
+            for (size_t i = 0; i < j_types.size(); ++i)
+            {
+                REQUIRE(expected[i].size() == j_types.size());
+                for (size_t j = 0; j < j_types.size(); ++j)
+                {
+                    CAPTURE(i)
+                    CAPTURE(j)
+                    CHECK((j_types[i] <=> j_types[j]) == expected[i][j]); // *NOPAD*
+                }
+            }
+        }
+#endif
    }

    SECTION("values")
@@ -228,6 +319,18 @@ TEST_CASE("lexicographical comparison operators")
            CHECK_FALSE(above_int64_max <= max_int64);
            CHECK(above_int64_max > max_int64);
            CHECK(above_int64_max >= max_int64);
+
+#if JSON_HAS_THREE_WAY_COMPARISON
+            // JSON_HAS_CPP_20 (do not remove; see note at top of file)
+            CHECK((negative_one <=> above_int64_max) == std::partial_ordering::less); // *NOPAD*
+            CHECK((above_int64_max <=> negative_one) == std::partial_ordering::greater); // *NOPAD*
+            CHECK((negative_one <=> max_uint64) == std::partial_ordering::less); // *NOPAD*
+            CHECK((max_uint64 <=> negative_one) == std::partial_ordering::greater); // *NOPAD*
+            CHECK((one <=> above_int64_max) == std::partial_ordering::less); // *NOPAD*
+            CHECK((above_int64_max <=> one) == std::partial_ordering::greater); // *NOPAD*
+            CHECK((max_int64 <=> above_int64_max) == std::partial_ordering::less); // *NOPAD*
+            CHECK((above_int64_max <=> max_int64) == std::partial_ordering::greater); // *NOPAD*
+#endif
        }

        SECTION("integer/float mixed comparison is exact")
@@ -278,6 +381,16 @@ TEST_CASE("lexicographical comparison operators")
            CHECK_FALSE(json(1) < json(nan));
            CHECK_FALSE(json(nan) < json(1));
            CHECK_FALSE(json(1u) == json(nan));
+
+#if JSON_HAS_THREE_WAY_COMPARISON
+            // JSON_HAS_CPP_20 (do not remove; see note at top of file)
+            CHECK((max_int64 <=> two_63) == std::partial_ordering::less); // *NOPAD*
+            CHECK((two_63 <=> max_int64) == std::partial_ordering::greater); // *NOPAD*
+            CHECK((below_two_63 <=> max_int64) == std::partial_ordering::less); // *NOPAD*
+            CHECK((max_uint64 <=> two_64) == std::partial_ordering::less); // *NOPAD*
+            CHECK((json(1) <=> json(1.0)) == std::partial_ordering::equivalent); // *NOPAD*
+            CHECK((json(1) <=> json(nan)) == std::partial_ordering::unordered); // *NOPAD*
+#endif
        }

        SECTION("compares unordered")
@@ -504,6 +617,72 @@ TEST_CASE("lexicographical comparison operators")
                }
            }
        }
+
+#if JSON_HAS_THREE_WAY_COMPARISON
+        // JSON_HAS_CPP_20 (do not remove; see note at top of file)
+        SECTION("comparison: 3-way")
+        {
+            std::vector<std::vector<std::partial_ordering>> expected =
+            {
+                //0   1   2   3   4   5   6   7   8   9  10  11  12  13  14  15  16  17  18  19  20  21
+                {eq, eq, lt, lt, lt, lt, lt, lt, lt, lt, lt, lt, lt, lt, lt, lt, lt, lt, lt, lt, un, un}, //  0
+                {eq, eq, lt, lt, lt, lt, lt, lt, lt, lt, lt, lt, lt, lt, lt, lt, lt, lt, lt, lt, un, un}, //  1
+                {gt, gt, eq, lt, lt, lt, lt, lt, un, un, lt, lt, gt, gt, lt, lt, lt, lt, lt, lt, un, un}, //  2
+                {gt, gt, gt, eq, gt, gt, gt, gt, un, un, lt, lt, gt, gt, lt, lt, lt, lt, lt, lt, un, un}, //  3
+                {gt, gt, gt, lt, eq, lt, gt, lt, un, un, lt, lt, gt, gt, lt, lt, lt, lt, lt, lt, un, un}, //  4
+                {gt, gt, gt, lt, gt, eq, gt, lt, un, un, lt, lt, gt, gt, lt, lt, lt, lt, lt, lt, un, un}, //  5
+                {gt, gt, gt, lt, lt, lt, eq, lt, un, un, lt, lt, gt, gt, lt, lt, lt, lt, lt, lt, un, un}, //  6
+                {gt, gt, gt, lt, gt, gt, gt, eq, un, un, lt, lt, gt, gt, lt, lt, lt, lt, lt, lt, un, un}, //  7
+                {gt, gt, un, un, un, un, un, un, un, un, lt, lt, gt, gt, lt, lt, lt, lt, lt, lt, un, un}, //  8
+                {gt, gt, un, un, un, un, un, un, un, un, lt, lt, gt, gt, lt, lt, lt, lt, lt, lt, un, un}, //  9
+                {gt, gt, gt, gt, gt, gt, gt, gt, gt, gt, eq, gt, gt, gt, gt, gt, gt, gt, lt, lt, un, un}, // 10
+                {gt, gt, gt, gt, gt, gt, gt, gt, gt, gt, lt, eq, gt, gt, gt, gt, gt, gt, lt, lt, un, un}, // 11
+                {gt, gt, lt, lt, lt, lt, lt, lt, lt, lt, lt, lt, eq, gt, lt, lt, lt, lt, lt, lt, un, un}, // 12
+                {gt, gt, lt, lt, lt, lt, lt, lt, lt, lt, lt, lt, lt, eq, lt, lt, lt, lt, lt, lt, un, un}, // 13
+                {gt, gt, gt, gt, gt, gt, gt, gt, gt, gt, lt, lt, gt, gt, eq, lt, gt, gt, lt, lt, un, un}, // 14
+                {gt, gt, gt, gt, gt, gt, gt, gt, gt, gt, lt, lt, gt, gt, gt, eq, gt, gt, lt, lt, un, un}, // 15
+                {gt, gt, gt, gt, gt, gt, gt, gt, gt, gt, lt, lt, gt, gt, lt, lt, eq, gt, lt, lt, un, un}, // 16
+                {gt, gt, gt, gt, gt, gt, gt, gt, gt, gt, lt, lt, gt, gt, lt, lt, lt, eq, lt, lt, un, un}, // 17
+                {gt, gt, gt, gt, gt, gt, gt, gt, gt, gt, gt, gt, gt, gt, gt, gt, gt, gt, eq, lt, un, un}, // 18
+                {gt, gt, gt, gt, gt, gt, gt, gt, gt, gt, gt, gt, gt, gt, gt, gt, gt, gt, gt, eq, un, un}, // 19
+                {un, un, un, un, un, un, un, un, un, un, un, un, un, un, un, un, un, un, un, un, un, un}, // 20
+                {un, un, un, un, un, un, un, un, un, un, un, un, un, un, un, un, un, un, un, un, un, un}, // 21
+            };
+
+            // check expected partial_ordering against expected booleans
+            REQUIRE(expected.size() == expected_eq.size());
+            REQUIRE(expected.size() == expected_lt.size());
+            for (size_t i = 0; i < expected.size(); ++i)
+            {
+                REQUIRE(expected[i].size() == expected_eq[i].size());
+                REQUIRE(expected[i].size() == expected_lt[i].size());
+                for (size_t j = 0; j < expected[i].size(); ++j)
+                {
+                    CAPTURE(i)
+                    CAPTURE(j)
+                    CHECK(std::is_eq(expected[i][j]) == expected_eq[i][j]);
+                    CHECK(std::is_lt(expected[i][j]) == expected_lt[i][j]);
+                    if (std::is_gt(expected[i][j]))
+                    {
+                        CHECK((!expected_eq[i][j] && !expected_lt[i][j]));
+                    }
+                }
+            }
+
+            // check that two values compare according to their expected ordering
+            REQUIRE(expected.size() == j_values.size());
+            for (size_t i = 0; i < j_values.size(); ++i)
+            {
+                REQUIRE(expected[i].size() == j_values.size());
+                for (size_t j = 0; j < j_values.size(); ++j)
+                {
+                    CAPTURE(i)
+                    CAPTURE(j)
+                    CHECK((j_values[i] <=> j_values[j]) == expected[i][j]); // *NOPAD*
+                }
+            }
+        }
+#endif
    }

 #if JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON
@@ -542,7 +721,60 @@ TEST_CASE("lexicographical comparison operators")
 #endif
 }

-namespace unit_comparison_detail
+#if JSON_HAS_THREE_WAY_COMPARISON
+// JSON_HAS_CPP_20 (do not remove; see note at top of file)
+
+TEST_CASE("regression #3868 - heterogeneous comparisons compile under C++20 (P2468R2)")
+{
+    // Issue #3868: operator!= was preventing compiler from synthesizing reversed
+    // operator== candidates under C++20's P2468R2 rewritten candidate rules.
+    // Verify that heterogeneous comparisons now work.
+
+    SECTION("string vs json")
+    {
+        std::string s = "string";
+        json j = "string";
+        CHECK(s == j);
+        CHECK(j == s);
+        CHECK_FALSE(s != j);
+        CHECK_FALSE(j != s);
+    }
+
+    SECTION("other heterogeneous types")
+    {
+        int i = 42;
+        json j = 42;
+        CHECK(i == j);
+        CHECK(j == i);
+        CHECK_FALSE(i != j);
+        CHECK_FALSE(j != i);
+    }
+}
+
+#if JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON
+TEST_CASE("regression #5665 - scalar <= discarded and scalar >= discarded in C++20 legacy mode")
+{
+    // Issue #5665: with a scalar on the left-hand side, <= and >= only had the
+    // candidate rewritten from operator<=>, which does not emulate the legacy
+    // discarded-value behavior. Check that scalar-on-the-left now matches the
+    // other three operand orders.
+    const json discarded(json::value_t::discarded);
+    const json one = 1;
+
+    CHECK(discarded <= 1);
+    CHECK(discarded >= 1);
+    CHECK(one <= discarded);
+    CHECK(one >= discarded);
+    CHECK(1 <= discarded);
+    CHECK(1 >= discarded);
+    CHECK(1.5 <= discarded);
+    CHECK(1.5 >= discarded);
+}
+#endif
+
+#endif
+
+namespace
 {
 // orders keys ascending or descending, as chosen when a map is created
 template<class Key>
@@ -592,7 +824,7 @@ struct unordered_object_t : std::map<Key, Value, directed_less<Key>, Allocator>
        return !(lhs == rhs);
    }
 };
-using unordered_json = nlohmann::json::with_object_t<unordered_object_t>;
+using unordered_json = nlohmann::basic_json<unordered_object_t>;

 // the entries "0" to "9", enumerated in ascending or in descending order
 unordered_json make_unordered_object(const bool descending)
@@ -643,7 +875,7 @@ struct key_case_less

 template<class Key, class Value, class /*Compare*/, class Allocator>
 using key_case_map = std::map<Key, Value, key_case_less, Allocator>;
-using key_case_json = nlohmann::json::with_object_t<key_case_map>;
+using key_case_json = nlohmann::basic_json<key_case_map>;

 // the innermost value of a chain of single-element arrays
 template<typename Json>
@@ -673,10 +905,8 @@ struct case_insensitive_less

 template<class Key, class Value, class /*Compare*/, class Allocator>
 using case_insensitive_map = std::map<Key, Value, case_insensitive_less, Allocator>;
-using ci_json = nlohmann::json::with_object_t<case_insensitive_map>;
-} // namespace unit_comparison_detail
-
-using namespace unit_comparison_detail; // NOLINT(google-build-using-namespace)
+using ci_json = nlohmann::basic_json<case_insensitive_map>;
+} // namespace

 TEST_CASE("equality of objects whose entries have no fixed order")
 {
@@ -819,6 +1049,12 @@ TEST_CASE("containers are compared element by element")
            CHECK(a < b);
            CHECK(b > a);
            CHECK_FALSE(b < a);
+#if JSON_HAS_THREE_WAY_COMPARISON
+            // JSON_HAS_CPP_20 (do not remove; see note at top of file)
+            CHECK((a <=> b) == std::partial_ordering::less); // *NOPAD*
+            CHECK((b <=> a) == std::partial_ordering::greater); // *NOPAD*
+            CHECK((a <=> a) == std::partial_ordering::equivalent); // *NOPAD*
+#endif
        }

        // a container that is a prefix of the other one
@@ -836,6 +1072,11 @@ TEST_CASE("containers are compared element by element")
            CHECK(smaller_object < larger_object);
            CHECK(larger_object > smaller_object);
            CHECK_FALSE(smaller_object == larger_object);
+#if JSON_HAS_THREE_WAY_COMPARISON
+            // JSON_HAS_CPP_20 (do not remove; see note at top of file)
+            CHECK((shorter <=> longer) == std::partial_ordering::less); // *NOPAD*
+            CHECK((longer <=> shorter) == std::partial_ordering::greater); // *NOPAD*
+#endif
        }

        // elements that cannot be ordered
@@ -846,7 +1087,13 @@ TEST_CASE("containers are compared element by element")

            CHECK_FALSE(lhs == lhs);
            CHECK_FALSE(rhs < lhs);
-#if !JSON_HAS_THREE_WAY_COMPARISON
+#if JSON_HAS_THREE_WAY_COMPARISON
+            // JSON_HAS_CPP_20 (do not remove; see note at top of file)
+            // operator<=> stops there, as std::lexicographical_compare_three_way
+            // does, and operator< is derived from it
+            CHECK((lhs <=> rhs) == std::partial_ordering::unordered); // *NOPAD*
+            CHECK_FALSE(lhs < rhs);
+#else
            // operator< skips a pair of elements that cannot be ordered, as
            // std::lexicographical_compare does, and the next pair decides
            CHECK(lhs < rhs);
@@ -855,3 +1102,50 @@ TEST_CASE("containers are compared element by element")
    }
 }

+#if JSON_HAS_THREE_WAY_COMPARISON
+// JSON_HAS_CPP_20 (do not remove; see note at top of file)
+TEST_CASE("operator<=> of binary values with a different subtype does not depend on nesting depth")
+{
+    // #5654: std::vector<std::uint8_t>::operator<=>, which the binary type's
+    // own operator<=> uses, ignores the subtype that operator== checks. So a
+    // pair of binary values with the same bytes but a different subtype is
+    // unequal, yet <=>-equivalent - the same inconsistency between == and <=>
+    // that a NaN has. Within the nesting bound, an array compares itself
+    // with std::vector's own operator<=>, which treats an equivalent pair as
+    // undecided and lets the next element decide, same as
+    // std::lexicographical_compare_three_way does. Past the bound,
+    // compare_iteratively<true>() takes over and must classify the pair the
+    // same way, or the result of operator<=> - and of <, which C++20 derives
+    // from it - depends on how deeply the values are nested.
+    const json a = json::array({json::binary({1}, 1), 1});
+    const json b = json::array({json::binary({1}, 2), 2});
+
+    // the root inconsistency: unequal, yet <=>-equivalent
+    CHECK_FALSE(a[0] == b[0]);
+    CHECK((a[0] <=> b[0]) == std::partial_ordering::equivalent); // *NOPAD*
+
+    const auto deep = [](const json & j, const std::size_t depth)
+    {
+        json result = j;
+        for (std::size_t i = 0; i < depth; ++i)
+        {
+            result = json::array({std::move(result)});
+        }
+        return result;
+    };
+
+    // 127 levels stay within nesting_depth_limit() (128); 128 and 200 do not,
+    // and must still agree with the levels that do
+    for (const std::size_t depth : std::vector<std::size_t> {0, 127, 128, 200})
+    {
+        CAPTURE(depth)
+        const json x = deep(a, depth);
+        const json y = deep(b, depth);
+        CHECK((x <=> y) == std::partial_ordering::less); // *NOPAD*
+        CHECK((y <=> x) == std::partial_ordering::greater); // *NOPAD*
+        CHECK(x < y);
+        CHECK(y > x);
+        CHECK_FALSE(y < x);
+    }
+}
+#endif
@@ -1,95 +0,0 @@
-//     __ _____ _____ _____
-//  __|  |   __|     |   | |  JSON for Modern C++ (supporting code)
-// |  |  |__   |  |  | | | |  version 3.12.0
-// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
-//
-// SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
-// SPDX-License-Identifier: MIT
-
-// This file contains the C++17-only part of unit-conversions1.cpp (conversions to and from
-// std::string_view). It is kept in a separate translation unit so the (much larger) unit-
-// conversions1.cpp is built for C++11 only and not rebuilt for every C++ standard.
-
-#include "doctest_compatibility.h"
-
-#include <nlohmann/json.hpp>
-using nlohmann::json;
-
-// workaround for MSVC, which does not set __cplusplus to the language version (#464)
-#if (defined(__cplusplus) && __cplusplus >= 201703L) || (defined(_HAS_CXX17) && _HAS_CXX17 == 1) // fix for issue #464
-    #define JSON_HAS_CPP_17
-#endif
-
-#ifdef JSON_HAS_CPP_17
-#include <string>
-#include <string_view>
-
-#if __has_include(<optional>)
-    #include <optional>
-#elif __has_include(<experimental/optional>)
-    #include <experimental/optional>
-#endif
-
-TEST_CASE("value conversion (C++17)")
-{
-    SECTION("get a string (explicit)")
-    {
-        const json::string_t s_reference{"Hello world"};
-        json j(s_reference);
-
-        SECTION("std::string_view")
-        {
-            std::string_view const s = j.get<std::string_view>();
-            CHECK(json(s) == j);
-        }
-
-        SECTION("exception in case of a non-string type using string_view")
-        {
-            CHECK_THROWS_WITH_AS(json(json::value_t::null).get<std::string_view>(),
-                                 "[json.exception.type_error.302] type must be string, but is null", json::type_error&);
-            CHECK_THROWS_WITH_AS(json(json::value_t::object).get<std::string_view>(),
-                                 "[json.exception.type_error.302] type must be string, but is object", json::type_error&);
-            CHECK_THROWS_WITH_AS(json(json::value_t::array).get<std::string_view>(),
-                                 "[json.exception.type_error.302] type must be string, but is array", json::type_error&);
-            CHECK_THROWS_WITH_AS(json(json::value_t::boolean).get<std::string_view>(),
-                                 "[json.exception.type_error.302] type must be string, but is boolean", json::type_error&);
-            CHECK_THROWS_WITH_AS(json(json::value_t::number_integer).get<std::string_view>(),
-                                 "[json.exception.type_error.302] type must be string, but is number", json::type_error&);
-            CHECK_THROWS_WITH_AS(json(json::value_t::number_unsigned).get<std::string_view>(),
-                                 "[json.exception.type_error.302] type must be string, but is number", json::type_error&);
-            CHECK_THROWS_WITH_AS(json(json::value_t::number_float).get<std::string_view>(),
-                                 "[json.exception.type_error.302] type must be string, but is number", json::type_error&);
-        }
-    }
-
-    SECTION("get a string (explicit, get_to)")
-    {
-        const json::string_t s_reference{"Hello world"};
-        json j(s_reference);
-
-        SECTION("std::string_view")
-        {
-            std::string const s = "previous value";
-            std::string_view sv = s;
-            j.get_to(sv);
-            CHECK(json(sv) == j);
-        }
-    }
-
-#if JSON_USE_IMPLICIT_CONVERSIONS
-    SECTION("get a string (implicit)")
-    {
-        const json::string_t s_reference{"Hello world"};
-        json j(s_reference);
-
-        SECTION("std::string_view")
-        {
-            std::string_view const s = j.get<std::string_view>();
-            CHECK(json(s) == j);
-        }
-    }
-#endif
-
-}
-
-#endif
@@ -6,11 +6,12 @@
 // SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
 // SPDX-License-Identifier: MIT

-// cmake/test.cmake builds a unit test with C++ standards beyond C++11 only if the
-// source file mentions the corresponding version macro. To avoid rebuilding this
-// large file for every standard, tests that depend on the standard version (e.g.,
-// those using JSON_HAS_FILESYSTEM, JSON_HAS_RANGES, or JSON_HAS_THREE_WAY_COMPARISON)
-// go into a separate file unit-conversions1-cpp<NN>.cpp. This file stays C++11-only.
+// cmake/test.cmake selects the C++ standard versions with which to build a
+// unit test based on the presence of JSON_HAS_CPP_<VERSION> macros.
+// When using macros that are only defined for particular versions of the standard
+// (e.g., JSON_HAS_FILESYSTEM for C++17 and up), please mention the corresponding
+// version macro in a comment close by, like this:
+// JSON_HAS_CPP_<VERSION> (do not remove; see note at top of file)

 #include "doctest_compatibility.h"

@@ -30,6 +31,25 @@ using nlohmann::json;
 DOCTEST_CLANG_SUPPRESS_WARNING_PUSH
 DOCTEST_CLANG_SUPPRESS_WARNING("-Wexit-time-destructors")

+#if (defined(__cplusplus) && __cplusplus >= 201703L) || (defined(_HAS_CXX17) && _HAS_CXX17 == 1) // fix for issue #464
+    #define JSON_HAS_CPP_17
+    #define JSON_HAS_CPP_14
+#elif (defined(__cplusplus) && __cplusplus >= 201402L) || (defined(_HAS_CXX14) && _HAS_CXX14 == 1)
+    #define JSON_HAS_CPP_14
+#endif
+
+#ifdef JSON_HAS_CPP_17
+    #if __has_include(<optional>)
+        #include <optional>
+    #elif __has_include(<experimental/optional>)
+        #include <experimental/optional>
+    #endif
+#endif
+
+#if defined(JSON_HAS_CPP_17)
+    #include <string_view>
+#endif
+
 TEST_CASE("value conversion")
 {
    SECTION("get an object (explicit)")
@@ -499,6 +519,13 @@ TEST_CASE("value conversion")
            const std::string s = j.get<std::string>();
            CHECK(json(s) == j);
        }
+#if defined(JSON_HAS_CPP_17)
+        SECTION("std::string_view")
+        {
+            std::string_view const s = j.get<std::string_view>();
+            CHECK(json(s) == j);
+        }
+#endif

        SECTION("exception in case of a non-string type")
        {
@@ -524,6 +551,26 @@ TEST_CASE("value conversion")
                json(json::value_t::number_float).get<json::string_t>(),
                "[json.exception.type_error.302] type must be string, but is number", json::type_error&);
        }
+
+#if defined(JSON_HAS_CPP_17)
+        SECTION("exception in case of a non-string type using string_view")
+        {
+            CHECK_THROWS_WITH_AS(json(json::value_t::null).get<std::string_view>(),
+                                 "[json.exception.type_error.302] type must be string, but is null", json::type_error&);
+            CHECK_THROWS_WITH_AS(json(json::value_t::object).get<std::string_view>(),
+                                 "[json.exception.type_error.302] type must be string, but is object", json::type_error&);
+            CHECK_THROWS_WITH_AS(json(json::value_t::array).get<std::string_view>(),
+                                 "[json.exception.type_error.302] type must be string, but is array", json::type_error&);
+            CHECK_THROWS_WITH_AS(json(json::value_t::boolean).get<std::string_view>(),
+                                 "[json.exception.type_error.302] type must be string, but is boolean", json::type_error&);
+            CHECK_THROWS_WITH_AS(json(json::value_t::number_integer).get<std::string_view>(),
+                                 "[json.exception.type_error.302] type must be string, but is number", json::type_error&);
+            CHECK_THROWS_WITH_AS(json(json::value_t::number_unsigned).get<std::string_view>(),
+                                 "[json.exception.type_error.302] type must be string, but is number", json::type_error&);
+            CHECK_THROWS_WITH_AS(json(json::value_t::number_float).get<std::string_view>(),
+                                 "[json.exception.type_error.302] type must be string, but is number", json::type_error&);
+        }
+#endif
    }

    SECTION("get a string (explicit, get_to)")
@@ -544,6 +591,15 @@ TEST_CASE("value conversion")
            j.get_to(s);
            CHECK(json(s) == j);
        }
+#if defined(JSON_HAS_CPP_17)
+        SECTION("std::string_view")
+        {
+            std::string const s = "previous value";
+            std::string_view sv = s;
+            j.get_to(sv);
+            CHECK(json(sv) == j);
+        }
+#endif
    }

    SECTION("get null (explicit)")
@@ -582,6 +638,14 @@ TEST_CASE("value conversion")
            CHECK(json(s) == j);
        }

+#if defined(JSON_HAS_CPP_17)
+        SECTION("std::string_view")
+        {
+            std::string_view const s = j.get<std::string_view>();
+            CHECK(json(s) == j);
+        }
+#endif
+
        SECTION("std::string")
        {
            const std::string s = j;
@@ -1192,4 +1256,11 @@ TEST_CASE("value conversion")
 #endif
 }

+#ifdef JSON_HAS_CPP_17
+    #undef JSON_HAS_CPP_17
+#endif
+
+#ifdef JSON_HAS_CPP_14
+    #undef JSON_HAS_CPP_14
+#endif
 DOCTEST_CLANG_SUPPRESS_WARNING_POP
@@ -1,225 +0,0 @@
-//     __ _____ _____ _____
-//  __|  |   __|     |   | |  JSON for Modern C++ (supporting code)
-// |  |  |__   |  |  | | | |  version 3.12.0
-// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
-//
-// SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
-// SPDX-License-Identifier: MIT
-
-// This file contains the C++17-only part of unit-conversions2.cpp (conversions of
-// std::filesystem::path, std::u8string and std::optional). It is kept in a separate
-// translation unit so the (much larger) unit-conversions2.cpp is built for C++11 only and
-// not rebuilt for every C++ standard.
-
-#include "doctest_compatibility.h"
-
-#include <nlohmann/json.hpp>
-using nlohmann::json;
-
-// workaround for MSVC, which does not set __cplusplus to the language version (#464)
-#if (defined(__cplusplus) && __cplusplus >= 201703L) || (defined(_HAS_CXX17) && _HAS_CXX17 == 1) // fix for issue #464
-    #define JSON_HAS_CPP_17
-#endif
-
-// NLOHMANN_JSON_SERIALIZE_ENUM uses a static std::pair
-DOCTEST_CLANG_SUPPRESS_WARNING_PUSH
-DOCTEST_CLANG_SUPPRESS_WARNING("-Wexit-time-destructors")
-
-#ifdef JSON_HAS_CPP_17
-#include <map>
-#include <stdexcept>
-#include <string>
-#include <string_view>
-#include <type_traits>
-#include <vector>
-
-#if __has_include(<optional>)
-    #include <optional>
-#elif __has_include(<experimental/optional>)
-    #include <experimental/optional>
-#endif
-
-#if JSON_HAS_FILESYSTEM || JSON_HAS_EXPERIMENTAL_FILESYSTEM
-TEST_CASE("std::filesystem::path")
-{
-    SECTION("ascii")
-    {
-        json const j_string = "Path";
-        auto p = j_string.template get<nlohmann::detail::std_fs::path>();
-        json const j_path = p;
-
-        CHECK(j_path.template get<std::string>() ==
-              j_string.template get<std::string>());
-    }
-
-    SECTION("utf-8")
-    {
-        json const j_string = "P\xc4\x9b\xc5\xa1ina";
-        auto p = j_string.template get<nlohmann::detail::std_fs::path>();
-        json const j_path = p;
-
-        CHECK(j_path.template get<std::string>() ==
-              j_string.template get<std::string>());
-    }
-}
-
-#endif
-
-// the ADL to_json overload for std::u8string only exists under the same guard
-// as std::filesystem::path support (it is otherwise only reached indirectly,
-// via std::filesystem::path::u8string()) -- mirror both #if conditions from
-// include/nlohmann/detail/conversions/to_json.hpp exactly
-#if JSON_HAS_FILESYSTEM || JSON_HAS_EXPERIMENTAL_FILESYSTEM
-#if defined(__cpp_lib_char8_t)
-TEST_CASE("std::u8string")
-{
-    SECTION("ascii")
-    {
-        const std::u8string s = u8"Path";
-        json const j = s;
-
-        CHECK(j.template get<std::string>() == "Path");
-    }
-
-    SECTION("utf-8")
-    {
-        // use \u universal-character-names (rather than raw \x byte escapes
-        // or literal non-ASCII source bytes) to compose the multi-byte UTF-8
-        // encoding -- MSVC treats \x escapes used that way inside a u8
-        // literal as a nonstandard extension (warning C5321), which some of
-        // our CI configs promote to an error; \u is portable and produces
-        // the exact same encoded bytes without depending on the source
-        // file's encoding
-        const std::u8string s = u8"P\u011B\u0161ina";
-        json const j = s;
-
-        CHECK(j.template get<std::string>() == "P\xc4\x9b\xc5\xa1ina");
-    }
-}
-
-#endif
-#endif
-
-#if !defined(JSON_NOEXCEPTION)
-namespace
-{
-// a type whose to_json reports an error by throwing, used below to check that
-// converting a std::optional<T> to JSON propagates an exception thrown while
-// converting its contained value instead of calling std::terminate (#5642)
-struct throwing_to_json_type {};
-
-[[noreturn]] void to_json(json& /*unused*/, const throwing_to_json_type& /*unused*/)
-{
-    throw std::runtime_error("cannot serialize throwing_to_json_type");
-}
-}  // namespace
-#endif
-
-TEST_CASE("std::optional")
-{
-    SECTION("null")
-    {
-        const json j_null;
-        const std::optional<std::string> opt_null;
-
-        CHECK(json(opt_null) == j_null);
-        CHECK(j_null.get<std::optional<std::string>>() == std::nullopt);
-
-        // Constructing std::optional<T> directly from JSON null throws because
-        // std::optional's own converting constructor is chosen over basic_json's
-        // operator T(). This is a language-level limitation (std::optional<T> is
-        // constructible from T, and T is constructible from basic_json via the
-        // operator); there is no SFINAE path that distinguishes "call from inside
-        // std::optional's constructor" from "direct call". Use get<std::optional<T>>()
-        // or get_to() instead for correct null handling. See #4864 and #5246.
-        CHECK_THROWS_WITH_AS(std::optional<std::string>(j_null),
-                             "[json.exception.type_error.302] type must be string, but is null", json::type_error&);
-        CHECK_THROWS_WITH_AS(std::optional<int>(j_null),
-                             "[json.exception.type_error.302] type must be number, but is null", json::type_error&);
-
-        // Assignment goes through the same overload resolution as direct
-        // construction, so it throws for the same reason. This relies on
-        // basic_json's implicit conversion operator, so it only applies
-        // when JSON_USE_IMPLICIT_CONVERSIONS is enabled (the default).
-#if JSON_USE_IMPLICIT_CONVERSIONS
-        std::optional<std::string> opt_assign;
-        CHECK_THROWS_WITH_AS(opt_assign = j_null,
-                             "[json.exception.type_error.302] type must be string, but is null", json::type_error&);
-#endif
-
-        // get_to() is the correct way to obtain std::nullopt from a JSON null.
-        std::optional<std::string> opt_get_to = "placeholder";
-        j_null.get_to(opt_get_to);
-        CHECK(opt_get_to == std::nullopt);
-    }
-
-    SECTION("string")
-    {
-        json j_string = "string";
-        std::optional<std::string> opt_string = "string";
-
-        CHECK(json(opt_string) == j_string);
-        CHECK(std::optional<std::string>(j_string) == opt_string);
-        // false positive: Infer attributes the destruction of the temporaries above to opt_string
-        // @infer-ignore USE_AFTER_DELETE
-    }
-
-    SECTION("bool")
-    {
-        json j_bool = true;
-        std::optional<bool> opt_bool = true;
-
-        CHECK(json(opt_bool) == j_bool);
-        CHECK(std::optional<bool>(j_bool) == opt_bool);
-    }
-
-    SECTION("number")
-    {
-        json j_number = 1;
-        std::optional<int> opt_int = 1;
-
-        CHECK(json(opt_int) == j_number);
-        CHECK(j_number.get<std::optional<int>>() == opt_int);
-    }
-
-    SECTION("array")
-    {
-        json j_array = {1, 2, nullptr};
-        std::vector<std::optional<int>> opt_array = {{1, 2, std::nullopt}};
-
-        CHECK(json(opt_array) == j_array);
-        CHECK(j_array.get<std::vector<std::optional<int>>>() == opt_array);
-    }
-
-    SECTION("object")
-    {
-        json j_object = {{"one", 1}, {"two", 2}, {"zero", nullptr}};
-        std::map<std::string, std::optional<int>> opt_object {{"one", 1}, {"two", 2}, {"zero", std::nullopt}};
-
-        CHECK(json(opt_object) == j_object);
-        CHECK(std::map<std::string, std::optional<int>>(j_object) == opt_object);
-    }
-
-#if !defined(JSON_NOEXCEPTION)
-    SECTION("exception from contained value's to_json propagates (#5642)")
-    {
-        // to_json(BasicJsonType&, const std::optional<T>&) must not be
-        // noexcept: it calls T's to_json, which may throw (a user-defined
-        // to_json that reports an error, or std::bad_alloc for T =
-        // std::string/vector/json). Before the fix, this called
-        // std::terminate() instead of letting the exception propagate.
-        const std::optional<throwing_to_json_type> opt = throwing_to_json_type{};
-        CHECK_THROWS_WITH_AS(json(opt), "cannot serialize throwing_to_json_type", std::runtime_error&);
-
-        // the conversion is noexcept exactly when converting the contained value is
-        // (except with MSVC 2017, where it is never noexcept, see to_json.hpp)
-#if !defined(_MSC_VER) || defined(__clang__) || _MSC_VER >= 1920
-        static_assert(!std::is_nothrow_constructible<json, const std::optional<throwing_to_json_type>&>::value);
-        static_assert(std::is_nothrow_constructible<json, const std::optional<int>&>::value);
-#endif
-    }
-#endif
-}
-
-DOCTEST_CLANG_SUPPRESS_WARNING_POP
-#endif
@@ -6,11 +6,12 @@
 // SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
 // SPDX-License-Identifier: MIT

-// cmake/test.cmake builds a unit test with C++ standards beyond C++11 only if the
-// source file mentions the corresponding version macro. To avoid rebuilding this
-// large file for every standard, tests that depend on the standard version (e.g.,
-// those using JSON_HAS_FILESYSTEM, JSON_HAS_RANGES, or JSON_HAS_THREE_WAY_COMPARISON)
-// go into a separate file unit-conversions2-cpp<NN>.cpp. This file stays C++11-only.
+// cmake/test.cmake selects the C++ standard versions with which to build a
+// unit test based on the presence of JSON_HAS_CPP_<VERSION> macros.
+// When using macros that are only defined for particular versions of the standard
+// (e.g., JSON_HAS_FILESYSTEM for C++17 and up), please mention the corresponding
+// version macro in a comment close by, like this:
+// JSON_HAS_CPP_<VERSION> (do not remove; see note at top of file)

 #include "doctest_compatibility.h"

@@ -35,6 +36,25 @@ using nlohmann::json;
 DOCTEST_CLANG_SUPPRESS_WARNING_PUSH
 DOCTEST_CLANG_SUPPRESS_WARNING("-Wexit-time-destructors")

+#if (defined(__cplusplus) && __cplusplus >= 201703L) || (defined(_HAS_CXX17) && _HAS_CXX17 == 1) // fix for issue #464
+    #define JSON_HAS_CPP_17
+    #define JSON_HAS_CPP_14
+#elif (defined(__cplusplus) && __cplusplus >= 201402L) || (defined(_HAS_CXX14) && _HAS_CXX14 == 1)
+    #define JSON_HAS_CPP_14
+#endif
+
+#ifdef JSON_HAS_CPP_17
+    #if __has_include(<optional>)
+        #include <optional>
+    #elif __has_include(<experimental/optional>)
+        #include <experimental/optional>
+    #endif
+#endif
+
+#if defined(JSON_HAS_CPP_17)
+    #include <string_view>
+#endif
+
 TEST_CASE("value conversion")
 {
    SECTION("get a binary value (explicit)")
@@ -660,4 +680,194 @@ TEST_CASE("Strict JSON to enum mapping")
    }
 }

+
+#ifdef JSON_HAS_CPP_17
+#if JSON_HAS_FILESYSTEM || JSON_HAS_EXPERIMENTAL_FILESYSTEM
+TEST_CASE("std::filesystem::path")
+{
+    SECTION("ascii")
+    {
+        json const j_string = "Path";
+        auto p = j_string.template get<nlohmann::detail::std_fs::path>();
+        json const j_path = p;
+
+        CHECK(j_path.template get<std::string>() ==
+              j_string.template get<std::string>());
+    }
+
+    SECTION("utf-8")
+    {
+        json const j_string = "P\xc4\x9b\xc5\xa1ina";
+        auto p = j_string.template get<nlohmann::detail::std_fs::path>();
+        json const j_path = p;
+
+        CHECK(j_path.template get<std::string>() ==
+              j_string.template get<std::string>());
+    }
+}
+#endif
+
+// the ADL to_json overload for std::u8string only exists under the same guard
+// as std::filesystem::path support (it is otherwise only reached indirectly,
+// via std::filesystem::path::u8string()) -- mirror both #if conditions from
+// include/nlohmann/detail/conversions/to_json.hpp exactly
+#if JSON_HAS_FILESYSTEM || JSON_HAS_EXPERIMENTAL_FILESYSTEM
+#if defined(__cpp_lib_char8_t)
+TEST_CASE("std::u8string")
+{
+    SECTION("ascii")
+    {
+        const std::u8string s = u8"Path";
+        json const j = s;
+
+        CHECK(j.template get<std::string>() == "Path");
+    }
+
+    SECTION("utf-8")
+    {
+        // use \u universal-character-names (rather than raw \x byte escapes
+        // or literal non-ASCII source bytes) to compose the multi-byte UTF-8
+        // encoding -- MSVC treats \x escapes used that way inside a u8
+        // literal as a nonstandard extension (warning C5321), which some of
+        // our CI configs promote to an error; \u is portable and produces
+        // the exact same encoded bytes without depending on the source
+        // file's encoding
+        const std::u8string s = u8"P\u011B\u0161ina";
+        json const j = s;
+
+        CHECK(j.template get<std::string>() == "P\xc4\x9b\xc5\xa1ina");
+    }
+}
+#endif
+#endif
+
+#if !defined(JSON_NOEXCEPTION)
+namespace
+{
+// a type whose to_json reports an error by throwing, used below to check that
+// converting a std::optional<T> to JSON propagates an exception thrown while
+// converting its contained value instead of calling std::terminate (#5642)
+struct throwing_to_json_type {};
+
+[[noreturn]] void to_json(json& /*unused*/, const throwing_to_json_type& /*unused*/)
+{
+    throw std::runtime_error("cannot serialize throwing_to_json_type");
+}
+}  // namespace
+#endif
+
+TEST_CASE("std::optional")
+{
+    SECTION("null")
+    {
+        const json j_null;
+        const std::optional<std::string> opt_null;
+
+        CHECK(json(opt_null) == j_null);
+        CHECK(j_null.get<std::optional<std::string>>() == std::nullopt);
+
+        // Constructing std::optional<T> directly from JSON null throws because
+        // std::optional's own converting constructor is chosen over basic_json's
+        // operator T(). This is a language-level limitation (std::optional<T> is
+        // constructible from T, and T is constructible from basic_json via the
+        // operator); there is no SFINAE path that distinguishes "call from inside
+        // std::optional's constructor" from "direct call". Use get<std::optional<T>>()
+        // or get_to() instead for correct null handling. See #4864 and #5246.
+        CHECK_THROWS_WITH_AS(std::optional<std::string>(j_null),
+                             "[json.exception.type_error.302] type must be string, but is null", json::type_error&);
+        CHECK_THROWS_WITH_AS(std::optional<int>(j_null),
+                             "[json.exception.type_error.302] type must be number, but is null", json::type_error&);
+
+        // Assignment goes through the same overload resolution as direct
+        // construction, so it throws for the same reason. This relies on
+        // basic_json's implicit conversion operator, so it only applies
+        // when JSON_USE_IMPLICIT_CONVERSIONS is enabled (the default).
+#if JSON_USE_IMPLICIT_CONVERSIONS
+        std::optional<std::string> opt_assign;
+        CHECK_THROWS_WITH_AS(opt_assign = j_null,
+                             "[json.exception.type_error.302] type must be string, but is null", json::type_error&);
+#endif
+
+        // get_to() is the correct way to obtain std::nullopt from a JSON null.
+        std::optional<std::string> opt_get_to = "placeholder";
+        j_null.get_to(opt_get_to);
+        CHECK(opt_get_to == std::nullopt);
+    }
+
+    SECTION("string")
+    {
+        json j_string = "string";
+        std::optional<std::string> opt_string = "string";
+
+        CHECK(json(opt_string) == j_string);
+        CHECK(std::optional<std::string>(j_string) == opt_string);
+        // false positive: Infer attributes the destruction of the temporaries above to opt_string
+        // @infer-ignore USE_AFTER_DELETE
+    }
+
+    SECTION("bool")
+    {
+        json j_bool = true;
+        std::optional<bool> opt_bool = true;
+
+        CHECK(json(opt_bool) == j_bool);
+        CHECK(std::optional<bool>(j_bool) == opt_bool);
+    }
+
+    SECTION("number")
+    {
+        json j_number = 1;
+        std::optional<int> opt_int = 1;
+
+        CHECK(json(opt_int) == j_number);
+        CHECK(j_number.get<std::optional<int>>() == opt_int);
+    }
+
+    SECTION("array")
+    {
+        json j_array = {1, 2, nullptr};
+        std::vector<std::optional<int>> opt_array = {{1, 2, std::nullopt}};
+
+        CHECK(json(opt_array) == j_array);
+        CHECK(j_array.get<std::vector<std::optional<int>>>() == opt_array);
+    }
+
+    SECTION("object")
+    {
+        json j_object = {{"one", 1}, {"two", 2}, {"zero", nullptr}};
+        std::map<std::string, std::optional<int>> opt_object {{"one", 1}, {"two", 2}, {"zero", std::nullopt}};
+
+        CHECK(json(opt_object) == j_object);
+        CHECK(std::map<std::string, std::optional<int>>(j_object) == opt_object);
+    }
+
+#if !defined(JSON_NOEXCEPTION)
+    SECTION("exception from contained value's to_json propagates (#5642)")
+    {
+        // to_json(BasicJsonType&, const std::optional<T>&) must not be
+        // noexcept: it calls T's to_json, which may throw (a user-defined
+        // to_json that reports an error, or std::bad_alloc for T =
+        // std::string/vector/json). Before the fix, this called
+        // std::terminate() instead of letting the exception propagate.
+        const std::optional<throwing_to_json_type> opt = throwing_to_json_type{};
+        CHECK_THROWS_WITH_AS(json(opt), "cannot serialize throwing_to_json_type", std::runtime_error&);
+
+        // the conversion is noexcept exactly when converting the contained value is
+        // (except with MSVC 2017, where it is never noexcept, see to_json.hpp)
+#if !defined(_MSC_VER) || defined(__clang__) || _MSC_VER >= 1920
+        static_assert(!std::is_nothrow_constructible<json, const std::optional<throwing_to_json_type>&>::value);
+        static_assert(std::is_nothrow_constructible<json, const std::optional<int>&>::value);
+#endif
+    }
+#endif
+}
+#endif
+
+#ifdef JSON_HAS_CPP_17
+    #undef JSON_HAS_CPP_17
+#endif
+
+#ifdef JSON_HAS_CPP_14
+    #undef JSON_HAS_CPP_14
+#endif
 DOCTEST_CLANG_SUPPRESS_WARNING_POP
@@ -22,7 +22,7 @@ namespace

 // std::deque has no capacity() member function, which the library only needs
 // to detect a reallocation for JSON_DIAGNOSTICS
-using deque_json = nlohmann::json::with_array_t<std::deque>;
+using deque_json = nlohmann::basic_json<std::map, std::deque>;

 // a std::vector whose at() is hidden: the library performs its own bounds
 // check and must not fall back to the container's checked accessor
@@ -39,7 +39,7 @@ class vector_without_at : public std::vector<T, Allocator>
    void at() = delete;
 };

-using no_at_json = nlohmann::json::with_array_t<vector_without_at>;
+using no_at_json = nlohmann::basic_json<std::map, vector_without_at>;

 } // namespace

@@ -1,58 +0,0 @@
-//     __ _____ _____ _____
-//  __|  |   __|     |   | |  JSON for Modern C++ (supporting code)
-// |  |  |__   |  |  | | | |  version 3.12.0
-// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
-//
-// SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
-// SPDX-License-Identifier: MIT
-
-// This file contains the C++17-only part of unit-custom-binary-type.cpp (binary types
-// whose value type is std::byte). It is kept in a separate translation unit so the (much
-// larger) unit-custom-binary-type.cpp is built for C++11 only and not rebuilt for every
-// C++ standard.
-
-#include "doctest_compatibility.h"
-
-#include <nlohmann/json.hpp>
-
-#ifdef JSON_HAS_CPP_17
-#include <cstddef>
-#include <cstdint>
-#include <functional>
-#include <map>
-#include <memory>
-#include <string>
-#include <vector>
-
-// a BinaryType whose value type is not an integer type at all
-using byte_binary_json = nlohmann::basic_json <
-                         std::map, std::vector, std::string, bool, std::int64_t, std::uint64_t,
-                         double, std::allocator, nlohmann::adl_serializer, std::vector<std::byte>, void >;
-
-TEST_CASE("binary type whose value type is not std::uint8_t (C++17)")
-{
-    SECTION("dumping a value type that is not an integer")
-    {
-        const std::vector<std::byte> bytes{std::byte{0}, std::byte{1}, std::byte{0xFF}};
-        CHECK(byte_binary_json::binary(bytes).dump() == R"({"bytes":[0,1,255],"subtype":null})");
-        CHECK(byte_binary_json::binary(bytes, 42).dump() == R"({"bytes":[0,1,255],"subtype":42})");
-        CHECK(byte_binary_json::binary({}).dump() == R"({"bytes":[],"subtype":null})");
-    }
-
-    SECTION("hashing and the binary formats")
-    {
-        const std::vector<std::byte> bytes{std::byte{0}, std::byte{1}, std::byte{0xFF}};
-        const auto j = byte_binary_json::binary(bytes);
-
-        CHECK(std::hash<byte_binary_json> {}(j) == std::hash<byte_binary_json> {}(j));
-        CHECK(byte_binary_json::from_cbor(byte_binary_json::to_cbor(j)) == j);
-        CHECK(byte_binary_json::from_msgpack(byte_binary_json::to_msgpack(j)) == j);
-
-        // UBJSON has no binary type, so binary values are written as an array
-        CHECK(byte_binary_json::from_ubjson(byte_binary_json::to_ubjson(j)) == byte_binary_json({0, 1, 255}));
-        // the same holds for BON8
-        CHECK(byte_binary_json::from_bon8(byte_binary_json::to_bon8(j)) == byte_binary_json({0, 1, 255}));
-    }
-}
-
-#endif
@@ -17,6 +17,10 @@
 #include <string>
 #include <vector>

+#ifdef JSON_HAS_CPP_17
+    #include <cstddef>
+#endif
+
 namespace
 {

@@ -26,6 +30,13 @@ using char_binary_json = nlohmann::basic_json <
                         std::map, std::vector, std::string, bool, std::int64_t, std::uint64_t,
                         double, std::allocator, nlohmann::adl_serializer, std::vector<char>, void >;

+#ifdef JSON_HAS_CPP_17
+    // a BinaryType whose value type is not an integer type at all
+    using byte_binary_json = nlohmann::basic_json <
+    std::map, std::vector, std::string, bool, std::int64_t, std::uint64_t,
+    double, std::allocator, nlohmann::adl_serializer, std::vector<std::byte>, void >;
+#endif
+
 } // namespace

 TEST_CASE("binary type whose value type is not std::uint8_t")
@@ -52,4 +63,29 @@ TEST_CASE("binary type whose value type is not std::uint8_t")
    {
        CHECK(nlohmann::json::binary({0, 1, 255}, 42).dump() == R"({"bytes":[0,1,255],"subtype":42})");
    }
+
+#ifdef JSON_HAS_CPP_17
+    SECTION("dumping a value type that is not an integer")
+    {
+        const std::vector<std::byte> bytes{std::byte{0}, std::byte{1}, std::byte{0xFF}};
+        CHECK(byte_binary_json::binary(bytes).dump() == R"({"bytes":[0,1,255],"subtype":null})");
+        CHECK(byte_binary_json::binary(bytes, 42).dump() == R"({"bytes":[0,1,255],"subtype":42})");
+        CHECK(byte_binary_json::binary({}).dump() == R"({"bytes":[],"subtype":null})");
+    }
+
+    SECTION("hashing and the binary formats")
+    {
+        const std::vector<std::byte> bytes{std::byte{0}, std::byte{1}, std::byte{0xFF}};
+        const auto j = byte_binary_json::binary(bytes);
+
+        CHECK(std::hash<byte_binary_json> {}(j) == std::hash<byte_binary_json> {}(j));
+        CHECK(byte_binary_json::from_cbor(byte_binary_json::to_cbor(j)) == j);
+        CHECK(byte_binary_json::from_msgpack(byte_binary_json::to_msgpack(j)) == j);
+
+        // UBJSON has no binary type, so binary values are written as an array
+        CHECK(byte_binary_json::from_ubjson(byte_binary_json::to_ubjson(j)) == byte_binary_json({0, 1, 255}));
+        // the same holds for BON8
+        CHECK(byte_binary_json::from_bon8(byte_binary_json::to_bon8(j)) == byte_binary_json({0, 1, 255}));
+    }
+#endif
 }
@@ -179,7 +179,7 @@ class no_key_compare_map
    }
 };

-using no_key_compare_json = nlohmann::json::with_object_t<no_key_compare_map>;
+using no_key_compare_json = nlohmann::basic_json<no_key_compare_map>;

 // An ObjectType whose erase(iterator) returns void rather than the following
 // iterator, as for instance Abseil's hash maps do
@@ -196,7 +196,7 @@ struct void_erase_map : std::map<Key, T, Compare, Allocator>
    }
 };

-using void_erase_json = nlohmann::json::with_object_t<void_erase_map>;
+using void_erase_json = nlohmann::basic_json<void_erase_map>;

 // wraps an iterator, but only offers the LegacyForwardIterator operations,
 // like the iterators of std::unordered_map and other hash maps
@@ -388,7 +388,7 @@ class forward_only_map
    }
 };

-using forward_only_json = nlohmann::json::with_object_t<forward_only_map>;
+using forward_only_json = nlohmann::basic_json<forward_only_map>;

 } // namespace

@@ -1,177 +0,0 @@
-//     __ _____ _____ _____
-//  __|  |   __|     |   | |  JSON for Modern C++ (supporting code)
-// |  |  |__   |  |  | | | |  version 3.12.0
-// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
-//
-// SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
-// SPDX-License-Identifier: MIT
-
-// This file contains the C++20-only part of unit-deserialization.cpp (char8_t support:
-// _json with char8_t literals and char8_t input). It is kept in a separate translation
-// unit so the (much larger) unit-deserialization.cpp is built for C++11 only and not
-// rebuilt for every C++ standard.
-
-#include "doctest_compatibility.h"
-
-#include <nlohmann/json.hpp>
-using nlohmann::json;
-#ifdef JSON_TEST_NO_GLOBAL_UDLS
-    using namespace nlohmann::literals; // NOLINT(google-build-using-namespace)
-#endif
-
-#ifdef JSON_HAS_CPP_20
-#include <string>
-#include <vector>
-
-#if defined(__cpp_char8_t) && (__cpp_char8_t >= 201811L)
-namespace
-{
-// copy of SaxEventLogger from unit-deserialization.cpp (renamed to avoid clashes in unity builds)
-struct SaxEventLoggerChar8 : public nlohmann::json_sax<json>
-{
-    bool null() override
-    {
-        events.emplace_back("null()");
-        return true;
-    }
-
-    bool boolean(bool val) override
-    {
-        events.emplace_back(val ? "boolean(true)" : "boolean(false)");
-        return true;
-    }
-
-    bool number_integer(json::number_integer_t val) override
-    {
-        events.push_back("number_integer(" + std::to_string(val) + ")");
-        return true;
-    }
-
-    bool number_unsigned(json::number_unsigned_t val) override
-    {
-        events.push_back("number_unsigned(" + std::to_string(val) + ")");
-        return true;
-    }
-
-    bool number_float(json::number_float_t /*val*/, const std::string& s) override
-    {
-        events.push_back("number_float(" + s + ")");
-        return true;
-    }
-
-    bool string(std::string& val) override
-    {
-        events.push_back("string(" + val + ")");
-        return true;
-    }
-
-    bool binary(json::binary_t& val) override
-    {
-        std::string binary_contents = "binary(";
-        std::string comma_space;
-        for (auto b : val)
-        {
-            binary_contents.append(comma_space);
-            binary_contents.append(std::to_string(static_cast<int>(b)));
-            comma_space = ", ";
-        }
-        binary_contents.append(")");
-        events.push_back(binary_contents);
-        return true;
-    }
-
-    bool start_object(std::size_t elements) override
-    {
-        if (elements == (std::numeric_limits<std::size_t>::max)())
-        {
-            events.emplace_back("start_object()");
-        }
-        else
-        {
-            events.push_back("start_object(" + std::to_string(elements) + ")");
-        }
-        return true;
-    }
-
-    bool key(std::string& val) override
-    {
-        events.push_back("key(" + val + ")");
-        return true;
-    }
-
-    bool end_object() override
-    {
-        events.emplace_back("end_object()");
-        return true;
-    }
-
-    bool start_array(std::size_t elements) override
-    {
-        if (elements == (std::numeric_limits<std::size_t>::max)())
-        {
-            events.emplace_back("start_array()");
-        }
-        else
-        {
-            events.push_back("start_array(" + std::to_string(elements) + ")");
-        }
-        return true;
-    }
-
-    bool end_array() override
-    {
-        events.emplace_back("end_array()");
-        return true;
-    }
-
-    bool parse_error(std::size_t position, const std::string& /*last_token*/, const json::exception& /*ex*/) override
-    {
-        events.push_back("parse_error(" + std::to_string(position) + ")");
-        return false;
-    }
-
-    std::vector<std::string> events {}; // NOLINT(readability-redundant-member-init)
-};
-} // namespace
-
-TEST_CASE_TEMPLATE("deserialization of different character types (ASCII) (C++20)", T, char8_t) // NOLINT(readability-math-missing-parentheses, bugprone-throwing-static-initialization)
-{
-    std::vector<T> const v = {'t', 'r', 'u', 'e'};
-    CHECK(json::parse(v) == json(true));
-    CHECK(json::accept(v));
-
-    SaxEventLoggerChar8 l;
-    CHECK(json::sax_parse(v, &l));
-    CHECK(l.events.size() == 1);
-    CHECK(l.events == std::vector<std::string>({"boolean(true)"}));
-}
-#endif
-
-TEST_CASE("deserialization (C++20)")
-{
-#if defined(__cpp_char8_t)
-    SECTION("Using _json with char8_t literals #4945")
-    {
-        // Regular narrow string literal
-        const auto j1 = R"({"key": "value", "num": 42})"_json;
-        CHECK(j1["key"] == "value");
-        CHECK(j1["num"] == 42);
-
-        // UTF-8 prefixed literal (C++20 and later); the emoji is written as a
-        // \U escape rather than a raw multibyte character so this does not
-        // depend on the compiler's source-file encoding (e.g., MSVC without
-        // /utf-8, or classic ICC, which does not encode non-ASCII narrow
-        // string literals as UTF-8 - compare against a \x-escaped expectation
-        // for the same reason)
-        const auto j2 = u8"{\"emoji\": \"\U0001F600\", \"msg\": \"hello\"}"_json;
-        CHECK(j2["emoji"] == "\xF0\x9F\x98\x80");
-        CHECK(j2["msg"] == "hello");
-
-        const auto j3 = u8R"({"key": "value", "num": 42})"_json;
-        CHECK(j3["key"] == "value");
-        CHECK(j3["num"] == 42);
-    }
-#endif
-}
-
-#endif
@@ -1306,9 +1306,44 @@ TEST_CASE("deserialization")
            CHECK(line == "foo");
        }
    }
+
+    // build with C++20
+    // JSON_HAS_CPP_20
+#if defined(__cpp_char8_t)
+    SECTION("Using _json with char8_t literals #4945")
+    {
+        // Regular narrow string literal
+        const auto j1 = R"({"key": "value", "num": 42})"_json;
+        CHECK(j1["key"] == "value");
+        CHECK(j1["num"] == 42);
+
+        // UTF-8 prefixed literal (C++20 and later); the emoji is written as a
+        // \U escape rather than a raw multibyte character so this does not
+        // depend on the compiler's source-file encoding (e.g., MSVC without
+        // /utf-8, or classic ICC, which does not encode non-ASCII narrow
+        // string literals as UTF-8 - compare against a \x-escaped expectation
+        // for the same reason)
+        const auto j2 = u8"{\"emoji\": \"\U0001F600\", \"msg\": \"hello\"}"_json;
+        CHECK(j2["emoji"] == "\xF0\x9F\x98\x80");
+        CHECK(j2["msg"] == "hello");
+
+        const auto j3 = u8R"({"key": "value", "num": 42})"_json;
+        CHECK(j3["key"] == "value");
+        CHECK(j3["num"] == 42);
+    }
+#endif
 }

-TEST_CASE_TEMPLATE("deserialization of different character types (ASCII)", T, char, wchar_t, char16_t, char32_t) // NOLINT(readability-math-missing-parentheses, bugprone-throwing-static-initialization)
+// select the types to test - char8_t is only available since C++20 if and only
+// if __cpp_char8_t is defined.
+#define TYPE_LIST(...) __VA_ARGS__
+#if defined(__cpp_char8_t) && (__cpp_char8_t >= 201811L)
+    #define ASCII_TYPES TYPE_LIST(char, wchar_t, char16_t, char32_t, char8_t)
+#else
+    #define ASCII_TYPES TYPE_LIST(char, wchar_t, char16_t, char32_t)
+#endif
+
+TEST_CASE_TEMPLATE("deserialization of different character types (ASCII)", T, ASCII_TYPES) // NOLINT(readability-math-missing-parentheses, bugprone-throwing-static-initialization)
 {
    std::vector<T> const v = {'t', 'r', 'u', 'e'};
    CHECK(json::parse(v) == json(true));
@@ -27,9 +27,6 @@ using nlohmann::json;
 DOCTEST_CLANG_SUPPRESS_WARNING_PUSH
 DOCTEST_CLANG_SUPPRESS_WARNING("-Wexit-time-destructors")

-// the types live in a namespace, because the file may be compiled together with other test files
-namespace enum_keyed_maps_default
-{
 enum class cards {kreuz, pik, herz, karo};

 // NOLINTNEXTLINE(misc-use-internal-linkage,misc-const-correctness,cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays) - false positive
@@ -68,7 +65,6 @@ NLOHMANN_JSON_SERIALIZE_ENUM_STRICT(strict_cards,
    {strict_cards::herz, "herz"},
    {strict_cards::karo, "karo"}
 })
-} // namespace enum_keyed_maps_default

 namespace
 {
@@ -86,15 +82,6 @@ struct enum_hash
 // see unit-enum_keyed_maps.cpp for JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS=1
 TEST_CASE("maps with enum keys")
 {
-    // block-scope using-declarations take precedence over same-named types of other files in the same translation unit
-    using enum_keyed_maps_default::cards;
-    using enum_keyed_maps_default::strict_cards;
-    using enum_keyed_maps_default::TaskState;
-    using enum_keyed_maps_default::TS_COMPLETED;
-    using enum_keyed_maps_default::TS_INVALID;
-    using enum_keyed_maps_default::TS_RUNNING;
-    using enum_keyed_maps_default::TS_STOPPED;
-
    using task_map = std::map<TaskState, std::string>;
    using task_umap = std::unordered_map<TaskState, std::string, enum_hash>;
    using task_gmap = std::map<TaskState, std::string, std::greater<TaskState>>;
@@ -6,11 +6,11 @@
 // SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
 // SPDX-License-Identifier: MIT

-// cmake/test.cmake builds a unit test with C++ standards beyond C++11 only if the
-// source file mentions the corresponding version macro. The regression below only
-// showed on C++17, and the whole file is just this explicit instantiation, so it
-// cannot be split: build this file for every standard like the other regression tests:
-// JSON_HAS_CPP_17 JSON_HAS_CPP_20 (do not remove)
+// cmake/test.cmake selects the C++ standard versions with which to build a
+// unit test based on the presence of JSON_HAS_CPP_<VERSION> macros.
+// The regression below only showed on C++17, so build this file for every
+// standard like the other regression tests:
+// JSON_HAS_CPP_17 JSON_HAS_CPP_20 (do not remove; see note at top of file)

 #include "doctest_compatibility.h"

@@ -157,13 +157,13 @@ TEST_CASE("hash<nlohmann::json>")
    // the ends of the integer ranges, which equal floats exactly
    const auto int_min = (std::numeric_limits<json::number_integer_t>::min)();
    const auto int_max = (std::numeric_limits<json::number_integer_t>::max)();
-    const auto two_63 = static_cast<json::number_unsigned_t>(1) << 63U;
+    const auto two_63 = json::number_unsigned_t(1) << 63U;
    CHECK(json(int_min) == json(-9223372036854775808.0));
    CHECK(std::hash<json> {}(json(int_min)) == std::hash<json> {}(json(-9223372036854775808.0)));
    CHECK(json(two_63) == json(9223372036854775808.0));
    CHECK(std::hash<json> {}(json(two_63)) == std::hash<json> {}(json(9223372036854775808.0)));
-    CHECK(json(static_cast<json::number_unsigned_t>(int_max)) == json(int_max));
-    CHECK(std::hash<json> {}(json(static_cast<json::number_unsigned_t>(int_max))) == std::hash<json> {}(json(int_max)));
+    CHECK(json(json::number_unsigned_t(int_max)) == json(int_max));
+    CHECK(std::hash<json> {}(json(json::number_unsigned_t(int_max))) == std::hash<json> {}(json(int_max)));
 }

 TEST_CASE("hash<nlohmann::ordered_json>")
@@ -1,122 +0,0 @@
-//     __ _____ _____ _____
-//  __|  |   __|     |   | |  JSON for Modern C++ (supporting code)
-// |  |  |__   |  |  | | | |  version 3.12.0
-// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
-//
-// SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
-// SPDX-License-Identifier: MIT
-
-// This file contains the C++20-only part of unit-iterators2.cpp (iterators and
-// std::ranges). It is kept in a separate translation unit so the (much larger) unit-
-// iterators2.cpp is built for C++11 only and not rebuilt for every C++ standard.
-
-#include "doctest_compatibility.h"
-
-#include <nlohmann/json.hpp>
-using nlohmann::json;
-
-#ifdef JSON_HAS_CPP_20
-#include <iterator>
-#include <string>
-#include <string_view>
-#include <type_traits>
-#include <utility>
-
-#if JSON_HAS_RANGES
-    #include <algorithm>
-    #include <ranges>
-#endif
-
-TEST_CASE("iterators 2 (C++20)")
-{
-#if JSON_HAS_RANGES
-    SECTION("ranges")
-    {
-        SECTION("concepts")
-        {
-            using nlohmann::detail::iteration_proxy_value;
-            CHECK(std::bidirectional_iterator<json::iterator>);
-            CHECK(std::input_iterator<iteration_proxy_value<json::iterator>>);
-
-            CHECK(std::is_same<json::iterator, std::ranges::iterator_t<json>>::value);
-            CHECK(std::ranges::bidirectional_range<json>);
-
-            using nlohmann::detail::iteration_proxy;
-            using items_type = decltype(std::declval<json&>().items());
-            CHECK(std::is_same<items_type, iteration_proxy<json::iterator>>::value);
-            CHECK(std::is_same<iteration_proxy_value<json::iterator>, std::ranges::iterator_t<items_type>>::value);
-            CHECK(std::ranges::input_range<items_type>);
-        }
-
-        SECTION("algorithms")
-        {
-            SECTION("copy")
-            {
-                json j{"foo", "bar"};
-                auto j_copied = json::array();
-
-                std::ranges::copy(j, std::back_inserter(j_copied));
-
-                CHECK(j == j_copied);
-            }
-
-            SECTION("find_if")
-            {
-                json j{1, 3, 2, 4};
-                auto j_even = json::array();
-
-#if JSON_USE_IMPLICIT_CONVERSIONS
-                auto it = std::ranges::find_if(j, [](int v) noexcept
-                {
-                    return (v % 2) == 0;
-                });
-#else
-                auto it = std::ranges::find_if(j, [](const json & j) noexcept
-                {
-                    int v;
-                    j.get_to(v);
-                    return (v % 2) == 0;
-                });
-#endif
-
-                CHECK(*it == 2);
-            }
-        }
-
-        SECTION("views")
-        {
-            SECTION("reverse")
-            {
-                json j{1, 2, 3, 4, 5};
-                json j_expected{5, 4, 3, 2, 1};
-
-                auto reversed = j | std::views::reverse;
-                CHECK(reversed == j_expected);
-            }
-
-            SECTION("transform")
-            {
-                json j
-                {
-                    { "a_key", "a_value"},
-                    { "b_key", "b_value"},
-                    { "c_key", "c_value"},
-                };
-                json j_expected{"a_key", "b_key", "c_key"};
-
-                // NOLINTNEXTLINE(fuchsia-trailing-return)
-                auto transformed = j.items() | std::views::transform([](const auto & item) -> std::string_view
-                {
-                    return item.key();
-                });
-                auto j_transformed = json::array();
-                std::ranges::copy(transformed, std::back_inserter(j_transformed));
-
-                CHECK(j_transformed == j_expected);
-            }
-        }
-    }
-#endif
-}
-
-#endif
@@ -6,17 +6,23 @@
 // SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
 // SPDX-License-Identifier: MIT

-// cmake/test.cmake builds a unit test with C++ standards beyond C++11 only if the
-// source file mentions the corresponding version macro. To avoid rebuilding this
-// large file for every standard, tests that depend on the standard version (e.g.,
-// those using JSON_HAS_FILESYSTEM, JSON_HAS_RANGES, or JSON_HAS_THREE_WAY_COMPARISON)
-// go into a separate file unit-iterators2-cpp<NN>.cpp. This file stays C++11-only.
+// cmake/test.cmake selects the C++ standard versions with which to build a
+// unit test based on the presence of JSON_HAS_CPP_<VERSION> macros.
+// When using macros that are only defined for particular versions of the standard
+// (e.g., JSON_HAS_FILESYSTEM for C++17 and up), please mention the corresponding
+// version macro in a comment close by, like this:
+// JSON_HAS_CPP_<VERSION> (do not remove; see note at top of file)

 #include "doctest_compatibility.h"

 #include <nlohmann/json.hpp>
 using nlohmann::json;

+#if JSON_HAS_RANGES
+    #include <algorithm>
+    #include <ranges>
+#endif
+
 TEST_CASE("iterators 2")
 {
    SECTION("iterator comparisons")
@@ -866,4 +872,94 @@ TEST_CASE("iterators 2")
            }
        }
    }
+
+#if JSON_HAS_RANGES
+    // JSON_HAS_CPP_20 (do not remove; see note at top of file)
+    SECTION("ranges")
+    {
+        SECTION("concepts")
+        {
+            using nlohmann::detail::iteration_proxy_value;
+            CHECK(std::bidirectional_iterator<json::iterator>);
+            CHECK(std::input_iterator<iteration_proxy_value<json::iterator>>);
+
+            CHECK(std::is_same<json::iterator, std::ranges::iterator_t<json>>::value);
+            CHECK(std::ranges::bidirectional_range<json>);
+
+            using nlohmann::detail::iteration_proxy;
+            using items_type = decltype(std::declval<json&>().items());
+            CHECK(std::is_same<items_type, iteration_proxy<json::iterator>>::value);
+            CHECK(std::is_same<iteration_proxy_value<json::iterator>, std::ranges::iterator_t<items_type>>::value);
+            CHECK(std::ranges::input_range<items_type>);
+        }
+
+        SECTION("algorithms")
+        {
+            SECTION("copy")
+            {
+                json j{"foo", "bar"};
+                auto j_copied = json::array();
+
+                std::ranges::copy(j, std::back_inserter(j_copied));
+
+                CHECK(j == j_copied);
+            }
+
+            SECTION("find_if")
+            {
+                json j{1, 3, 2, 4};
+                auto j_even = json::array();
+
+#if JSON_USE_IMPLICIT_CONVERSIONS
+                auto it = std::ranges::find_if(j, [](int v) noexcept
+                {
+                    return (v % 2) == 0;
+                });
+#else
+                auto it = std::ranges::find_if(j, [](const json & j) noexcept
+                {
+                    int v;
+                    j.get_to(v);
+                    return (v % 2) == 0;
+                });
+#endif
+
+                CHECK(*it == 2);
+            }
+        }
+
+        SECTION("views")
+        {
+            SECTION("reverse")
+            {
+                json j{1, 2, 3, 4, 5};
+                json j_expected{5, 4, 3, 2, 1};
+
+                auto reversed = j | std::views::reverse;
+                CHECK(reversed == j_expected);
+            }
+
+            SECTION("transform")
+            {
+                json j
+                {
+                    { "a_key", "a_value"},
+                    { "b_key", "b_value"},
+                    { "c_key", "c_value"},
+                };
+                json j_expected{"a_key", "b_key", "c_key"};
+
+                // NOLINTNEXTLINE(fuchsia-trailing-return)
+                auto transformed = j.items() | std::views::transform([](const auto & item) -> std::string_view
+                {
+                    return item.key();
+                });
+                auto j_transformed = json::array();
+                std::ranges::copy(transformed, std::back_inserter(j_transformed));
+
+                CHECK(j_transformed == j_expected);
+            }
+        }
+    }
+#endif
 }
@@ -1,145 +0,0 @@
-//     __ _____ _____ _____
-//  __|  |   __|     |   | |  JSON for Modern C++ (supporting code)
-// |  |  |__   |  |  | | | |  version 3.12.0
-// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
-//
-// SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
-// SPDX-License-Identifier: MIT
-
-// This file contains the C++20-only part of unit-json_pointer.cpp (JSON pointer comparison
-// with C++20 rewritten candidates and operator<=>, and char8_t literals). It is kept in a
-// separate translation unit so the (much larger) unit-json_pointer.cpp is built for C++11
-// only and not rebuilt for every C++ standard.
-
-#include "doctest_compatibility.h"
-
-// capture whether JSON_DELETE_DEPRECATED_FUNCTIONS was enabled on the command
-// line *before* including json.hpp, since the library #undefs it once the header
-// has been fully processed (see include/nlohmann/detail/macro_unscope.hpp); the
-// tests of deprecated functions are skipped if these functions are deleted
-#if defined(JSON_DELETE_DEPRECATED_FUNCTIONS) && (JSON_DELETE_DEPRECATED_FUNCTIONS == 1)
-    #define JSON_TEST_DEPRECATED_FUNCTIONS_DELETED
-#endif
-
-#include <nlohmann/json.hpp>
-using nlohmann::json;
-#ifdef JSON_TEST_NO_GLOBAL_UDLS
-    using namespace nlohmann::literals; // NOLINT(google-build-using-namespace)
-#endif
-
-#ifdef JSON_HAS_CPP_20
-#include <compare>
-#include <string>
-#include <type_traits>
-
-TEST_CASE("JSON pointers (C++20)")
-{
-    SECTION("equality comparison")
-    {
-        std::string ptr_string{"/foo/bar"};
-        auto ptr1 = json::json_pointer(ptr_string);
-        auto ptr2 = json::json_pointer(ptr_string);
-
-        CHECK(ptr1 == ptr2);
-
-        CHECK_FALSE(ptr1 != ptr2);
-
-#ifndef JSON_TEST_DEPRECATED_FUNCTIONS_DELETED
-        const char* ptr_cpstring = "/foo/bar";
-        const char ptr_castring[] = "/foo/bar"; // NOLINT(misc-const-correctness,hicpp-avoid-c-arrays,modernize-avoid-c-arrays,cppcoreguidelines-avoid-c-arrays)
-
-        CHECK(ptr1 == "/foo/bar");
-        CHECK(ptr1 == ptr_cpstring);
-        CHECK(ptr1 == ptr_castring);
-        CHECK(ptr1 == ptr_string);
-
-        CHECK("/foo/bar" == ptr1);
-        CHECK(ptr_cpstring == ptr1);
-        CHECK(ptr_castring == ptr1);
-        CHECK(ptr_string == ptr1);
-
-        CHECK_FALSE(ptr1 != "/foo/bar");
-        CHECK_FALSE(ptr1 != ptr_cpstring);
-        CHECK_FALSE(ptr1 != ptr_castring);
-        CHECK_FALSE(ptr1 != ptr_string);
-
-        CHECK_FALSE("/foo/bar" != ptr1);
-        CHECK_FALSE(ptr_cpstring != ptr1);
-        CHECK_FALSE(ptr_castring != ptr1);
-        CHECK_FALSE(ptr_string != ptr1);
-
-        SECTION("exceptions")
-        {
-            CHECK_THROWS_WITH_AS(ptr1 == "foo",
-                                 "[json.exception.parse_error.107] parse error at byte 1: JSON pointer must be empty or begin with '/' - was: 'foo'", json::parse_error&);
-            CHECK_THROWS_WITH_AS("foo" == ptr1,
-                                 "[json.exception.parse_error.107] parse error at byte 1: JSON pointer must be empty or begin with '/' - was: 'foo'", json::parse_error&);
-            CHECK_THROWS_WITH_AS(ptr1 == "/~~",
-                                 "[json.exception.parse_error.108] parse error: escape character '~' must be followed with '0' or '1'", json::parse_error&);
-            CHECK_THROWS_WITH_AS("/~~" == ptr1,
-                                 "[json.exception.parse_error.108] parse error: escape character '~' must be followed with '0' or '1'", json::parse_error&);
-        }
-#endif
-    }
-
-    SECTION("less-than comparison")
-    {
-        auto ptr1 = json::json_pointer("/foo/a");
-        auto ptr2 = json::json_pointer("/foo/b");
-
-#if JSON_HAS_THREE_WAY_COMPARISON
-        CHECK((ptr1 <=> ptr2) == std::strong_ordering::less); // *NOPAD*
-        CHECK(ptr2 > ptr1);
-#endif
-    }
-
-    SECTION("backwards compatibility and mixing")
-    {
-        json j = R"(
-        {
-            "foo": ["bar", "baz"]
-        }
-        )"_json;
-
-        using nlohmann::ordered_json;
-        using json_ptr_str = nlohmann::json_pointer<std::string>;
-        using json_ptr_j = nlohmann::json_pointer<json>;
-        using json_ptr_oj = nlohmann::json_pointer<ordered_json>;
-
-        std::string const ptr_string{"/foo/0"};
-        json_ptr_str ptr{ptr_string};
-        json_ptr_j ptr_j{ptr_string};
-        json_ptr_oj ptr_oj{ptr_string};
-
-        SECTION("equality comparison")
-        {
-            CHECK(ptr == ptr_j);
-            CHECK(ptr == ptr_oj);
-            CHECK(ptr_j == ptr);
-            CHECK(ptr_j == ptr_oj);
-            CHECK(ptr_oj == ptr_j);
-            CHECK(ptr_oj == ptr);
-
-            CHECK_FALSE(ptr != ptr_j);
-            CHECK_FALSE(ptr != ptr_oj);
-            CHECK_FALSE(ptr_j != ptr);
-            CHECK_FALSE(ptr_j != ptr_oj);
-            CHECK_FALSE(ptr_oj != ptr_j);
-            CHECK_FALSE(ptr_oj != ptr);
-        }
-    }
-
-#if defined(__cpp_char8_t)
-    SECTION("Using _json_pointer with char8_t literals #4945")
-    {
-        const json j = R"({"a": {"b": {"c": 123}}})"_json;
-        const auto p1 = "/a/b/c"_json_pointer;
-        CHECK(j[p1] == 123);
-
-        const auto p2 = u8"/a/b/c"_json_pointer;
-        CHECK(j[p2] == 123);
-    }
-#endif
-}
-
-#endif
@@ -752,13 +752,14 @@ TEST_CASE("JSON pointers")
        CHECK(ptr.to_string() == "/object/~1");
    }

-#if !JSON_HAS_THREE_WAY_COMPARISON // with three-way comparison, see unit-json_pointer-cpp20.cpp
    SECTION("equality comparison")
    {
        std::string ptr_string{"/foo/bar"};
        auto ptr1 = json::json_pointer(ptr_string);
        auto ptr2 = json::json_pointer(ptr_string);

+        // build with C++20 to test rewritten candidates
+        // JSON_HAS_CPP_20

        CHECK(ptr1 == ptr2);

@@ -801,7 +802,6 @@ TEST_CASE("JSON pointers")
        }
 #endif
    }
-#endif

    SECTION("less-than comparison")
    {
@@ -811,6 +811,12 @@ TEST_CASE("JSON pointers")
        CHECK(ptr1 < ptr2);
        CHECK_FALSE(ptr2 < ptr1);

+        // build with C++20
+        // JSON_HAS_CPP_20
+#if JSON_HAS_THREE_WAY_COMPARISON
+        CHECK((ptr1 <=> ptr2) == std::strong_ordering::less); // *NOPAD*
+        CHECK(ptr2 > ptr1);
+#endif
    }

    SECTION("usable as map key")
@@ -866,9 +872,10 @@ TEST_CASE("JSON pointers")
        CHECK_FALSE(ptr != ptr_j);
        CHECK_FALSE(ptr != ptr_oj);

-#if !JSON_HAS_THREE_WAY_COMPARISON // with three-way comparison, see unit-json_pointer-cpp20.cpp
        SECTION("equality comparison")
        {
+            // build with C++20 to test rewritten candidates
+            // JSON_HAS_CPP_20

            CHECK(ptr == ptr_j);
            CHECK(ptr == ptr_oj);
@@ -884,7 +891,6 @@ TEST_CASE("JSON pointers")
            CHECK_FALSE(ptr_oj != ptr_j);
            CHECK_FALSE(ptr_oj != ptr);
        }
-#endif
    }

    SECTION("value(json_pointer, default) with ordered_json #5664")
@@ -906,6 +912,19 @@ TEST_CASE("JSON pointers")
        CHECK(j.value(ptr_missing, 42) == 42);
    }

+    // build with C++20
+    // JSON_HAS_CPP_20
+#if defined(__cpp_char8_t)
+    SECTION("Using _json_pointer with char8_t literals #4945")
+    {
+        const json j = R"({"a": {"b": {"c": 123}}})"_json;
+        const auto p1 = "/a/b/c"_json_pointer;
+        CHECK(j[p1] == 123);
+
+        const auto p2 = u8"/a/b/c"_json_pointer;
+        CHECK(j[p2] == 123);
+    }
+#endif
 }

 TEST_CASE("unescaping keeps a '~' that does not start an escape sequence")
@@ -426,7 +426,7 @@ TEST_CASE("issue #5392 - binary writers on deeply nested values")
    {
        for (std::size_t depth = 120; depth <= 140; ++depth)
        {
-            CAPTURE(depth)
+            CAPTURE(depth);

            const json array = nested_array(depth, json(7));
            CHECK(json::from_cbor(json::to_cbor(array)) == array);
@@ -464,7 +464,7 @@ TEST_CASE("issue #5392 - binary writers on deeply nested values")
                    nlohmann::detail::recursion_depth_limit() + 1, nlohmann::detail::recursion_depth_limit() + 2
                })
        {
-            CAPTURE(depth)
+            CAPTURE(depth);
            const json array = nested_array(depth, json(0));

            std::vector<std::uint8_t> expected_cbor(depth, 0x81);
@@ -505,22 +505,10 @@ TEST_CASE("issue #5392 - binary writers on deeply nested values")
        const json discarded_leaf(json::value_t::discarded);
        const json deep_discarded = nested_array(depth, discarded_leaf);

-        // with diagnostics, the message names the path to the discarded leaf
-#if JSON_DIAGNOSTICS
-        std::string path;
-        for (std::size_t i = 0; i < depth; ++i)
-        {
-            path += "/0";
-        }
-        const std::string prefix = "[json.exception.type_error.321] (" + path + ") ";
-#else
-        const std::string prefix = "[json.exception.type_error.321] ";
-#endif
-
-        CHECK_THROWS_WITH_AS(json::to_cbor(deep_discarded), (prefix + "cannot serialize discarded value to CBOR").c_str(), json::type_error);
-        CHECK_THROWS_WITH_AS(json::to_msgpack(deep_discarded), (prefix + "cannot serialize discarded value to MessagePack").c_str(), json::type_error);
-        CHECK_THROWS_WITH_AS(json::to_ubjson(deep_discarded), (prefix + "cannot serialize discarded value to UBJSON").c_str(), json::type_error);
-        CHECK_THROWS_WITH_AS(json::to_bjdata(deep_discarded), (prefix + "cannot serialize discarded value to BJData").c_str(), json::type_error);
+        CHECK_THROWS_WITH_AS(json::to_cbor(deep_discarded), "[json.exception.type_error.321] cannot serialize discarded value to CBOR", json::type_error);
+        CHECK_THROWS_WITH_AS(json::to_msgpack(deep_discarded), "[json.exception.type_error.321] cannot serialize discarded value to MessagePack", json::type_error);
+        CHECK_THROWS_WITH_AS(json::to_ubjson(deep_discarded), "[json.exception.type_error.321] cannot serialize discarded value to UBJSON", json::type_error);
+        CHECK_THROWS_WITH_AS(json::to_bjdata(deep_discarded), "[json.exception.type_error.321] cannot serialize discarded value to BJData", json::type_error);
    }

    SECTION("does not overflow the C++ stack")
@@ -172,7 +172,7 @@ TEST_CASE("locale-dependent test (LC_NUMERIC=de_DE)")
            // a floating-point type that is not a float or a double is written
            // with snprintf, whose locale-specific decimal point and thousands
            // separator are undone afterwards
-            using long_double_json = nlohmann::json::with_float_t<long double>;
+            using long_double_json = nlohmann::basic_json<std::map, std::vector, std::string, bool, std::int64_t, std::uint64_t, long double>;
            CHECK(long_double_json(12345.5L).dump() == "12345.5");
            CHECK(long_double_json(1.0L).dump() == "1.0");
            CHECK(long_double_json(-0.25L).dump() == "-0.25");
@@ -272,7 +272,7 @@ TEST_CASE("locale changes between lexer construction and number conversion (#519
    }
    text += "]";

-    using long_double_json = nlohmann::json::with_float_t<long double>;
+    using long_double_json = nlohmann::basic_json<std::map, std::vector, std::string, bool, std::int64_t, std::uint64_t, long double>;

    // reference values, parsed without a locale switch
    REQUIRE(std::setlocale(LC_NUMERIC, "C") != nullptr);
@@ -432,7 +432,7 @@ TEST_CASE("locale changes during a single dump() (#5709 item 3)")
    // long double on 64-bit Arm, where it is IEEE-754 double) takes the
    // locale-independent to_chars() path instead, and this test is a no-op
    // there.
-    using long_double_json = nlohmann::json::with_float_t<long double>;
+    using long_double_json = nlohmann::basic_json<std::map, std::vector, std::string, bool, std::int64_t, std::uint64_t, long double>;
    using ld_limits = std::numeric_limits<long_double_json::number_float_t>;
    const bool is_ieee_single_or_double =
        (ld_limits::is_iec559 && ld_limits::digits == 24 && ld_limits::max_exponent == 128) ||
@@ -46,7 +46,7 @@ void reference_merge_patch(json& target, const json& patch)

 // objects nested `depth` levels deep under the key "a", with members that
 // differ by `variant` on the way down
-std::string nested_objects_merge_patch(const std::size_t depth, const int variant)
+std::string nested_objects(const std::size_t depth, const int variant)
 {
    std::string text;
    for (std::size_t i = 0; i < depth; ++i)
@@ -309,9 +309,9 @@ TEST_CASE("JSON Merge Patch on deeply nested values")
            for (int variant = 0; variant < 3; ++variant)
            {
                CAPTURE(variant)
-                const json patch = json::parse(nested_objects_merge_patch(depth, variant));
+                const json patch = json::parse(nested_objects(depth, variant));

-                json result = json::parse(nested_objects_merge_patch(depth, (variant + 1) % 3));
+                json result = json::parse(nested_objects(depth, (variant + 1) % 3));
                json expected = result;
                result.merge_patch(patch);
                reference_merge_patch(expected, patch);
@@ -332,8 +332,8 @@ TEST_CASE("JSON Merge Patch on deeply nested values")
        // applying a patch used to recurse once per nesting level. The result
        // is only walked, never copied or compared, since those recurse too.
        const std::size_t depth = 100000;
-        json target = json::parse(nested_objects_merge_patch(depth, 0));
-        target.merge_patch(json::parse(nested_objects_merge_patch(depth, 1)));
+        json target = json::parse(nested_objects(depth, 0));
+        target.merge_patch(json::parse(nested_objects(depth, 1)));

        const json* p = &target;
        for (std::size_t i = 0; i < depth; ++i)
@@ -404,7 +404,7 @@ TEST_CASE("merge_patch() with an argument that aliases *this (#5641)")
                })
        {
            CAPTURE(depth)
-            json j = json::parse(nested_objects_merge_patch(depth, 0));
+            json j = json::parse(nested_objects(depth, 0));
            const json expected = j;
            j.merge_patch(j);
            CHECK(j == expected);
@@ -35,7 +35,7 @@ void reference_update(json& target, const json& source)

 // objects nested `depth` levels deep under the key "a", with members that
 // differ by `variant` on the way down
-std::string nested_objects_update(const std::size_t depth, const int variant)
+std::string nested_objects(const std::size_t depth, const int variant)
 {
    std::string text;
    for (std::size_t i = 0; i < depth; ++i)
@@ -1131,8 +1131,8 @@ TEST_CASE("update() on deeply nested values")
            for (int variant = 0; variant < 3; ++variant)
            {
                CAPTURE(variant)
-                const json source = json::parse(nested_objects_update(depth, variant));
-                json result = json::parse(nested_objects_update(depth, (variant + 1) % 3));
+                const json source = json::parse(nested_objects(depth, variant));
+                json result = json::parse(nested_objects(depth, (variant + 1) % 3));
                json expected = result;
                result.update(source, true);
                reference_update(expected, source);
@@ -1146,8 +1146,8 @@ TEST_CASE("update() on deeply nested values")
        // merging used to recurse once per nesting level. The result is only
        // walked, never copied or compared, since those recurse too.
        const std::size_t depth = 100000;
-        json target = json::parse(nested_objects_update(depth, 0));
-        target.update(json::parse(nested_objects_update(depth, 1)), true);
+        json target = json::parse(nested_objects(depth, 0));
+        target.update(json::parse(nested_objects(depth, 1)), true);

        const json* p = &target;
        for (std::size_t i = 0; i < depth; ++i)
@@ -1223,7 +1223,7 @@ TEST_CASE("update() with an argument that aliases *this (#5641)")
                })
        {
            CAPTURE(depth)
-            json j = json::parse(nested_objects_update(depth, 0));
+            json j = json::parse(nested_objects(depth, 0));
            const json expected = j;
            j.update(j, true);
            CHECK(j == expected);
@@ -2285,7 +2285,7 @@ TEST_CASE("MessagePack Size above uint32 for object")
 }

 #ifdef JSON_TEST_BEYOND_UINT32_STRING
-struct msgpack_huge_string : std::string
+struct huge_string : std::string
 {
    using std::string::string;

@@ -2295,31 +2295,31 @@ struct msgpack_huge_string : std::string
    }
 };

-using msgpack_huge_string_json = nlohmann::basic_json <
-                                 std::map,
-                                 std::vector,
-                                 msgpack_huge_string,
-                                 bool,
-                                 std::int64_t,
-                                 std::uint64_t,
-                                 double,
-                                 std::allocator,
-                                 nlohmann::adl_serializer,
-                                 std::vector<std::uint8_t>,
-                                 void >;
+using huge_string_json = nlohmann::basic_json <
+                         std::map,
+                         std::vector,
+                         huge_string,
+                         bool,
+                         std::int64_t,
+                         std::uint64_t,
+                         double,
+                         std::allocator,
+                         nlohmann::adl_serializer,
+                         std::vector<std::uint8_t>,
+                         void >;

 TEST_CASE("MessagePack Size above uint32 for string")
 {
-    const msgpack_huge_string_json j = "hello";
+    const huge_string_json j = "hello";

    CHECK_THROWS_WITH_AS(
-        msgpack_huge_string_json::to_msgpack(j),
+        huge_string_json::to_msgpack(j),
        "[json.exception.out_of_range.412] MessagePack length 4294967296 exceeds maximum of 4294967295",
        json::out_of_range&);
 }
 #endif

-struct msgpack_huge_binary : std::vector<std::uint8_t>
+struct huge_binary : std::vector<std::uint8_t>
 {
    using std::vector<std::uint8_t>::vector;

@@ -2329,29 +2329,29 @@ struct msgpack_huge_binary : std::vector<std::uint8_t>
    }
 };

-using msgpack_huge_binary_json = nlohmann::basic_json <
-                                 std::map,
-                                 std::vector,
-                                 std::string,
-                                 bool,
-                                 std::int64_t,
-                                 std::uint64_t,
-                                 double,
-                                 std::allocator,
-                                 nlohmann::adl_serializer,
-                                 msgpack_huge_binary,
-                                 void >;
+using huge_binary_json = nlohmann::basic_json <
+                         std::map,
+                         std::vector,
+                         std::string,
+                         bool,
+                         std::int64_t,
+                         std::uint64_t,
+                         double,
+                         std::allocator,
+                         nlohmann::adl_serializer,
+                         huge_binary,
+                         void >;

 TEST_CASE("MessagePack Size above uint32 for binary")
 {

-    msgpack_huge_binary_json j = msgpack_huge_binary_json::binary(msgpack_huge_binary{});
+    huge_binary_json j = huge_binary_json::binary(huge_binary{});

    j.get_binary().push_back(0x01);
    j.get_binary().push_back(0x02);

    CHECK_THROWS_WITH_AS(
-        msgpack_huge_binary_json::to_msgpack(j),
+        huge_binary_json::to_msgpack(j),
        "[json.exception.out_of_range.412] MessagePack length 4294967296 exceeds maximum of 4294967295",
        json::out_of_range&);
 }
@@ -2432,8 +2432,8 @@ TEST_CASE("MessagePack numbers use the active union member (see #5644)")
    // used to read the union member that was not the active one, writing
    // wrong bytes for some values; std::int64_t/std::uint64_t (the default
    // types, where both members have the same width) were not affected
-    using int32_json = nlohmann::json::with_integers_t<std::int32_t, std::uint64_t>;
-    using int16_json = nlohmann::json::with_integers_t<std::int16_t, std::uint64_t>;
+    using int32_json = nlohmann::basic_json<std::map, std::vector, std::string, bool, std::int32_t, std::uint64_t, double>;
+    using int16_json = nlohmann::basic_json<std::map, std::vector, std::string, bool, std::int16_t, std::uint64_t, double>;

    SECTION("number_integer_t = std::int32_t")
    {
@@ -44,8 +44,6 @@ using nlohmann::ordered_json;
 // this type, which is presumably why the gap was never noticed.
 /////////////////////////////////////////////////////////////////////////////

-namespace unit_ordered_json2_detail
-{
 class alt_string;
 bool operator<(const char* op1, const alt_string& op2) noexcept; // NOLINT(misc-use-internal-linkage)
 void int_to_string(alt_string& target, std::size_t value); // NOLINT(misc-use-internal-linkage)
@@ -219,24 +217,21 @@ void int_to_string(alt_string& target, std::size_t value)
    target = std::to_string(value).c_str();
 }

-using ordered_json2_alt_json = nlohmann::basic_json <
-                               std::map,
-                               std::vector,
-                               alt_string,
-                               bool,
-                               std::int64_t,
-                               std::uint64_t,
-                               double,
-                               std::allocator,
-                               nlohmann::adl_serializer >;
+using alt_json = nlohmann::basic_json <
+                 std::map,
+                 std::vector,
+                 alt_string,
+                 bool,
+                 std::int64_t,
+                 std::uint64_t,
+                 double,
+                 std::allocator,
+                 nlohmann::adl_serializer >;

 bool operator<(const char* op1, const alt_string& op2) noexcept
 {
    return op1 < op2.str_impl;
 }
-} // namespace unit_ordered_json2_detail
-
-using unit_ordered_json2_detail::ordered_json2_alt_json;

 namespace
 {
@@ -267,11 +262,11 @@ ordered_json make_rich_ordered_json()
    return j;
 }

-ordered_json2_alt_json make_rich_alt_json()
+alt_json make_rich_alt_json()
 {
-    ordered_json2_alt_json j;
+    alt_json j;
    j["zebra"] = 1;
-    j["apple"] = ordered_json2_alt_json::array({1, 2, 3});
+    j["apple"] = alt_json::array({1, 2, 3});
    j["mango"]["z_nested"] = true;
    j["mango"]["a_nested"] = nullptr;
    j["banana"] = "some text";
@@ -344,47 +339,47 @@ TEST_CASE("ordered_json across binary formats")

 TEST_CASE("alt_json (custom string_t) across binary formats")
 {
-    const ordered_json2_alt_json original = make_rich_alt_json();
+    const alt_json original = make_rich_alt_json();

    SECTION("CBOR")
    {
-        const auto bytes = ordered_json2_alt_json::to_cbor(original);
-        const auto restored = ordered_json2_alt_json::from_cbor(bytes);
+        const auto bytes = alt_json::to_cbor(original);
+        const auto restored = alt_json::from_cbor(bytes);
        CHECK(restored == original);
    }

    SECTION("MessagePack")
    {
-        const auto bytes = ordered_json2_alt_json::to_msgpack(original);
-        const auto restored = ordered_json2_alt_json::from_msgpack(bytes);
+        const auto bytes = alt_json::to_msgpack(original);
+        const auto restored = alt_json::from_msgpack(bytes);
        CHECK(restored == original);
    }

    SECTION("UBJSON")
    {
-        const auto bytes = ordered_json2_alt_json::to_ubjson(original);
-        const auto restored = ordered_json2_alt_json::from_ubjson(bytes);
+        const auto bytes = alt_json::to_ubjson(original);
+        const auto restored = alt_json::from_ubjson(bytes);
        CHECK(restored == original);
    }

    SECTION("BON8")
    {
-        const auto bytes = ordered_json2_alt_json::to_bon8(original);
-        const auto restored = ordered_json2_alt_json::from_bon8(bytes);
+        const auto bytes = alt_json::to_bon8(original);
+        const auto restored = alt_json::from_bon8(bytes);
        CHECK(restored == original);
    }

    SECTION("BSON")
    {
-        const auto bytes = ordered_json2_alt_json::to_bson(original);
-        const auto restored = ordered_json2_alt_json::from_bson(bytes);
+        const auto bytes = alt_json::to_bson(original);
+        const auto restored = alt_json::from_bson(bytes);
        CHECK(restored == original);
    }

    SECTION("BJData")
    {
-        const auto bytes = ordered_json2_alt_json::to_bjdata(original);
-        const auto restored = ordered_json2_alt_json::from_bjdata(bytes);
+        const auto bytes = alt_json::to_bjdata(original);
+        const auto restored = alt_json::from_bjdata(bytes);
        CHECK(restored == original);
    }
 }
@@ -1,40 +0,0 @@
-//     __ _____ _____ _____
-//  __|  |   __|     |   | |  JSON for Modern C++ (supporting code)
-// |  |  |__   |  |  | | | |  version 3.12.0
-// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
-//
-// SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
-// SPDX-License-Identifier: MIT
-
-// This file contains the C++17-only part of unit-ordered_map.cpp (ordered_map::find with
-// std::string_view keys). It is kept in a separate translation unit so the (much larger)
-// unit-ordered_map.cpp is built for C++11 only and not rebuilt for every C++ standard.
-
-#include "doctest_compatibility.h"
-
-#include <nlohmann/json.hpp>
-using nlohmann::ordered_map;
-
-#ifdef JSON_HAS_CPP_17
-#include <string>
-#include <string_view>
-
-TEST_CASE("ordered_map (C++17)")
-{
-    SECTION("find")
-    {
-        ordered_map<std::string, std::string> om;
-        om["eins"] = "one";
-        om["zwei"] = "two";
-        om["drei"] = "three";
-        const auto com = om;
-
-        const std::string eins("eins");
-        const std::string vier("vier");
-
-        CHECK(om.find(std::string_view("eins")) == om.begin());
-        CHECK(com.find(std::string_view("eins")) == com.begin());
-    }
-}
-
-#endif
@@ -360,6 +360,11 @@ TEST_CASE("ordered_map")
        CHECK(com.find("vier") == com.end());
        CHECK(com.find(std::string("vier")) == com.end());
        CHECK(com.find(vier) == com.end());
+
+#ifdef JSON_HAS_CPP_17
+        CHECK(om.find(std::string_view("eins")) == om.begin());
+        CHECK(com.find(std::string_view("eins")) == com.begin());
+#endif
    }

    SECTION("insert")
@@ -39,7 +39,7 @@ using nlohmann::json;

 template<class K, class V, class dummy_compare, class A>
 using my_workaround_fifo_map = nlohmann::fifo_map<K, V, nlohmann::fifo_map_compare<K>, A>;
-using my_json = nlohmann::json::with_object_t<my_workaround_fifo_map>;
+using my_json = nlohmann::basic_json<my_workaround_fifo_map>;

 /////////////////////////////////////////////////////////////////////
 // for #977
@@ -86,7 +86,8 @@ struct foo_serializer < T, typename std::enable_if < !std::is_same<foo, T>::valu
 };
 } // namespace ns

-using foo_json = nlohmann::json::with_json_serializer_t<ns::foo_serializer>;
+using foo_json = nlohmann::basic_json<std::map, std::vector, std::string, bool, std::int64_t,
+      std::uint64_t, double, std::allocator, ns::foo_serializer, std::vector<std::uint8_t>>;

 /////////////////////////////////////////////////////////////////////
 // for #805
@@ -253,7 +254,7 @@ TEST_CASE("regression tests 1")
    {
        // create JSON class with nonstandard integer number type
        using custom_json =
-            nlohmann::json::with_integers_t<std::int32_t, std::uint32_t>::with_float_t<float>;
+            nlohmann::basic_json<std::map, std::vector, std::string, bool, int32_t, uint32_t, float>;
        custom_json j;
        j["int_1"] = 1;
        CHECK(j["int_1"] == 1);
@@ -469,17 +470,18 @@ TEST_CASE("regression tests 1")
        // create JSON class with nonstandard float number type

        // float
-        nlohmann::json::with_integers_t<std::int32_t, std::uint32_t>::with_float_t<float> const j_float =
+        nlohmann::basic_json<std::map, std::vector, std::string, bool, int32_t, uint32_t, float> const j_float =
            1.23e25f;
        CHECK(j_float.get<float>() == 1.23e25f);

        // double
-        nlohmann::json const j_double =
+        nlohmann::basic_json<std::map, std::vector, std::string, bool, int64_t, uint64_t, double> const j_double =
            1.23e35;
        CHECK(j_double.get<double>() == 1.23e35);

        // long double
-        nlohmann::json::with_float_t<long double> const j_long_double = 1.23e45L;
+        nlohmann::basic_json<std::map, std::vector, std::string, bool, int64_t, uint64_t, long double>
+        const j_long_double = 1.23e45L;
        CHECK(j_long_double.get<long double>() == 1.23e45L);
    }

@@ -1,67 +0,0 @@
-//     __ _____ _____ _____
-//  __|  |   __|     |   | |  JSON for Modern C++ (supporting code)
-// |  |  |__   |  |  | | | |  version 3.12.0
-// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
-//
-// SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
-// SPDX-License-Identifier: MIT
-
-// This file contains the C++17-only part of unit-regression2.cpp (std::variant, std::any
-// and std::optional regression tests). It is kept in a separate translation unit so the
-// (much larger) unit-regression2.cpp is built for C++11 only and not rebuilt for every C++
-// standard.
-
-#include "doctest_compatibility.h"
-
-#include <nlohmann/json.hpp>
-using json = nlohmann::json;
-#ifdef JSON_TEST_NO_GLOBAL_UDLS
-    using namespace nlohmann::literals; // NOLINT(google-build-using-namespace)
-#endif
-
-#ifdef JSON_HAS_CPP_17
-#include <string>
-#include <type_traits>
-#include <vector>
-
-#include <any>
-#include <variant>
-
-#if __has_include(<optional>)
-    #include <optional>
-#elif __has_include(<experimental/optional>)
-    #include <experimental/optional>
-#endif
-
-/////////////////////////////////////////////////////////////////////
-// for #4804
-/////////////////////////////////////////////////////////////////////
-using json_4804 = nlohmann::json::with_binary_t<std::vector<std::byte>>;
-
-TEST_CASE("regression tests 2 (C++17)")
-{
-    SECTION("issue #1292 - Serializing std::variant causes stack overflow")
-    {
-        static_assert(!std::is_constructible<json, std::variant<int, float>>::value, "unexpected value");
-    }
-
-    SECTION("issue #5066 - MSVC converts json to std::variant<json> via the conversion operator")
-    {
-        // std::variant<json> must not be retrievable via get<>(), because otherwise the
-        // implicit conversion operator becomes a candidate that MSVC picks over the variant's
-        // converting constructor, routing a number through the string from_json overload
-        static_assert(!nlohmann::detail::is_detected<nlohmann::detail::get_template_function, const json&, std::variant<json>>::value,
-                      "std::variant<json> must not be retrievable via get<>()");
-
-        // clang before 7 cannot instantiate libstdc++'s std::variant<json>
-#if !(defined(__clang__) && __clang_major__ < 7)
-        // push_back, not emplace_back: #5066 needs the implicit conversion
-        // from json to the vector's value type
-        std::vector<std::variant<json>> v;
-        v.push_back(json(1)); // NOLINT(hicpp-use-emplace,modernize-use-emplace)
-        CHECK(std::get<0>(v[0]) == 1);
-#endif
-    }
-}
-
-#endif
@@ -1,57 +0,0 @@
-//     __ _____ _____ _____
-//  __|  |   __|     |   | |  JSON for Modern C++ (supporting code)
-// |  |  |__   |  |  | | | |  version 3.12.0
-// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
-//
-// SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
-// SPDX-License-Identifier: MIT
-
-// This file contains the C++20-only part of unit-regression2.cpp (std::span and ranges
-// regression tests). It is kept in a separate translation unit so the (much larger) unit-
-// regression2.cpp is built for C++11 only and not rebuilt for every C++ standard.
-
-#include "doctest_compatibility.h"
-
-#include <nlohmann/json.hpp>
-using json = nlohmann::json;
-#ifdef JSON_TEST_NO_GLOBAL_UDLS
-    using namespace nlohmann::literals; // NOLINT(google-build-using-namespace)
-#endif
-
-#ifdef JSON_HAS_CPP_20
-#include <string>
-
-#if __has_include(<span>)
-    #include <span>
-#endif
-
-/////////////////////////////////////////////////////////////////////
-// for #4440
-/////////////////////////////////////////////////////////////////////
-#if JSON_HAS_RANGES == 1
-    #include <ranges>
-#endif
-
-TEST_CASE("regression tests 2 (C++20)")
-{
-#ifndef _LIBCPP_VERSION // see https://github.com/nlohmann/json/issues/4490
-    // classic Intel ICC reports <span> as includable but cannot actually compile
-    // std::span/std::as_bytes usage below
-#if __has_include(<span>) && !defined(__ICC) && !defined(__INTEL_COMPILER)
-    SECTION("issue #2546 - parsing containers of std::byte")
-    {
-        const char DATA[] = R"("Hello, world!")"; // NOLINT(misc-const-correctness,cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
-        // exclude the trailing '\0' that string-literal initialization adds to
-        // DATA: std::span(DATA) would span the full array extent (including
-        // that NUL), which is only silently accepted as end-of-input by default
-        // and would fail under JSON_STRICT_NUL_HANDLING
-        const auto s = std::as_bytes(std::span(DATA, sizeof(DATA) - 1));
-        const json j = json::parse(s);
-        CHECK(j.dump() == "\"Hello, world!\"");
-    }
-#endif
-#endif
-
-}
-
-#endif
@@ -6,11 +6,12 @@
 // SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
 // SPDX-License-Identifier: MIT

-// cmake/test.cmake builds a unit test with C++ standards beyond C++11 only if the
-// source file mentions the corresponding version macro. To avoid rebuilding this
-// large file for every standard, tests that depend on the standard version (e.g.,
-// those using JSON_HAS_FILESYSTEM, JSON_HAS_RANGES, or JSON_HAS_THREE_WAY_COMPARISON)
-// go into a separate file unit-regression2-cpp<NN>.cpp. This file stays C++11-only.
+// cmake/test.cmake selects the C++ standard versions with which to build a
+// unit test based on the presence of JSON_HAS_CPP_<VERSION> macros.
+// When using macros that are only defined for particular versions of the standard
+// (e.g., JSON_HAS_FILESYSTEM for C++17 and up), please mention the corresponding
+// version macro in a comment close by, like this:
+// JSON_HAS_CPP_<VERSION> (do not remove; see note at top of file)

 #include "doctest_compatibility.h"

@@ -48,6 +49,41 @@ using ordered_json = nlohmann::ordered_json;

 #include "test_utils.hpp"

+#ifdef JSON_HAS_CPP_17
+    #include <any>
+    #include <variant>
+#endif
+
+#ifdef JSON_HAS_CPP_17
+    #if __has_include(<optional>)
+        #include <optional>
+    #elif __has_include(<experimental/optional>)
+        #include <experimental/optional>
+    #endif
+
+    /////////////////////////////////////////////////////////////////////
+    // for #4804
+    /////////////////////////////////////////////////////////////////////
+    using json_4804 = nlohmann::basic_json<std::map,        // ObjectType
+    std::vector,     // ArrayType
+    std::string,     // StringType
+    bool,            // BooleanType
+    std::int64_t,    // NumberIntegerType
+    std::uint64_t,   // NumberUnsignedType
+    double,          // NumberFloatType
+    std::allocator,  // AllocatorType
+    nlohmann::adl_serializer,  // JSONSerializer
+    std::vector<std::byte>,    // BinaryType
+    void                       // CustomBaseClass
+    >;
+#endif
+
+#ifdef JSON_HAS_CPP_20
+    #if __has_include(<span>)
+        #include <span>
+    #endif
+#endif
+
 /////////////////////////////////////////////////////////////////////
 // for #4825 - explicitly instantiating basic_json must compile; this
 // forces instantiation of binary_writer::write_bjdata_ndarray, whose
@@ -56,6 +92,13 @@ using ordered_json = nlohmann::ordered_json;
 /////////////////////////////////////////////////////////////////////
 template class nlohmann::basic_json<>;

+/////////////////////////////////////////////////////////////////////
+// for #4440
+/////////////////////////////////////////////////////////////////////
+#if JSON_HAS_RANGES == 1
+    #include <ranges>
+#endif
+
 // NLOHMANN_JSON_SERIALIZE_ENUM uses a static std::pair
 DOCTEST_CLANG_SUPPRESS_WARNING_PUSH
 DOCTEST_CLANG_SUPPRESS_WARNING("-Wexit-time-destructors")
@@ -64,7 +107,7 @@ DOCTEST_CLANG_SUPPRESS_WARNING("-Wexit-time-destructors")
 // for #1021
 /////////////////////////////////////////////////////////////////////

-using float_json = nlohmann::json::with_float_t<float>;
+using float_json = nlohmann::basic_json<std::map, std::vector, std::string, bool, std::int64_t, std::uint64_t, float>;

 #if (defined(__cpp_exceptions) || defined(__EXCEPTIONS) || defined(_CPPUNWIND)) && !defined(JSON_NOEXCEPTION)
 namespace
@@ -112,8 +155,10 @@ struct failing_allocator : std::allocator<T>
    };
 };

-using failing_json = nlohmann::json::with_allocator_t<failing_allocator>;
-using failing_ordered_json = nlohmann::ordered_json::with_allocator_t<failing_allocator>;
+using failing_json = nlohmann::basic_json<std::map, std::vector, std::string, bool,
+      std::int64_t, std::uint64_t, double, failing_allocator>;
+using failing_ordered_json = nlohmann::basic_json<nlohmann::ordered_map, std::vector, std::string, bool,
+      std::int64_t, std::uint64_t, double, failing_allocator>;

 // builds `depth` levels of nesting around a scalar, iteratively (never
 // recursing: each wrap only moves the previous, already-built value, which
@@ -253,18 +298,18 @@ struct adl_serializer<NonDefaultConstructible>
 /////////////////////////////////////////////////////////////////////

 template<class T>
-class my_allocator_2982 : public std::allocator<T>
+class my_allocator : public std::allocator<T>
 {
  public:
    using std::allocator<T>::allocator;

-    my_allocator_2982() = default;
-    template<class U> my_allocator_2982(const my_allocator_2982<U>& /*unused*/) { }
+    my_allocator() = default;
+    template<class U> my_allocator(const my_allocator<U>& /*unused*/) { }

    template <class U>
    struct rebind
    {
-        using other = my_allocator_2982<U>;
+        using other = my_allocator<U>;
    };
 };

@@ -436,6 +481,13 @@ TEST_CASE("regression tests 2")
        CHECK(diffs.size() == 1);  // Note the change here, was 2
    }

+#ifdef JSON_HAS_CPP_17
+    SECTION("issue #1292 - Serializing std::variant causes stack overflow")
+    {
+        static_assert(!std::is_constructible<json, std::variant<int, float>>::value, "unexpected value");
+    }
+#endif
+
    SECTION("issue #1299 - compile error in from_json converting to container "
            "with std::pair")
    {
@@ -679,6 +731,26 @@ TEST_CASE("regression tests 2")
        CHECK(j.dump() == "{}");
    }

+#ifdef JSON_HAS_CPP_20
+#ifndef _LIBCPP_VERSION // see https://github.com/nlohmann/json/issues/4490
+    // classic Intel ICC reports <span> as includable but cannot actually compile
+    // std::span/std::as_bytes usage below
+#if __has_include(<span>) && !defined(__ICC) && !defined(__INTEL_COMPILER)
+    SECTION("issue #2546 - parsing containers of std::byte")
+    {
+        const char DATA[] = R"("Hello, world!")"; // NOLINT(misc-const-correctness,cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
+        // exclude the trailing '\0' that string-literal initialization adds to
+        // DATA: std::span(DATA) would span the full array extent (including
+        // that NUL), which is only silently accepted as end-of-input by default
+        // and would fail under JSON_STRICT_NUL_HANDLING
+        const auto s = std::as_bytes(std::span(DATA, sizeof(DATA) - 1));
+        const json j = json::parse(s);
+        CHECK(j.dump() == "\"Hello, world!\"");
+    }
+#endif
+#endif
+#endif
+
    SECTION("issue #2574 - Deserialization to std::array, std::pair, and std::tuple with non-default constructable types fails")
    {
        SECTION("std::array")
@@ -809,7 +881,7 @@ TEST_CASE("regression tests 2")

    SECTION("issue #2982 - to_{binary format} does not provide a mechanism for specifying a custom allocator for the returned type")
    {
-        std::vector<std::uint8_t, my_allocator_2982<std::uint8_t>> my_vector;
+        std::vector<std::uint8_t, my_allocator<std::uint8_t>> my_vector;
        const json j = {1, 2, 3, 4};
        json::to_cbor(j, my_vector);
        json k = json::from_cbor(my_vector);
@@ -825,6 +897,26 @@ TEST_CASE("regression tests 2")
        CHECK(node.dump(-1, ' ', true, json::error_handler_t::keep) == "{\"test\":\"test\334\\u0005\"}");
    }

+#ifdef JSON_HAS_CPP_17
+    SECTION("issue #5066 - MSVC converts json to std::variant<json> via the conversion operator")
+    {
+        // std::variant<json> must not be retrievable via get<>(), because otherwise the
+        // implicit conversion operator becomes a candidate that MSVC picks over the variant's
+        // converting constructor, routing a number through the string from_json overload
+        static_assert(!nlohmann::detail::is_detected<nlohmann::detail::get_template_function, const json&, std::variant<json>>::value,
+                      "std::variant<json> must not be retrievable via get<>()");
+
+        // clang before 7 cannot instantiate libstdc++'s std::variant<json>
+#if !(defined(__clang__) && __clang_major__ < 7)
+        // push_back, not emplace_back: #5066 needs the implicit conversion
+        // from json to the vector's value type
+        std::vector<std::variant<json>> v;
+        v.push_back(json(1)); // NOLINT(hicpp-use-emplace,modernize-use-emplace)
+        CHECK(std::get<0>(v[0]) == 1);
+#endif
+    }
+#endif
+
    SECTION("issue #3669 - invalid use of incomplete type with optional member and to_json")
    {
        const Issue3669Holder h{};
@@ -1,171 +0,0 @@
-//     __ _____ _____ _____
-//  __|  |   __|     |   | |  JSON for Modern C++ (supporting code)
-// |  |  |__   |  |  | | | |  version 3.12.0
-// |_____|_____|_____|_|___|  https://github.com/nlohmann/json
-//
-// SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>
-// SPDX-License-Identifier: MIT
-
-// This file contains the C++17-only part of unit-regression3.cpp (std::any, std::optional,
-// std::variant and std::filesystem regression tests). It is kept in a separate translation
-// unit so the (much larger) unit-regression3.cpp is built for C++11 only and not rebuilt
-// for every C++ standard.
-
-#include "doctest_compatibility.h"
-
-// skip tests if JSON_DisableEnumSerialization=ON (#4384): std::byte is a
-// scoped enum, so get<std::byte>() (needed below to get<std::vector<std::byte>>()
-// from a plain JSON array, not just from an already-binary value) relies on
-// enum serialization being enabled
-#if defined(JSON_DISABLE_ENUM_SERIALIZATION) && (JSON_DISABLE_ENUM_SERIALIZATION == 1)
-    #define SKIP_TESTS_FOR_ENUM_SERIALIZATION
-#endif
-
-#include <nlohmann/json.hpp>
-using json = nlohmann::json;
-using ordered_json = nlohmann::ordered_json;
-#ifdef JSON_TEST_NO_GLOBAL_UDLS
-    using namespace nlohmann::literals; // NOLINT(google-build-using-namespace)
-#endif
-
-#ifdef JSON_HAS_CPP_17
-#include <cstdint>
-#include <string>
-#include <typeinfo>
-#include <vector>
-
-#include <any>
-#include <variant>
-
-#if __has_include(<optional>)
-    #include <optional>
-#elif __has_include(<experimental/optional>)
-#endif
-
-/////////////////////////////////////////////////////////////////////
-// for #4804
-/////////////////////////////////////////////////////////////////////
-using json_4804 = nlohmann::json::with_binary_t<std::vector<std::byte>>;
-
-/////////////////////////////////////////////////////////////////////
-// for #4740
-/////////////////////////////////////////////////////////////////////
-
-struct Example_4740
-{
-    std::optional<std::string> host = std::nullopt;
-    std::optional<int> port = std::nullopt;
-    NLOHMANN_DEFINE_TYPE_INTRUSIVE_WITH_DEFAULT(Example_4740, host, port)
-};
-
-TEST_CASE("regression tests 3 (C++17)")
-{
-#if JSON_HAS_FILESYSTEM || JSON_HAS_EXPERIMENTAL_FILESYSTEM
-    SECTION("issue #3070 - Version 3.10.3 breaks backward-compatibility with 3.10.2 ")
-    {
-        nlohmann::detail::std_fs::path text_path("/tmp/text.txt");
-        const json j(text_path);
-
-        const auto j_path = j.get<nlohmann::detail::std_fs::path>();
-        CHECK(j_path == text_path);
-
-#if DOCTEST_CLANG || DOCTEST_GCC >= DOCTEST_COMPILER(8, 4, 0)
-        // only known to work on Clang and GCC >=8.4
-        CHECK_THROWS_WITH_AS(nlohmann::detail::std_fs::path(json(1)), "[json.exception.type_error.302] type must be string, but is number", json::type_error);
-#endif
-    }
-#endif
-
-#if JSON_USE_IMPLICIT_CONVERSIONS
-    SECTION("issue #3428 - Error occurred when converting nlohmann::json to std::any")
-    {
-        const json j;
-        const std::any a1 = j;
-        std::any&& a2 = j;
-
-        CHECK(a1.type() == typeid(j));
-        CHECK(a2.type() == typeid(j));
-    }
-#endif
-
-    SECTION("issue #4740 - build issue with std::optional")
-    {
-        const auto t1 = Example_4740();
-        const auto j1 = nlohmann::json(t1);
-        CHECK(j1.dump() == "{\"host\":null,\"port\":null}");
-        const auto t2 = j1.get<Example_4740>();
-        CHECK(!t2.host.has_value());
-        CHECK(!t2.port.has_value());
-
-        // improve coverage
-        auto t3 = Example_4740();
-        t3.port = 80;
-        t3.host = "example.com";
-        const auto j2 = nlohmann::json(t3);
-        CHECK(j2.dump() == "{\"host\":\"example.com\",\"port\":80}");
-        const auto t4 = j2.get<Example_4740>();
-        CHECK(t4.host.has_value());
-        CHECK(t4.port.has_value());
-    }
-
-    SECTION("issue #4804: from_cbor incompatible with std::vector<std::byte> as binary_t")
-    {
-        const std::vector<std::uint8_t> data = {0x80};
-        const auto decoded = json_4804::from_cbor(data);
-        CHECK((decoded == json_4804::array()));
-    }
-
-#ifndef SKIP_TESTS_FOR_ENUM_SERIALIZATION
-    SECTION("discussion #4209 - custom BinaryType direct assignment and round-tripping")
-    {
-        // Test that assigning a custom BinaryType directly creates a binary value, not an array
-        const std::vector<std::byte> original{std::byte{1}, std::byte{2}, std::byte{3}};
-        const json_4804 j = original;
-        CHECK(j.is_binary());
-        CHECK(!j.is_array());
-
-        // Test round-tripping: extracting the binary value back as the custom container type
-        const auto extracted = j.get<std::vector<std::byte>>();
-        CHECK(extracted == original);
-
-        // Test that the default json alias behavior is unchanged: std::vector<uint8_t> -> array
-        const json default_json = std::vector<std::uint8_t> {1, 2, 3};
-        CHECK(default_json.is_array());
-        CHECK(!default_json.is_binary());
-    }
-
-    SECTION("discussion #4209 - custom BinaryType extraction from parsed array")
-    {
-        // Test that extracting a custom BinaryType from a parsed JSON array still works
-        // (not just from a binary-typed node)
-        const auto j = json_4804::parse("[1,2,3]");
-        CHECK(j.is_array());
-        CHECK(!j.is_binary());
-
-        // Extracting as custom BinaryType should work from arrays
-        const auto extracted = j.get<std::vector<std::byte>>();
-        CHECK(extracted.size() == 3);
-        CHECK(extracted[0] == std::byte{1});
-        CHECK(extracted[1] == std::byte{2});
-        CHECK(extracted[2] == std::byte{3});
-    }
-#endif
-
-    SECTION("issue #5046 - implicit conversion of return json to std::optional no longer implicit")
-    {
-        const json jval{};
-        auto GetValue = [](const json & valRoot) -> std::optional<json>
-        {
-            if (valRoot.contains("default"))
-            {
-                return valRoot.at("default");
-            }
-            return std::nullopt;
-        };
-        auto result = GetValue(jval);
-        CHECK(!result.has_value());
-    }
-
-}
-
-#endif
Author	SHA1	Message	Date
Niels Lohmann	1d2dea7769	Do not force inlining of the recovery stubs with MSVC `f8ff0942b` marked the stubs that stand in for error recovery with JSON_HEDLEY_ALWAYS_INLINE, which is __forceinline with MSVC. Visual Studio 2015 and 2017 do not inline them and warn (C4714), which /WX turns into an error on AppVeyor. The new internal macro JSON_INTERNAL_ALWAYS_INLINE forces inlining everywhere else (including clang-cl), and leaves the decision to MSVC. The MinGW objects keep their smaller section counts, as GCC and clang still inline the stubs. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-10-09 00:52:35 +02:00
Niels Lohmann	f8ff0942b2	Keep the MinGW test objects below the linker's section limit The MinGW clang job links with a GNU ld that cannot relocate an object with more than 32767 sections. unit-regression2, unit-regression3 and unit-msgpack went over it: - At -O0, the parser and binary reader for parse(), accept() and from_*() still emitted the stubs that stand in for recovering, and the parser referenced its recovery helpers from code that never runs. The stubs are now always inlined, and the parser reaches its helpers through the same allow_recovery tag as the stubs, so that this code is not even instantiated there. This removes about 300 sections from unit-msgpack. - Every sax_parse call instantiates the parser and binary reader that recover from errors. The tests that call it move from unit-regression2.cpp (#3989) and unit-regression3.cpp (#5676) into unit-sax_parse.cpp, like unit-explicit_instantiation.cpp got a file of its own (#5511), and CONTRIBUTING.md points there. Section counts of the MinGW Debug objects (clang 19, -g0), develop / PR: unit-msgpack 32281 / 32558, unit-regression2 31272 / 31278, unit-regression3 32392 / 27462, unit-sax_parse - / 19836. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-10-08 10:36:16 +02:00
Niels Lohmann	d1e6439187	Use the file-scope float_json alias in the #3989 test The local alias that the out-of-range test declared shadows the identical file-scope one, which GCC's -Wshadow=global turns into an error. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-10-07 22:56:50 +02:00
Niels Lohmann	dcf7e2222c	Merge remote-tracking branch 'origin/develop' into claude/fix-issue-3989-db7e45 Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-10-07 19:24:12 +02:00
Niels Lohmann	d99932fb3f	Merge remote-tracking branch 'origin/develop' into claude/fix-issue-3989-db7e45 Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-10-07 09:04:47 +02:00
Niels Lohmann	1d2cb49ff3	Merge remote-tracking branch 'origin/develop' into claude/fix-issue-3989-db7e45 Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-10-07 08:54:17 +02:00
Niels Lohmann	a2766df787	Merge remote-tracking branch 'origin/develop' into claude/fix-issue-3989-db7e45 Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-10-07 07:42:58 +02:00
Niels Lohmann	2ea5bed0e3	Merge remote-tracking branch 'origin/develop' into claude/fix-issue-3989-db7e45 Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-10-06 08:39:31 +02:00
Niels Lohmann	632f5369fe	Merge remote-tracking branch 'origin/develop' into claude/fix-issue-3989-db7e45 Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-10-06 07:43:24 +02:00
Niels Lohmann	c2619bf460	Merge remote-tracking branch 'origin/develop' into claude/fix-issue-3989-db7e45 Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-10-04 18:03:20 +02:00
Niels Lohmann	351aeb7440	Merge remote-tracking branch 'origin/develop' into HEAD Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-10-04 17:19:32 +02:00
Niels Lohmann	7b0af0072e	Merge remote-tracking branch 'origin/develop' into claude/fix-issue-3989-db7e45 Signed-off-by: Niels Lohmann <mail@nlohmann.me> # Conflicts: # include/nlohmann/detail/input/binary_reader.hpp # include/nlohmann/detail/string_utils.hpp # single_include/nlohmann/json.hpp	2026-10-04 12:22:05 +02:00
Niels Lohmann	650886d126	Merge remote-tracking branch 'origin/develop' into claude/fix-issue-3989-db7e45 Signed-off-by: Niels Lohmann <mail@nlohmann.me> # Conflicts: # tests/src/unit-alt-string.cpp	2026-10-04 11:50:33 +02:00
Niels Lohmann	a759afc99f	Fix CI: no semicolon after CAPTURE() in the #3989 tests #5737 enabled -Wextra-semi-stmt for the tests and removed the semicolons after CAPTURE(), which expands to a complete statement; the #3989 tests added twelve more. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-10-03 09:11:00 +02:00
Niels Lohmann	1143da4faa	Fix CI: keep the binary readers' recovery code out of from_() The MinGW job ("clang (20.1.8)", Debug) failed to link test-msgpack_cpp17 with "relocation truncated to fit: IMAGE_REL_AMD64_REL32 against `.rdata'". Its GNU ld (MinGW 12.2.0) cannot link an object file with more than 32767 sections. Reproduced with clang 20.1.8 and binutils 2.40: unit-msgpack.cpp's object has 31958 sections on develop and had 33210 with #3989; binutils 2.44 links both. The readers of from_() never recover, but unoptimized builds still emitted the recovery code their dead branches referenced: about 20 helpers per reader instantiation, plus the lexer's recovery functions through the UBJSON high-precision number repair. Now: - Errors are reported with report_error() only. The helpers that act on the SAX parser's answer (repair_requested(), resync(), value_failed(), close_open_containers(), and the repairs of high-precision numbers and unsupported BSON elements) have one trivial variant for readers that do not recover, so the recovery code is not referenced there. - Object keys that are not strings and BSON elements whose end is lost are marked at the error site and skipped by resync() in the reading loops; report_repairable_error(), report_error_repairable_if(), report_bson_element_error(), and bon8_error_repairable_if() are gone. - is_cbor_item_head() is a free function, and the BSON element type is formatted as on develop again. The object now has 32638 sections and links. Behavior is unchanged (regression tests, binary format suites, and fuzzing), and an optimized program that only calls from_*() is now 256 bytes smaller than on develop. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-10-02 19:48:27 +02:00
Niels Lohmann	8de151f928	Fix CI: no backslash sequence in the lexer's doc comments clang's -Wdocumentation-unknown-command reads "\u" in a doc comment as an unknown command, even in backticks. Two comments of the recovery code now say "Unicode escape" instead. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-10-02 19:08:41 +02:00
Niels Lohmann	ab52c98f71	Merge remote-tracking branch 'origin/develop' into claude/fix-issue-3989-db7e45 Signed-off-by: Niels Lohmann <mail@nlohmann.me> # Conflicts: # docs/mkdocs/docs/api/json_sax/parse_error.md # docs/mkdocs/docs/features/parsing/index.md	2026-10-02 11:38:09 +02:00
Niels Lohmann	5e93415d91	Merge remote-tracking branch 'origin/develop' into claude/fix-issue-3989-db7e45 Signed-off-by: Niels Lohmann <mail@nlohmann.me> # Conflicts: # include/nlohmann/detail/input/lexer.hpp # include/nlohmann/detail/input/parser.hpp # single_include/nlohmann/json.hpp # tests/src/fuzzer-parse_json.cpp	2026-10-01 07:36:30 +02:00
Niels Lohmann	7e8e8e219b	Merge remote-tracking branch 'origin/develop' into claude/fix-issue-3989-db7e45 Signed-off-by: Niels Lohmann <mail@nlohmann.me> # Conflicts: # include/nlohmann/detail/input/binary_reader.hpp # include/nlohmann/json.hpp # single_include/nlohmann/json.hpp	2026-09-30 22:53:03 +02:00
Niels Lohmann	5f1727cef2	Merge remote-tracking branch 'origin/develop' into claude/fix-issue-3989-db7e45 Signed-off-by: Niels Lohmann <mail@nlohmann.me> # Conflicts: # tests/src/unit-alt-string.cpp	2026-09-30 20:11:28 +02:00
Niels Lohmann	c16dd7e4f5	Fix CI: do not hide base class methods in the #3989 test SAX parsers clang-tidy's bugprone-derived-method-shadowing-base-method rejected the test SAX parsers that derive from json_sax_dom_parser (or the test's SaxEventLogger) and redefine their non-virtual event functions. The recovering DOM parsers of unit-class_parser.cpp and unit-regression2.cpp now hold a json_sax_dom_parser and forward to it, SaxEventLogger gets a flag to recover from errors instead of a derived class, and the one function unit-alt-string.cpp redefines is marked as intended. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-09-30 04:50:11 +02:00
Niels Lohmann	792853d725	Fix CI: clang-tidy and JSON_NOEXCEPTION in the #3989 changes ci_clang_tidy flagged nested conditional operators in the BON8 skip code and in remove_incomplete_utf8_sequence() (readability-avoid-nested-conditional-operator), and two branches with the same body in recover_string() (bugprone-branch-clone). Use if chains instead of the nested conditionals and merge the two branches into one condition; the short-circuit order is unchanged. ci_test_noexceptions aborted in the #3989 regression test: it compares the first recovered error with the message of the exception that from_cbor() and friends throw, and under JSON_NOEXCEPTION that call aborts instead of throwing. Guard binary_error_message() and its uses with #if !defined(JSON_NOEXCEPTION), as other tests in the suite do. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-09-29 16:42:57 +02:00
Niels Lohmann	4bdf1b7e74	Fix CI: no global std::string in the #3989 regression test The U+FFFD constant was a global std::string, which the clang CI build rejects with -Wglobal-constructors. It is now a function. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-09-29 09:27:46 +02:00
Niels Lohmann	b1e9d98e41	Merge remote-tracking branch 'origin/claude/fix-issue-3989-db7e45' into claude/fix-issue-3989-db7e45 Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-09-29 03:31:07 +02:00
Niels Lohmann	f855d257df	Fix CI: keep raw strings with backslashes out of test macros for MSVC MSVC stringizes the arguments of doctest's CHECK() so that a raw string literal becomes an ordinary one, and then reported the "\q" in the new alt_string recovery test as warning C4129, an error with /WX. The input is now a variable. The same pattern with "\u0000" in the parser's recovery test is replaced by a JSON value built from a std::string. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-09-29 03:30:39 +02:00
Niels Lohmann	3e683e9c04	Merge branch 'develop' into claude/fix-issue-3989-db7e45 Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-09-28 22:22:25 +02:00
Niels Lohmann	d1d84ed9af	Fix Flawfinder: format the BSON element type without snprintf Moving the report of an unsupported BSON element type into skip_unsupported_bson_element() moved its snprintf() call, which Flawfinder then reported as a new CWE-134 finding. The two hexadecimal digits are now computed directly; the message is unchanged. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-09-28 20:36:28 +02:00
Niels Lohmann	de8529f99b	Merge remote-tracking branch 'origin/develop' into claude/fix-issue-3989-db7e45 Signed-off-by: Niels Lohmann <mail@nlohmann.me> # Conflicts: # include/nlohmann/detail/input/binary_reader.hpp # single_include/nlohmann/json.hpp	2026-09-28 17:53:51 +02:00
Niels Lohmann	677794f076	Fix CI: recover numbers with the string operations every string_t has recover_number() used back(), pop_back(), front(), and find_first_of(const char*), which the minimal alt_string of unit-alt-string.cpp does not provide. Since the binary readers recover UBJSON/BJData high-precision numbers with it, from_ubjson() instantiated it, too, and the test no longer compiled. It now uses only size(), operator[], and resize(), and unit-alt-string.cpp recovers from errors in JSON text, UBJSON, and CBOR. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-09-28 12:17:11 +02:00
Niels Lohmann	437a95cfdb	Repair complete items in binary formats when parse_error() returns true (#3989 ) When the SAX parser asks to recover, the binary readers now repair an item whose end is known and read on after it, as RFC 8949, Section 5.3 describes for CBOR: - CBOR: tags are ignored, and simple values other than false, true, and null become null (RFC 8949, Section 6.1); a negative integer below the range of number_integer_t becomes the nearest floating-point number. - Strings that are not valid UTF-8 get U+FFFD for each ill-formed sequence, as in JSON text; so does a UBJSON/BJData char above 0x7F. - UBJSON/BJData high-precision numbers keep their longest valid beginning (via the lexer's recover_token()), or become infinity. - Members whose key is not a string are skipped (CBOR, MessagePack, BON8), like members without a key in JSON text. - BSON elements of types the library does not read (ObjectId, datetime, decimal128, ...) become null; a string without its terminator and a document whose size does not match are kept. Where the end of an item is unknown, reading stops as before, except that BSON skips to the end of the document, whose size it knows. The value read before such an error is now completed by the reader from its container stack, as the JSON parser does, instead of by a proxy SAX parser, which is removed. Like the parser, binary_reader gets an AllowRecovery template parameter, so that from_() compile without the new code. Tests: a table of repairs, numbers out of range, errors that stop, and a sweep over changed and removed bytes of eight encodings that checks balanced events and that the first error is the one from_() reports. All fuzzers now run a recovering checker; the binary ones also check that it reports an error exactly when from_*() fails. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-09-27 21:40:59 +02:00
Niels Lohmann	c8735246d0	Merge remote-tracking branch 'origin/develop' into claude/fix-issue-3989-db7e45 Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-09-27 21:02:38 +02:00
Niels Lohmann	9adb510a0d	Recover from parse errors when parse_error() returns true (#3989 ) The return value of json_sax::parse_error() was documented both as "must return false" and as "whether the parsing should continue", and the code just passed it on. For JSON text, parsing stopped anyway, but sax_parse() could report success for invalid input. The binary readers read on after the error, looping forever on a CBOR indefinite-length array without its end. Now false stops parsing, and true recovers from the error: - JSON text is repaired with the smallest local edit (insert a missing ',' or ':', remove a stray token, keep the readable part of a broken string or number, null for a value that cannot be read, close the innermost container at a wrong closing bracket and all of them at the end of the input), and parsing continues. The SAX events stay balanced, every key is followed by exactly one value, and each token is reported at most once. - The binary formats cannot resynchronize, so they stop, but complete the value read so far. sax_parse() returns false after any error. parse(), accept(), and the from_*() functions never recover and compile to the same code as before. Supersedes #4522. Signed-off-by: Niels Lohmann <mail@nlohmann.me>	2026-09-27 20:16:42 +02:00