Validate UTF-8 in CBOR/MessagePack/BSON/UBJSON/BJData text strings on develop

PR #5531 fixed the UTF-8-validation gap described in #5529, but it was merged onto the still-unmerged bson-sizes branch rather than develop, so develop was left with the original bug for all affected formats. A follow-up comment on #5529 reproduced this on develop and additionally found that UBJSON (and, by the same code path, BJData) has the identical gap, undocumented. Port the same fix directly onto develop: extract the UTF-8 DFA decoder out of serializer<>::decode() into a shared detail::decode()/is_valid_utf8() in string_utils.hpp, and call it from binary_reader::get_string() - the single choke point shared by all five binary readers - so malformed text strings are rejected at decode time (parse_error.113) instead of only failing later on dump() (type_error.316). Byte/binary payloads are unaffected. Add matching decode-time tests for CBOR, MessagePack, BSON, UBJSON, and BJData, and document the new behavior on all five binary format pages (the two UBJSON/BJData pages didn't get this note in #5531). Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_017sdieJCn6BHxzRMaXP49sP
2026-09-25 09:20:32 +00:00 · 2026-09-16 05:20:00 +00:00
103 changed files with 1440 additions and 7906 deletions
@@ -158,15 +158,6 @@ make amalgamate
 Running `make amalgamate` will also apply automatic formatting to the source files using
 [`Artistic Style`](https://astyle.sourceforge.net/). This formatting may modify your source files in-place. Be certain to review and commit any changes to avoid unintended formatting diffs in commits.

-If you add, rename, or remove a header in `include/nlohmann`, also regenerate the header list in
-[`BUILD.bazel`](https://github.com/nlohmann/json/blob/develop/BUILD.bazel) (requires CMake) by executing:
-
-```shell
-make BUILD.bazel
-```
-
-The amalgamation check in CI fails if any of these generated files is out of date.
-
 ## Recommended documentation

 - The library’s [README file](https://github.com/nlohmann/json/blob/master/README.md) is an excellent starting point to
@@ -29,27 +29,6 @@ labels:
  files:
    - ".github/external_ci/.*"

- label: "CI"
-  files:
-    - ".github/(dependabot|labeler)\\.yml"
-
- label: "aspect: binary formats"
-  files:
-    - "include/nlohmann/detail/input/binary_reader\\.hpp"
-    - "include/nlohmann/detail/output/binary_writer\\.hpp"
-    - "tests/src/unit-(bson|cbor|msgpack|ubjson|bjdata|binary_formats)"
-    - "tests/src/fuzzer-parse_(bson|cbor|msgpack|ubjson|bjdata)"
-    - "docs/mkdocs/docs/features/binary_formats/"
-    - "docs/mkdocs/docs/(api/basic_json|examples)/(to|from)_(bson|cbor|msgpack|ubjson|bjdata)"
-
- label: "aspect: binary formats"
-  title: "(?i)(bson|cbor|msgpack|messagepack|ubjson|bjdata|binary format)"
-
- label: "python"
-  files:
-    - "\\.py$"
-    - "requirements[^/]*\\.txt$"
-
 - label: "S"
  size-below: 10
 - label: "M"
@@ -57,16 +57,13 @@ jobs:
          python3 -mvenv venv
          venv/bin/pip3 install -r $MAIN_DIR/tools/astyle/requirements.txt

-      - name: Regenerate amalgamation, formatting, and BUILD.bazel
+      - name: Regenerate amalgamation and formatting
        run: |
          cd $MAIN_DIR

          python3 $TOOL_DIR/amalgamate.py -c $TOOL_DIR/config_json.json -s .
          python3 $TOOL_DIR/amalgamate.py -c $TOOL_DIR/config_json_fwd.json -s .

-          # the header list of the Bazel "json" target must match the files in include/
-          cmake -P cmake/scripts/gen_bazel_build_file.cmake
-
          ${{ github.workspace }}/venv/bin/astyle --project=tools/astyle/.astylerc --suffix=none --quiet \
            $INCLUDE_DIR/json.hpp $INCLUDE_DIR/json_fwd.hpp

@@ -90,7 +87,7 @@ jobs:
          mkdir -p ${{ github.workspace }}/patch
          git diff --patch --no-color > ${{ github.workspace }}/patch/amalgamation.patch
          if [ -s ${{ github.workspace }}/patch/amalgamation.patch ]; then
-            echo "The source code has not been amalgamated/formatted correctly or BUILD.bazel is out of date. Diff:"
+            echo "The source code has not been amalgamated/formatted correctly. Diff:"
            cat ${{ github.workspace }}/patch/amalgamation.patch
            echo "has_diff=true" >> "$GITHUB_OUTPUT"
          else
@@ -38,14 +38,14 @@ jobs:

    # Initializes the CodeQL tools for scanning.
    - name: Initialize CodeQL
-      uses: github/codeql-action/init@b96794f015dfd88f77b49b1c93e0fa7110f94c63 # v4.38.0
+      uses: github/codeql-action/init@cdf488f595d80d6e07e03d4674febd5ab45fa938 # v4.37.9
      with:
        languages: c-cpp

    # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
    # If this step fails, then you should remove it and run the build manually (see below)
    - name: Autobuild
-      uses: github/codeql-action/autobuild@b96794f015dfd88f77b49b1c93e0fa7110f94c63 # v4.38.0
+      uses: github/codeql-action/autobuild@cdf488f595d80d6e07e03d4674febd5ab45fa938 # v4.37.9

    - name: Perform CodeQL Analysis
-      uses: github/codeql-action/analyze@b96794f015dfd88f77b49b1c93e0fa7110f94c63 # v4.38.0
+      uses: github/codeql-action/analyze@cdf488f595d80d6e07e03d4674febd5ab45fa938 # v4.37.9
@@ -95,13 +95,13 @@ jobs:
              issue_number: issue_number,
              owner: context.repo.owner,
              repo: context.repo.repo,
-              body: '## 🔴 Amalgamation check failed! 🔴\nThe source code has not been amalgamated and/or formatted correctly, or `BUILD.bazel` is out of date.'
+              body: '## 🔴 Amalgamation check failed! 🔴\nThe source code has not been amalgamated and/or formatted correctly.'
                    + (hasPatch ? '\n\n📎 A ready-to-apply patch is attached to the [failed workflow run](' + runUrl + ') as the `amalgamation-patch` artifact.'
                                  + ' Download it, then apply it locally from the repository root with:'
                                  + '\n\n```shell\ngit apply amalgamation.patch\n```\n\n'
                                  + 'This does not require installing astyle yourself.'
                                : '')
                    + (first ? '\n\n@' + author + ' Please read and follow the [Contribution Guidelines]'
-                               + '(https://github.com/nlohmann/json/blob/develop/.github/CONTRIBUTING.md#amalgamate-the-source-code).'
+                               + '(https://github.com/nlohmann/json/blob/develop/.github/CONTRIBUTING.md#files-to-change).'
                             : '')
              })
@@ -43,6 +43,6 @@ jobs:
          output: 'flawfinder_results.sarif'

      - name: Upload analysis results to GitHub Security tab
-        uses: github/codeql-action/upload-sarif@b96794f015dfd88f77b49b1c93e0fa7110f94c63 # v4.38.0
+        uses: github/codeql-action/upload-sarif@cdf488f595d80d6e07e03d4674febd5ab45fa938 # v4.37.9
        with:
          sarif_file: ${{github.workspace}}/flawfinder_results.sarif
@@ -76,6 +76,6 @@ jobs:

      # Upload the results to GitHub's code scanning dashboard.
      - name: "Upload to code-scanning"
-        uses: github/codeql-action/upload-sarif@b96794f015dfd88f77b49b1c93e0fa7110f94c63 # v4.38.0
+        uses: github/codeql-action/upload-sarif@cdf488f595d80d6e07e03d4674febd5ab45fa938 # v4.37.9
        with:
          sarif_file: results.sarif
@@ -61,7 +61,7 @@ jobs:

      # Upload SARIF file generated in previous step
      - name: Upload SARIF file
-        uses: github/codeql-action/upload-sarif@b96794f015dfd88f77b49b1c93e0fa7110f94c63 # v4.38.0
+        uses: github/codeql-action/upload-sarif@cdf488f595d80d6e07e03d4674febd5ab45fa938 # v4.37.9
        with:
          sarif_file: semgrep.sarif
        if: always()
@@ -100,7 +100,7 @@ jobs:
    container: ubuntu:focal
    strategy:
      matrix:
-        target: [ci_cmake_flags, ci_test_diagnostics, ci_test_diagnostic_positions, ci_test_noexceptions, ci_test_noimplicitconversions, ci_test_legacycomparison, ci_test_noglobaludls, ci_test_disableenumserialization, ci_test_skiplibraryversioncheck, ci_test_simdutf, ci_test_strict_nul_handling, ci_test_no_thread_local]
+        target: [ci_cmake_flags, ci_test_diagnostics, ci_test_diagnostic_positions, ci_test_noexceptions, ci_test_noimplicitconversions, ci_test_legacycomparison, ci_test_noglobaludls, ci_test_simdutf]
    steps:
      - name: Install build-essential
        run: apt-get update ; apt-get install -y build-essential unzip wget git libssl-dev
@@ -158,10 +158,6 @@ jobs:
      # to fit: IMAGE_REL_AMD64_SECREL against `.debug_line'" because the
      # MinGW linker cannot relocate the debug sections this test produces.
      # The tests are only built and run here, so the debug info is not used.
-      # Do not add -O1 here to shrink the objects further: it does make them
-      # link, but the binaries clang 11.0.1 and clang 18.1.8 then produce crash
-      # before doctest prints its first line - 39 of 102 tests on clang 18.
-      # Keep the objects small by splitting the test files instead.
      - name: Run CMake
        run: cmake -S . -B build ^
             -DCMAKE_CXX_COMPILER="C:/Program Files/LLVM/bin/clang++.exe" ^
@@ -30,10 +30,8 @@ cc_library(
        "include/nlohmann/detail/input/input_adapters.hpp",
        "include/nlohmann/detail/input/json_sax.hpp",
        "include/nlohmann/detail/input/lexer.hpp",
-        "include/nlohmann/detail/input/number_parse.hpp",
        "include/nlohmann/detail/input/parser.hpp",
        "include/nlohmann/detail/input/position_t.hpp",
-        "include/nlohmann/detail/input/string_scan.hpp",
        "include/nlohmann/detail/iterators/internal_iterator.hpp",
        "include/nlohmann/detail/iterators/iter_impl.hpp",
        "include/nlohmann/detail/iterators/iteration_proxy.hpp",
@@ -51,14 +49,12 @@ cc_library(
        "include/nlohmann/detail/meta/detected.hpp",
        "include/nlohmann/detail/meta/identity_tag.hpp",
        "include/nlohmann/detail/meta/is_sax.hpp",
-        "include/nlohmann/detail/meta/logic.hpp",
        "include/nlohmann/detail/meta/std_fs.hpp",
        "include/nlohmann/detail/meta/type_traits.hpp",
        "include/nlohmann/detail/meta/void_t.hpp",
        "include/nlohmann/detail/output/binary_writer.hpp",
        "include/nlohmann/detail/output/output_adapters.hpp",
        "include/nlohmann/detail/output/serializer.hpp",
-        "include/nlohmann/detail/recursion_depth_limit.hpp",
        "include/nlohmann/detail/string_concat.hpp",
        "include/nlohmann/detail/string_escape.hpp",
        "include/nlohmann/detail/string_utils.hpp",
@@ -59,7 +59,6 @@ option(JSON_LegacyDiscardedValueComparison "Enable legacy discarded value compar
 option(JSON_Install                        "Install CMake targets during install step." ${MAIN_PROJECT})
 option(JSON_MultipleHeaders                "Use non-amalgamated version of the library." ON)
 option(JSON_SystemInclude                  "Include as system headers (skip for clang-tidy)." OFF)
-option(JSON_StrictNulHandling              "Build with strict NUL-byte handling enabled." OFF)

 if (JSON_CI)
    include(ci)
@@ -109,10 +108,6 @@ if (JSON_Diagnostics)
    message(STATUS "Diagnostics enabled (JSON_DIAGNOSTICS=1)")
 endif()

-if (JSON_StrictNulHandling)
-    message(STATUS "Strict NUL-byte handling enabled (JSON_STRICT_NUL_HANDLING=1)")
-endif()
-
 if (JSON_Diagnostic_Positions)
    message(STATUS "Diagnostic positions enabled (JSON_DIAGNOSTIC_POSITIONS=1)")
 endif()
@@ -146,7 +141,6 @@ target_compile_definitions(
    $<$<BOOL:${JSON_Diagnostics}>:JSON_DIAGNOSTICS=1>
    $<$<BOOL:${JSON_Diagnostic_Positions}>:JSON_DIAGNOSTIC_POSITIONS=1>
    $<$<BOOL:${JSON_LegacyDiscardedValueComparison}>:JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON=1>
-    $<$<BOOL:${JSON_StrictNulHandling}>:JSON_STRICT_NUL_HANDLING=1>
 )

 target_include_directories(
@@ -250,16 +250,12 @@ Further documentation:

 ### `BUILD.bazel`

-The build definition for [Bazel](https://bazel.build). The file is generated by
-`cmake/scripts/gen_bazel_build_file.cmake`, which derives the header list from the files in `include`; change the
-script rather than editing the file by hand. The file can be updated by calling
+The file can be updated by calling

 ```shell
 make BUILD.bazel
 ```

-The "Check amalgamation" workflow fails if the file is out of date.
-
 ### `meson.build`

 The build definition for the [Meson](https://mesonbuild.com) build system.
@@ -1,4 +1,4 @@
-.PHONY: pretty clean ChangeLog.md release update_hedley update_hedley_undef BUILD.bazel
+.PHONY: pretty clean ChangeLog.md release update_hedley update_hedley_undef

 ##########################################################################
 # configuration
@@ -30,9 +30,8 @@ AMALGAMATED_FWD_FILE=single_include/nlohmann/json_fwd.hpp
 # main target
 all:
 	@echo "amalgamate - amalgamate files single_include/nlohmann/json{,_fwd}.hpp from the include/nlohmann sources"
-	@echo "BUILD.bazel - regenerate the Bazel BUILD file from the include/nlohmann sources"
 	@echo "ChangeLog.md - generate ChangeLog file"
-	@echo "check-amalgamation - check whether sources have been amalgamated and BUILD.bazel is up to date"
+	@echo "check-amalgamation - check whether sources have been amalgamated"
 	@echo "clean - remove built files"
 	@echo "doctest - compile example files and check their output"
 	@echo "fuzz_testing - prepare fuzz testing of the JSON parser"
@@ -173,13 +172,8 @@ check-amalgamation:
 	@diff $(AMALGAMATED_FWD_FILE) $(AMALGAMATED_FWD_FILE)~ || (echo "===================================================================\n  Amalgamation required! Please read the contribution guidelines\n  in file .github/CONTRIBUTING.md.\n===================================================================" ; mv $(AMALGAMATED_FWD_FILE)~ $(AMALGAMATED_FWD_FILE) ; false)
 	@mv $(AMALGAMATED_FILE)~ $(AMALGAMATED_FILE)
 	@mv $(AMALGAMATED_FWD_FILE)~ $(AMALGAMATED_FWD_FILE)
-	@mv BUILD.bazel BUILD.bazel~
-	@$(MAKE) BUILD.bazel
-	@diff BUILD.bazel BUILD.bazel~ || (echo "===================================================================\n  BUILD.bazel is out of date! Please run 'make BUILD.bazel'.\n===================================================================" ; mv BUILD.bazel~ BUILD.bazel ; false)
-	@mv BUILD.bazel~ BUILD.bazel

-# generate the Bazel BUILD file; phony, because a removed header would not trigger a rebuild
-BUILD.bazel:
+BUILD.bazel: $(SRCS)
 	cmake -P cmake/scripts/gen_bazel_build_file.cmake

 ##########################################################################
@@ -1421,7 +1421,7 @@ I deeply appreciate the help of the following people.
 6. [Joshua C. Randall](https://github.com/jrandall) fixed a bug in the floating-point serialization.
 7. [Aaron Burghardt](https://github.com/aburgh) implemented code to parse streams incrementally. Furthermore, he greatly improved the parser class by allowing the definition of a filter function to discard undesired elements while parsing.
 8. [Daniel Kopeček](https://github.com/dkopecek) fixed a bug in the compilation with GCC 5.0.
-9. [Fiona Johanna Weber](https://github.com/Fiona-J-W) fixed a bug in and improved the performance of the comparison operators.
+9. [Florian Weber](https://github.com/Florianjw) fixed a bug in and improved the performance of the comparison operators.
 10. [Eric Cornelius](https://github.com/EricMCornelius) pointed out a bug in the handling with NaN and infinity values. He also improved the performance of the string escaping.
 11. [易思龙](https://github.com/likebeta) implemented a conversion from anonymous enums.
 12. [kepkin](https://github.com/kepkin) patiently pushed forward the support for Microsoft Visual Studio.
@@ -1523,14 +1523,14 @@ I deeply appreciate the help of the following people.
 108. [Kevin Tonon](https://github.com/ktonon) overworked the C++11 compiler checks in CMake.
 109. [Axel Huebl](https://github.com/ax3l) simplified a CMake check and added support for the [Spack package manager](https://spack.io).
 110. [Carlos O'Ryan](https://github.com/coryan) fixed a typo.
-111. [James Upjohn](https://github.com/jupjohn) fixed a version number in the compilers section.
+111. [James Upjohn](https://github.com/jammehcow) fixed a version number in the compilers section.
 112. [Chuck Atkins](https://github.com/chuckatkins) adjusted the CMake files to the CMake packaging guidelines and provided documentation for the CMake integration.
 113. [Jan Schöppach](https://github.com/dns13) fixed a typo.
 114. [martin-mfg](https://github.com/martin-mfg) fixed a typo.
 115. [Matthias Möller](https://github.com/TinyTinni) removed the dependency from `std::stringstream`.
 116. [agrianius](https://github.com/agrianius) added code to use alternative string implementations.
 117. [Daniel599](https://github.com/Daniel599) allowed to use more algorithms with the `items()` function.
-118. [Julius Rakow](https://github.com/juliusrakow) fixed the Meson include directory and fixed the links to [cppreference.com](https://cppreference.com).
+118. [Julius Rakow](https://github.com/jrakow) fixed the Meson include directory and fixed the links to [cppreference.com](https://cppreference.com).
 119. [Sonu Lohani](https://github.com/sonulohani) fixed the compilation with MSVC 2015 in debug mode.
 120. [grembo](https://github.com/grembo) fixed the test suite and re-enabled several test cases.
 121. [Hyeon Kim](https://github.com/simnalamburt) introduced the macro `JSON_INTERNAL_CATCH` to control the exception handling inside the library.
@@ -1581,7 +1581,7 @@ I deeply appreciate the help of the following people.
 166. [Mark Beckwith](https://github.com/wythe) fixed a typo.
 167. [yann-morin-1998](https://github.com/yann-morin-1998) helped to reduce the CMake requirement to version 3.1.
 168. [Konstantin Podsvirov](https://github.com/podsvirov) maintains a package for the MSYS2 software distro.
-169. [remyabel](https://github.com/remyabel2) added GNUInstallDirs to the CMake files.
+169. [remyabel](https://github.com/remyabel) added GNUInstallDirs to the CMake files.
 170. [Taylor Howard](https://github.com/taylorhoward92) fixed a unit test.
 171. [Gabe Ron](https://github.com/Macr0Nerd) implemented the `to_string` method.
 172. [Watal M. Iwasaki](https://github.com/heavywatal) fixed a Clang warning.
@@ -1608,7 +1608,7 @@ I deeply appreciate the help of the following people.
 193. [Hubert Chathi](https://github.com/uhoreg) made CMake's version config file architecture-independent.
 194. [OmnipotentEntity](https://github.com/OmnipotentEntity) implemented the binary values for CBOR, MessagePack, BSON, and UBJSON.
 195. [ArtemSarmini](https://github.com/ArtemSarmini) fixed a compilation issue with GCC 10 and fixed a leak.
-196. [Evgenii Sopov](https://github.com/sea5kg) integrated the library to the wsjcpp package manager.
+196. [Evgenii Sopov](https://github.com/sea-kg) integrated the library to the wsjcpp package manager.
 197. [Sergey Linev](https://github.com/linev) fixed a compiler warning.
 198. [Miguel Magalhães](https://github.com/magamig) fixed the year in the copyright.
 199. [Gareth Sylvester-Bradley](https://github.com/garethsb-sony) fixed a compilation issue with MSVC.
@@ -1702,7 +1702,7 @@ I deeply appreciate the help of the following people.
 287. [NN](https://github.com/NN---) added the Visual Studio output directory to `.gitignore`.
 288. [Romain Reignier](https://github.com/romainreignier) improved the performance of the vector output adapter.
 289. [Mike](https://github.com/Mike-Leo-Smith) fixed the `std::iterator_traits`.
-290. [Richard Hozák](https://github.com/richardhozak) added macro `JSON_NO_ENUM` to disable default enum conversions.
+290. [Richard Hozák](https://github.com/zxey) added macro `JSON_NO_ENUM` to disable default enum conversions.
 291. [vakokako](https://github.com/vakokako) fixed tests when compiling with C++20.
 292. [Alexander “weej” Jones](https://github.com/alexweej) fixed an example in the README.
 293. [Eli Schwartz](https://github.com/eli-schwartz) added more files to the `include.zip` archive.
@@ -1727,7 +1727,7 @@ I deeply appreciate the help of the following people.
 312. [Gareth Sylvester-Bradley](https://github.com/garethsb) added `operator/=` and `operator/` to construct JSON pointers.
 313. [Michael Macnair](https://github.com/mykter) added support for afl-fuzz testing.
 314. [Berkus Decker](https://github.com/berkus) fixed a typo in the README.
-315. [Illia Polishchuk](https://github.com/ilqvya) improved the CMake testing.
+315. [Illia Polishchuk](https://github.com/effolkronium) improved the CMake testing.
 316. [Ikko Ashimine](https://github.com/eltociear) fixed a typo.
 317. [Raphael Grimm](https://github.com/barcode) added the possibility to define a custom base class.
 318. [tocic](https://github.com/tocic) fixed typos in the documentation.
@@ -1797,66 +1797,6 @@ I deeply appreciate the help of the following people.
 382. [bitFiedler](https://github.com/bitFiedler) made GDB pretty printer work with Python 3.8.
 383. [Gianfranco Costamagna](https://github.com/LocutusOfBorg) fixed a compiler warning.
 384. [risa2000](https://github.com/risa2000) made `std::filesystem::path` conversion to/from UTF-8 encoded string explicit.
-385. [AM](https://github.com/maqnouch) fixed typos in the README.
-386. [dmenendez-gruposantander](https://github.com/dmenendez-gruposantander) fixed typos in the comments of the examples.
-387. [Mihai Stan](https://github.com/mstan-xx) fixed comparisons against the literal `0`.
-388. [Matt Gumbel](https://github.com/intelmatt) fixed some `-Weffc++` warnings.
-389. [vimpunk](https://github.com/vimpunk) moved a lambda out of an unevaluated context to support older compilers.
-390. [Chris Harris](https://github.com/cjh1) fixed the compilation with GCC 4.8.
-391. [Palmer Dabbelt](https://github.com/palmer-dabbelt) generated and installed a pkg-config file.
-392. [Gus Pozuelo](https://github.com/ap-viavi) made `ordered_map` compatible with GCC 5.5, Clang 3.6, and Xcode 9.
-393. [AK](https://github.com/Lioncky) fixed an MSVC build error caused by the `min`/`max` macros from `windows.h`.
-394. [Sergiu Deitsch](https://github.com/sergiud) provided a fallback for missing `char8_t` support.
-395. [Xiaochuan Ye](https://github.com/XueSongTap) fixed `from_msgpack` for `std::byte` input by specializing `std::char_traits`.
-396. [Ville Vesilehto](https://github.com/thevilledev) fixed an overflow in the BJData size calculation and rejected overflowing negative integers in CBOR.
-397. [NmPassTHFan](https://github.com/nmpassthf) replaced the deprecated `std::is_trivial` for C++26.
-398. [Chris Ever](https://github.com/chirsz-ever) added the `ignore_trailing_commas` parser option.
-399. [Kuan-Fu Wu](https://github.com/kfwu1999) fixed the example code for `json_pointer` initialization.
-400. [David Kilzer](https://github.com/ddkilzer) added a missing header to the input adapters.
-401. [Miko](https://github.com/mikomikotaishi) added proper C++20 module support, simplified the module API, and fixed missing exports.
-402. [hitgirl](https://github.com/hitgil) fixed the CMake configuration when cross-compiling.
-403. [Devon Thomas](https://github.com/ThomaDevOSU) mentioned the Artistic Style formatting in the contribution guidelines.
-404. [Erik Hu](https://github.com/Erikhu1) made Coveralls upload errors non-fatal in the CI.
-405. [co63oc](https://github.com/co63oc) fixed typos.
-406. [DmitriBogdanov](https://github.com/DmitriBogdanov) fixed broken package manager links in the documentation.
-407. [Bander](https://github.com/banderzhm) improved the MSVC compatibility of the C++ modules.
-408. [Andy Choi](https://github.com/ccpong) removed an unnecessary `template` keyword before `get` in the README and the documentation.
-409. [SamareshSingh](https://github.com/ssam18) fixed single-element brace initialization to copy/move instead of wrapping in an array, fixed the `WITH_DEFAULT` macros for `ordered_map`, and handled moved events in `serve_header.py`.
-410. [Aditya](https://github.com/Lumowhisp) improved the documentation of the documentation generation.
-411. [cheese1](https://github.com/cheese1) clarified the README.
-412. [KhloodElhossiny](https://github.com/khloodelhossiny) enabled `std::string_view` keys in `operator[]`.
-413. [Charles Cabergs](https://github.com/cacharle) fixed a `-Wtautological-constant-out-of-range-compare` warning.
-414. [EALePain](https://github.com/EALePain) made the `std::tuple` conversion work with reference types such as `std::tie`.
-415. [koala_oishi](https://github.com/chibi-dogs) fixed grammatical wording in the README.
-416. [riccardoori11](https://github.com/riccardoori11) fixed a typo in the documentation.
-417. [Swastik Bose](https://github.com/VasuBhakt) fixed the parent pointers after `update()` with `JSON_DIAGNOSTICS` and fixed the Doxygen autolinking of requirements.
-418. [trdesilva](https://github.com/trdesilva) added `front`, `pop_front`, and `push_front` to `json_pointer`.
-419. [Akhilesh Arora](https://github.com/akhilesharora) fixed an incomplete-type error with `ordered_json`.
-420. [Hariom Phulre](https://github.com/hariomphulre) fixed the C++20 modules compilation with GCC.
-421. [Kirill Lokotkov](https://github.com/RUSLoker) fixed printing `long double` values.
-422. [George Sedov](https://github.com/radistmorse) added the `NLOHMANN_DEFINE_TYPE_*_WITH_NAMES` macros.
-423. [Caillin Nugent](https://github.com/nugentcaillin) added the `NLOHMANN_JSON_SERIALIZE_ENUM_STRICT` macro.
-424. [Cosmin D.](https://github.com/drcosmin) fixed `std::filesystem::path` conversions and added an MSVC workaround for `std::unique_ptr`.
-425. [Paul Dreik](https://github.com/pauldreik) fixed a test relying on implementation-specific behavior.
-426. [Daniel Falk](https://github.com/daniel-falk) added missing copyright notices to the SBOM.
-427. [Federico Sfriso](https://github.com/federicosfriso05-dotcom) added support for constructing JSON values from C++20 range views.
-428. [Luke Banicevic](https://github.com/banaboi) fixed corrupt BSON output for lengths exceeding `INT32_MAX`, cleaned up the BSON writer, and improved the documentation.
-429. [Patrick Armstrong](https://github.com/Patrick10199) updated the CBOR references and the half-precision float assertions.
-430. [Yash Bavadiya](https://github.com/xevrion) added checks to all BSON reads.
-431. [hum4nBeing](https://github.com/hum4nBeing) fixed the overflow handling of high-precision numbers in UBJSON.
-432. [tomatotomata](https://github.com/tomatotomata) added checks for reading CBOR tagged subtypes.
-433. [YingqiDuan](https://github.com/YingqiDuan) documented the BSON interoperability.
-434. [KBS](https://github.com/youdie006) documented the standards compliance and the strictness of `parse()` and `operator>>`.
-435. [Petr Bělohlávek](https://github.com/petrbel) added Clang 21 and 22 to the CI.
-436. [Dmitry Rantovov](https://github.com/darkdi) fixed the placement of a CBOR documentation block.
-437. [ljcjclljc](https://github.com/ljcjclljc) fixed the comparison of large unsigned integers with signed integers.
-438. [Sahil Kamate](https://github.com/sahilkamate03) fixed the handling of CBOR tags 0-5 and 21-23.
-439. [Krishnanand G](https://github.com/Krishnanand-G) made the UBJSON writer reject `use_type` without `use_size`.
-440. [whn](https://github.com/Whning0513) documented the lenient BSON input handling and corrected the complexity of `to_bson`.
-441. [elix3r](https://github.com/22elix3r) fixed `update()` with `merge_objects` when merging a primitive into an object.
-442. [Avionic Harshit](https://github.com/avionicharshit-byte) made `diff()` linear when an array shrinks.
-443. [Qatadaha Bin Matloob](https://github.com/qatcod) fixed comparisons between integers and floats and fixed unparsable BJData output.
-444. [Wu Shuwen](https://github.com/dajiaohuang) removed an unused include.

 Thanks a lot for helping out! Please [let me know](mailto:mail@nlohmann.me) if I forgot someone.

@@ -231,20 +231,18 @@ add_custom_target(ci_test_simdutf
 )

 ###############################################################################
-# Enable strict NUL-byte handling.
+# Enable brace-init copy semantics.
 ###############################################################################

-add_custom_target(ci_test_strict_nul_handling
+add_custom_target(ci_test_brace_init_copy_semantics
    COMMAND ${CMAKE_COMMAND}
    -DCMAKE_BUILD_TYPE=Debug -GNinja
-    -DJSON_BuildTests=ON -DJSON_FastTests=ON -DJSON_StrictNulHandling=ON
-    -S${PROJECT_SOURCE_DIR} -B${PROJECT_BINARY_DIR}/build_strict_nul_handling
-    COMMAND ${CMAKE_COMMAND} --build ${PROJECT_BINARY_DIR}/build_strict_nul_handling
-    # unit-testsuites contains a fixture (a "1e308" test value) that relies on the
-    # legacy NUL-as-end-of-input behavior this macro disables; exclude it here, as
-    # it is expected to fail under strict NUL handling and is out of scope for it
-    COMMAND cd ${PROJECT_BINARY_DIR}/build_strict_nul_handling && ${CMAKE_CTEST_COMMAND} --parallel ${N} --output-on-failure -E "test-testsuites"
-    COMMENT "Compile and test with strict NUL-byte handling enabled"
+    -DJSON_BuildTests=ON -DJSON_FastTests=ON
+    -DCMAKE_CXX_FLAGS=-DJSON_BRACE_INIT_COPY_SEMANTICS=1
+    -S${PROJECT_SOURCE_DIR} -B${PROJECT_BINARY_DIR}/build_brace_init_copy_semantics
+    COMMAND ${CMAKE_COMMAND} --build ${PROJECT_BINARY_DIR}/build_brace_init_copy_semantics
+    COMMAND cd ${PROJECT_BINARY_DIR}/build_brace_init_copy_semantics && ${CMAKE_CTEST_COMMAND} --parallel ${N} --output-on-failure
+    COMMENT "Compile and test with brace-init copy semantics enabled"
 )

 ###############################################################################
@@ -262,59 +260,6 @@ add_custom_target(ci_test_noglobaludls
    COMMENT "Compile and test with global UDLs disabled"
 )

-###############################################################################
-# Disable enum serialization.
-###############################################################################
-
-add_custom_target(ci_test_disableenumserialization
-    COMMAND ${CMAKE_COMMAND}
-    -DCMAKE_BUILD_TYPE=Debug -GNinja
-    -DJSON_BuildTests=ON -DJSON_FastTests=ON -DJSON_DisableEnumSerialization=ON
-    -S${PROJECT_SOURCE_DIR} -B${PROJECT_BINARY_DIR}/build_disableenumserialization
-    COMMAND ${CMAKE_COMMAND} --build ${PROJECT_BINARY_DIR}/build_disableenumserialization
-    COMMAND cd ${PROJECT_BINARY_DIR}/build_disableenumserialization && ${CMAKE_CTEST_COMMAND} --parallel ${N} --output-on-failure
-    COMMENT "Compile and test with enum serialization disabled"
-)
-
-###############################################################################
-# Skip the multiple-inclusion library version check.
-###############################################################################
-
-# tests/src/skip_library_version_check.cpp deliberately simulates a scenario
-# (mixing two differently-versioned inclusions of the library in one
-# translation unit) that unavoidably triggers the compiler's own "macro
-# redefined" warning, so -- unlike the ci_test_* targets above -- it is
-# compiled directly here, with a modest warning set, instead of being folded
-# into the library's own -Weverything/-Werror unit test matrix.
-add_custom_target(ci_test_skiplibraryversioncheck
-    COMMAND ${CMAKE_COMMAND} -E make_directory ${PROJECT_BINARY_DIR}/skip_library_version_check
-    COMMAND ${CMAKE_CXX_COMPILER} -std=c++11 -Wall -Wextra
-        -I${PROJECT_SOURCE_DIR}/include
-        ${PROJECT_SOURCE_DIR}/tests/src/skip_library_version_check.cpp
-        -o ${PROJECT_BINARY_DIR}/skip_library_version_check/skip_library_version_check
-    COMMAND ${PROJECT_BINARY_DIR}/skip_library_version_check/skip_library_version_check
-    COMMENT "Compile and run a translation unit simulating a mismatched library version, with JSON_SKIP_LIBRARY_VERSION_CHECK defined"
-)
-
-###############################################################################
-# Disable thread-local storage.
-###############################################################################
-
-# Without thread-local storage, the copy constructor cannot bound its descent
-# and copies every object and array without the call stack. That path is
-# otherwise only reached by values nested deeper than the bound, so this target
-# is what runs the whole test suite through it.
-add_custom_target(ci_test_no_thread_local
-    COMMAND ${CMAKE_COMMAND}
-    -DCMAKE_BUILD_TYPE=Debug -GNinja
-    -DJSON_BuildTests=ON
-    -DCMAKE_CXX_FLAGS=-DJSON_NO_THREAD_LOCAL
-    -S${PROJECT_SOURCE_DIR} -B${PROJECT_BINARY_DIR}/build_no_thread_local
-    COMMAND ${CMAKE_COMMAND} --build ${PROJECT_BINARY_DIR}/build_no_thread_local
-    COMMAND cd ${PROJECT_BINARY_DIR}/build_no_thread_local && ${CMAKE_CTEST_COMMAND} --parallel ${N} --output-on-failure
-    COMMENT "Compile and test without thread-local storage"
-)
-
 ###############################################################################
 # Coverage.
 ###############################################################################
@@ -1,58 +1,24 @@
 # generate Bazel BUILD file
-#
-# usage: cmake -P cmake/scripts/gen_bazel_build_file.cmake (or: make BUILD.bazel)
-#
-# The header list of the "json" target is derived from the files in include/. Everything else is fixed text below,
-# so edit this script rather than BUILD.bazel.

-get_filename_component(PROJECT_ROOT "${CMAKE_CURRENT_LIST_DIR}/../.." ABSOLUTE)
+set(PROJECT_ROOT "${CMAKE_CURRENT_LIST_DIR}/../..")
 set(BUILD_FILE "${PROJECT_ROOT}/BUILD.bazel")

-file(GLOB_RECURSE HEADERS LIST_DIRECTORIES false RELATIVE "${PROJECT_ROOT}" "${PROJECT_ROOT}/include/*.hpp")
-list(SORT HEADERS)
-
-set(CONTENT [=[
-load("@rules_cc//cc:cc_library.bzl", "cc_library")
-load("@rules_license//rules:license.bzl", "license")
-
-package(
-    default_applicable_licenses = [":license"],
-)
-
-exports_files([
-    "LICENSE.MIT",
-])
-
-license(
-    name = "license",
-    license_kinds = ["@rules_license//licenses/spdx:MIT"],
-    license_text = "LICENSE.MIT",
-)
+file(GLOB_RECURSE HEADERS LIST_DIRECTORIES false RELATIVE "${PROJECT_ROOT}" "include/*.hpp")

+file(WRITE "${BUILD_FILE}" [=[
 cc_library(
    name = "json",
    hdrs = [
 ]=])

 foreach(header ${HEADERS})
-    string(APPEND CONTENT "        \"${header}\",\n")
+    file(APPEND "${BUILD_FILE}" "        \"${header}\",\n")
 endforeach()

-string(APPEND CONTENT [=[
+file(APPEND "${BUILD_FILE}" [=[
    ],
    includes = ["include"],
    visibility = ["//visibility:public"],
    alwayslink = True,
 )
-
-cc_library(
-    name = "singleheader-json",
-    hdrs = [
-        "single_include/nlohmann/json.hpp",
-    ],
-    includes = ["single_include"],
-    visibility = ["//visibility:public"],
-)
 ]=])
-
-file(WRITE "${BUILD_FILE}" "${CONTENT}")
@@ -90,10 +90,6 @@ Linear in the length of the input. The parser is a predictive LL(1) parser.

 A UTF-8 byte order mark is silently ignored.

-By default, a `'\0'` (NUL) byte anywhere in the input is treated as end of input, rather than as an ordinary (and,
-outside of a string, invalid) byte; see the [FAQ entry](../../home/faq.md#nul-bytes-in-the-input) for details and the
-[`JSON_STRICT_NUL_HANDLING`](../macros/json_strict_nul_handling.md) macro to opt into rejecting it instead.
-
 ## Examples

 ??? example
@@ -115,8 +111,6 @@ outside of a string, invalid) byte; see the [FAQ entry](../../home/faq.md#nul-by
 - [parse](parse.md) - deserialize from a compatible input
 - [sax_parse](sax_parse.md) - parse input using the SAX interface
 - [operator>>](../operator_gtgt.md) - deserialize from stream
- [`JSON_STRICT_NUL_HANDLING`](../macros/json_strict_nul_handling.md) - opt in to rejecting a NUL byte in the input
-  instead of treating it as end of input

 ## Version history

@@ -126,8 +120,6 @@ outside of a string, invalid) byte; see the [FAQ entry](../../home/faq.md#nul-by
 - Added `ignore_trailing_commas` 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.
 - Extended overload (2) to accept heterogeneous iterator+sentinel pairs (C++20 ranges support) in version 3.13.0.
- `JSON_STRICT_NUL_HANDLING` added in version 3.13.0 to optionally reject a NUL byte in the input instead of treating
-  it as end of input; planned to become the default in version 4.0.0.

 !!! warning "Deprecation"

@@ -88,8 +88,6 @@ Strong exception safety: if an exception occurs, the original value stays intact
      do not belong to the same JSON value; example: `"iterators do not fit"`
    - Throws [`invalid_iterator.211`](../../home/exceptions.md#jsonexceptioninvalid_iterator211) if `first` or `last`
      are iterators into container for which insert is called; example: `"passed iterators may not belong to container"`
-    - Throws [`invalid_iterator.202`](../../home/exceptions.md#jsonexceptioninvalid_iterator202) if `first` or `last`
-      do not point to an array; example: `"iterators first and last must point to arrays"`
 4. The function can throw the following exceptions:
    - Throws [`type_error.309`](../../home/exceptions.md#jsonexceptiontype_error309) if called on JSON values other than
      arrays; example: `"cannot use insert() with string"`
@@ -103,10 +103,6 @@ A UTF-8 byte order mark is silently ignored.
 Invalid Unicode escapes and unpaired surrogates in the input are reported as
 [`parse_error.101`](../../home/exceptions.md#jsonexceptionparse_error101) with a detailed message.

-By default, a `'\0'` (NUL) byte anywhere in the input is treated as end of input, rather than as an ordinary (and,
-outside of a string, invalid) byte; see the [FAQ entry](../../home/faq.md#nul-bytes-in-the-input) for details and the
-[`JSON_STRICT_NUL_HANDLING`](../macros/json_strict_nul_handling.md) macro to opt into rejecting it instead.
-
 ## Examples

 ??? example "Parsing from a character array"
@@ -240,8 +236,6 @@ outside of a string, invalid) byte; see the [FAQ entry](../../home/faq.md#nul-by
 - [accept](accept.md) - check if the input is valid JSON
 - [sax_parse](sax_parse.md) - parse input using the SAX interface
 - [operator>>](../operator_gtgt.md) - deserialize from stream
- [`JSON_STRICT_NUL_HANDLING`](../macros/json_strict_nul_handling.md) - opt in to rejecting a NUL byte in the input
-  instead of treating it as end of input

 ## Version history

@@ -252,8 +246,6 @@ outside of a string, invalid) byte; see the [FAQ entry](../../home/faq.md#nul-by
 - Added `ignore_trailing_commas` 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.
 - Extended overload (2) to accept heterogeneous iterator+sentinel pairs (C++20 ranges support) in version 3.13.0.
- `JSON_STRICT_NUL_HANDLING` added in version 3.13.0 to optionally reject a NUL byte in the input instead of treating
-  it as end of input; planned to become the default in version 4.0.0.

 !!! warning "Deprecation"

@@ -46,8 +46,9 @@ Strong guarantee: if an exception is thrown, there are no changes in the JSON va

 ## Complexity

-Linear in the size of the JSON value `j`. The length prefixes of all nested documents and arrays are computed in one
-pass before anything is written.
+Proportional to the size of the JSON value `j` multiplied by its maximum nesting
+depth, `O(n × d)`. BSON length prefixes are computed recursively before nested
+values are written.

 ## Examples

@@ -76,4 +77,3 @@ pass before anything is written.
 ## Version history

 - Added in version 3.4.0.
- Linear in the size of `j`, and no longer limited by the call stack for deeply nested values, since version 3.13.0.
@@ -14,11 +14,6 @@ header. See also the [macro overview page](../../features/macros.md).
 - [**JSON_DIAGNOSTIC_POSITIONS**](json_diagnostic_positions.md) - access positions of elements
 - [**JSON_NOEXCEPTION**](json_noexception.md) - switch off exceptions

-## Parsing
-
- [**JSON_STRICT_NUL_HANDLING**](json_strict_nul_handling.md) - opt in to rejecting a NUL byte in the input instead of
-  treating it as end of input
-
 ## Language support

 - [**JSON_HAS_CPP_11**<br>**JSON_HAS_CPP_14**<br>**JSON_HAS_CPP_17**<br>**JSON_HAS_CPP_20**](json_has_cpp_11.md) - set supported C++ standard
@@ -27,7 +22,6 @@ header. See also the [macro overview page](../../features/macros.md).
 - [**JSON_HAS_STD_FORMAT**](json_has_std_format.md) - control `std::format`/`std::formatter` support
 - [**JSON_HAS_THREE_WAY_COMPARISON**](json_has_three_way_comparison.md) - control 3-way comparison support
 - [**JSON_NO_IO**](json_no_io.md) - switch off functions relying on certain C++ I/O headers
- [**JSON_NO_THREAD_LOCAL**](json_no_thread_local.md) - switch off the use of `thread_local` storage
 - [**JSON_SKIP_UNSUPPORTED_COMPILER_CHECK**](json_skip_unsupported_compiler_check.md) - do not warn about unsupported compilers
 - [**JSON_USE_GLOBAL_UDLS**](json_use_global_udls.md) - place user-defined string literals (UDLs) into the global namespace
 - [**JSON_USE_SIMDUTF**](json_use_simdutf.md) - use the simdutf library to accelerate UTF-8 validation
@@ -38,28 +38,6 @@ The default value is `0` (disabled — existing behavior is preserved).

    This macro must be defined **before** including `<nlohmann/json.hpp>`. Defining it after the include has no effect.

-!!! warning "Applies to every single-element list"
-
-    The macro does not only affect a single JSON value in braces. **Any** single-element braced list is treated as its
-    element, so it no longer creates a one-element array:
-
-    ```cpp
-    json j1 = {1};       // 1, not [1]
-    json j2 = {"text"};  // "text", not ["text"]
-    json j3 = {{1, 2}};  // [1,2], not [[1,2]]
-    ```
-
-    Code that relies on these producing arrays must use `json::array()` instead (see below). Lists with more than one
-    element, and a single `[string, value]` pair such as `{{"key", "value"}}`, which still creates an object, are not
-    affected. The library's own conversions are not affected either: for example, `std::tuple<int>{5}` still becomes
-    `[5]`.
-
-!!! note "ABI compatibility"
-
-    The value of this macro is encoded in the [namespace](../../features/namespace.md) (tag `_bics`), resulting in
-    distinct symbol names. Translation units compiled with and without it can therefore be linked into the same program
-    without One Definition Rule (ODR) violations, but they cannot exchange instances of library types.
-
 !!! tip "Workaround without the macro"

    To explicitly create a single-element array without enabling this macro, use `json::array()`:
@@ -1,47 +0,0 @@
-# JSON_NO_THREAD_LOCAL
-
-```cpp
-#define JSON_NO_THREAD_LOCAL
-```
-
-When defined, the library does not use `#!cpp thread_local` storage. This is relevant for the few environments whose
-toolchain does not support it.
-
-The copy constructor copies the first levels of a value by copying the containers, which copy their elements, and
-completes whatever is nested deeper than that without the call stack, so that copying a value cannot exhaust the stack
-however deeply it is nested. It counts the levels it has descended into in a `#!cpp thread_local` variable, as a counter
-shared between threads would be raced.
-
-Without that counter, no descent can be bounded safely, so objects and arrays are copied without the call stack right
-away. Copying keeps working exactly as it does otherwise - the same values come out, and deeply nested values are copied
-just as safely - but copying is slower, because the containers no longer copy themselves. Copying the benchmark
-documents takes 9% (`canada.json`) to 34% (`twitter.json`) longer; values built mostly from objects are affected the
-most.
-
-## Default definition
-
-By default, `#!cpp JSON_NO_THREAD_LOCAL` is not defined.
-
-```cpp
-#undef JSON_NO_THREAD_LOCAL
-```
-
-The library defines it by itself for Clang targeting MinGW, which does not survive the `#!cpp thread_local` storage:
-copying a value segfaults there, with both old and current Clang versions, while GCC targeting MinGW is unaffected.
-
-## Examples
-
-??? example
-
-    The code below forces the library not to use `#!cpp thread_local` storage.
-
-    ```cpp
-    #define JSON_NO_THREAD_LOCAL 1
-    #include <nlohmann/json.hpp>
-
-    ...
-    ```
-
-## Version history
-
- Added in version 3.12.1.
@@ -1,126 +0,0 @@
-# JSON_STRICT_NUL_HANDLING
-
-```cpp
-#define JSON_STRICT_NUL_HANDLING /* value */
-```
-
-When defined to `1`, a `'\0'` (NUL) byte in JSON text input is rejected with `parse_error.101`, like any other
-unexpected byte, instead of being silently treated as end of input.
-
-The macro only affects the JSON text parser ([`parse`](../basic_json/parse.md), [`accept`](../basic_json/accept.md),
-[`sax_parse`](../basic_json/sax_parse.md), and [`operator>>`](../operator_gtgt.md)). There are three cases where a NUL
-byte is still not rejected:
-
- The binary formats ([`from_bjdata`](../basic_json/from_bjdata.md), [`from_bson`](../basic_json/from_bson.md),
-  [`from_cbor`](../basic_json/from_cbor.md), [`from_msgpack`](../basic_json/from_msgpack.md),
-  [`from_ubjson`](../basic_json/from_ubjson.md)) are never affected: there, `0x00` is ordinary data.
- A bare `const char*` pointer has no length of its own, so its length is still determined with `strlen()`. The first
-  NUL byte therefore still marks the end of the input, and nothing after it is read.
- One trailing `'\0'` at the end of a `char` array (e.g., a string literal) is trimmed; see the warning below.
-
-## Default definition
-
-The default value is `0` (disabled — existing behavior is preserved).
-
-```cpp
-#define JSON_STRICT_NUL_HANDLING 0
-```
-
-## Notes
-
-!!! note "Background"
-
-    By default, a `'\0'` byte anywhere in the input is treated the same as the real end of the input, rather than as
-    an ordinary (and, outside of a string, invalid) byte. Everything from that byte onward is silently ignored,
-    without a parse error - including further, otherwise well-formed JSON:
-
-    ```cpp
-    json::parse(std::string("123") + '\0');          // == 123, no error
-    json::parse(std::string("123") + '\0' + "true"); // == 123, the "true" is silently ignored too
-    ```
-
-    This falls out of the same convention used when no explicit input length is given at all: parsing from a
-    `const char*` already stops at the first NUL byte via `strlen()`, since a bare pointer has no length of its own.
-    The library applies that same NUL-terminated-C-string convention uniformly, rather than only when a length is
-    genuinely unavailable - so a `std::string`, iterator range, or container whose content happens to include a NUL
-    byte is affected the same way a raw `const char*` would be (see the
-    [FAQ entry](../../home/faq.md#nul-bytes-in-the-input) for a fuller explanation).
-
-    This was not fixed unconditionally, because doing so is backwards-incompatible for any caller who happens to
-    depend on the current behavior - even unknowingly, for instance because their input already contains trailing
-    padding they never noticed was being discarded (see [#5530](https://github.com/nlohmann/json/issues/5530)).
-    This macro instead offers an opt-in path to the corrected behavior ahead of version 4.0.0, where it is planned to
-    become the default.
-
-!!! warning "Opt-in only"
-
-    This macro must be defined **before** including `<nlohmann/json.hpp>`. Defining it after the include has no
-    effect.
-
-    Enabling it also changes how a `char` array (including a string literal, e.g. `json::parse("123")`) is read: such
-    an array normally carries a trailing `'\0'` contributed by the compiler, not by the source text. With this macro
-    enabled, that one trailing byte is trimmed if present so that parsing a string literal keeps working; every other
-    byte in the array - including any `'\0'` that is not the very last element - is read as real data and rejected
-    like any other unexpected byte. Arrays of any other element type (`unsigned char`, `std::uint8_t`, ...), as used
-    for CBOR or MessagePack, are never affected by this trimming; their full extent - including a genuine trailing
-    `0x00` - is always preserved, in both states of this macro.
-
-!!! tip "Workaround without the macro"
-
-    To reject a NUL byte without enabling this macro, trim your input yourself before calling `parse()`:
-
-    ```cpp
-    s.resize(s.find('\0')); // drop everything from the first NUL onward, if any
-    json::parse(s);
-    ```
-
-## Examples
-
-??? example "Default behavior (macro not defined)"
-
-    Without the macro, a NUL byte silently ends parsing at that point:
-
-    ```cpp
-    #include <nlohmann/json.hpp>
-
-    using json = nlohmann::json;
-
-    int main()
-    {
-        json j = json::parse(std::string("123") + '\0' + "true");
-        // j is 123 -- the '\0' and everything after it is silently ignored
-    }
-    ```
-
-??? example "Opt-in strict handling (macro defined to 1)"
-
-    With the macro, a NUL byte is rejected like any other unexpected byte:
-
-    ```cpp
-    #define JSON_STRICT_NUL_HANDLING 1
-    #include <nlohmann/json.hpp>
-
-    using json = nlohmann::json;
-
-    int main()
-    {
-        json j = json::parse(std::string("123") + '\0' + "true");
-        // throws parse_error.101 -- the NUL byte is now invalid input,
-        // exactly like any other unexpected trailing byte
-
-        json ok = json::parse("123");
-        // ok is 123 -- parsing from a string literal still works
-    }
-    ```
-
-## See also
-
- [FAQ: NUL bytes in the input](../../home/faq.md#nul-bytes-in-the-input)
- [**parse**](../basic_json/parse.md) - deserialize from a compatible input
- [**accept**](../basic_json/accept.md) - check if the input is valid JSON
- [**operator>>**](../operator_gtgt.md) - deserialize from stream
-
-## Version history
-
- Added in version 3.13.0.
- Planned to become the default (with the macro removed) in version 4.0.0.
@@ -24,14 +24,6 @@ By default, implicit conversions are enabled.
    You can prepare existing code by already defining `JSON_USE_IMPLICIT_CONVERSIONS` to `0` and replace any implicit
    conversions with calls to [`get`](../basic_json/get.md).

-!!! tip "Automatic migration"
-
-    The community-maintained clang-tidy check `modernize-nlohmann-json-explicit-conversions` rewrites implicit
-    conversions into explicit calls to [`get`](../basic_json/get.md); for example, `#!cpp int i = j;` becomes
-    `#!cpp int i = j.get<int>();`. The check is not part of clang-tidy itself, and it does not catch every case (for
-    example, constructing a `std::optional` from a JSON value), so review the result. See
-    [discussion #4610](https://github.com/nlohmann/json/discussions/4610) for how to build and use it.
-
 !!! hint "CMake option"

    Implicit conversions can also be controlled with the CMake option
@@ -72,13 +72,6 @@ input >> j2;  // parses the next value
 Note that reading concatenated values does **not** work for [JSON Lines](../features/parsing/json_lines.md)
 (newline-delimited JSON) input -- see that page for why and for the recommended alternative.

-By default, a `'\0'` (NUL) byte encountered while reading a value is treated as end of input, rather than as an
-ordinary (and, outside of a string, invalid) byte; see the [FAQ entry](../home/faq.md#nul-bytes-in-the-input) for
-details and the [`JSON_STRICT_NUL_HANDLING`](macros/json_strict_nul_handling.md) macro to opt into rejecting it
-instead. Because `operator>>` only parses a single value and does not require the rest of the stream to be consumed,
-a NUL byte *after* a complete value has no effect on `operator>>` either way; it only matters while a value is still
-being read.
-
 !!! warning "Deprecation"

    This function replaces function `#!cpp std::istream& operator<<(basic_json& j, std::istream& i)` which has
@@ -105,11 +98,7 @@ being read.

 - [accept](basic_json/accept.md) - check if the input is valid JSON
 - [parse](basic_json/parse.md) - deserialize from a compatible input
- [`JSON_STRICT_NUL_HANDLING`](macros/json_strict_nul_handling.md) - opt in to rejecting a NUL byte in the input
-  instead of treating it as end of input

 ## Version history

 - Added in version 1.0.0.
- `JSON_STRICT_NUL_HANDLING` added in version 3.13.0 to optionally reject a NUL byte in the input instead of treating
-  it as end of input; planned to become the default in version 4.0.0.
@@ -116,22 +116,18 @@ The library uses the following mapping from JSON values types to BJData types ac
    ```

    Likewise, when a JSON object in the above form is serialized using
-    [`to_bjdata`](../../api/basic_json/to_bjdata.md), it is automatically converted into a compact BJData ND-array.
+    [`to_bjdata`](../../api/basic_json/to_bjdata.md), it is automatically converted into a compact BJData ND-array. When
+    the 1-dimensional vector stored in `"_ArraySize_"` contains a single integer or two integers with one being 1, a
+    regular 1-D optimized array is generated instead.

-    When parsing, an ND-array whose dimension vector is empty, contains a single integer, contains two integers with the
-    first being 1, or contains a 0 is returned as a regular (possibly empty) array rather than an annotated object.
-
-    An object is only converted if the annotation describes a packed array that is parsed back into the same annotated
-    object; otherwise it is serialized as a regular JSON object, so the annotation is never lost in a round trip. This requires
-    all of the following:
+    An object is only converted if the annotation actually describes a packed array; otherwise it is serialized as a
+    regular JSON object. This requires all of the following:

    - `"_ArrayType_"` is one of `uint8`, `int8`, `uint16`, `int16`, `uint32`, `int32`, `uint64`, `int64`, `single`,
      `double`, `char`, or `byte`,
    - `"_ArraySize_"` is an array, since the dimensions are written as the ND-array header's length,
-    - `"_ArraySize_"` has at least two entries and is not a 1×N row vector (first entry 1), since other shapes are
-      parsed back as a regular array,
-    - every entry of `"_ArraySize_"` is a positive integer, and their product is representable as a `std::size_t`,
-    - `"_ArrayData_"` is an array holding exactly that many elements, and
+    - every entry of `"_ArraySize_"` is a non-negative integer, and their product is representable as a `std::size_t`,
+    - `"_ArrayData_"` holds exactly that many elements, and
    - every element of `"_ArrayData_"` is a number of the kind named by `"_ArrayType_"` (a floating-point number for
      `single` and `double`, an integer otherwise).

@@ -208,6 +204,14 @@ The library maps BJData types to JSON value types as follows:

    The mapping is **complete** in the sense that any BJData value can be converted to a JSON value.

+!!! warning "UTF-8 validation of string values"
+
+    BJData does not specify an encoding for its `string`/`char` types, but this library requires them to be valid
+    UTF-8, consistent with the rest of the library. The bytes of every such string (object keys included) are
+    validated at decode time, and ill-formed UTF-8 is rejected with a
+    [`parse_error.113`](../../home/exceptions.md#jsonexceptionparse_error113) exception (or, with `allow_exceptions`
+    set to `false`, a discarded value), rather than only failing later when the resulting value is dumped.
+
 ??? example

    ```cpp
@@ -109,6 +109,15 @@ The library maps BSON record types to JSON value types as follows:
    If BSON input must be validated for strict specification compliance, validate it separately before passing it to
    `from_bson()`.

+!!! warning "UTF-8 validation of string values"
+
+    The BSON specification requires `string` values (type `0x02`) to be valid UTF-8. This library validates the
+    bytes of every such string at decode time and rejects ill-formed UTF-8 with a
+    [`parse_error.113`](../../home/exceptions.md#jsonexceptionparse_error113) exception (or, with `allow_exceptions`
+    set to `false`, a discarded value), rather than only failing later when the resulting value is dumped. Element
+    (key) names and `binary` values (type `0x05`) are unaffected and are never validated, since they are read
+    byte-by-byte as a C string, or are not required to hold text, respectively.
+
 ??? example

    ```cpp
@@ -176,6 +176,16 @@ The library maps CBOR types to JSON value types as follows:

    CBOR allows map keys of any type, whereas JSON only allows strings as keys in object values. Therefore, CBOR maps with keys other than UTF-8 strings are rejected.

+!!! warning "UTF-8 validation of text strings"
+
+    [RFC 8949, Section 3.1](https://www.rfc-editor.org/rfc/rfc8949.html#section-3.1) requires CBOR text strings
+    (major type 3) to be valid UTF-8. This library validates the bytes of every text string (object keys included) at
+    decode time and rejects ill-formed UTF-8 with a
+    [`parse_error.113`](../../home/exceptions.md#jsonexceptionparse_error113) exception (or, with
+    `allow_exceptions` set to `false`, a discarded value), rather than only failing later when the resulting value is
+    dumped. Byte strings (major type 2) are unaffected and are never validated, since they are not required to hold
+    text.
+
 !!! warning "Tagged items"

    Tagged items (0xC0..0xDB) will throw a parse error by default. They can be ignored by passing `cbor_tag_handler_t::ignore` to function `from_cbor`, in which case the tag is skipped and the enclosed data item is parsed on its own. They can be stored by passing `cbor_tag_handler_t::store` to function `from_cbor`. Note that no tag is ever interpreted: for instance, a text string tagged with tag 0 (date/time) stays a string.
@@ -136,6 +136,14 @@ The library maps MessagePack types to JSON value types as follows:

    Any MessagePack output created by `to_msgpack` can be successfully parsed by `from_msgpack`.

+!!! warning "UTF-8 validation of string values"
+
+    The MessagePack specification requires `str` values (`fixstr`, `str 8`, `str 16`, `str 32`) to be valid UTF-8.
+    This library validates the bytes of every such string (object keys included) at decode time and rejects
+    ill-formed UTF-8 with a [`parse_error.113`](../../home/exceptions.md#jsonexceptionparse_error113) exception (or,
+    with `allow_exceptions` set to `false`, a discarded value), rather than only failing later when the resulting
+    value is dumped. `bin`/`ext`/`fixext` values are unaffected and are never validated, since they are not required
+    to hold text.

 ??? example

@@ -120,6 +120,14 @@ The library maps UBJSON types to JSON value types as follows:

    The mapping is **complete** in the sense that any UBJSON value can be converted to a JSON value.

+!!! warning "UTF-8 validation of string values"
+
+    UBJSON does not specify an encoding for its `string`/`char` types, but this library requires them to be valid
+    UTF-8, consistent with the rest of the library. The bytes of every such string (object keys included) are
+    validated at decode time, and ill-formed UTF-8 is rejected with a
+    [`parse_error.113`](../../home/exceptions.md#jsonexceptionparse_error113) exception (or, with `allow_exceptions`
+    set to `false`, a discarded value), rather than only failing later when the resulting value is dumped.
+
 ??? example

    ```cpp
@@ -91,13 +91,6 @@ security reasons (e.g., Intel Software Guard Extensions (SGX)).

 See [full documentation of `JSON_NO_IO`](../api/macros/json_no_io.md).

-## `JSON_NO_THREAD_LOCAL`
-
-When defined, the library does not use `#!cpp thread_local` storage. Copying a value then always avoids the call stack
-rather than descending into a bounded number of levels first, which is slower but yields the same values.
-
-See [full documentation of `JSON_NO_THREAD_LOCAL`](../api/macros/json_no_thread_local.md).
-
 ## `JSON_SKIP_LIBRARY_VERSION_CHECK`

 When defined, the library will not create a compiler warning when a different version of the library was already
@@ -112,19 +105,6 @@ using the library with compilers that do not fully support C++11 and may only wo

 See [full documentation of `JSON_SKIP_UNSUPPORTED_COMPILER_CHECK`](../api/macros/json_skip_unsupported_compiler_check.md).

-## `JSON_STRICT_NUL_HANDLING`
-
-When defined to `1`, a `'\0'` (NUL) byte anywhere in the input is rejected with `parse_error.101`, like any other
-unexpected byte, instead of being silently treated as end of input (see the
-[FAQ entry](../home/faq.md#nul-bytes-in-the-input) for background). The default value is `0`, which preserves the
-existing behavior; this is planned to become the default in version 4.0.0.
-
-The strict handling can also be enabled with the CMake option
-[`JSON_StrictNulHandling`](../integration/cmake.md#json_strictnulhandling) (`OFF` by default) which sets
-`JSON_STRICT_NUL_HANDLING` accordingly.
-
-See [full documentation of `JSON_STRICT_NUL_HANDLING`](../api/macros/json_strict_nul_handling.md).
-
 ## `JSON_THROW_USER(exception)`

 This macro overrides `#!cpp throw` calls inside the library. The argument is the exception to be thrown.
@@ -15,9 +15,6 @@ The complete default namespace name is derived as follows:
    - [`JSON_DIAGNOSTICS`](../api/macros/json_diagnostics.md) defined non-zero appends `_diag`.
    - [`JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON`](../api/macros/json_use_legacy_discarded_value_comparison.md)
      defined non-zero appends `_ldvcmp`.
-    - [`JSON_DIAGNOSTIC_POSITIONS`](../api/macros/json_diagnostic_positions.md) defined non-zero appends `_dp`.
-    - [`JSON_BRACE_INIT_COPY_SEMANTICS`](../api/macros/json_brace_init_copy_semantics.md) defined non-zero appends
-      `_bics`.
 - The inline namespace ends with the suffix `_v` followed by the 3 components of the version number separated by
  underscores. To omit the version component, see [Disabling the version component](#disabling-the-version-component)
  below.
@@ -340,7 +340,8 @@ An unexpected byte was read in a [binary format](../features/binary_formats/inde
 ### json.exception.parse_error.113

 A string could not be read from a [binary format](../features/binary_formats/index.md): either a value that is not a
-string was read where one was required (for instance as a map key), or the string's length specification is invalid.
+string was read where one was required (for instance as a map key), the string's length specification is invalid, or
+the string's bytes are not valid UTF-8.

 !!! failure "Example messages"

@@ -356,6 +357,9 @@ string was read where one was required (for instance as a map key), or the strin
    ```
    [json.exception.parse_error.113] parse error at byte 3: syntax error while parsing BJData string: string length must not be negative
    ```
+    ```
+    [json.exception.parse_error.113] parse error at byte 3: syntax error while parsing CBOR string: invalid string: ill-formed UTF-8 byte
+    ```

 ### json.exception.parse_error.114

@@ -970,21 +974,6 @@ A JSON Patch `move` operation's `"from"` location is a proper prefix of its `"pa

    This exception was added in version 3.13.0. Before that, this situation could succeed with a corrupted result: for an array target, removing the "from" element before the "add" step shifted subsequent indices, so "path" silently re-resolved to a different element than intended.

-### json.exception.out_of_range.415
-
-MessagePack's ext type and BSON's binary subtype are each stored in a single byte. This exception is thrown when serializing a
-[`byte_container_with_subtype`](../api/byte_container_with_subtype/index.md) whose subtype exceeds 255.
-
-!!! failure "Example message"
-
-    ```
-    [json.exception.out_of_range.415] subtype 70000 is too large for the MessagePack ext type (max 255)
-    ```
-
-!!! note
-
-    This exception was added in version 3.13.0. Before that, subtypes above 255 were silently truncated modulo 256 instead of raising an error.
-
 ## Further exceptions

 This exception is thrown in case of errors that cannot be classified with the
@@ -90,54 +90,6 @@ The library supports **Unicode input** as follows:
 In most cases, the parser is right to complain, because the input is not UTF-8 encoded. This is especially true for Microsoft Windows, where Latin-1 or ISO 8859-1 is often the standard encoding.


-### NUL bytes in the input
-
-!!! question "Questions"
-
-    - Why does `json::parse()` silently ignore part of my input?
-    - Why does a `std::string`/buffer with extra data after the JSON text parse without error, while a similar-looking string with extra text does not?
-
-A `'\0'` (NUL) byte anywhere in the input is treated the same as the real end of the input, rather than as an ordinary (and, outside of a string, invalid) byte. Everything from that byte onward is silently ignored, without a parse error — including further, otherwise well-formed JSON:
-
-```cpp
-json::parse(std::string("123") + '\0');          // == 123, no error
-json::parse(std::string("123") + '\0' + "true"); // == 123, the "true" is silently ignored too
-```
-
-This is different from any other unexpected trailing byte, which *does* raise [`parse_error.101`](../home/exceptions.md#jsonexceptionparse_error101):
-
-```cpp
-json::parse("123x"); // throws parse_error.101: unexpected additional data
-```
-
-This falls out of the same convention used when no explicit input length is given at all: `json::parse(const char*)` already stops at the first NUL byte via `strlen()`, since a bare pointer has no length of its own. The library applies that same NUL-terminated-C-string convention uniformly, rather than only when a length is genuinely unavailable — so a `std::string`, iterator range, or container whose content happens to include a NUL byte is affected the same way a raw `const char*` would be.
-
-If your input may contain a trailing or embedded NUL that is **not** meant to signal the end of the JSON text — for instance, a fixed-size, zero-padded buffer — trim it yourself before calling `parse()`, since the library will otherwise silently stop there instead of raising an error:
-
-```cpp
-s.resize(s.find('\0')); // drop everything from the first NUL onward, if any
-json::parse(s);
-```
-
-**Opt-in strict handling (since version 3.13.0)**
-
-Manually trimming every input is easy to forget. If you define [`JSON_STRICT_NUL_HANDLING`](../api/macros/json_strict_nul_handling.md) to `1` before including the library, a `'\0'` byte is instead rejected like any other unexpected byte and raises `parse_error.101`, instead of being treated as end of input:
-
-```cpp
-#define JSON_STRICT_NUL_HANDLING 1
-#include <nlohmann/json.hpp>
-
-json::parse(std::string("123") + '\0'); // throws parse_error.101 instead of silently returning 123
-```
-
-This macro defaults to `0` (disabled, preserving the behavior described above) to avoid breaking existing code that may depend on it, even unknowingly; it is planned to become the default in version 4.0.0. See [its documentation](../api/macros/json_strict_nul_handling.md) for details, including how it also affects `char` arrays such as string literals.
-
-Note that this is unrelated to an *unescaped* NUL byte occurring **inside** a quoted JSON string, which is a different, already-invalid case and is correctly rejected either way:
-
-```cpp
-json::parse(std::string("\"") + '\0' + "\""); // throws parse_error.101: control character U+0000 (NUL) must be escaped to \u0000
-```
-
 ### Wide string handling

 !!! question
@@ -198,11 +198,6 @@ Use the non-amalgamated version of the library. This option is `ON` by default.

 Treat the library headers like system headers (i.e., adding `SYSTEM` to the [`target_include_directories`](https://cmake.org/cmake/help/latest/command/target_include_directories.html) call) to check for this library by tools like Clang-Tidy. This option is `OFF` by default.

-### `JSON_StrictNulHandling`
-
-Reject a `'\0'` (NUL) byte in the input instead of treating it as end of input, by defining the macro
-[`JSON_STRICT_NUL_HANDLING`](../api/macros/json_strict_nul_handling.md). This option is `OFF` by default.
-
 ### `JSON_Valgrind`

 Execute the test suite with [Valgrind](https://valgrind.org). This option is `OFF` by default. Depends on `JSON_BuildTests`.
@@ -176,12 +176,6 @@ You can prepare existing code by already defining
 conversions with calls to [`get`](../api/basic_json/get.md), [`get_to`](../api/basic_json/get_to.md),
 [`get_ref`](../api/basic_json/get_ref.md), or [`get_ptr`](../api/basic_json/get_ptr.md).

-!!! tip "Automatic migration"
-
-    The community-maintained clang-tidy check `modernize-nlohmann-json-explicit-conversions` rewrites most implicit
-    conversions into calls to [`get`](../api/basic_json/get.md). It is not part of clang-tidy itself; see
-    [discussion #4610](https://github.com/nlohmann/json/discussions/4610) for how to build and use it.
-
 === "Deprecated"

      ```cpp
@@ -292,10 +292,8 @@ nav:
          - 'JSON_HAS_THREE_WAY_COMPARISON': api/macros/json_has_three_way_comparison.md
          - 'JSON_NOEXCEPTION': api/macros/json_noexception.md
          - 'JSON_NO_IO': api/macros/json_no_io.md
-          - 'JSON_NO_THREAD_LOCAL': api/macros/json_no_thread_local.md
          - 'JSON_SKIP_LIBRARY_VERSION_CHECK': api/macros/json_skip_library_version_check.md
          - 'JSON_SKIP_UNSUPPORTED_COMPILER_CHECK': api/macros/json_skip_unsupported_compiler_check.md
-          - 'JSON_STRICT_NUL_HANDLING': api/macros/json_strict_nul_handling.md
          - 'JSON_USE_GLOBAL_UDLS': api/macros/json_use_global_udls.md
          - 'JSON_USE_IMPLICIT_CONVERSIONS': api/macros/json_use_implicit_conversions.md
          - 'JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON': api/macros/json_use_legacy_discarded_value_comparison.md
@@ -1,7 +1,7 @@
 wheel==0.48.0

 mkdocs==1.6.1                                       # documentation framework
-mkdocs-git-revision-date-localized-plugin==1.6.0    # plugin "git-revision-date-localized"
+mkdocs-git-revision-date-localized-plugin==1.5.4    # plugin "git-revision-date-localized"
 mkdocs-material==9.7.7                             # theme for mkdocs
 mkdocs-material-extensions==1.3.1                   # extensions
 mkdocs-minify-plugin==0.8.0                         # plugin "minify"
@@ -34,10 +34,6 @@
    #define JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON 0
 #endif

-#ifndef JSON_BRACE_INIT_COPY_SEMANTICS
-    #define JSON_BRACE_INIT_COPY_SEMANTICS 0
-#endif
-
 #if JSON_DIAGNOSTICS
    #define NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS _diag
 #else
@@ -56,27 +52,20 @@
    #define NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON
 #endif

-#if JSON_BRACE_INIT_COPY_SEMANTICS
-    #define NLOHMANN_JSON_ABI_TAG_BRACE_INIT_COPY_SEMANTICS _bics
-#else
-    #define NLOHMANN_JSON_ABI_TAG_BRACE_INIT_COPY_SEMANTICS
-#endif
-
 #ifndef NLOHMANN_JSON_NAMESPACE_NO_VERSION
    #define NLOHMANN_JSON_NAMESPACE_NO_VERSION 0
 #endif

 // Construct the namespace ABI tags component
-#define NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b, c, d) json_abi ## a ## b ## c ## d
-#define NLOHMANN_JSON_ABI_TAGS_CONCAT(a, b, c, d) \
-    NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b, c, d)
+#define NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b, c) json_abi ## a ## b ## c
+#define NLOHMANN_JSON_ABI_TAGS_CONCAT(a, b, c) \
+    NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b, c)

 #define NLOHMANN_JSON_ABI_TAGS                                       \
    NLOHMANN_JSON_ABI_TAGS_CONCAT(                                   \
            NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS,                       \
            NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON, \
-            NLOHMANN_JSON_ABI_TAG_DIAGNOSTIC_POSITIONS,              \
-            NLOHMANN_JSON_ABI_TAG_BRACE_INIT_COPY_SEMANTICS)
+            NLOHMANN_JSON_ABI_TAG_DIAGNOSTIC_POSITIONS)

 // Construct the namespace version component
 #define NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT_EX(major, minor, patch) \
@@ -471,30 +471,6 @@ inline void to_json_tuple_impl(BasicJsonType& j, const Tuple& t, index_sequence<
    j = { std::get<Idx>(t)... };
 }

-#if JSON_BRACE_INIT_COPY_SEMANTICS
-// JSON_BRACE_INIT_COPY_SEMANTICS makes a one-element braced list copy its
-// element instead of wrapping it, which would serialize std::tuple<int>{5} as 5
-// rather than [5]. Build what the default deduction builds instead: an object
-// if the element is a [string, value] pair, a one-element array otherwise.
-template<typename BasicJsonType, typename Tuple>
-inline void to_json_tuple_impl(BasicJsonType& j, const Tuple& t, index_sequence<0> /*unused*/)
-{
-    BasicJsonType element(std::get<0>(t));
-    // same test as the initializer-list constructor, including the cast that
-    // keeps a string type constructible from 0 from selecting operator[](key)
-    const bool is_member = element.is_array() && element.size() == 2
-                           && element[static_cast<typename BasicJsonType::size_type>(0)].is_string();
-    if (is_member)
-    {
-        j = BasicJsonType::object({std::move(element)});
-    }
-    else
-    {
-        j = BasicJsonType::array({std::move(element)});
-    }
-}
-#endif
-
 template<typename BasicJsonType, typename Tuple>
 inline void to_json_tuple_impl(BasicJsonType& j, const Tuple& /*unused*/, index_sequence<> /*unused*/)
 {
@@ -11,10 +11,8 @@
 #include <cstdint> // uint8_t
 #include <cstddef> // size_t
 #include <functional> // hash
-#include <vector> // vector

 #include <nlohmann/detail/abi_macros.hpp>
-#include <nlohmann/detail/recursion_depth_limit.hpp>
 #include <nlohmann/detail/value_t.hpp>

 NLOHMANN_JSON_NAMESPACE_BEGIN
@@ -28,9 +26,6 @@ inline std::size_t combine(std::size_t seed, std::size_t h) noexcept
    return seed;
 }

-template<typename BasicJsonType>
-std::size_t hash_iteratively(const BasicJsonType& j);
-
 /*!
@brief hash a JSON value

@@ -38,21 +33,12 @@ The hash function tries to rely on std::hash where possible. Furthermore, the
 type of the JSON value is taken into account to have different hash values for
 null, 0, 0U, and false, etc.

-Hashing an array or an object hashes its elements, which used to call this
-function again once per nesting level, so a value nested deeply enough
-exhausted the call stack and terminated the process. The descent is bounded
-here: once @ref recursion_depth_limit levels have been entered, @ref
-hash_iteratively hashes what is left without the call stack. A value nested
-less deeply than that - all but a vanishing minority - is hashed exactly as
-before, without allocating.
-
@tparam BasicJsonType basic_json specialization
@param j JSON value to hash
-@param depth nesting level of @a j, counted from the value passed by the caller
@return hash value of j
 */
 template<typename BasicJsonType>
-std::size_t hash(const BasicJsonType& j, const std::size_t depth = 0)
+std::size_t hash(const BasicJsonType& j)
 {
    using string_t = typename BasicJsonType::string_t;
    using number_integer_t = typename BasicJsonType::number_integer_t;
@@ -70,32 +56,22 @@ std::size_t hash(const BasicJsonType& j, const std::size_t depth = 0)

        case BasicJsonType::value_t::object:
        {
-            if (JSON_HEDLEY_UNLIKELY(depth >= recursion_depth_limit()))
-            {
-                return hash_iteratively(j);
-            }
-
            auto seed = combine(type, j.size());
            for (const auto& element : j.items())
            {
                const auto h = std::hash<string_t> {}(element.key());
                seed = combine(seed, h);
-                seed = combine(seed, hash(element.value(), depth + 1));
+                seed = combine(seed, hash(element.value()));
            }
            return seed;
        }

        case BasicJsonType::value_t::array:
        {
-            if (JSON_HEDLEY_UNLIKELY(depth >= recursion_depth_limit()))
-            {
-                return hash_iteratively(j);
-            }
-
            auto seed = combine(type, j.size());
            for (const auto& element : j)
            {
-                seed = combine(seed, hash(element, depth + 1));
+                seed = combine(seed, hash(element));
            }
            return seed;
        }
@@ -151,77 +127,5 @@ std::size_t hash(const BasicJsonType& j, const std::size_t depth = 0)
    }
 }

-/// an array or object whose elements @ref hash_iteratively is hashing
-template<typename BasicJsonType>
-struct hash_frame
-{
-    hash_frame(const BasicJsonType* value_, std::size_t seed_) noexcept
-        : value(value_), position(value_->cbegin()), seed(seed_)
-    {}
-
-    const BasicJsonType* value;
-    typename BasicJsonType::const_iterator position;
-    std::size_t seed;
-};
-
-/*!
-@brief hash the array or object @a j without the call stack
-
-Computes the same value as @ref hash, keeping the arrays and objects it has
-entered on an explicit stack instead of descending into them. Only reached for
-values nested deeper than @ref recursion_depth_limit.
-
-@tparam BasicJsonType basic_json specialization
-@param j array or object to hash
-@return hash value of j
-*/
-template<typename BasicJsonType>
-std::size_t hash_iteratively(const BasicJsonType& j)
-{
-    using string_t = typename BasicJsonType::string_t;
-
-    std::vector<hash_frame<BasicJsonType>> stack;
-    stack.emplace_back(&j, combine(static_cast<std::size_t>(j.type()), j.size()));
-
-    while (true)
-    {
-        // a copy, as entering an element below can reallocate the stack; the
-        // frame itself is only changed through stack.back()
-        const hash_frame<BasicJsonType> frame = stack.back();
-
-        if (frame.position == frame.value->cend())
-        {
-            // all elements are hashed: fold this value's hash into its parent's
-            // seed, exactly where the recursive version returns it
-            const std::size_t h = frame.seed;
-            stack.pop_back();
-            if (stack.empty())
-            {
-                return h;
-            }
-            stack.back().seed = combine(stack.back().seed, h);
-            continue;
-        }
-
-        if (frame.value->is_object())
-        {
-            stack.back().seed = combine(stack.back().seed, std::hash<string_t> {}(frame.position.key()));
-        }
-
-        // advance before entering the element, which pushes onto the stack
-        const BasicJsonType& element = *frame.position;
-        ++stack.back().position;
-
-        if (element.is_structured())
-        {
-            stack.emplace_back(&element, combine(static_cast<std::size_t>(element.type()), element.size()));
-        }
-        else
-        {
-            stack.back().seed = combine(stack.back().seed, hash(element));
-        }
-    }
-}
-
 }  // namespace detail
 NLOHMANN_JSON_NAMESPACE_END
@@ -32,6 +32,7 @@
 #include <nlohmann/detail/meta/is_sax.hpp>
 #include <nlohmann/detail/meta/type_traits.hpp>
 #include <nlohmann/detail/string_concat.hpp>
+#include <nlohmann/detail/string_utils.hpp>
 #include <nlohmann/detail/value_t.hpp>

 NLOHMANN_JSON_NAMESPACE_BEGIN
@@ -3304,7 +3305,24 @@ class binary_reader
                    const NumberType len,
                    string_t& result)
    {
-        return get_bytes(format, len, "string", result);
+        if (JSON_HEDLEY_UNLIKELY(!get_bytes(format, len, "string", result)))
+        {
+            return false;
+        }
+
+        // RFC 8949 (CBOR) §3.1 and the MessagePack/BSON/UBJSON specifications
+        // all require text strings to be valid UTF-8; reject anything else
+        // right here so malformed input is caught at decode time instead of
+        // only surfacing later as a type_error.316 when the value is dumped
+        // (which would defeat allow_exceptions=false / strict discarding).
+        if (JSON_HEDLEY_UNLIKELY(!is_valid_utf8(result)))
+        {
+            return sax->parse_error(chars_read, get_token_string(),
+                                     parse_error::create(113, chars_read,
+                                             exception_message(format, "invalid string: ill-formed UTF-8 byte", "string"), nullptr));
+        }
+
+        return true;
    }

    /*!
@@ -762,21 +762,6 @@ contiguous_bytes_input_adapter input_adapter(CharT b)
 template<typename T, std::size_t N>
 auto input_adapter(T (&array)[N]) -> decltype(input_adapter(array, array + N)) // NOLINT(cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)
 {
-#if JSON_STRICT_NUL_HANDLING
-    // A `char` array from string-literal initialization (e.g. json::parse("123"))
-    // carries a trailing '\0' contributed by the compiler, not by the source
-    // text; drop exactly that one byte so it is not mistaken for real trailing
-    // data. Every other element type (unsigned char, std::uint8_t, ...) keeps
-    // the full extent unconditionally, since a trailing zero byte there is
-    // genuine data (e.g. CBOR/MessagePack). This intentionally does not
-    // strlen()-scan the array (as the pointer overload above does for a
-    // null-delimited string): for a `char` array that is not NUL-terminated
-    // within its bounds, that would read past the end of the array.
-    if (std::is_same<typename std::remove_cv<T>::type, char>::value && N > 0 && array[N - 1] == 0)
-    {
-        return input_adapter(array, array + N - 1);
-    }
-#endif
    return input_adapter(array, array + N);
 }

@@ -8,11 +8,11 @@

 #pragma once

-#include <algorithm> // find_if, min
+#include <algorithm> // min
 #include <cstddef>
 #include <string> // string
 #include <type_traits> // enable_if_t
-#include <utility> // move, pair
+#include <utility> // move
 #include <vector> // vector

 #include <nlohmann/detail/exceptions.hpp>
@@ -278,7 +278,7 @@ class json_sax_dom_parser

        if (JSON_HEDLEY_UNLIKELY(len != detail::unknown_size() && len > ref_stack.back()->max_size()))
        {
-            return parse_error(0, "", out_of_range::create(408, concat("excessive object size: ", std::to_string(len)), ref_stack.back()));
+            JSON_THROW(out_of_range::create(408, concat("excessive object size: ", std::to_string(len)), ref_stack.back()));
        }

        return true;
@@ -327,7 +327,7 @@ class json_sax_dom_parser

        if (JSON_HEDLEY_UNLIKELY(len != detail::unknown_size() && len > ref_stack.back()->max_size()))
        {
-            return parse_error(0, "", out_of_range::create(408, concat("excessive array size: ", std::to_string(len)), ref_stack.back()));
+            JSON_THROW(out_of_range::create(408, concat("excessive array size: ", std::to_string(len)), ref_stack.back()));
        }

        if (len != detail::unknown_size())
@@ -611,7 +611,7 @@ class json_sax_dom_callback_parser
            // check object limit
            if (JSON_HEDLEY_UNLIKELY(len != detail::unknown_size() && len > ref_stack.back()->max_size()))
            {
-                return parse_error(0, "", out_of_range::create(408, concat("excessive object size: ", std::to_string(len)), ref_stack.back()));
+                JSON_THROW(out_of_range::create(408, concat("excessive object size: ", std::to_string(len)), ref_stack.back()));
            }
        }
        return true;
@@ -631,17 +631,7 @@ class json_sax_dom_callback_parser
        // add discarded value at the given key and store the reference for later
        if (keep && ref_stack.back())
        {
-            auto& obj = *ref_stack.back()->m_data.m_value.object;
-            const auto it = obj.find(val);
-            if (it != obj.end())
-            {
-                // this is a duplicate key (legal in JSON); remember its
-                // current value so it can be restored later if the new
-                // value is rejected by the callback, instead of being
-                // erased together with the discarded placeholder
-                duplicate_key_stash.emplace_back(&(it->second), it->second);
-            }
-            object_element = &(obj[val] = discarded);
+            object_element = &(ref_stack.back()->m_data.m_value.object->operator[](val) = discarded);
        }

        return true;
@@ -653,18 +643,13 @@ class json_sax_dom_callback_parser
        {
            if (!callback(static_cast<int>(ref_stack.size()) - 1, parse_event_t::object_end, *ref_stack.back()))
            {
-                // discard object, unless this slot holds a duplicate key's
-                // previous value pending restoration, in which case that
-                // value is restored instead of being discarded
-                if (!resolve_duplicate_key_stash(ref_stack.back(), true))
-                {
-                    *ref_stack.back() = discarded;
+                // discard object
+                *ref_stack.back() = discarded;

 #if JSON_DIAGNOSTIC_POSITIONS
-                    // Set start/end positions for discarded object.
-                    handle_diagnostic_positions_for_json_value(*ref_stack.back());
+                // Set start/end positions for discarded object.
+                handle_diagnostic_positions_for_json_value(*ref_stack.back());
 #endif
-                }
            }
            else
            {
@@ -678,10 +663,6 @@ class json_sax_dom_callback_parser
 #endif

                ref_stack.back()->set_parents();
-                // this object is finally, definitively kept; drop any
-                // pending duplicate-key stash entry for its slot since it
-                // can no longer be restored
-                resolve_duplicate_key_stash(ref_stack.back(), false);
            }
        }

@@ -730,7 +711,7 @@ class json_sax_dom_callback_parser
            // check array limit
            if (JSON_HEDLEY_UNLIKELY(len != detail::unknown_size() && len > ref_stack.back()->max_size()))
            {
-                return parse_error(0, "", out_of_range::create(408, concat("excessive array size: ", std::to_string(len)), ref_stack.back()));
+                JSON_THROW(out_of_range::create(408, concat("excessive array size: ", std::to_string(len)), ref_stack.back()));
            }

            if (len != detail::unknown_size())
@@ -762,25 +743,16 @@ class json_sax_dom_callback_parser
 #endif

                ref_stack.back()->set_parents();
-                // this array is finally, definitively kept; drop any
-                // pending duplicate-key stash entry for its slot since it
-                // can no longer be restored
-                resolve_duplicate_key_stash(ref_stack.back(), false);
            }
            else
            {
-                // discard array, unless this slot holds a duplicate key's
-                // previous value pending restoration, in which case that
-                // value is restored instead of being discarded
-                if (!resolve_duplicate_key_stash(ref_stack.back(), true))
-                {
-                    *ref_stack.back() = discarded;
+                // discard array
+                *ref_stack.back() = discarded;

 #if JSON_DIAGNOSTIC_POSITIONS
-                    // Set start/end positions for discarded array.
-                    handle_diagnostic_positions_for_json_value(*ref_stack.back());
+                // Set start/end positions for discarded array.
+                handle_diagnostic_positions_for_json_value(*ref_stack.back());
 #endif
-                }
            }
        }

@@ -897,35 +869,6 @@ class json_sax_dom_callback_parser
    }
 #endif

-    /// if there is a pending duplicate-key stash entry for this exact slot,
-    /// remove it from the stash; if restore_value is true, the stashed
-    /// previous value is moved back into the slot first (use this when the
-    /// new value at that slot was rejected); otherwise the stash entry is
-    /// simply dropped (use this when the new value was accepted, so it
-    /// correctly supersedes the old one and no restore should ever happen
-    /// for this slot again)
-    /// @return whether a matching stash entry was found (and processed)
-    bool resolve_duplicate_key_stash(BasicJsonType* slot, bool restore_value)
-    {
-        const auto it = std::find_if(duplicate_key_stash.begin(), duplicate_key_stash.end(),
-                                     [slot](const std::pair<BasicJsonType*, BasicJsonType>& entry)
-        {
-            return entry.first == slot;
-        });
-
-        if (it == duplicate_key_stash.end())
-        {
-            return false;
-        }
-
-        if (restore_value)
-        {
-            *slot = std::move(it->second);
-        }
-        duplicate_key_stash.erase(it);
-        return true;
-    }
-
    /*!
    @brief the key the value now being handled will be stored under

@@ -944,9 +887,7 @@ class json_sax_dom_callback_parser
    }

    /*!
-    @brief remove the discarded value the callback rejected from its parent,
-    unless it is a duplicate key's slot with a stashed previous value, in
-    which case that previous value is restored instead
+    @brief remove the discarded value the callback rejected from its parent

    A rejected value can only ever be the one most recently added to @a parent:
    the last element of an array, or the placeholder key() stored under @a key
@@ -961,7 +902,7 @@ class json_sax_dom_callback_parser
    @param[in,out] parent  the container to remove the rejected value from
    @param[in] key  the key the value was stored under; unused for arrays
    */
-    void remove_discarded_value(BasicJsonType& parent, const string_t& key)
+    static void remove_discarded_value(BasicJsonType& parent, const string_t& key)
    {
        if (parent.is_array())
        {
@@ -977,12 +918,7 @@ class json_sax_dom_callback_parser
            const auto it = object.find(key);
            if (it != object.end() && it->second.is_discarded())
            {
-                // a duplicate key's slot has a stashed previous value that
-                // must be restored instead of being erased
-                if (!resolve_duplicate_key_stash(&it->second, true))
-                {
-                    object.erase(it);
-                }
+                object.erase(it);
            }
        }
    }
@@ -1084,16 +1020,6 @@ class json_sax_dom_callback_parser

        JSON_ASSERT(object_element);
        *object_element = std::move(value);
-        if (!skip_callback)
-        {
-            // this scalar value finally, definitively replaces whatever was
-            // at this slot; drop any pending duplicate-key stash entry for
-            // it since it can no longer be restored (a container value at
-            // this slot is resolved later, in end_object()/end_array(),
-            // since skip_callback is true for the placeholder handling that
-            // happens here for those)
-            resolve_duplicate_key_stash(object_element, false);
-        }
        return {true, object_element};
    }

@@ -1113,12 +1039,6 @@ class json_sax_dom_callback_parser
    std::vector<string_t> container_key_stack {}; // NOLINT(readability-redundant-member-init)
    /// helper to hold the reference for the next object element
    BasicJsonType* object_element = nullptr;
-    /// stash of (slot pointer, previous value) for object members that
-    /// already existed when key() was called again for the same key
-    /// (duplicate keys); used to restore the previous value if the new
-    /// value is later rejected by the callback, instead of erasing the
-    /// member entirely
-    std::vector<std::pair<BasicJsonType*, BasicJsonType>> duplicate_key_stash {};
    /// whether a syntax error occurred
    bool errored = false;
    /// callback function
@@ -952,9 +952,7 @@ class lexer : public lexer_base<BasicJsonType>
                        case '\n':
                        case '\r':
                        case char_traits<char_type>::eof():
-#if !JSON_STRICT_NUL_HANDLING
                        case '\0':
-#endif
                            return true;

                        default:
@@ -972,10 +970,8 @@ class lexer : public lexer_base<BasicJsonType>
                {
                    switch (get())
                    {
-#if !JSON_STRICT_NUL_HANDLING
-                        case '\0':
-#endif
                        case char_traits<char_type>::eof():
+                        case '\0':
                        {
                            error_message = "invalid comment; missing closing '*/'";
                            return false;
@@ -2157,12 +2153,9 @@ scan_number_done:
            case '9':
                return scan_number_dispatch(std::integral_constant<bool, bulk_scan> {});

-#if !JSON_STRICT_NUL_HANDLING
+            // end of input (the null byte is needed when parsing from
+            // string literals)
            case '\0':
-#endif
-            // end of input; by default, a null byte is also treated as end of
-            // input for backwards compatibility (see JSON_STRICT_NUL_HANDLING
-            // to opt into rejecting a null byte in the input instead)
            case char_traits<char_type>::eof():
                return token_type::end_of_input;

@@ -186,15 +186,6 @@
    #define JSON_NO_UNIQUE_ADDRESS
 #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
-// GCC targeting MinGW and with every other toolchain the library is tested on.
-// Copying works the same way without the counter, only more slowly.
-#if !defined(JSON_NO_THREAD_LOCAL) && defined(__clang__) && defined(__MINGW32__)
-    #define JSON_NO_THREAD_LOCAL 1
-#endif
-
 // disable documentation warnings on clang
 #if defined(__clang__)
    #pragma clang diagnostic push
@@ -813,6 +804,6 @@ void templated_json_throw(ExceptionType exception)
    #define JSON_USE_GLOBAL_UDLS 1
 #endif

-#ifndef JSON_STRICT_NUL_HANDLING
-    #define JSON_STRICT_NUL_HANDLING 0
+#ifndef JSON_BRACE_INIT_COPY_SEMANTICS
+    #define JSON_BRACE_INIT_COPY_SEMANTICS 0
 #endif
@@ -26,7 +26,7 @@
 #undef JSON_NO_UNIQUE_ADDRESS
 #undef JSON_DISABLE_ENUM_SERIALIZATION
 #undef JSON_USE_GLOBAL_UDLS
-#undef JSON_STRICT_NUL_HANDLING
+#undef JSON_BRACE_INIT_COPY_SEMANTICS

 #ifndef JSON_TEST_KEEP_MACROS
    #undef JSON_CATCH
@@ -44,7 +44,6 @@
    #undef JSON_HAS_STD_FORMAT
    #undef JSON_HAS_STATIC_RTTI
    #undef JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON
-    #undef JSON_BRACE_INIT_COPY_SEMANTICS
 #endif

 #include <nlohmann/thirdparty/hedley/hedley_undef.hpp>
@@ -13,7 +13,6 @@
 #include <iterator> // back_inserter
 #include <memory> // shared_ptr, make_shared
 #include <string> // basic_string
-#include <utility> // move
 #include <vector> // vector

 #ifndef JSON_NO_IO
@@ -45,32 +44,22 @@ template<typename CharType> struct output_adapter_protocol
 template<typename CharType>
 using output_adapter_t = std::shared_ptr<output_adapter_protocol<CharType>>;

-/// @brief non-virtual output sink writing into a std::vector
-///
-/// This sink is not part of the virtual output_adapter_protocol hierarchy: it is
-/// passed to binary_writer by value as a template parameter, so
-/// write_character()/write_characters() are ordinary (inlinable) calls with no
-/// vtable lookup and no shared_ptr. It is used for the common
-/// `to_cbor`/`to_msgpack`/... into a std::vector. output_vector_adapter below
-/// wraps this same sink to provide the virtual interface.
+/// output adapter for byte vectors
 template<typename CharType, typename AllocatorType = std::allocator<CharType>>
-class output_vector_sink
+class output_vector_adapter : public output_adapter_protocol<CharType>
 {
  public:
-    explicit output_vector_sink(std::vector<CharType, AllocatorType>& vec) noexcept
+    explicit output_vector_adapter(std::vector<CharType, AllocatorType>& vec) noexcept
        : v(vec)
    {}

-    void write_character(CharType c)
+    void write_character(CharType c) override
    {
        v.push_back(c);
    }

-    // no JSON_HEDLEY_NON_NULL here: binary_writer legitimately passes a null
-    // pointer with length 0 for empty strings/binary values. Appending an empty
-    // range is a no-op; the type-erased path tolerates this via the (unattributed)
-    // virtual base, and the concrete sink must do the same.
-    void write_characters(const CharType* s, std::size_t length)
+    JSON_HEDLEY_NON_NULL(2)
+    void write_characters(const CharType* s, std::size_t length) override
    {
        v.insert(v.end(), s, s + length);
    }
@@ -79,34 +68,6 @@ class output_vector_sink
    std::vector<CharType, AllocatorType>& v;
 };

-/// output adapter for byte vectors
-///
-/// The appending itself lives in output_vector_sink; this class only adds the
-/// virtual output_adapter_protocol interface on top of it, so both the
-/// type-erased and the templated path share one implementation.
-template<typename CharType, typename AllocatorType = std::allocator<CharType>>
-class output_vector_adapter : public output_adapter_protocol<CharType>
-{
-  public:
-    explicit output_vector_adapter(std::vector<CharType, AllocatorType>& vec) noexcept
-        : sink(vec)
-    {}
-
-    void write_character(CharType c) override
-    {
-        sink.write_character(c);
-    }
-
-    JSON_HEDLEY_NON_NULL(2)
-    void write_characters(const CharType* s, std::size_t length) override
-    {
-        sink.write_characters(s, length);
-    }
-
-  private:
-    output_vector_sink<CharType, AllocatorType> sink;
-};
-
 #ifndef JSON_NO_IO
 /// output adapter for output streams
 template<typename CharType>
@@ -157,39 +118,6 @@ class output_string_adapter : public output_adapter_protocol<CharType>
    StringType& str;
 };

-/// @brief output sink forwarding to a type-erased output adapter
-///
-/// Wraps the polymorphic output_adapter_t so the same binary_writer template can
-/// also target arbitrary adapters (output streams, strings, user-provided
-/// adapters) via the `output_adapter`-based overloads. Each write still goes
-/// through one virtual call, exactly as before; only the concrete sinks above
-/// avoid it.
-template<typename CharType>
-class output_adapter_sink
-{
-  public:
-    explicit output_adapter_sink(output_adapter_t<CharType> adapter)
-        : oa(std::move(adapter))
-    {
-        JSON_ASSERT(oa);
-    }
-
-    void write_character(CharType c)
-    {
-        oa->write_character(c);
-    }
-
-    // no JSON_HEDLEY_NON_NULL: forwards (null, 0) for empty payloads, exactly as
-    // the type-erased path already did before this sink existed
-    void write_characters(const CharType* s, std::size_t length)
-    {
-        oa->write_characters(s, length);
-    }
-
-  private:
-    output_adapter_t<CharType> oa;
-};
-
 template<typename CharType, typename StringType = std::basic_string<CharType>>
 class output_adapter
 {
@@ -30,8 +30,8 @@
 #include <nlohmann/detail/meta/cpp_future.hpp>
 #include <nlohmann/detail/output/binary_writer.hpp>
 #include <nlohmann/detail/output/output_adapters.hpp>
-#include <nlohmann/detail/recursion_depth_limit.hpp>
 #include <nlohmann/detail/string_concat.hpp>
+#include <nlohmann/detail/string_utils.hpp>
 #include <nlohmann/detail/value_t.hpp>

 NLOHMANN_JSON_NAMESPACE_BEGIN
@@ -58,8 +58,6 @@ class serializer
    using number_integer_t = typename BasicJsonType::number_integer_t;
    using number_unsigned_t = typename BasicJsonType::number_unsigned_t;
    using binary_char_t = typename BasicJsonType::binary_t::value_type;
-    static constexpr std::uint8_t UTF8_ACCEPT = 0;
-    static constexpr std::uint8_t UTF8_REJECT = 1;

  public:
    /*!
@@ -134,7 +132,7 @@ class serializer

    Serializing a container descends into its elements, so a value nested deeply
    enough used to exhaust the call stack and terminate the process with no
-    exception to catch. The descent is bounded here: once @ref recursion_depth_limit
+    exception to catch. The descent is bounded here: once @ref dump_depth_limit
    levels have been entered, @ref dump_iteratively writes out what is left
    without the call stack. A value nested less deeply than that - all but a
    vanishing minority - is written by exactly the code that always wrote it.
@@ -149,7 +147,7 @@ class serializer
        {
            case value_t::object:
            {
-                if (JSON_HEDLEY_UNLIKELY(depth >= recursion_depth_limit()))
+                if (JSON_HEDLEY_UNLIKELY(depth >= dump_depth_limit()))
                {
                    dump_iteratively(val, current_indent);
                    return;
@@ -224,7 +222,7 @@ class serializer

            case value_t::array:
            {
-                if (JSON_HEDLEY_UNLIKELY(depth >= recursion_depth_limit()))
+                if (JSON_HEDLEY_UNLIKELY(depth >= dump_depth_limit()))
                {
                    dump_iteratively(val, current_indent);
                    return;
@@ -409,12 +407,19 @@ class serializer
    }

  private:
+    /// the number of levels @ref dump_internal descends into before it hands
+    /// over to @ref dump_iteratively
+    static constexpr std::size_t dump_depth_limit()
+    {
+        return 128;
+    }
+
    /*!
    @brief write out @a val and everything below it without the call stack

    Emits the same bytes as @ref dump_internal, keeping the containers it has
    entered on an explicit stack instead of descending into them. Only reached
-    for values nested deeper than @ref recursion_depth_limit, which is why it is not
+    for values nested deeper than @ref dump_depth_limit, which is why it is not
    written for speed: walking every value this way measured up to 20% slower on
    object-heavy documents than letting the compiler drive the descent.
    */
@@ -1592,62 +1597,6 @@ class serializer
        }
    }

-    /*!
-    @brief check whether a string is UTF-8 encoded
-
-    The function checks each byte of a string whether it is UTF-8 encoded. The
-    result of the check is stored in the @a state parameter. The function must
-    be called initially with state 0 (accept). State 1 means the string must
-    be rejected, because the current byte is not allowed. If the string is
-    completely processed, but the state is non-zero, the string ended
-    prematurely; that is, the last byte indicated more bytes should have
-    followed.
-
-    @param[in,out] state  the state of the decoding
-    @param[in,out] codep  codepoint (valid only if resulting state is UTF8_ACCEPT)
-    @param[in] byte       next byte to decode
-    @return               new state
-
-    @note The function has been edited: a std::array is used.
-
-    @copyright Copyright (c) 2008-2009 Bjoern Hoehrmann <bjoern@hoehrmann.de>
-    @sa http://bjoern.hoehrmann.de/utf-8/decoder/dfa/
-    */
-    static std::uint8_t decode(std::uint8_t& state, std::uint32_t& codep, const std::uint8_t byte) noexcept
-    {
-        static const std::array<std::uint8_t, 400> utf8d =
-        {
-            {
-                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 00..1F
-                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 20..3F
-                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 40..5F
-                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 60..7F
-                1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, // 80..9F
-                7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // A0..BF
-                8, 8, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, // C0..DF
-                0xA, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x4, 0x3, 0x3, // E0..EF
-                0xB, 0x6, 0x6, 0x6, 0x5, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, // F0..FF
-                0x0, 0x1, 0x2, 0x3, 0x5, 0x8, 0x7, 0x1, 0x1, 0x1, 0x4, 0x6, 0x1, 0x1, 0x1, 0x1, // s0..s0
-                1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, // s1..s2
-                1, 2, 1, 1, 1, 1, 1, 2, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, // s3..s4
-                1, 2, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 1, 3, 1, 1, 1, 1, 1, 1, // s5..s6
-                1, 3, 1, 1, 1, 1, 1, 3, 1, 3, 1, 1, 1, 1, 1, 1, 1, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 // s7..s8
-            }
-        };
-
-        JSON_ASSERT(static_cast<std::size_t>(byte) < utf8d.size());
-        const std::uint8_t type = utf8d[byte];
-
-        codep = (state != UTF8_ACCEPT)
-                ? (byte & 0x3fu) | (codep << 6u)
-                : (0xFFu >> type) & (byte);
-
-        const std::size_t index = 256u + (static_cast<size_t>(state) * 16u) + static_cast<size_t>(type);
-        JSON_ASSERT(index < utf8d.size());
-        state = utf8d[index];
-        return state;
-    }
-
    /*
     * Overload to make the compiler happy while it is instantiating
     * dump_integer for number_unsigned_t.
@@ -1,35 +0,0 @@
-//     __ _____ _____ _____
-//  __|  |   __|     |   | |  JSON for Modern C++
-// |  |  |__   |  |  | | | |  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 <cstddef> // size_t
-
-#include <nlohmann/detail/abi_macros.hpp>
-
-NLOHMANN_JSON_NAMESPACE_BEGIN
-namespace detail
-{
-
-/*!
-@brief the number of nesting levels an operation recurses into
-
-Operations that walk a value (serializing, hashing, merging, ...) recurse once
-per nesting level, which is fastest, but a value nested deeply enough would
-exhaust the call stack. So they recurse only this many levels deep and finish
-whatever lies below with an explicit stack. All of them share this limit.
-
-@sa https://github.com/nlohmann/json/issues/5387
-*/
-constexpr std::size_t recursion_depth_limit() noexcept
-{
-    return 128;
-}
-
-}  // namespace detail
-NLOHMANN_JSON_NAMESPACE_END
@@ -8,10 +8,13 @@

 #pragma once

+#include <array> // array
 #include <cstddef> // size_t
+#include <cstdint> // uint8_t, uint32_t
 #include <string> // string, to_string

 #include <nlohmann/detail/abi_macros.hpp>
+#include <nlohmann/detail/macro_scope.hpp>

 NLOHMANN_JSON_NAMESPACE_BEGIN
 namespace detail
@@ -33,5 +36,99 @@ StringType to_string(std::size_t value)
    return result;
 }

+///////////////////
+// UTF-8 decoding //
+///////////////////
+
+// UTF-8 decoder states used by decode() below
+static constexpr std::uint8_t UTF8_ACCEPT = 0;
+static constexpr std::uint8_t UTF8_REJECT = 1;
+
+/*!
+@brief process a byte of a UTF-8 sequence
+
+This is a single-byte step of a "shift-based" UTF-8 decoder originally
+written by Björn Hoehrmann. See
+http://bjoern.hoehrmann.de/utf-8/decoder/dfa/ for details.
+
+This decoder is the single source of truth for UTF-8 validation in this
+library: it is used both by the serializer (to escape and, in strict mode,
+reject ill-formed UTF-8 when dumping a string) and by the binary readers
+(to reject ill-formed UTF-8 in CBOR/MessagePack/BSON/UBJSON text strings at
+decode time; see @ref is_valid_utf8 below).
+
+@param[in,out] state  the current decoder state
+@param[in,out] codep  codepoint (valid only if resulting state is UTF8_ACCEPT)
+@param[in] byte       next byte to decode
+@return               new state
+
+@note Original source: http://bjoern.hoehrmann.de/utf-8/decoder/dfa/
+@sa http://bjoern.hoehrmann.de/utf-8/decoder/dfa/
+*/
+inline std::uint8_t decode(std::uint8_t& state, std::uint32_t& codep, const std::uint8_t byte) noexcept
+{
+    static const std::array<std::uint8_t, 400> utf8d =
+    {
+        {
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 00..1F
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 20..3F
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 40..5F
+            0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 60..7F
+            1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, // 80..9F
+            7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, // A0..BF
+            8, 8, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, // C0..DF
+            0xA, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x4, 0x3, 0x3, // E0..EF
+            0xB, 0x6, 0x6, 0x6, 0x5, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, // F0..FF
+            0x0, 0x1, 0x2, 0x3, 0x5, 0x8, 0x7, 0x1, 0x1, 0x1, 0x4, 0x6, 0x1, 0x1, 0x1, 0x1, // s0..s0
+            1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, // s1..s2
+            1, 2, 1, 1, 1, 1, 1, 2, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, // s3..s4
+            1, 2, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 1, 3, 1, 1, 1, 1, 1, 1, // s5..s6
+            1, 3, 1, 1, 1, 1, 1, 3, 1, 3, 1, 1, 1, 1, 1, 1, 1, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 // s7..s8
+        }
+    };
+
+    JSON_ASSERT(static_cast<std::size_t>(byte) < utf8d.size());
+    const std::uint8_t type = utf8d[byte];
+
+    codep = (state != UTF8_ACCEPT)
+            ? (byte & 0x3fu) | (codep << 6u)
+            : (0xFFu >> type) & (byte);
+
+    const std::size_t index = 256u + (static_cast<std::size_t>(state) * 16u) + static_cast<std::size_t>(type);
+    JSON_ASSERT(index < utf8d.size());
+    state = utf8d[index];
+    return state;
+}
+
+/*!
+@brief check whether a string consists solely of valid UTF-8
+
+Used by the CBOR/MessagePack/BSON/UBJSON binary readers to reject text
+strings that are not valid UTF-8 at decode time (RFC 8949 §3.1 and the
+MessagePack/BSON specifications all require text strings to be UTF-8), so
+that malformed input is caught immediately instead of only surfacing later
+as a type_error.316 when the resulting value is dumped.
+
+@param[in] s  the string to check
+@return whether @a s is valid UTF-8
+*/
+template<typename StringType>
+inline bool is_valid_utf8(const StringType& s) noexcept
+{
+    std::uint8_t state = UTF8_ACCEPT;
+    std::uint32_t codepoint = 0;
+
+    for (std::size_t i = 0; i < s.size(); ++i)
+    {
+        decode(state, codepoint, static_cast<std::uint8_t>(s[i]));
+        if (state == UTF8_REJECT)
+        {
+            return false;
+        }
+    }
+
+    return state == UTF8_ACCEPT;
+}
+
 }  // namespace detail
 NLOHMANN_JSON_NAMESPACE_END
@@ -28,14 +28,14 @@
    #pragma GCC diagnostic ignored "-Wignored-attributes"
 #endif

-#include <algorithm> // all_of, find, for_each, none_of
+#include <algorithm> // all_of, find, for_each
 #include <cstddef> // nullptr_t, ptrdiff_t, size_t
 #include <functional> // hash, less
 #include <initializer_list> // initializer_list
 #ifndef JSON_NO_IO
    #include <iosfwd> // istream, ostream
 #endif  // JSON_NO_IO
-#include <iterator> // make_move_iterator, random_access_iterator_tag
+#include <iterator> // random_access_iterator_tag
 #include <memory> // unique_ptr
 #include <string> // string, stoi, to_string
 #include <utility> // declval, forward, move, pair, swap
@@ -68,7 +68,6 @@
 #include <nlohmann/detail/output/binary_writer.hpp>
 #include <nlohmann/detail/output/output_adapters.hpp>
 #include <nlohmann/detail/output/serializer.hpp>
-#include <nlohmann/detail/recursion_depth_limit.hpp>
 #include <nlohmann/detail/value_t.hpp>
 #include <nlohmann/json_fwd.hpp>
 #include <nlohmann/ordered_map.hpp>
@@ -141,7 +140,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    friend ::nlohmann::detail::serializer<basic_json>;
    template<typename BasicJsonType>
    friend class ::nlohmann::detail::iter_impl;
-    template<typename BasicJsonType, typename CharType, typename OutputSinkType>
+    template<typename BasicJsonType, typename CharType>
    friend class ::nlohmann::detail::binary_writer;
    template<typename BasicJsonType, typename InputType, typename SAX>
    friend class ::nlohmann::detail::binary_reader;
@@ -189,14 +188,6 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    template<typename InputType>
    using binary_reader = ::nlohmann::detail::binary_reader<basic_json, InputType>;
    template<typename CharType> using binary_writer = ::nlohmann::detail::binary_writer<basic_json, CharType>;
-    // binary_writer over a concrete (non-virtual) sink appending into a std::vector,
-    // used by the vector-returning to_* overloads
-    template<typename CharType> using vector_binary_writer =
-        ::nlohmann::detail::binary_writer<basic_json, CharType, ::nlohmann::detail::output_vector_sink<CharType>>;
-    template<typename CharType> static vector_binary_writer<CharType> vector_writer(std::vector<CharType>& v)
-    {
-        return vector_binary_writer<CharType>(::nlohmann::detail::output_vector_sink<CharType>(v));
-    }

  JSON_PRIVATE_UNLESS_TESTED:
    using serializer = ::nlohmann::detail::serializer<basic_json>;
@@ -897,352 +888,6 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        return j;
    }

-#ifndef JSON_NO_THREAD_LOCAL
-    /// the number of levels an operation descends into before it finishes the
-    /// value below it without the call stack
-    static constexpr std::uint8_t nesting_depth_limit()
-    {
-        return 128;
-    }
-
-    /*!
-    @brief how many levels the operation going on in this thread has descended into
-
-    Copying a value and comparing two values share this count. The library never
-    nests one inside the other - copying a value does not compare one, and
-    comparing two values does not copy them - and where user code nests them
-    anyway, sharing the count only ends a descent sooner than it had to, which
-    costs a little speed and is never wrong.
-
-    A byte is enough: the count never exceeds the limit by more than the single
-    level that notices the limit has been reached.
-    */
-    static std::uint8_t& nesting_depth() noexcept
-    {
-        static thread_local std::uint8_t depth = 0; // NOLINT(misc-use-internal-linkage)
-        return depth;
-    }
-#endif
-
-    /*!
-    @brief counts one level of a bounded descent for as long as it runs, and
-           reports whether the descent was still within the limit when it began
-
-    Looks the count up and tests it against the limit itself, rather than
-    leaving that to the caller: either way it is reached exactly once, so
-    there is nothing to be gained by making the caller do it.
-
-    Does nothing and is never @ref okay without thread-local storage, where no
-    descent can be bounded at all: a caller that only descends while this says
-    it may always ends up finishing without the call stack, exactly as if every
-    value were nested past the limit.
-    */
-    class nesting_depth_guard
-    {
-      public:
-        nesting_depth_guard() noexcept
-#ifdef JSON_NO_THREAD_LOCAL
-            : m_okay(false)
-#else
-            : m_okay(nesting_depth() < nesting_depth_limit())
-#endif
-        {
-#ifndef JSON_NO_THREAD_LOCAL
-            ++nesting_depth();
-#endif
-        }
-
-        ~nesting_depth_guard()
-        {
-#ifndef JSON_NO_THREAD_LOCAL
-            --nesting_depth();
-#endif
-        }
-
-        nesting_depth_guard(const nesting_depth_guard&) = delete;
-        nesting_depth_guard& operator=(const nesting_depth_guard&) = delete;
-        nesting_depth_guard(nesting_depth_guard&&) = delete;
-        nesting_depth_guard& operator=(nesting_depth_guard&&) = delete;
-
-        bool okay() const noexcept
-        {
-            return m_okay;
-        }
-
-      private:
-        bool m_okay;
-    };
-
-    /// an entry of the iterative deep copy's worklist: a structured value and
-    /// the value that is to become its copy
-    using copy_worklist_t = std::vector<std::pair<const basic_json*, basic_json*>>;
-
-    /// scratch space to build the key skeleton of an object copy in one go
-    using copy_scratch_t = std::vector<std::pair<typename object_t::key_type, basic_json>>;
-
-    /// @brief copy everything of @a src into @a dst but its type and value
-    static void copy_metadata(const basic_json& src, basic_json& dst)
-    {
-        // a custom base class is only required to be copy-constructible and
-        // move-assignable, so the copy has to go through a temporary
-        static_cast<json_base_class_t&>(dst) = json_base_class_t(static_cast<const json_base_class_t&>(src));
-
-#if JSON_DIAGNOSTIC_POSITIONS
-        dst.start_position = src.start_position;
-        dst.end_position = src.end_position;
-#endif
-    }
-
-    /*!
-    @brief copy the value of @a src into @a dst, which must not be structured
-
-    Objects and arrays are left alone: creating those is the one thing the copy
-    constructor and @ref copy_shallow do differently from one another, and it is
-    the reason copying a value can descend at all.
-    */
-    /// @note inlined on purpose: both callers have already told an object or an
-    ///       array apart from the rest, and letting the compiler fold that test
-    ///       into this switch is worth a few percent when copying a value made
-    ///       mostly of numbers
-    JSON_HEDLEY_ALWAYS_INLINE
-    static void copy_leaf_value(const basic_json& src, basic_json& dst)
-    {
-        switch (src.m_data.m_type)
-        {
-            case value_t::string:
-            {
-                dst.m_data.m_value = *src.m_data.m_value.string;
-                break;
-            }
-
-            case value_t::binary:
-            {
-                dst.m_data.m_value = *src.m_data.m_value.binary;
-                break;
-            }
-
-            case value_t::boolean:
-            {
-                dst.m_data.m_value = src.m_data.m_value.boolean;
-                break;
-            }
-
-            case value_t::number_integer:
-            {
-                dst.m_data.m_value = src.m_data.m_value.number_integer;
-                break;
-            }
-
-            case value_t::number_unsigned:
-            {
-                dst.m_data.m_value = src.m_data.m_value.number_unsigned;
-                break;
-            }
-
-            case value_t::number_float:
-            {
-                dst.m_data.m_value = src.m_data.m_value.number_float;
-                break;
-            }
-
-            case value_t::object:
-            case value_t::array:
-            case value_t::null:
-            case value_t::discarded:
-            default:
-                break;
-        }
-    }
-
-    /*!
-    @brief copy everything of @a src into the null value @a dst but the children
-
-    Objects and arrays are not copied here; they are appended to @a worklist to
-    be created later by @ref copy_iteratively. Until that happens, @a dst remains
-    a null value, so that a partially built copy can be destroyed at any point
-    without ever violating the class invariants.
-    */
-    static void copy_shallow(const basic_json& src, basic_json& dst, copy_worklist_t& worklist)
-    {
-        copy_metadata(src, dst);
-
-        if (src.m_data.m_type == value_t::object || src.m_data.m_type == value_t::array)
-        {
-            // defer: dst stays a null value until its container exists
-            worklist.emplace_back(&src, &dst);
-            return;
-        }
-
-        copy_leaf_value(src, dst);
-
-        // only now that the value exists may the type be set: had the creation
-        // of the value thrown, dst would have been left as a valid null value
-        dst.m_data.m_type = src.m_data.m_type;
-    }
-
-    /// @brief create the copy of the array @a src in @a dst
-    /// @note structured elements are appended to @a worklist instead
-    static void copy_array_level(const basic_json& src, basic_json& dst, copy_worklist_t& worklist)
-    {
-        const array_t& src_array = *src.m_data.m_value.array;
-
-        // create all elements up front: growing the array afterwards could
-        // invalidate the pointers that are handed to the worklist; resize()
-        // rather than the fill constructor, because not every array type
-        // provides the latter (e.g., ones without a matching allocator-aware
-        // fill constructor)
-        dst.m_data.m_value.array = create<array_t>();
-        dst.m_data.m_value.array->resize(src_array.size());
-
-        auto dst_it = dst.m_data.m_value.array->begin();
-        for (auto src_it = src_array.cbegin(); src_it != src_array.cend(); ++src_it, ++dst_it)
-        {
-            copy_shallow(*src_it, *dst_it, worklist);
-        }
-    }
-
-    /// @brief create the copy of the object @a src in @a dst
-    /// @note structured values are appended to @a worklist instead
-    static void copy_object_level(const basic_json& src, basic_json& dst,
-                                  copy_worklist_t& worklist, copy_scratch_t& scratch)
-    {
-        const object_t& src_object = *src.m_data.m_value.object;
-
-        // build the complete key skeleton and hand it to the object's range
-        // constructor: adding the keys one by one would be quadratic for object
-        // types that are backed by a vector, such as nlohmann::ordered_map
-        scratch.clear();
-        scratch.reserve(src_object.size());
-        for (const auto& element : src_object)
-        {
-            scratch.emplace_back(element.first, basic_json());
-        }
-
-        dst.m_data.m_value.object = create<object_t>(std::make_move_iterator(scratch.begin()),
-                                    std::make_move_iterator(scratch.end()));
-        scratch.clear();
-
-        // pair every value of the copy with its counterpart in the original;
-        // both are enumerated in the same order for every object type with a
-        // deterministic order, so the lookup is only needed for exotic ones
-        auto src_it = src_object.cbegin();
-        for (auto& element : *dst.m_data.m_value.object)
-        {
-            if (JSON_HEDLEY_LIKELY(src_it != src_object.cend() && src_it->first == element.first))
-            {
-                copy_shallow(src_it->second, element.second, worklist);
-                ++src_it;
-            }
-            else
-            {
-                const auto found = src_object.find(element.first);
-                JSON_ASSERT(found != src_object.cend());
-                copy_shallow(found->second, element.second, worklist);
-            }
-        }
-    }
-
-    /*!
-    @brief deep-copy the object or array @a src into this value without recursing
-
-    The values whose copy has not been created yet are kept on an explicit
-    worklist rather than on the call stack. This is only reached for values
-    nested deeper than @ref nesting_depth_limit levels, which is why it copies
-    every container by hand instead of letting the container do it: the fast
-    ways of doing so would descend into the elements and defeat the purpose.
-    */
-    void copy_iteratively(const basic_json& src)
-    {
-        copy_worklist_t worklist;
-        copy_scratch_t scratch;
-
-        const basic_json* src_value = &src;
-        basic_json* dst_value = this;
-
-        for (;;)
-        {
-            if (src_value->m_data.m_type == value_t::array)
-            {
-                copy_array_level(*src_value, *dst_value, worklist);
-            }
-            else
-            {
-                copy_object_level(*src_value, *dst_value, worklist, scratch);
-            }
-
-            // the container is complete and will not be modified again
-            dst_value->set_parents();
-
-            if (worklist.empty())
-            {
-                break;
-            }
-
-            const auto& next = worklist.back();
-            src_value = next.first;
-            dst_value = next.second;
-            worklist.pop_back();
-
-            // the value stops being a null value exactly here
-            dst_value->m_data.m_type = src_value->m_data.m_type;
-        }
-    }
-
-    /*!
-    @brief copy one level of the object or array @a src into this value
-
-    The container copies its own elements, which is the fastest way to fill it.
-    Every element that is structured itself comes back to @ref copy_structured.
-    */
-    void copy_level(const basic_json& src)
-    {
-        if (m_data.m_type == value_t::object)
-        {
-            m_data.m_value = *src.m_data.m_value.object;
-        }
-        else
-        {
-            m_data.m_value = *src.m_data.m_value.array;
-        }
-
-        set_parents();
-    }
-
-    /*!
-    @brief deep-copy the object or array @a src into this value
-
-    Copying a container copies its elements, so a value nested deeply enough
-    used to exhaust the call stack. The descent is bounded here: the first
-    @ref nesting_depth_limit levels are copied by the containers themselves, just
-    as they always were, and anything below that is copied without the call
-    stack by @ref copy_iteratively. Copying a value can therefore no longer
-    exhaust the stack, however deeply it is nested, just like destroying one
-    cannot since #1436.
-
-    Nothing has to be scanned or built by hand to reach that: a value that is
-    not nested deeper than the limit - all but a vanishing minority - is copied
-    exactly as it was before, and this whole detour costs it one counter.
-
-    @sa https://github.com/nlohmann/json/issues/5387
-    */
-    void copy_structured(const basic_json& src)
-    {
-        const nesting_depth_guard guard;
-
-        if (JSON_HEDLEY_LIKELY(guard.okay()))
-        {
-            copy_level(src);
-            return;
-        }
-
-        // Finish this value without descending any further. It is completed
-        // before this returns, so a copy made by a custom base class - or by
-        // anything else that runs while a copy is going on - is unaffected by
-        // the copy it is nested in.
-        copy_iteratively(src);
-    }
-
-
  public:
    //////////////////////////
    // JSON parser callback //
@@ -1622,15 +1267,60 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        // check of passed value is valid
        other.assert_invariant();

-        if (m_data.m_type == value_t::object || m_data.m_type == value_t::array)
+        switch (m_data.m_type)
        {
-            // copying the container directly would call this constructor again
-            // for every element, once per nesting level
-            copy_structured(other);
-        }
-        else
-        {
-            copy_leaf_value(other, *this);
+            case value_t::object:
+            {
+                m_data.m_value = *other.m_data.m_value.object;
+                break;
+            }
+
+            case value_t::array:
+            {
+                m_data.m_value = *other.m_data.m_value.array;
+                break;
+            }
+
+            case value_t::string:
+            {
+                m_data.m_value = *other.m_data.m_value.string;
+                break;
+            }
+
+            case value_t::boolean:
+            {
+                m_data.m_value = other.m_data.m_value.boolean;
+                break;
+            }
+
+            case value_t::number_integer:
+            {
+                m_data.m_value = other.m_data.m_value.number_integer;
+                break;
+            }
+
+            case value_t::number_unsigned:
+            {
+                m_data.m_value = other.m_data.m_value.number_unsigned;
+                break;
+            }
+
+            case value_t::number_float:
+            {
+                m_data.m_value = other.m_data.m_value.number_float;
+                break;
+            }
+
+            case value_t::binary:
+            {
+                m_data.m_value = *other.m_data.m_value.binary;
+                break;
+            }
+
+            case value_t::null:
+            case value_t::discarded:
+            default:
+                break;
        }

        set_parents();
@@ -3821,12 +3511,6 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
            JSON_THROW(invalid_iterator::create(211, "passed iterators may not belong to container", this));
        }

-        // passed iterators must belong to arrays
-        if (JSON_HEDLEY_UNLIKELY(!first.m_object->is_array()))
-        {
-            JSON_THROW(invalid_iterator::create(202, "iterators first and last must point to arrays", this));
-        }
-
        // insert to array and return iterator
        return insert_iterator(pos, first.m_it.array_iterator, last.m_it.array_iterator);
    }
@@ -3913,54 +3597,17 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
            JSON_THROW(type_error::create(312, detail::concat("cannot use update() with ", first.m_object->type_name()), first.m_object));
        }

-        update_members(first, last, merge_objects, 0);
-    }
-
-  private:
-    /// @brief an object @ref update_members_iteratively or @ref
-    /// merge_patch_iteratively is merging into, and the members still to merge
-    struct merge_frame
-    {
-        merge_frame(basic_json* target_, const_iterator position_, const_iterator last_) noexcept
-            : target(target_), position(std::move(position_)), last(std::move(last_))
-        {}
-
-        basic_json* target;
-        const_iterator position;
-        const_iterator last;
-    };
-
-    /*!
-    @brief the members loop of @ref update, for this object and range
-
-    Merging a nested object calls this function again, once per nesting
-    level, so a value nested deeply enough used to exhaust the call stack and
-    terminate the process. The descent is bounded here: once @ref
-    detail::recursion_depth_limit levels have been entered, @ref
-    update_members_iteratively merges what is left without the call stack.
-
-    @param[in] depth  nesting level of this object, counted from the object
-                      @ref update was called on
-    */
-    void update_members(const const_iterator& first, const const_iterator& last, const bool merge_objects, const std::size_t depth)
-    {
-        if (JSON_HEDLEY_UNLIKELY(depth >= detail::recursion_depth_limit()))
-        {
-            update_members_iteratively(first, last);
-            return;
-        }
-
        for (auto it = first; it != last; ++it)
        {
            if (merge_objects && it.value().is_object())
            {
-                const auto it2 = m_data.m_value.object->find(it.key());
+                auto it2 = m_data.m_value.object->find(it.key());
                // Only recurse when the existing value is itself an object.
                // Otherwise overwrite, matching the documented "all other values
                // are overwritten as usual" behavior (see #5402).
                if (it2 != m_data.m_value.object->end() && it2->second.is_object())
                {
-                    it2->second.update_members(it.value().cbegin(), it.value().cend(), true, depth + 1);
+                    it2->second.update(it.value(), true);
 #if JSON_DIAGNOSTICS
                    it2->second.set_parents();
 #endif
@@ -3974,64 +3621,6 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        }
    }

-    /*!
-    @brief merge @a first to @a last into this object without the call stack
-
-    Does the same as @ref update_members with `merge_objects` set, keeping the
-    objects whose merge was interrupted by a nested one on an explicit stack
-    instead of descending into them. A nested object is still merged
-    completely before the next member, in the same order as the recursive
-    version. Only reached for values nested deeper than @ref
-    detail::recursion_depth_limit.
-    */
-    void update_members_iteratively(const_iterator first, const_iterator last)
-    {
-        std::vector<merge_frame> stack;
-
-        basic_json* target = this;
-        while (true)
-        {
-            if (first == last)
-            {
-                if (stack.empty())
-                {
-                    break;
-                }
-
-                // a nested object is merged: continue with its parent
-#if JSON_DIAGNOSTICS
-                target->set_parents();
-#endif
-                target = stack.back().target;
-                first = stack.back().position;
-                last = stack.back().last;
-                stack.pop_back();
-                continue;
-            }
-
-            if (first.value().is_object())
-            {
-                const auto it2 = target->m_data.m_value.object->find(first.key());
-                if (it2 != target->m_data.m_value.object->end() && it2->second.is_object())
-                {
-                    const basic_json& source = first.value();
-                    ++first;
-                    stack.emplace_back(target, first, last);
-                    target = &it2->second;
-                    first = source.cbegin();
-                    last = source.cend();
-                    continue;
-                }
-            }
-            target->m_data.m_value.object->operator[](first.key()) = first.value();
-#if JSON_DIAGNOSTICS
-            target->m_data.m_value.object->operator[](first.key()).m_parent = target;
-#endif
-            ++first;
-        }
-    }
-
-  public:
    /// @brief exchanges the values
    /// @sa https://json.nlohmann.me/api/basic_json/swap/
    void swap(reference other) noexcept (
@@ -4849,8 +4438,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    static std::vector<std::uint8_t> to_cbor(const basic_json& j)
    {
        std::vector<std::uint8_t> result;
-        result.reserve(detail::binary_reserve_hint(j));
-        vector_writer(result).write_cbor(j);
+        to_cbor(j, result);
        return result;
    }

@@ -4873,8 +4461,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    static std::vector<std::uint8_t> to_msgpack(const basic_json& j)
    {
        std::vector<std::uint8_t> result;
-        result.reserve(detail::binary_reserve_hint(j));
-        vector_writer(result).write_msgpack(j);
+        to_msgpack(j, result);
        return result;
    }

@@ -4899,8 +4486,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
            const bool use_type = false)
    {
        std::vector<std::uint8_t> result;
-        result.reserve(detail::binary_reserve_hint(j));
-        vector_writer(result).write_ubjson(j, use_size, use_type);
+        to_ubjson(j, result, use_size, use_type);
        return result;
    }

@@ -4928,8 +4514,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
            const bjdata_version_t version = bjdata_version_t::draft2)
    {
        std::vector<std::uint8_t> result;
-        result.reserve(detail::binary_reserve_hint(j));
-        vector_writer(result).write_ubjson(j, use_size, use_type, true, true, version);
+        to_bjdata(j, result, use_size, use_type, version);
        return result;
    }

@@ -4956,8 +4541,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    static std::vector<std::uint8_t> to_bson(const basic_json& j)
    {
        std::vector<std::uint8_t> result;
-        result.reserve(detail::binary_reserve_hint(j));
-        vector_writer(result).write_bson(j);
+        to_bson(j, result);
        return result;
    }

@@ -5748,139 +5332,34 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec

            case value_t::object:
            {
-                // first pass: record, for every source key, whether it is
-                // common to both objects (in source's iteration order) or
-                // was deleted (i.e., in source but not in target) -- this is
-                // a by-product of the target.find() call already needed to
-                // tell the two cases apart, so it adds no extra lookups. The
-                // "remove" ops themselves are emitted later, interleaved
-                // with the recursive per-key diffs in the fast path below,
-                // to match source's original iteration order (as the
-                // original, pre-reordering-aware implementation did) instead
-                // of grouping all removes before all recursive diffs.
-                std::vector<typename object_t::key_type> common_keys_source_order;
+                // first pass: traverse this object's elements
                for (auto it = source.cbegin(); it != source.cend(); ++it)
                {
+                    // escape the key name to be used in a JSON patch
+                    const auto path_key = detail::concat<string_t>(path, '/', detail::escape(it.key()));
+
                    if (target.find(it.key()) != target.end())
                    {
-                        common_keys_source_order.push_back(it.key());
-                    }
-                }
-
-                // second pass: find keys that were added (i.e., in target but
-                // not in source), and record the keys common to both, in
-                // target's iteration order -- again a by-product of the
-                // source.find() call already needed to detect added keys. At
-                // the same time, determine whether every added key comes
-                // after every common key in target's order (a precondition
-                // for the fast path below, which only ever appends new keys
-                // at the very end): for an object_t whose iteration order is
-                // a pure function of the key set (e.g. the default std::map,
-                // which always iterates in sorted key order), the order
-                // check further below is always true and this whole
-                // mechanism is effectively a no-op; it only matters for a
-                // reorderable object_t such as the one backing `ordered_json`.
-                // patch ops for keys that were added (i.e., in target but not
-                // in source); built here so the fast path below can reuse
-                // them without a second source.find() per target key. Only
-                // used by the fast path -- the slow (reordering) path
-                // rebuilds "add" ops for every key itself.
-                std::vector<typename object_t::key_type> common_keys_target_order;
-                basic_json added_ops(value_t::array);
-                bool new_keys_form_suffix = true;
-                bool seen_new_key = false;
-                for (auto it = target.cbegin(); it != target.cend(); ++it)
-                {
-                    if (source.find(it.key()) == source.end())
-                    {
-                        seen_new_key = true;
-                        const auto path_key = detail::concat<string_t>(path, '/', detail::escape(it.key()));
-                        added_ops.push_back(
-                        {
-                            {"op", "add"}, {"path", path_key},
-                            {"value", it.value()}
-                        });
+                        // recursive call to compare object values at key it
+                        auto temp_diff = diff(it.value(), target[it.key()], path_key);
+                        result.insert(result.end(), temp_diff.begin(), temp_diff.end());
                    }
                    else
                    {
-                        common_keys_target_order.push_back(it.key());
-                        if (seen_new_key)
-                        {
-                            new_keys_form_suffix = false;
-                        }
-                    }
-                }
-
-                if (common_keys_source_order == common_keys_target_order && new_keys_form_suffix)
-                {
-                    // fast path: order of common keys already matches (or the
-                    // object_t's iteration order does not depend on
-                    // insertion history), so a plain per-key recursive diff
-                    // is correct and minimal, as before. common_keys_source_order
-                    // is, by construction, the subsequence of source's keys
-                    // that are common to both objects, in source's iteration
-                    // order -- so it can be walked in lockstep with `source`
-                    // using a cheap key comparison instead of another lookup.
-                    // Deleted keys (those source keys not in common_keys_source_order)
-                    // are interleaved here too, in source's original order, to
-                    // match the historical (pre-reordering-aware) output order.
-                    auto common_it = common_keys_source_order.cbegin();
-                    for (auto it = source.cbegin(); it != source.cend(); ++it)
-                    {
-                        if (common_it != common_keys_source_order.cend() && it.key() == *common_it)
-                        {
-                            const auto path_key = detail::concat<string_t>(path, '/', detail::escape(it.key()));
-                            auto temp_diff = diff(it.value(), target[it.key()], path_key);
-                            result.insert(result.end(), temp_diff.begin(), temp_diff.end());
-                            ++common_it;
-                        }
-                        else
-                        {
-                            // found a key that is not in target -> remove it
-                            const auto path_key = detail::concat<string_t>(path, '/', detail::escape(it.key()));
-                            result.push_back(object(
-                            {
-                                {"op", "remove"}, {"path", path_key}
-                            }));
-                        }
-                    }
-
-                    // append the "add" ops for brand-new keys collected above
-                    // during the pass over target -- no second source.find()
-                    // per target key needed
-                    result.insert(result.end(), added_ops.begin(), added_ops.end());
-                }
-                else
-                {
-                    // slow path: the common keys are in a different relative
-                    // order in source and target (only possible for a
-                    // reorderable object_t like ordered_map). Building a
-                    // minimal reordering patch is a nontrivial (LCS-like)
-                    // problem; instead, remove every source key -- both
-                    // deleted keys (which must be removed regardless) and
-                    // common keys (removed so they can be re-added in
-                    // target's order) -- and re-add every key that should
-                    // remain, with its final target value, in target's
-                    // order. basic_json::patch()'s "add" operation on an
-                    // object uses operator[], which appends at the end for a
-                    // vector-backed insertion-ordered map when the key does
-                    // not already exist -- so removing a key and then adding
-                    // it moves it to the end, fixing its position.
-                    for (auto it = source.cbegin(); it != source.cend(); ++it)
-                    {
-                        const auto path_key = detail::concat<string_t>(path, '/', detail::escape(it.key()));
+                        // found a key that is not in o -> remove it
                        result.push_back(object(
                        {
                            {"op", "remove"}, {"path", path_key}
                        }));
                    }
+                }

-                    // add every key that is either common (just removed
-                    // above) or brand new, in target's iteration order, so
-                    // that the final order after applying the patch matches
-                    // target exactly
-                    for (auto it = target.cbegin(); it != target.cend(); ++it)
+                // second pass: traverse other object's elements
+                for (auto it = target.cbegin(); it != target.cend(); ++it)
+                {
+                    if (source.find(it.key()) == source.end())
                    {
+                        // found a key that is not in this -> add it
                        const auto path_key = detail::concat<string_t>(path, '/', detail::escape(it.key()));
                        result.push_back(
                        {
@@ -5926,30 +5405,9 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
    /// @brief applies a JSON Merge Patch
    /// @sa https://json.nlohmann.me/api/basic_json/merge_patch/
    void merge_patch(const basic_json& apply_patch)
-    {
-        apply_merge_patch(apply_patch, 0);
-    }
-
-  private:
-    /*!
-    @brief @ref merge_patch, for a patch at nesting level @a depth
-
-    Applying a nested object calls this function again, once per nesting
-    level, so a patch nested deeply enough used to exhaust the call stack and
-    terminate the process. The descent is bounded here: once @ref
-    detail::recursion_depth_limit levels have been entered, @ref
-    merge_patch_iteratively applies what is left without the call stack.
-    */
-    void apply_merge_patch(const basic_json& apply_patch, const std::size_t depth)
    {
        if (apply_patch.is_object())
        {
-            if (JSON_HEDLEY_UNLIKELY(depth >= detail::recursion_depth_limit()))
-            {
-                merge_patch_iteratively(apply_patch);
-                return;
-            }
-
            if (!is_object())
            {
                *this = object();
@@ -5962,7 +5420,7 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
                }
                else
                {
-                    operator[](it.key()).apply_merge_patch(it.value(), depth + 1);
+                    operator[](it.key()).merge_patch(it.value());
                }
            }
        }
@@ -5972,62 +5430,6 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
        }
    }

-    /*!
-    @brief apply @a apply_patch to this value without the call stack
-
-    Does the same as @ref merge_patch, keeping the objects being patched on an
-    explicit stack instead of descending into them. A nested object is still
-    patched completely before the next member, in the same order as the
-    recursive version. Only reached for patches nested deeper than @ref
-    detail::recursion_depth_limit.
-    */
-    void merge_patch_iteratively(const basic_json& apply_patch)
-    {
-        std::vector<merge_frame> stack;
-
-        // patch `target` with `patch`, or start patching it member by member
-        const auto apply = [&stack](basic_json & target, const basic_json & patch)
-        {
-            if (patch.is_object())
-            {
-                if (!target.is_object())
-                {
-                    target = basic_json::object();
-                }
-                stack.emplace_back(&target, patch.cbegin(), patch.cend());
-            }
-            else
-            {
-                target = patch;
-            }
-        };
-
-        apply(*this, apply_patch);
-        while (!stack.empty())
-        {
-            // a copy, as applying a member below can reallocate the stack;
-            // the frame itself is only changed through stack.back()
-            const merge_frame frame = stack.back();
-            if (frame.position == frame.last)
-            {
-                stack.pop_back();
-                continue;
-            }
-
-            const const_iterator member = frame.position;
-            ++stack.back().position;
-            if (member.value().is_null())
-            {
-                frame.target->erase(member.key());
-            }
-            else
-            {
-                apply(frame.target->operator[](member.key()), member.value());
-            }
-        }
-    }
-
-  public:
    /// @}
 };

@@ -215,126 +215,6 @@
        </Expand>
    </Type>

-    <!-- Namespace nlohmann::json_abi_dp -->
-    <Type Name="nlohmann::json_abi_dp::basic_json&lt;*&gt;">
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_dp::detail::value_t::null">null</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_dp::detail::value_t::object">{*(m_data.m_value.object)}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_dp::detail::value_t::array">{*(m_data.m_value.array)}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_dp::detail::value_t::string">{*(m_data.m_value.string)}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_dp::detail::value_t::boolean">{m_data.m_value.boolean}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_dp::detail::value_t::number_integer">{m_data.m_value.number_integer}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_dp::detail::value_t::number_unsigned">{m_data.m_value.number_unsigned}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_dp::detail::value_t::number_float">{m_data.m_value.number_float}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_dp::detail::value_t::discarded">discarded</DisplayString>
-        <Expand>
-            <ExpandedItem Condition="m_data.m_type == nlohmann::json_abi_dp::detail::value_t::object">
-                *(m_data.m_value.object),view(simple)
-            </ExpandedItem>
-            <ExpandedItem Condition="m_data.m_type == nlohmann::json_abi_dp::detail::value_t::array">
-                *(m_data.m_value.array),view(simple)
-            </ExpandedItem>
-        </Expand>
-    </Type>
-
-    <!-- Skip the pair first/second members in the treeview while traversing a map.
-         Only works in VS 2015 Update 2 and beyond using the new visualization -->
-    <Type Name="std::pair&lt;*, nlohmann::json_abi_dp::basic_json&lt;*&gt;&gt;" IncludeView="MapHelper">
-        <DisplayString>{second}</DisplayString>
-        <Expand>
-            <ExpandedItem>second</ExpandedItem>
-        </Expand>
-    </Type>
-
-    <!-- Namespace nlohmann::json_abi_dp_v3_12_0 -->
-    <Type Name="nlohmann::json_abi_dp_v3_12_0::basic_json&lt;*&gt;">
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_dp_v3_12_0::detail::value_t::null">null</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_dp_v3_12_0::detail::value_t::object">{*(m_data.m_value.object)}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_dp_v3_12_0::detail::value_t::array">{*(m_data.m_value.array)}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_dp_v3_12_0::detail::value_t::string">{*(m_data.m_value.string)}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_dp_v3_12_0::detail::value_t::boolean">{m_data.m_value.boolean}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_dp_v3_12_0::detail::value_t::number_integer">{m_data.m_value.number_integer}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_dp_v3_12_0::detail::value_t::number_unsigned">{m_data.m_value.number_unsigned}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_dp_v3_12_0::detail::value_t::number_float">{m_data.m_value.number_float}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_dp_v3_12_0::detail::value_t::discarded">discarded</DisplayString>
-        <Expand>
-            <ExpandedItem Condition="m_data.m_type == nlohmann::json_abi_dp_v3_12_0::detail::value_t::object">
-                *(m_data.m_value.object),view(simple)
-            </ExpandedItem>
-            <ExpandedItem Condition="m_data.m_type == nlohmann::json_abi_dp_v3_12_0::detail::value_t::array">
-                *(m_data.m_value.array),view(simple)
-            </ExpandedItem>
-        </Expand>
-    </Type>
-
-    <!-- Skip the pair first/second members in the treeview while traversing a map.
-         Only works in VS 2015 Update 2 and beyond using the new visualization -->
-    <Type Name="std::pair&lt;*, nlohmann::json_abi_dp_v3_12_0::basic_json&lt;*&gt;&gt;" IncludeView="MapHelper">
-        <DisplayString>{second}</DisplayString>
-        <Expand>
-            <ExpandedItem>second</ExpandedItem>
-        </Expand>
-    </Type>
-
-    <!-- Namespace nlohmann::json_abi_bics -->
-    <Type Name="nlohmann::json_abi_bics::basic_json&lt;*&gt;">
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_bics::detail::value_t::null">null</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_bics::detail::value_t::object">{*(m_data.m_value.object)}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_bics::detail::value_t::array">{*(m_data.m_value.array)}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_bics::detail::value_t::string">{*(m_data.m_value.string)}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_bics::detail::value_t::boolean">{m_data.m_value.boolean}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_bics::detail::value_t::number_integer">{m_data.m_value.number_integer}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_bics::detail::value_t::number_unsigned">{m_data.m_value.number_unsigned}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_bics::detail::value_t::number_float">{m_data.m_value.number_float}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_bics::detail::value_t::discarded">discarded</DisplayString>
-        <Expand>
-            <ExpandedItem Condition="m_data.m_type == nlohmann::json_abi_bics::detail::value_t::object">
-                *(m_data.m_value.object),view(simple)
-            </ExpandedItem>
-            <ExpandedItem Condition="m_data.m_type == nlohmann::json_abi_bics::detail::value_t::array">
-                *(m_data.m_value.array),view(simple)
-            </ExpandedItem>
-        </Expand>
-    </Type>
-
-    <!-- Skip the pair first/second members in the treeview while traversing a map.
-         Only works in VS 2015 Update 2 and beyond using the new visualization -->
-    <Type Name="std::pair&lt;*, nlohmann::json_abi_bics::basic_json&lt;*&gt;&gt;" IncludeView="MapHelper">
-        <DisplayString>{second}</DisplayString>
-        <Expand>
-            <ExpandedItem>second</ExpandedItem>
-        </Expand>
-    </Type>
-
-    <!-- Namespace nlohmann::json_abi_bics_v3_12_0 -->
-    <Type Name="nlohmann::json_abi_bics_v3_12_0::basic_json&lt;*&gt;">
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_bics_v3_12_0::detail::value_t::null">null</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_bics_v3_12_0::detail::value_t::object">{*(m_data.m_value.object)}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_bics_v3_12_0::detail::value_t::array">{*(m_data.m_value.array)}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_bics_v3_12_0::detail::value_t::string">{*(m_data.m_value.string)}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_bics_v3_12_0::detail::value_t::boolean">{m_data.m_value.boolean}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_bics_v3_12_0::detail::value_t::number_integer">{m_data.m_value.number_integer}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_bics_v3_12_0::detail::value_t::number_unsigned">{m_data.m_value.number_unsigned}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_bics_v3_12_0::detail::value_t::number_float">{m_data.m_value.number_float}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_bics_v3_12_0::detail::value_t::discarded">discarded</DisplayString>
-        <Expand>
-            <ExpandedItem Condition="m_data.m_type == nlohmann::json_abi_bics_v3_12_0::detail::value_t::object">
-                *(m_data.m_value.object),view(simple)
-            </ExpandedItem>
-            <ExpandedItem Condition="m_data.m_type == nlohmann::json_abi_bics_v3_12_0::detail::value_t::array">
-                *(m_data.m_value.array),view(simple)
-            </ExpandedItem>
-        </Expand>
-    </Type>
-
-    <!-- Skip the pair first/second members in the treeview while traversing a map.
-         Only works in VS 2015 Update 2 and beyond using the new visualization -->
-    <Type Name="std::pair&lt;*, nlohmann::json_abi_bics_v3_12_0::basic_json&lt;*&gt;&gt;" IncludeView="MapHelper">
-        <DisplayString>{second}</DisplayString>
-        <Expand>
-            <ExpandedItem>second</ExpandedItem>
-        </Expand>
-    </Type>
-
    <!-- Namespace nlohmann::json_abi_diag_ldvcmp -->
    <Type Name="nlohmann::json_abi_diag_ldvcmp::basic_json&lt;*&gt;">
        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_ldvcmp::detail::value_t::null">null</DisplayString>
@@ -395,604 +275,4 @@
        </Expand>
    </Type>

-    <!-- Namespace nlohmann::json_abi_diag_dp -->
-    <Type Name="nlohmann::json_abi_diag_dp::basic_json&lt;*&gt;">
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_dp::detail::value_t::null">null</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_dp::detail::value_t::object">{*(m_data.m_value.object)}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_dp::detail::value_t::array">{*(m_data.m_value.array)}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_dp::detail::value_t::string">{*(m_data.m_value.string)}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_dp::detail::value_t::boolean">{m_data.m_value.boolean}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_dp::detail::value_t::number_integer">{m_data.m_value.number_integer}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_dp::detail::value_t::number_unsigned">{m_data.m_value.number_unsigned}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_dp::detail::value_t::number_float">{m_data.m_value.number_float}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_dp::detail::value_t::discarded">discarded</DisplayString>
-        <Expand>
-            <ExpandedItem Condition="m_data.m_type == nlohmann::json_abi_diag_dp::detail::value_t::object">
-                *(m_data.m_value.object),view(simple)
-            </ExpandedItem>
-            <ExpandedItem Condition="m_data.m_type == nlohmann::json_abi_diag_dp::detail::value_t::array">
-                *(m_data.m_value.array),view(simple)
-            </ExpandedItem>
-        </Expand>
-    </Type>
-
-    <!-- Skip the pair first/second members in the treeview while traversing a map.
-         Only works in VS 2015 Update 2 and beyond using the new visualization -->
-    <Type Name="std::pair&lt;*, nlohmann::json_abi_diag_dp::basic_json&lt;*&gt;&gt;" IncludeView="MapHelper">
-        <DisplayString>{second}</DisplayString>
-        <Expand>
-            <ExpandedItem>second</ExpandedItem>
-        </Expand>
-    </Type>
-
-    <!-- Namespace nlohmann::json_abi_diag_dp_v3_12_0 -->
-    <Type Name="nlohmann::json_abi_diag_dp_v3_12_0::basic_json&lt;*&gt;">
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_dp_v3_12_0::detail::value_t::null">null</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_dp_v3_12_0::detail::value_t::object">{*(m_data.m_value.object)}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_dp_v3_12_0::detail::value_t::array">{*(m_data.m_value.array)}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_dp_v3_12_0::detail::value_t::string">{*(m_data.m_value.string)}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_dp_v3_12_0::detail::value_t::boolean">{m_data.m_value.boolean}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_dp_v3_12_0::detail::value_t::number_integer">{m_data.m_value.number_integer}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_dp_v3_12_0::detail::value_t::number_unsigned">{m_data.m_value.number_unsigned}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_dp_v3_12_0::detail::value_t::number_float">{m_data.m_value.number_float}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_dp_v3_12_0::detail::value_t::discarded">discarded</DisplayString>
-        <Expand>
-            <ExpandedItem Condition="m_data.m_type == nlohmann::json_abi_diag_dp_v3_12_0::detail::value_t::object">
-                *(m_data.m_value.object),view(simple)
-            </ExpandedItem>
-            <ExpandedItem Condition="m_data.m_type == nlohmann::json_abi_diag_dp_v3_12_0::detail::value_t::array">
-                *(m_data.m_value.array),view(simple)
-            </ExpandedItem>
-        </Expand>
-    </Type>
-
-    <!-- Skip the pair first/second members in the treeview while traversing a map.
-         Only works in VS 2015 Update 2 and beyond using the new visualization -->
-    <Type Name="std::pair&lt;*, nlohmann::json_abi_diag_dp_v3_12_0::basic_json&lt;*&gt;&gt;" IncludeView="MapHelper">
-        <DisplayString>{second}</DisplayString>
-        <Expand>
-            <ExpandedItem>second</ExpandedItem>
-        </Expand>
-    </Type>
-
-    <!-- Namespace nlohmann::json_abi_diag_bics -->
-    <Type Name="nlohmann::json_abi_diag_bics::basic_json&lt;*&gt;">
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_bics::detail::value_t::null">null</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_bics::detail::value_t::object">{*(m_data.m_value.object)}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_bics::detail::value_t::array">{*(m_data.m_value.array)}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_bics::detail::value_t::string">{*(m_data.m_value.string)}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_bics::detail::value_t::boolean">{m_data.m_value.boolean}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_bics::detail::value_t::number_integer">{m_data.m_value.number_integer}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_bics::detail::value_t::number_unsigned">{m_data.m_value.number_unsigned}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_bics::detail::value_t::number_float">{m_data.m_value.number_float}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_bics::detail::value_t::discarded">discarded</DisplayString>
-        <Expand>
-            <ExpandedItem Condition="m_data.m_type == nlohmann::json_abi_diag_bics::detail::value_t::object">
-                *(m_data.m_value.object),view(simple)
-            </ExpandedItem>
-            <ExpandedItem Condition="m_data.m_type == nlohmann::json_abi_diag_bics::detail::value_t::array">
-                *(m_data.m_value.array),view(simple)
-            </ExpandedItem>
-        </Expand>
-    </Type>
-
-    <!-- Skip the pair first/second members in the treeview while traversing a map.
-         Only works in VS 2015 Update 2 and beyond using the new visualization -->
-    <Type Name="std::pair&lt;*, nlohmann::json_abi_diag_bics::basic_json&lt;*&gt;&gt;" IncludeView="MapHelper">
-        <DisplayString>{second}</DisplayString>
-        <Expand>
-            <ExpandedItem>second</ExpandedItem>
-        </Expand>
-    </Type>
-
-    <!-- Namespace nlohmann::json_abi_diag_bics_v3_12_0 -->
-    <Type Name="nlohmann::json_abi_diag_bics_v3_12_0::basic_json&lt;*&gt;">
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_bics_v3_12_0::detail::value_t::null">null</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_bics_v3_12_0::detail::value_t::object">{*(m_data.m_value.object)}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_bics_v3_12_0::detail::value_t::array">{*(m_data.m_value.array)}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_bics_v3_12_0::detail::value_t::string">{*(m_data.m_value.string)}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_bics_v3_12_0::detail::value_t::boolean">{m_data.m_value.boolean}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_bics_v3_12_0::detail::value_t::number_integer">{m_data.m_value.number_integer}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_bics_v3_12_0::detail::value_t::number_unsigned">{m_data.m_value.number_unsigned}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_bics_v3_12_0::detail::value_t::number_float">{m_data.m_value.number_float}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_bics_v3_12_0::detail::value_t::discarded">discarded</DisplayString>
-        <Expand>
-            <ExpandedItem Condition="m_data.m_type == nlohmann::json_abi_diag_bics_v3_12_0::detail::value_t::object">
-                *(m_data.m_value.object),view(simple)
-            </ExpandedItem>
-            <ExpandedItem Condition="m_data.m_type == nlohmann::json_abi_diag_bics_v3_12_0::detail::value_t::array">
-                *(m_data.m_value.array),view(simple)
-            </ExpandedItem>
-        </Expand>
-    </Type>
-
-    <!-- Skip the pair first/second members in the treeview while traversing a map.
-         Only works in VS 2015 Update 2 and beyond using the new visualization -->
-    <Type Name="std::pair&lt;*, nlohmann::json_abi_diag_bics_v3_12_0::basic_json&lt;*&gt;&gt;" IncludeView="MapHelper">
-        <DisplayString>{second}</DisplayString>
-        <Expand>
-            <ExpandedItem>second</ExpandedItem>
-        </Expand>
-    </Type>
-
-    <!-- Namespace nlohmann::json_abi_ldvcmp_dp -->
-    <Type Name="nlohmann::json_abi_ldvcmp_dp::basic_json&lt;*&gt;">
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_ldvcmp_dp::detail::value_t::null">null</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_ldvcmp_dp::detail::value_t::object">{*(m_data.m_value.object)}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_ldvcmp_dp::detail::value_t::array">{*(m_data.m_value.array)}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_ldvcmp_dp::detail::value_t::string">{*(m_data.m_value.string)}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_ldvcmp_dp::detail::value_t::boolean">{m_data.m_value.boolean}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_ldvcmp_dp::detail::value_t::number_integer">{m_data.m_value.number_integer}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_ldvcmp_dp::detail::value_t::number_unsigned">{m_data.m_value.number_unsigned}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_ldvcmp_dp::detail::value_t::number_float">{m_data.m_value.number_float}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_ldvcmp_dp::detail::value_t::discarded">discarded</DisplayString>
-        <Expand>
-            <ExpandedItem Condition="m_data.m_type == nlohmann::json_abi_ldvcmp_dp::detail::value_t::object">
-                *(m_data.m_value.object),view(simple)
-            </ExpandedItem>
-            <ExpandedItem Condition="m_data.m_type == nlohmann::json_abi_ldvcmp_dp::detail::value_t::array">
-                *(m_data.m_value.array),view(simple)
-            </ExpandedItem>
-        </Expand>
-    </Type>
-
-    <!-- Skip the pair first/second members in the treeview while traversing a map.
-         Only works in VS 2015 Update 2 and beyond using the new visualization -->
-    <Type Name="std::pair&lt;*, nlohmann::json_abi_ldvcmp_dp::basic_json&lt;*&gt;&gt;" IncludeView="MapHelper">
-        <DisplayString>{second}</DisplayString>
-        <Expand>
-            <ExpandedItem>second</ExpandedItem>
-        </Expand>
-    </Type>
-
-    <!-- Namespace nlohmann::json_abi_ldvcmp_dp_v3_12_0 -->
-    <Type Name="nlohmann::json_abi_ldvcmp_dp_v3_12_0::basic_json&lt;*&gt;">
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_ldvcmp_dp_v3_12_0::detail::value_t::null">null</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_ldvcmp_dp_v3_12_0::detail::value_t::object">{*(m_data.m_value.object)}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_ldvcmp_dp_v3_12_0::detail::value_t::array">{*(m_data.m_value.array)}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_ldvcmp_dp_v3_12_0::detail::value_t::string">{*(m_data.m_value.string)}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_ldvcmp_dp_v3_12_0::detail::value_t::boolean">{m_data.m_value.boolean}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_ldvcmp_dp_v3_12_0::detail::value_t::number_integer">{m_data.m_value.number_integer}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_ldvcmp_dp_v3_12_0::detail::value_t::number_unsigned">{m_data.m_value.number_unsigned}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_ldvcmp_dp_v3_12_0::detail::value_t::number_float">{m_data.m_value.number_float}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_ldvcmp_dp_v3_12_0::detail::value_t::discarded">discarded</DisplayString>
-        <Expand>
-            <ExpandedItem Condition="m_data.m_type == nlohmann::json_abi_ldvcmp_dp_v3_12_0::detail::value_t::object">
-                *(m_data.m_value.object),view(simple)
-            </ExpandedItem>
-            <ExpandedItem Condition="m_data.m_type == nlohmann::json_abi_ldvcmp_dp_v3_12_0::detail::value_t::array">
-                *(m_data.m_value.array),view(simple)
-            </ExpandedItem>
-        </Expand>
-    </Type>
-
-    <!-- Skip the pair first/second members in the treeview while traversing a map.
-         Only works in VS 2015 Update 2 and beyond using the new visualization -->
-    <Type Name="std::pair&lt;*, nlohmann::json_abi_ldvcmp_dp_v3_12_0::basic_json&lt;*&gt;&gt;" IncludeView="MapHelper">
-        <DisplayString>{second}</DisplayString>
-        <Expand>
-            <ExpandedItem>second</ExpandedItem>
-        </Expand>
-    </Type>
-
-    <!-- Namespace nlohmann::json_abi_ldvcmp_bics -->
-    <Type Name="nlohmann::json_abi_ldvcmp_bics::basic_json&lt;*&gt;">
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_ldvcmp_bics::detail::value_t::null">null</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_ldvcmp_bics::detail::value_t::object">{*(m_data.m_value.object)}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_ldvcmp_bics::detail::value_t::array">{*(m_data.m_value.array)}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_ldvcmp_bics::detail::value_t::string">{*(m_data.m_value.string)}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_ldvcmp_bics::detail::value_t::boolean">{m_data.m_value.boolean}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_ldvcmp_bics::detail::value_t::number_integer">{m_data.m_value.number_integer}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_ldvcmp_bics::detail::value_t::number_unsigned">{m_data.m_value.number_unsigned}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_ldvcmp_bics::detail::value_t::number_float">{m_data.m_value.number_float}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_ldvcmp_bics::detail::value_t::discarded">discarded</DisplayString>
-        <Expand>
-            <ExpandedItem Condition="m_data.m_type == nlohmann::json_abi_ldvcmp_bics::detail::value_t::object">
-                *(m_data.m_value.object),view(simple)
-            </ExpandedItem>
-            <ExpandedItem Condition="m_data.m_type == nlohmann::json_abi_ldvcmp_bics::detail::value_t::array">
-                *(m_data.m_value.array),view(simple)
-            </ExpandedItem>
-        </Expand>
-    </Type>
-
-    <!-- Skip the pair first/second members in the treeview while traversing a map.
-         Only works in VS 2015 Update 2 and beyond using the new visualization -->
-    <Type Name="std::pair&lt;*, nlohmann::json_abi_ldvcmp_bics::basic_json&lt;*&gt;&gt;" IncludeView="MapHelper">
-        <DisplayString>{second}</DisplayString>
-        <Expand>
-            <ExpandedItem>second</ExpandedItem>
-        </Expand>
-    </Type>
-
-    <!-- Namespace nlohmann::json_abi_ldvcmp_bics_v3_12_0 -->
-    <Type Name="nlohmann::json_abi_ldvcmp_bics_v3_12_0::basic_json&lt;*&gt;">
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_ldvcmp_bics_v3_12_0::detail::value_t::null">null</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_ldvcmp_bics_v3_12_0::detail::value_t::object">{*(m_data.m_value.object)}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_ldvcmp_bics_v3_12_0::detail::value_t::array">{*(m_data.m_value.array)}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_ldvcmp_bics_v3_12_0::detail::value_t::string">{*(m_data.m_value.string)}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_ldvcmp_bics_v3_12_0::detail::value_t::boolean">{m_data.m_value.boolean}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_ldvcmp_bics_v3_12_0::detail::value_t::number_integer">{m_data.m_value.number_integer}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_ldvcmp_bics_v3_12_0::detail::value_t::number_unsigned">{m_data.m_value.number_unsigned}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_ldvcmp_bics_v3_12_0::detail::value_t::number_float">{m_data.m_value.number_float}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_ldvcmp_bics_v3_12_0::detail::value_t::discarded">discarded</DisplayString>
-        <Expand>
-            <ExpandedItem Condition="m_data.m_type == nlohmann::json_abi_ldvcmp_bics_v3_12_0::detail::value_t::object">
-                *(m_data.m_value.object),view(simple)
-            </ExpandedItem>
-            <ExpandedItem Condition="m_data.m_type == nlohmann::json_abi_ldvcmp_bics_v3_12_0::detail::value_t::array">
-                *(m_data.m_value.array),view(simple)
-            </ExpandedItem>
-        </Expand>
-    </Type>
-
-    <!-- Skip the pair first/second members in the treeview while traversing a map.
-         Only works in VS 2015 Update 2 and beyond using the new visualization -->
-    <Type Name="std::pair&lt;*, nlohmann::json_abi_ldvcmp_bics_v3_12_0::basic_json&lt;*&gt;&gt;" IncludeView="MapHelper">
-        <DisplayString>{second}</DisplayString>
-        <Expand>
-            <ExpandedItem>second</ExpandedItem>
-        </Expand>
-    </Type>
-
-    <!-- Namespace nlohmann::json_abi_dp_bics -->
-    <Type Name="nlohmann::json_abi_dp_bics::basic_json&lt;*&gt;">
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_dp_bics::detail::value_t::null">null</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_dp_bics::detail::value_t::object">{*(m_data.m_value.object)}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_dp_bics::detail::value_t::array">{*(m_data.m_value.array)}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_dp_bics::detail::value_t::string">{*(m_data.m_value.string)}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_dp_bics::detail::value_t::boolean">{m_data.m_value.boolean}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_dp_bics::detail::value_t::number_integer">{m_data.m_value.number_integer}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_dp_bics::detail::value_t::number_unsigned">{m_data.m_value.number_unsigned}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_dp_bics::detail::value_t::number_float">{m_data.m_value.number_float}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_dp_bics::detail::value_t::discarded">discarded</DisplayString>
-        <Expand>
-            <ExpandedItem Condition="m_data.m_type == nlohmann::json_abi_dp_bics::detail::value_t::object">
-                *(m_data.m_value.object),view(simple)
-            </ExpandedItem>
-            <ExpandedItem Condition="m_data.m_type == nlohmann::json_abi_dp_bics::detail::value_t::array">
-                *(m_data.m_value.array),view(simple)
-            </ExpandedItem>
-        </Expand>
-    </Type>
-
-    <!-- Skip the pair first/second members in the treeview while traversing a map.
-         Only works in VS 2015 Update 2 and beyond using the new visualization -->
-    <Type Name="std::pair&lt;*, nlohmann::json_abi_dp_bics::basic_json&lt;*&gt;&gt;" IncludeView="MapHelper">
-        <DisplayString>{second}</DisplayString>
-        <Expand>
-            <ExpandedItem>second</ExpandedItem>
-        </Expand>
-    </Type>
-
-    <!-- Namespace nlohmann::json_abi_dp_bics_v3_12_0 -->
-    <Type Name="nlohmann::json_abi_dp_bics_v3_12_0::basic_json&lt;*&gt;">
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_dp_bics_v3_12_0::detail::value_t::null">null</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_dp_bics_v3_12_0::detail::value_t::object">{*(m_data.m_value.object)}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_dp_bics_v3_12_0::detail::value_t::array">{*(m_data.m_value.array)}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_dp_bics_v3_12_0::detail::value_t::string">{*(m_data.m_value.string)}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_dp_bics_v3_12_0::detail::value_t::boolean">{m_data.m_value.boolean}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_dp_bics_v3_12_0::detail::value_t::number_integer">{m_data.m_value.number_integer}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_dp_bics_v3_12_0::detail::value_t::number_unsigned">{m_data.m_value.number_unsigned}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_dp_bics_v3_12_0::detail::value_t::number_float">{m_data.m_value.number_float}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_dp_bics_v3_12_0::detail::value_t::discarded">discarded</DisplayString>
-        <Expand>
-            <ExpandedItem Condition="m_data.m_type == nlohmann::json_abi_dp_bics_v3_12_0::detail::value_t::object">
-                *(m_data.m_value.object),view(simple)
-            </ExpandedItem>
-            <ExpandedItem Condition="m_data.m_type == nlohmann::json_abi_dp_bics_v3_12_0::detail::value_t::array">
-                *(m_data.m_value.array),view(simple)
-            </ExpandedItem>
-        </Expand>
-    </Type>
-
-    <!-- Skip the pair first/second members in the treeview while traversing a map.
-         Only works in VS 2015 Update 2 and beyond using the new visualization -->
-    <Type Name="std::pair&lt;*, nlohmann::json_abi_dp_bics_v3_12_0::basic_json&lt;*&gt;&gt;" IncludeView="MapHelper">
-        <DisplayString>{second}</DisplayString>
-        <Expand>
-            <ExpandedItem>second</ExpandedItem>
-        </Expand>
-    </Type>
-
-    <!-- Namespace nlohmann::json_abi_diag_ldvcmp_dp -->
-    <Type Name="nlohmann::json_abi_diag_ldvcmp_dp::basic_json&lt;*&gt;">
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_ldvcmp_dp::detail::value_t::null">null</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_ldvcmp_dp::detail::value_t::object">{*(m_data.m_value.object)}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_ldvcmp_dp::detail::value_t::array">{*(m_data.m_value.array)}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_ldvcmp_dp::detail::value_t::string">{*(m_data.m_value.string)}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_ldvcmp_dp::detail::value_t::boolean">{m_data.m_value.boolean}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_ldvcmp_dp::detail::value_t::number_integer">{m_data.m_value.number_integer}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_ldvcmp_dp::detail::value_t::number_unsigned">{m_data.m_value.number_unsigned}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_ldvcmp_dp::detail::value_t::number_float">{m_data.m_value.number_float}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_ldvcmp_dp::detail::value_t::discarded">discarded</DisplayString>
-        <Expand>
-            <ExpandedItem Condition="m_data.m_type == nlohmann::json_abi_diag_ldvcmp_dp::detail::value_t::object">
-                *(m_data.m_value.object),view(simple)
-            </ExpandedItem>
-            <ExpandedItem Condition="m_data.m_type == nlohmann::json_abi_diag_ldvcmp_dp::detail::value_t::array">
-                *(m_data.m_value.array),view(simple)
-            </ExpandedItem>
-        </Expand>
-    </Type>
-
-    <!-- Skip the pair first/second members in the treeview while traversing a map.
-         Only works in VS 2015 Update 2 and beyond using the new visualization -->
-    <Type Name="std::pair&lt;*, nlohmann::json_abi_diag_ldvcmp_dp::basic_json&lt;*&gt;&gt;" IncludeView="MapHelper">
-        <DisplayString>{second}</DisplayString>
-        <Expand>
-            <ExpandedItem>second</ExpandedItem>
-        </Expand>
-    </Type>
-
-    <!-- Namespace nlohmann::json_abi_diag_ldvcmp_dp_v3_12_0 -->
-    <Type Name="nlohmann::json_abi_diag_ldvcmp_dp_v3_12_0::basic_json&lt;*&gt;">
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_ldvcmp_dp_v3_12_0::detail::value_t::null">null</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_ldvcmp_dp_v3_12_0::detail::value_t::object">{*(m_data.m_value.object)}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_ldvcmp_dp_v3_12_0::detail::value_t::array">{*(m_data.m_value.array)}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_ldvcmp_dp_v3_12_0::detail::value_t::string">{*(m_data.m_value.string)}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_ldvcmp_dp_v3_12_0::detail::value_t::boolean">{m_data.m_value.boolean}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_ldvcmp_dp_v3_12_0::detail::value_t::number_integer">{m_data.m_value.number_integer}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_ldvcmp_dp_v3_12_0::detail::value_t::number_unsigned">{m_data.m_value.number_unsigned}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_ldvcmp_dp_v3_12_0::detail::value_t::number_float">{m_data.m_value.number_float}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_ldvcmp_dp_v3_12_0::detail::value_t::discarded">discarded</DisplayString>
-        <Expand>
-            <ExpandedItem Condition="m_data.m_type == nlohmann::json_abi_diag_ldvcmp_dp_v3_12_0::detail::value_t::object">
-                *(m_data.m_value.object),view(simple)
-            </ExpandedItem>
-            <ExpandedItem Condition="m_data.m_type == nlohmann::json_abi_diag_ldvcmp_dp_v3_12_0::detail::value_t::array">
-                *(m_data.m_value.array),view(simple)
-            </ExpandedItem>
-        </Expand>
-    </Type>
-
-    <!-- Skip the pair first/second members in the treeview while traversing a map.
-         Only works in VS 2015 Update 2 and beyond using the new visualization -->
-    <Type Name="std::pair&lt;*, nlohmann::json_abi_diag_ldvcmp_dp_v3_12_0::basic_json&lt;*&gt;&gt;" IncludeView="MapHelper">
-        <DisplayString>{second}</DisplayString>
-        <Expand>
-            <ExpandedItem>second</ExpandedItem>
-        </Expand>
-    </Type>
-
-    <!-- Namespace nlohmann::json_abi_diag_ldvcmp_bics -->
-    <Type Name="nlohmann::json_abi_diag_ldvcmp_bics::basic_json&lt;*&gt;">
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_ldvcmp_bics::detail::value_t::null">null</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_ldvcmp_bics::detail::value_t::object">{*(m_data.m_value.object)}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_ldvcmp_bics::detail::value_t::array">{*(m_data.m_value.array)}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_ldvcmp_bics::detail::value_t::string">{*(m_data.m_value.string)}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_ldvcmp_bics::detail::value_t::boolean">{m_data.m_value.boolean}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_ldvcmp_bics::detail::value_t::number_integer">{m_data.m_value.number_integer}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_ldvcmp_bics::detail::value_t::number_unsigned">{m_data.m_value.number_unsigned}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_ldvcmp_bics::detail::value_t::number_float">{m_data.m_value.number_float}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_ldvcmp_bics::detail::value_t::discarded">discarded</DisplayString>
-        <Expand>
-            <ExpandedItem Condition="m_data.m_type == nlohmann::json_abi_diag_ldvcmp_bics::detail::value_t::object">
-                *(m_data.m_value.object),view(simple)
-            </ExpandedItem>
-            <ExpandedItem Condition="m_data.m_type == nlohmann::json_abi_diag_ldvcmp_bics::detail::value_t::array">
-                *(m_data.m_value.array),view(simple)
-            </ExpandedItem>
-        </Expand>
-    </Type>
-
-    <!-- Skip the pair first/second members in the treeview while traversing a map.
-         Only works in VS 2015 Update 2 and beyond using the new visualization -->
-    <Type Name="std::pair&lt;*, nlohmann::json_abi_diag_ldvcmp_bics::basic_json&lt;*&gt;&gt;" IncludeView="MapHelper">
-        <DisplayString>{second}</DisplayString>
-        <Expand>
-            <ExpandedItem>second</ExpandedItem>
-        </Expand>
-    </Type>
-
-    <!-- Namespace nlohmann::json_abi_diag_ldvcmp_bics_v3_12_0 -->
-    <Type Name="nlohmann::json_abi_diag_ldvcmp_bics_v3_12_0::basic_json&lt;*&gt;">
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_ldvcmp_bics_v3_12_0::detail::value_t::null">null</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_ldvcmp_bics_v3_12_0::detail::value_t::object">{*(m_data.m_value.object)}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_ldvcmp_bics_v3_12_0::detail::value_t::array">{*(m_data.m_value.array)}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_ldvcmp_bics_v3_12_0::detail::value_t::string">{*(m_data.m_value.string)}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_ldvcmp_bics_v3_12_0::detail::value_t::boolean">{m_data.m_value.boolean}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_ldvcmp_bics_v3_12_0::detail::value_t::number_integer">{m_data.m_value.number_integer}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_ldvcmp_bics_v3_12_0::detail::value_t::number_unsigned">{m_data.m_value.number_unsigned}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_ldvcmp_bics_v3_12_0::detail::value_t::number_float">{m_data.m_value.number_float}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_ldvcmp_bics_v3_12_0::detail::value_t::discarded">discarded</DisplayString>
-        <Expand>
-            <ExpandedItem Condition="m_data.m_type == nlohmann::json_abi_diag_ldvcmp_bics_v3_12_0::detail::value_t::object">
-                *(m_data.m_value.object),view(simple)
-            </ExpandedItem>
-            <ExpandedItem Condition="m_data.m_type == nlohmann::json_abi_diag_ldvcmp_bics_v3_12_0::detail::value_t::array">
-                *(m_data.m_value.array),view(simple)
-            </ExpandedItem>
-        </Expand>
-    </Type>
-
-    <!-- Skip the pair first/second members in the treeview while traversing a map.
-         Only works in VS 2015 Update 2 and beyond using the new visualization -->
-    <Type Name="std::pair&lt;*, nlohmann::json_abi_diag_ldvcmp_bics_v3_12_0::basic_json&lt;*&gt;&gt;" IncludeView="MapHelper">
-        <DisplayString>{second}</DisplayString>
-        <Expand>
-            <ExpandedItem>second</ExpandedItem>
-        </Expand>
-    </Type>
-
-    <!-- Namespace nlohmann::json_abi_diag_dp_bics -->
-    <Type Name="nlohmann::json_abi_diag_dp_bics::basic_json&lt;*&gt;">
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_dp_bics::detail::value_t::null">null</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_dp_bics::detail::value_t::object">{*(m_data.m_value.object)}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_dp_bics::detail::value_t::array">{*(m_data.m_value.array)}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_dp_bics::detail::value_t::string">{*(m_data.m_value.string)}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_dp_bics::detail::value_t::boolean">{m_data.m_value.boolean}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_dp_bics::detail::value_t::number_integer">{m_data.m_value.number_integer}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_dp_bics::detail::value_t::number_unsigned">{m_data.m_value.number_unsigned}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_dp_bics::detail::value_t::number_float">{m_data.m_value.number_float}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_dp_bics::detail::value_t::discarded">discarded</DisplayString>
-        <Expand>
-            <ExpandedItem Condition="m_data.m_type == nlohmann::json_abi_diag_dp_bics::detail::value_t::object">
-                *(m_data.m_value.object),view(simple)
-            </ExpandedItem>
-            <ExpandedItem Condition="m_data.m_type == nlohmann::json_abi_diag_dp_bics::detail::value_t::array">
-                *(m_data.m_value.array),view(simple)
-            </ExpandedItem>
-        </Expand>
-    </Type>
-
-    <!-- Skip the pair first/second members in the treeview while traversing a map.
-         Only works in VS 2015 Update 2 and beyond using the new visualization -->
-    <Type Name="std::pair&lt;*, nlohmann::json_abi_diag_dp_bics::basic_json&lt;*&gt;&gt;" IncludeView="MapHelper">
-        <DisplayString>{second}</DisplayString>
-        <Expand>
-            <ExpandedItem>second</ExpandedItem>
-        </Expand>
-    </Type>
-
-    <!-- Namespace nlohmann::json_abi_diag_dp_bics_v3_12_0 -->
-    <Type Name="nlohmann::json_abi_diag_dp_bics_v3_12_0::basic_json&lt;*&gt;">
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_dp_bics_v3_12_0::detail::value_t::null">null</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_dp_bics_v3_12_0::detail::value_t::object">{*(m_data.m_value.object)}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_dp_bics_v3_12_0::detail::value_t::array">{*(m_data.m_value.array)}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_dp_bics_v3_12_0::detail::value_t::string">{*(m_data.m_value.string)}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_dp_bics_v3_12_0::detail::value_t::boolean">{m_data.m_value.boolean}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_dp_bics_v3_12_0::detail::value_t::number_integer">{m_data.m_value.number_integer}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_dp_bics_v3_12_0::detail::value_t::number_unsigned">{m_data.m_value.number_unsigned}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_dp_bics_v3_12_0::detail::value_t::number_float">{m_data.m_value.number_float}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_dp_bics_v3_12_0::detail::value_t::discarded">discarded</DisplayString>
-        <Expand>
-            <ExpandedItem Condition="m_data.m_type == nlohmann::json_abi_diag_dp_bics_v3_12_0::detail::value_t::object">
-                *(m_data.m_value.object),view(simple)
-            </ExpandedItem>
-            <ExpandedItem Condition="m_data.m_type == nlohmann::json_abi_diag_dp_bics_v3_12_0::detail::value_t::array">
-                *(m_data.m_value.array),view(simple)
-            </ExpandedItem>
-        </Expand>
-    </Type>
-
-    <!-- Skip the pair first/second members in the treeview while traversing a map.
-         Only works in VS 2015 Update 2 and beyond using the new visualization -->
-    <Type Name="std::pair&lt;*, nlohmann::json_abi_diag_dp_bics_v3_12_0::basic_json&lt;*&gt;&gt;" IncludeView="MapHelper">
-        <DisplayString>{second}</DisplayString>
-        <Expand>
-            <ExpandedItem>second</ExpandedItem>
-        </Expand>
-    </Type>
-
-    <!-- Namespace nlohmann::json_abi_ldvcmp_dp_bics -->
-    <Type Name="nlohmann::json_abi_ldvcmp_dp_bics::basic_json&lt;*&gt;">
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_ldvcmp_dp_bics::detail::value_t::null">null</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_ldvcmp_dp_bics::detail::value_t::object">{*(m_data.m_value.object)}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_ldvcmp_dp_bics::detail::value_t::array">{*(m_data.m_value.array)}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_ldvcmp_dp_bics::detail::value_t::string">{*(m_data.m_value.string)}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_ldvcmp_dp_bics::detail::value_t::boolean">{m_data.m_value.boolean}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_ldvcmp_dp_bics::detail::value_t::number_integer">{m_data.m_value.number_integer}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_ldvcmp_dp_bics::detail::value_t::number_unsigned">{m_data.m_value.number_unsigned}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_ldvcmp_dp_bics::detail::value_t::number_float">{m_data.m_value.number_float}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_ldvcmp_dp_bics::detail::value_t::discarded">discarded</DisplayString>
-        <Expand>
-            <ExpandedItem Condition="m_data.m_type == nlohmann::json_abi_ldvcmp_dp_bics::detail::value_t::object">
-                *(m_data.m_value.object),view(simple)
-            </ExpandedItem>
-            <ExpandedItem Condition="m_data.m_type == nlohmann::json_abi_ldvcmp_dp_bics::detail::value_t::array">
-                *(m_data.m_value.array),view(simple)
-            </ExpandedItem>
-        </Expand>
-    </Type>
-
-    <!-- Skip the pair first/second members in the treeview while traversing a map.
-         Only works in VS 2015 Update 2 and beyond using the new visualization -->
-    <Type Name="std::pair&lt;*, nlohmann::json_abi_ldvcmp_dp_bics::basic_json&lt;*&gt;&gt;" IncludeView="MapHelper">
-        <DisplayString>{second}</DisplayString>
-        <Expand>
-            <ExpandedItem>second</ExpandedItem>
-        </Expand>
-    </Type>
-
-    <!-- Namespace nlohmann::json_abi_ldvcmp_dp_bics_v3_12_0 -->
-    <Type Name="nlohmann::json_abi_ldvcmp_dp_bics_v3_12_0::basic_json&lt;*&gt;">
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_ldvcmp_dp_bics_v3_12_0::detail::value_t::null">null</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_ldvcmp_dp_bics_v3_12_0::detail::value_t::object">{*(m_data.m_value.object)}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_ldvcmp_dp_bics_v3_12_0::detail::value_t::array">{*(m_data.m_value.array)}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_ldvcmp_dp_bics_v3_12_0::detail::value_t::string">{*(m_data.m_value.string)}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_ldvcmp_dp_bics_v3_12_0::detail::value_t::boolean">{m_data.m_value.boolean}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_ldvcmp_dp_bics_v3_12_0::detail::value_t::number_integer">{m_data.m_value.number_integer}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_ldvcmp_dp_bics_v3_12_0::detail::value_t::number_unsigned">{m_data.m_value.number_unsigned}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_ldvcmp_dp_bics_v3_12_0::detail::value_t::number_float">{m_data.m_value.number_float}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_ldvcmp_dp_bics_v3_12_0::detail::value_t::discarded">discarded</DisplayString>
-        <Expand>
-            <ExpandedItem Condition="m_data.m_type == nlohmann::json_abi_ldvcmp_dp_bics_v3_12_0::detail::value_t::object">
-                *(m_data.m_value.object),view(simple)
-            </ExpandedItem>
-            <ExpandedItem Condition="m_data.m_type == nlohmann::json_abi_ldvcmp_dp_bics_v3_12_0::detail::value_t::array">
-                *(m_data.m_value.array),view(simple)
-            </ExpandedItem>
-        </Expand>
-    </Type>
-
-    <!-- Skip the pair first/second members in the treeview while traversing a map.
-         Only works in VS 2015 Update 2 and beyond using the new visualization -->
-    <Type Name="std::pair&lt;*, nlohmann::json_abi_ldvcmp_dp_bics_v3_12_0::basic_json&lt;*&gt;&gt;" IncludeView="MapHelper">
-        <DisplayString>{second}</DisplayString>
-        <Expand>
-            <ExpandedItem>second</ExpandedItem>
-        </Expand>
-    </Type>
-
-    <!-- Namespace nlohmann::json_abi_diag_ldvcmp_dp_bics -->
-    <Type Name="nlohmann::json_abi_diag_ldvcmp_dp_bics::basic_json&lt;*&gt;">
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_ldvcmp_dp_bics::detail::value_t::null">null</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_ldvcmp_dp_bics::detail::value_t::object">{*(m_data.m_value.object)}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_ldvcmp_dp_bics::detail::value_t::array">{*(m_data.m_value.array)}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_ldvcmp_dp_bics::detail::value_t::string">{*(m_data.m_value.string)}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_ldvcmp_dp_bics::detail::value_t::boolean">{m_data.m_value.boolean}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_ldvcmp_dp_bics::detail::value_t::number_integer">{m_data.m_value.number_integer}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_ldvcmp_dp_bics::detail::value_t::number_unsigned">{m_data.m_value.number_unsigned}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_ldvcmp_dp_bics::detail::value_t::number_float">{m_data.m_value.number_float}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_ldvcmp_dp_bics::detail::value_t::discarded">discarded</DisplayString>
-        <Expand>
-            <ExpandedItem Condition="m_data.m_type == nlohmann::json_abi_diag_ldvcmp_dp_bics::detail::value_t::object">
-                *(m_data.m_value.object),view(simple)
-            </ExpandedItem>
-            <ExpandedItem Condition="m_data.m_type == nlohmann::json_abi_diag_ldvcmp_dp_bics::detail::value_t::array">
-                *(m_data.m_value.array),view(simple)
-            </ExpandedItem>
-        </Expand>
-    </Type>
-
-    <!-- Skip the pair first/second members in the treeview while traversing a map.
-         Only works in VS 2015 Update 2 and beyond using the new visualization -->
-    <Type Name="std::pair&lt;*, nlohmann::json_abi_diag_ldvcmp_dp_bics::basic_json&lt;*&gt;&gt;" IncludeView="MapHelper">
-        <DisplayString>{second}</DisplayString>
-        <Expand>
-            <ExpandedItem>second</ExpandedItem>
-        </Expand>
-    </Type>
-
-    <!-- Namespace nlohmann::json_abi_diag_ldvcmp_dp_bics_v3_12_0 -->
-    <Type Name="nlohmann::json_abi_diag_ldvcmp_dp_bics_v3_12_0::basic_json&lt;*&gt;">
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_ldvcmp_dp_bics_v3_12_0::detail::value_t::null">null</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_ldvcmp_dp_bics_v3_12_0::detail::value_t::object">{*(m_data.m_value.object)}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_ldvcmp_dp_bics_v3_12_0::detail::value_t::array">{*(m_data.m_value.array)}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_ldvcmp_dp_bics_v3_12_0::detail::value_t::string">{*(m_data.m_value.string)}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_ldvcmp_dp_bics_v3_12_0::detail::value_t::boolean">{m_data.m_value.boolean}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_ldvcmp_dp_bics_v3_12_0::detail::value_t::number_integer">{m_data.m_value.number_integer}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_ldvcmp_dp_bics_v3_12_0::detail::value_t::number_unsigned">{m_data.m_value.number_unsigned}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_ldvcmp_dp_bics_v3_12_0::detail::value_t::number_float">{m_data.m_value.number_float}</DisplayString>
-        <DisplayString Condition="m_data.m_type == nlohmann::json_abi_diag_ldvcmp_dp_bics_v3_12_0::detail::value_t::discarded">discarded</DisplayString>
-        <Expand>
-            <ExpandedItem Condition="m_data.m_type == nlohmann::json_abi_diag_ldvcmp_dp_bics_v3_12_0::detail::value_t::object">
-                *(m_data.m_value.object),view(simple)
-            </ExpandedItem>
-            <ExpandedItem Condition="m_data.m_type == nlohmann::json_abi_diag_ldvcmp_dp_bics_v3_12_0::detail::value_t::array">
-                *(m_data.m_value.array),view(simple)
-            </ExpandedItem>
-        </Expand>
-    </Type>
-
-    <!-- Skip the pair first/second members in the treeview while traversing a map.
-         Only works in VS 2015 Update 2 and beyond using the new visualization -->
-    <Type Name="std::pair&lt;*, nlohmann::json_abi_diag_ldvcmp_dp_bics_v3_12_0::basic_json&lt;*&gt;&gt;" IncludeView="MapHelper">
-        <DisplayString>{second}</DisplayString>
-        <Expand>
-            <ExpandedItem>second</ExpandedItem>
-        </Expand>
-    </Type>
-
 </AutoVisualizer>
@@ -52,10 +52,6 @@
    #define JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON 0
 #endif

-#ifndef JSON_BRACE_INIT_COPY_SEMANTICS
-    #define JSON_BRACE_INIT_COPY_SEMANTICS 0
-#endif
-
 #if JSON_DIAGNOSTICS
    #define NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS _diag
 #else
@@ -74,27 +70,20 @@
    #define NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON
 #endif

-#if JSON_BRACE_INIT_COPY_SEMANTICS
-    #define NLOHMANN_JSON_ABI_TAG_BRACE_INIT_COPY_SEMANTICS _bics
-#else
-    #define NLOHMANN_JSON_ABI_TAG_BRACE_INIT_COPY_SEMANTICS
-#endif
-
 #ifndef NLOHMANN_JSON_NAMESPACE_NO_VERSION
    #define NLOHMANN_JSON_NAMESPACE_NO_VERSION 0
 #endif

 // Construct the namespace ABI tags component
-#define NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b, c, d) json_abi ## a ## b ## c ## d
-#define NLOHMANN_JSON_ABI_TAGS_CONCAT(a, b, c, d) \
-    NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b, c, d)
+#define NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b, c) json_abi ## a ## b ## c
+#define NLOHMANN_JSON_ABI_TAGS_CONCAT(a, b, c) \
+    NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b, c)

 #define NLOHMANN_JSON_ABI_TAGS                                       \
    NLOHMANN_JSON_ABI_TAGS_CONCAT(                                   \
            NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS,                       \
            NLOHMANN_JSON_ABI_TAG_LEGACY_DISCARDED_VALUE_COMPARISON, \
-            NLOHMANN_JSON_ABI_TAG_DIAGNOSTIC_POSITIONS,              \
-            NLOHMANN_JSON_ABI_TAG_BRACE_INIT_COPY_SEMANTICS)
+            NLOHMANN_JSON_ABI_TAG_DIAGNOSTIC_POSITIONS)

 // Construct the namespace version component
 #define NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT_EX(major, minor, patch) \
@@ -75,12 +75,7 @@ target_compile_options(test_main PUBLIC
    #                              is annotated JSON_HEDLEY_NO_RETURN (it always throws), which
    #                              makes MSVC flag the code following its call in binary_reader.hpp
    #                              as unreachable for that instantiation, in both Debug and Release
-    #       Disable warning C4503: decorated name length exceeded, name was truncated; the deep
-    #                              copy support added for #5387 pushes the mangled name of
-    #                              std::allocator_traits<...>::construct for the custom-base-class
-    #                              test's map type past VS2015's limit. The name is only used for
-    #                              debug info, so truncation does not affect the build.
-    $<$<CXX_COMPILER_ID:MSVC>:/W4;/wd4566;/wd4996;/wd4702;/wd4503>
+    $<$<CXX_COMPILER_ID:MSVC>:/W4;/wd4566;/wd4996;/wd4702>
    # https://github.com/nlohmann/json/issues/1114
    $<$<CXX_COMPILER_ID:MSVC>:/bigobj> $<$<BOOL:${MINGW}>:-Wa,-mbig-obj>

@@ -14,20 +14,6 @@ add_test(
    NAME test-abi_config_noversion
    COMMAND abi_config_noversion ${DOCTEST_TEST_FILTER})

-# test default and no version namespace with all ABI tags enabled, so the
-# expected tag order is checked regardless of the JSON_* CMake options
-foreach(test default noversion)
-    add_executable(abi_config_${test}_all_tags ${test}.cpp)
-    target_compile_definitions(abi_config_${test}_all_tags PRIVATE
-        JSON_DIAGNOSTICS=1
-        JSON_DIAGNOSTIC_POSITIONS=1
-        JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON=1)
-    target_link_libraries(abi_config_${test}_all_tags PRIVATE abi_compat_main)
-    add_test(
-        NAME test-abi_config_${test}_all_tags
-        COMMAND abi_config_${test}_all_tags ${DOCTEST_TEST_FILTER})
-endforeach()
-
 # test custom namespace
 add_executable(abi_config_custom custom.cpp)
 target_link_libraries(abi_config_custom PRIVATE abi_compat_main)
@@ -24,16 +24,12 @@ TEST_CASE("default namespace")
        expected += "_diag";
 #endif

-#if JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON
-        expected += "_ldvcmp";
-#endif
-
 #if JSON_DIAGNOSTIC_POSITIONS
        expected += "_dp";
 #endif

-#if JSON_BRACE_INIT_COPY_SEMANTICS
-        expected += "_bics";
+#if JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON
+        expected += "_ldvcmp";
 #endif

        expected += "_v" STRINGIZE(NLOHMANN_JSON_VERSION_MAJOR);
@@ -25,16 +25,12 @@ TEST_CASE("default namespace without version component")
        expected += "_diag";
 #endif

-#if JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON
-        expected += "_ldvcmp";
-#endif
-
 #if JSON_DIAGNOSTIC_POSITIONS
        expected += "_dp";
 #endif

-#if JSON_BRACE_INIT_COPY_SEMANTICS
-        expected += "_bics";
+#if JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON
+        expected += "_ldvcmp";
 #endif

        expected += "::basic_json";
@@ -21,50 +21,16 @@ array data, it performs the following steps:
 - j4 = from_bjdata(vec3)
 - assert(j1 == j4)

-Re-serializing j2/j3/j4 with the same use_size/use_type settings is checked
-for value-stability rather than byte-exact stability: from_bjdata(to_bjdata(j2))
-must equal j2 (and likewise for j3, j4). Byte-exact stability does not hold in
-general, because a BJData value can lose type fidelity across a round trip
-(e.g. a binary_t value serialized without the optimized "$U#" array header is
-parsed back as a plain array of numbers, see #5398 and the discussion on
-PR #5494) - the numeric value is preserved, but the writer's smallest-type
-selection for the now-plain numbers may legitimately pick a different, but
-equally valid, single-byte type marker than the dedicated binary-data writer
-would have. Both encodings are valid BJData and both decode to the same
-value, so this is not treated as a round-trip failure here.
-
-"Value-stable" is checked by comparing dump()s rather than with operator==
-directly: a BJData/UBJSON payload can decode to a non-finite double (NaN or
-+-Infinity), and IEEE 754 NaN is never equal to itself, so operator== would
-report two structurally-identical trees as different whenever a NaN is
-involved -- not a round-trip bug, just NaN's ordinary (non-)reflexivity.
-dump() serializes any non-finite double the same deterministic way (as JSON
-`null`, since JSON itself cannot represent NaN/Infinity), so comparing
-dumps is stable under exactly the same values that break operator==.
-
 The provided function `LLVMFuzzerTestOneInput` can be used in different fuzzer
 drivers.
 */

-#include <cassert>
 #include <iostream>
 #include <sstream>
 #include <nlohmann/json.hpp>

-// the round-trip checks below are assertions; NDEBUG would compile them away
-#ifdef NDEBUG
-    #error "the fuzzer drivers must be built without NDEBUG"
-#endif
-
 using json = nlohmann::json;

-// value-stable comparison for the round-trip checks below; see the note
-// above on why this compares dump()s rather than the json values directly
-static bool is_value_stable(const json& lhs, const json& rhs)
-{
-    return lhs.dump() == rhs.dump();
-}
-
 // see http://llvm.org/docs/LibFuzzer.html
 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
 {
@@ -90,12 +56,10 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
            json const j3 = json::from_bjdata(vec3);
            json const j4 = json::from_bjdata(vec4);

-            // re-serializing must be value-stable (see the notes above on
-            // why byte-exact stability is not guaranteed in general, and
-            // why this compares dump()s rather than the values directly)
-            assert(is_value_stable(json::from_bjdata(json::to_bjdata(j2, false, false)), j2));
-            assert(is_value_stable(json::from_bjdata(json::to_bjdata(j3, true, false)), j3));
-            assert(is_value_stable(json::from_bjdata(json::to_bjdata(j4, true, true)), j4));
+            // serializations must match
+            assert(json::to_bjdata(j2, false, false) == vec2);
+            assert(json::to_bjdata(j3, true, false) == vec3);
+            assert(json::to_bjdata(j4, true, true) == vec4);
        }
        catch (const json::parse_error&)
        {
@@ -19,16 +19,10 @@ The provided function `LLVMFuzzerTestOneInput` can be used in different fuzzer
 drivers.
 */

-#include <cassert>
 #include <iostream>
 #include <sstream>
 #include <nlohmann/json.hpp>

-// the round-trip checks below are assertions; NDEBUG would compile them away
-#ifdef NDEBUG
-    #error "the fuzzer drivers must be built without NDEBUG"
-#endif
-
 using json = nlohmann::json;

 // see http://llvm.org/docs/LibFuzzer.html
@@ -19,16 +19,10 @@ The provided function `LLVMFuzzerTestOneInput` can be used in different fuzzer
 drivers.
 */

-#include <cassert>
 #include <iostream>
 #include <sstream>
 #include <nlohmann/json.hpp>

-// the round-trip checks below are assertions; NDEBUG would compile them away
-#ifdef NDEBUG
-    #error "the fuzzer drivers must be built without NDEBUG"
-#endif
-
 using json = nlohmann::json;

 // see http://llvm.org/docs/LibFuzzer.html
@@ -20,16 +20,10 @@ The provided function `LLVMFuzzerTestOneInput` can be used in different fuzzer
 drivers.
 */

-#include <cassert>
 #include <iostream>
 #include <sstream>
 #include <nlohmann/json.hpp>

-// the round-trip checks below are assertions; NDEBUG would compile them away
-#ifdef NDEBUG
-    #error "the fuzzer drivers must be built without NDEBUG"
-#endif
-
 using json = nlohmann::json;

 // see http://llvm.org/docs/LibFuzzer.html
@@ -19,16 +19,10 @@ The provided function `LLVMFuzzerTestOneInput` can be used in different fuzzer
 drivers.
 */

-#include <cassert>
 #include <iostream>
 #include <sstream>
 #include <nlohmann/json.hpp>

-// the round-trip checks below are assertions; NDEBUG would compile them away
-#ifdef NDEBUG
-    #error "the fuzzer drivers must be built without NDEBUG"
-#endif
-
 using json = nlohmann::json;

 // see http://llvm.org/docs/LibFuzzer.html
@@ -25,16 +25,10 @@ The provided function `LLVMFuzzerTestOneInput` can be used in different fuzzer
 drivers.
 */

-#include <cassert>
 #include <iostream>
 #include <sstream>
 #include <nlohmann/json.hpp>

-// the round-trip checks below are assertions; NDEBUG would compile them away
-#ifdef NDEBUG
-    #error "the fuzzer drivers must be built without NDEBUG"
-#endif
-
 using json = nlohmann::json;

 // see http://llvm.org/docs/LibFuzzer.html
@@ -1,61 +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
-
-// Standalone compile-and-run check for the JSON_SKIP_LIBRARY_VERSION_CHECK
-// configuration macro, which (per #5423) was never exercised anywhere in the
-// test matrix.
-//
-// include/nlohmann/detail/abi_macros.hpp normally emits a #warning if
-// NLOHMANN_JSON_VERSION_MAJOR/MINOR/PATCH are already defined (as they would
-// be by an earlier inclusion of a different version of the library) with
-// values that mismatch the version about to be defined -- unless
-// JSON_SKIP_LIBRARY_VERSION_CHECK is defined, in which case the check (and
-// that #warning) is skipped.
-//
-// This file deliberately is not named tests/src/unit-*.cpp: it is compiled
-// directly (with a modest, non-strict warning set) by the dedicated
-// ci_test_skiplibraryversioncheck target in cmake/ci.cmake, rather than being
-// folded into the library's own -Weverything/-Werror unit test matrix. That
-// is because the scenario simulated here -- mixing two different, already
-// differently-versioned inclusions of the library in one translation unit --
-// unavoidably also triggers the *compiler's own* "macro redefined" warning,
-// independent of (and unaffected by) JSON_SKIP_LIBRARY_VERSION_CHECK, which
-// only ever silences the library's own #warning. Building this file under
-// -Weverything -Werror would therefore fail for a reason unrelated to the
-// macro under test.
-#define NLOHMANN_JSON_VERSION_MAJOR 0
-#define NLOHMANN_JSON_VERSION_MINOR 0
-#define NLOHMANN_JSON_VERSION_PATCH 0
-
-#define JSON_SKIP_LIBRARY_VERSION_CHECK 1
-
-#include <nlohmann/json.hpp>
-
-int main()
-{
-    // reaching this point at all already proves that the mismatched,
-    // pre-defined version macros above did not stop compilation -- which is
-    // exactly what JSON_SKIP_LIBRARY_VERSION_CHECK is for. The library must
-    // also still be fully usable.
-    const nlohmann::json j = {{"a", 1}, {"b", {1, 2, 3}}};
-    if (j.dump() != "{\"a\":1,\"b\":[1,2,3]}")
-    {
-        return 1;
-    }
-
-    // include/nlohmann/detail/abi_macros.hpp unconditionally (re)defines the
-    // version macros to the library's real, current version right after the
-    // (here, skipped) mismatch check, regardless of the deliberately wrong
-    // stand-in values defined above.
-    if (NLOHMANN_JSON_VERSION_MAJOR == 0 && NLOHMANN_JSON_VERSION_MINOR == 0 && NLOHMANN_JSON_VERSION_PATCH == 0)
-    {
-        return 1;
-    }
-
-    return 0;
-}
@@ -216,57 +216,6 @@ TEST_CASE("controlled bad_alloc")
            CHECK_THROWS_AS(my_json(s), std::bad_alloc&);
            next_construct_fails = false;
        }
-
-        SECTION("basic_json(const basic_json&) of a deeply nested value (#5387)")
-        {
-            // Copying a value nested deeper than the descent bound builds the
-            // copy from the top down: every value whose own copy has not been
-            // made yet stays a null value until it is. Failing an allocation
-            // part-way through is what proves such a half-built copy can still
-            // be destroyed.
-            //
-            // Which path the failure lands in depends on the build: the first
-            // allocation of a copy belongs to the outermost level, so here it
-            // is the descending one. Built with JSON_NO_THREAD_LOCAL - as the
-            // ci_test_no_thread_local target builds the whole suite - no
-            // descent is made at all and the very same failure lands in the
-            // iterative path instead, part-way through its worklist.
-            const auto check_deep_copy = [](bool objects)
-            {
-                CAPTURE(objects);
-
-                next_construct_fails = false;
-
-                // deeper than the 128 levels the copy constructor descends into
-                const std::size_t depth = 300;
-
-                my_json j = 1;
-                for (std::size_t i = 0; i < depth; ++i)
-                {
-                    if (objects)
-                    {
-                        my_json wrapper = my_json::object();
-                        wrapper["a"] = std::move(j);
-                        j = std::move(wrapper);
-                    }
-                    else
-                    {
-                        j = my_json::array({std::move(j)});
-                    }
-                }
-
-                // NOLINTNEXTLINE(performance-unnecessary-copy-initialization): the copy is what is tested
-                CHECK_NOTHROW(my_json(j));
-
-                next_construct_fails = true;
-                // NOLINTNEXTLINE(performance-unnecessary-copy-initialization): the copy is what is tested
-                CHECK_THROWS_AS(my_json(j), std::bad_alloc&);
-                next_construct_fails = false;
-            };
-
-            check_deep_copy(false);
-            check_deep_copy(true);
-        }
    }
 }

@@ -1,198 +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
-
-#include "doctest_compatibility.h"
-
-#include <nlohmann/json.hpp>
-using nlohmann::json;
-
-#include <cstdint>
-#include <string>
-#include <vector>
-
-namespace
-{
-
-// a spread of values exercising every writer path: scalars of each width, the
-// float paths, strings, binary, and containers big enough to reallocate
-std::vector<json> test_values()
-{
-    json big_array = json::array();
-    for (int i = 0; i < 5000; ++i)
-    {
-        big_array.push_back(i);
-    }
-
-    json big_object = json::object();
-    for (int i = 0; i < 1000; ++i)
-    {
-        big_object[std::to_string(i)] = i;
-    }
-
-    return
-    {
-        json(nullptr), json(true), json(false),
-        json(0), json(-1), json(255), json(-129), json(65535), json(-32769),
-        json(4294967295U), json(-2147483649LL), json(18446744073709551615ULL),
-        json(0.0), json(-0.5), json(3.1415926535897932),
-        json(""), json("hello"), json(std::string(1000, 'x')),
-        json::binary({0x00, 0x01, 0x02}, 42),
-        json::array(), json::object(),
-        json::array({1, 2, 3}), json({{"a", 1}, {"b", nullptr}}),
-        json({{"nested", {{"deep", json::array({1, "two", 3.0, nullptr})}}}}),
-        big_array, big_object
-    };
-}
-
-// values to_bson() accepts: the document must be an object
-std::vector<json> bson_values()
-{
-    json big_object = json::object();
-    for (int i = 0; i < 1000; ++i)
-    {
-        big_object[std::to_string(i)] = i;
-    }
-
-    return
-    {
-        json::object(),
-        json({{"a", 1}, {"b", nullptr}, {"c", true}, {"d", 2.5}, {"e", "text"}}),
-        json({{"arr", json::array({1, 2, 3})}, {"obj", {{"k", "v"}}}}),
-        big_object
-    };
-}
-
-} // namespace
-
-// The vector-returning to_*(j) overloads write through the non-virtual
-// output_vector_sink, while to_*(j, adapter) goes through output_adapter_sink.
-// The two are separate code paths that must stay byte-for-byte identical; these
-// checks fail if either overload is ever changed without the other.
-TEST_CASE("binary writer output sinks")
-{
-    SECTION("vector sink and adapter sink agree")
-    {
-        // note: no SUBCASE inside these loops - doctest keys subcases by
-        // name/file/line, so a subcase in a loop body would only ever run for
-        // the first iteration
-        for (const auto& j : test_values())
-        {
-            CAPTURE(j.dump(-1, ' ', false, json::error_handler_t::replace));
-
-            std::vector<std::uint8_t> cbor;
-            json::to_cbor(j, cbor);
-            CHECK(json::to_cbor(j) == cbor);
-
-            std::vector<std::uint8_t> msgpack;
-            json::to_msgpack(j, msgpack);
-            CHECK(json::to_msgpack(j) == msgpack);
-
-            for (const bool use_size :
-                    {
-                        false, true
-                    })
-            {
-                for (const bool use_type :
-                        {
-                            false, true
-                        })
-                {
-                    if (use_type && !use_size)
-                    {
-                        continue; // not a supported combination
-                    }
-                    CAPTURE(use_size);
-                    CAPTURE(use_type);
-                    std::vector<std::uint8_t> ubjson;
-                    json::to_ubjson(j, ubjson, use_size, use_type);
-                    CHECK(json::to_ubjson(j, use_size, use_type) == ubjson);
-                }
-            }
-
-            for (const auto version :
-                    {
-                        json::bjdata_version_t::draft2, json::bjdata_version_t::draft3
-                    })
-            {
-                std::vector<std::uint8_t> bjdata;
-                json::to_bjdata(j, bjdata, false, false, version);
-                CHECK(json::to_bjdata(j, false, false, version) == bjdata);
-            }
-        }
-
-        for (const auto& j : bson_values())
-        {
-            CAPTURE(j.dump());
-            std::vector<std::uint8_t> bson;
-            json::to_bson(j, bson);
-            CHECK(json::to_bson(j) == bson);
-        }
-    }
-
-    SECTION("the char adapter produces the same bytes")
-    {
-        for (const auto& j : test_values())
-        {
-            CAPTURE(j.dump(-1, ' ', false, json::error_handler_t::replace));
-
-            const std::vector<std::uint8_t> expected = json::to_cbor(j);
-            std::vector<char> as_char;
-            json::to_cbor(j, as_char);
-
-            REQUIRE(as_char.size() == expected.size());
-            std::vector<std::uint8_t> as_bytes;
-            as_bytes.reserve(as_char.size());
-            for (const char c : as_char)
-            {
-                as_bytes.push_back(static_cast<std::uint8_t>(c));
-            }
-            CHECK(as_bytes == expected);
-        }
-    }
-}
-
-// binary_reserve_hint() is documented as a *lower* bound on the serialized size,
-// so that reserving it up front can never leave the returned vector holding
-// capacity beyond what the value actually needs.
-TEST_CASE("binary_reserve_hint never over-reserves")
-{
-    for (const auto& j : test_values())
-    {
-        CAPTURE(j.dump(-1, ' ', false, json::error_handler_t::replace));
-
-        const std::size_t hint = nlohmann::detail::binary_reserve_hint(j);
-
-        CHECK(hint <= json::to_cbor(j).size());
-        CHECK(hint <= json::to_msgpack(j).size());
-        CHECK(hint <= json::to_ubjson(j).size());
-        CHECK(hint <= json::to_ubjson(j, true, true).size());
-        CHECK(hint <= json::to_bjdata(j).size());
-    }
-
-    for (const auto& j : bson_values())
-    {
-        CAPTURE(j.dump());
-        CHECK(nlohmann::detail::binary_reserve_hint(j) <= json::to_bson(j).size());
-    }
-
-    SECTION("scalars get no hint")
-    {
-        CHECK(nlohmann::detail::binary_reserve_hint(json(nullptr)) == 0);
-        CHECK(nlohmann::detail::binary_reserve_hint(json(42)) == 0);
-        CHECK(nlohmann::detail::binary_reserve_hint(json("a string")) == 0);
-        CHECK(nlohmann::detail::binary_reserve_hint(json::binary({0x01})) == 0);
-    }
-
-    SECTION("containers are hinted from their element count")
-    {
-        CHECK(nlohmann::detail::binary_reserve_hint(json::array()) == 1);
-        CHECK(nlohmann::detail::binary_reserve_hint(json::array({1, 2, 3})) == 4);
-        CHECK(nlohmann::detail::binary_reserve_hint(json::object()) == 1);
-        CHECK(nlohmann::detail::binary_reserve_hint(json({{"a", 1}, {"b", 2}})) == 5);
-    }
-}
@@ -2586,12 +2586,7 @@ TEST_CASE("BJData")
                CHECK(json::to_bjdata(json::from_bjdata(v_d), true, true) == v_d);
                CHECK(json::to_bjdata(json::from_bjdata(v_D), true, true) == v_D);
                CHECK(json::to_bjdata(json::from_bjdata(v_C), true, true) == v_C);
-                // v_B uses the Draft-3-only 'B' marker, so it round-trips only when
-                // Draft 3 is explicitly selected (see GitHub issue #5404); the
-                // default Draft 2 falls back to a plain object instead, covered by
-                // the "ndarray with _ArrayType_ "byte" is gated by the BJData draft
-                // version" section below
-                CHECK(json::to_bjdata(json::from_bjdata(v_B), true, true, json::bjdata_version_t::draft3) == v_B);
+                CHECK(json::to_bjdata(json::from_bjdata(v_B), true, true) == v_B);
            }

            SECTION("ndarray with data not matching _ArrayType_ is written as an object")
@@ -2604,25 +2599,25 @@ TEST_CASE("BJData")
                // that still round-trips.

                // string data declared as a uint64 array
-                json const j_str = json({{"_ArrayType_", "uint64"}, {"_ArraySize_", {2, 1}}, {"_ArrayData_", {"pointer", "value"}}});
+                json const j_str = json({{"_ArrayType_", "uint64"}, {"_ArraySize_", {1}}, {"_ArrayData_", {"pointer"}}});
                const auto out_str = json::to_bjdata(j_str);
                CHECK(out_str.at(0) == '{');
                CHECK(json::from_bjdata(out_str) == j_str);

                // integer data declared as a double array
-                json const j_float = json({{"_ArrayType_", "double"}, {"_ArraySize_", {2, 1}}, {"_ArrayData_", {1, 2}}});
+                json const j_float = json({{"_ArrayType_", "double"}, {"_ArraySize_", {2}}, {"_ArrayData_", {1, 2}}});
                const auto out_float = json::to_bjdata(j_float);
                CHECK(out_float.at(0) == '{');
                CHECK(json::from_bjdata(out_float) == j_float);

                // a non-integer shape entry is likewise not treated as an ndarray
-                json const j_size = json({{"_ArrayType_", "uint8"}, {"_ArraySize_", {"x", 1}}, {"_ArrayData_", {1}}});
+                json const j_size = json({{"_ArrayType_", "uint8"}, {"_ArraySize_", {"x"}}, {"_ArrayData_", {1}}});
                const auto out_size = json::to_bjdata(j_size);
                CHECK(out_size.at(0) == '{');
                CHECK(json::from_bjdata(out_size) == j_size);

                // a negative shape entry is not a usable dimension either
-                json const j_neg = json::parse(R"({"_ArrayType_":"uint8","_ArraySize_":[-1,1],"_ArrayData_":[1]})");
+                json const j_neg = json::parse(R"({"_ArrayType_":"uint8","_ArraySize_":[-1],"_ArrayData_":[1]})");
                const auto out_neg = json::to_bjdata(j_neg);
                CHECK(out_neg.at(0) == '{');
                CHECK(json::from_bjdata(out_neg) == j_neg);
@@ -2634,10 +2629,8 @@ TEST_CASE("BJData")
                // the C++ API stores an int literal as number_integer, so _ArrayType_
                // names the wire type rather than the storage. Both storages have to
                // produce the same typed array for every type.
-                // "byte" is checked separately below since it additionally requires
-                // BJData Draft 3 to be selected explicitly (see GitHub issue #5404).
                for (const char* type :
-                        {"uint8", "int8", "uint16", "int16", "uint32", "int32", "uint64", "int64", "char"
+                        {"uint8", "int8", "uint16", "int16", "uint32", "int32", "uint64", "int64", "char", "byte"
                        })
                {
                    CAPTURE(type);
@@ -2648,23 +2641,15 @@ TEST_CASE("BJData")
                    CHECK(from_text == json::to_bjdata(json({{"_ArrayType_", type}, {"_ArraySize_", {2, 3}}, {"_ArrayData_", {1, 2, 3, 4, 5, 6}}})));
                }

-                {
-                    const std::string text = R"({"_ArrayType_":"byte","_ArraySize_":[2,3],"_ArrayData_":[1,2,3,4,5,6]})";
-                    const auto from_text = json::to_bjdata(json::parse(text), true, true, json::bjdata_version_t::draft3);
-                    CHECK(from_text.at(0) == '[');
-                    CHECK(from_text == json::to_bjdata(json({{"_ArrayType_", "byte"}, {"_ArraySize_", {2, 3}}, {"_ArrayData_", {1, 2, 3, 4, 5, 6}}}),
-                    true, true, json::bjdata_version_t::draft3));
-                }
-
                // negative values under a signed type behave the same way
-                const auto from_neg = json::to_bjdata(json::parse(R"({"_ArrayType_":"int32","_ArraySize_":[2,1],"_ArrayData_":[-5,7]})"));
+                const auto from_neg = json::to_bjdata(json::parse(R"({"_ArrayType_":"int32","_ArraySize_":[2],"_ArrayData_":[-5,7]})"));
                CHECK(from_neg.at(0) == '[');
-                CHECK(from_neg == json::to_bjdata(json({{"_ArrayType_", "int32"}, {"_ArraySize_", {2, 1}}, {"_ArrayData_", {-5, 7}}})));
+                CHECK(from_neg == json::to_bjdata(json({{"_ArrayType_", "int32"}, {"_ArraySize_", {2}}, {"_ArrayData_", {-5, 7}}})));

                // and so do the floating point types
-                const auto from_float = json::to_bjdata(json::parse(R"({"_ArrayType_":"double","_ArraySize_":[2,1],"_ArrayData_":[1.5,2.5]})"));
+                const auto from_float = json::to_bjdata(json::parse(R"({"_ArrayType_":"double","_ArraySize_":[2],"_ArrayData_":[1.5,2.5]})"));
                CHECK(from_float.at(0) == '[');
-                CHECK(from_float == json::to_bjdata(json({{"_ArrayType_", "double"}, {"_ArraySize_", {2, 1}}, {"_ArrayData_", {1.5, 2.5}}})));
+                CHECK(from_float == json::to_bjdata(json({{"_ArrayType_", "double"}, {"_ArraySize_", {2}}, {"_ArrayData_", {1.5, 2.5}}})));
            }

            SECTION("optimized ndarray (type and vector-size as 1D array)")
@@ -2746,83 +2731,6 @@ TEST_CASE("BJData")
                CHECK(json::from_bjdata(json::to_bjdata(j_size), true, true) == j_size);
            }

-            SECTION("ndarray whose _ArrayType_ is not a string stays as object")
-            {
-                // the type name is looked up as a string below the annotation
-                // check; a non-string _ArrayType_ cannot name a known dtype,
-                // so calling get<string_t>() on it would throw type_error.302
-                // instead of falling back like an unrecognized type name
-                // already does (see GitHub issue #5398)
-                json const j_number = json({{"_ArrayType_", 1}, {"_ArraySize_", {2}}, {"_ArrayData_", {1, 2}}});
-                const auto out_number = json::to_bjdata(j_number);
-                CHECK(out_number.at(0) == '{');
-                CHECK(json::from_bjdata(out_number) == j_number);
-
-                json const j_null = json({{"_ArrayType_", nullptr}, {"_ArraySize_", {2}}, {"_ArrayData_", {1, 2}}});
-                const auto out_null = json::to_bjdata(j_null);
-                CHECK(out_null.at(0) == '{');
-                CHECK(json::from_bjdata(out_null) == j_null);
-
-                json const j_bool = json({{"_ArrayType_", true}, {"_ArraySize_", {2}}, {"_ArrayData_", {1, 2}}});
-                const auto out_bool = json::to_bjdata(j_bool);
-                CHECK(out_bool.at(0) == '{');
-                CHECK(json::from_bjdata(out_bool) == j_bool);
-
-                json const j_array = json({{"_ArrayType_", {"uint8"}}, {"_ArraySize_", {2}}, {"_ArrayData_", {1, 2}}});
-                const auto out_array = json::to_bjdata(j_array);
-                CHECK(out_array.at(0) == '{');
-                CHECK(json::from_bjdata(out_array) == j_array);
-
-                json const j_object = json({{"_ArrayType_", {{"a", 1}}}, {"_ArraySize_", {2}}, {"_ArrayData_", {1, 2}}});
-                const auto out_object = json::to_bjdata(j_object);
-                CHECK(out_object.at(0) == '{');
-                CHECK(json::from_bjdata(out_object) == j_object);
-            }
-
-            SECTION("re-serializing a value containing a plain-array-of-bytes is value-stable but not byte-stable")
-            {
-                // OSS-Fuzz found this input (an array whose first element is a
-                // binary_t byte, followed by an object whose _ArrayType_ is
-                // not a string) while exercising the fix for #5398 above: once
-                // the fix stops to_bjdata() from throwing type_error.302 for
-                // the third element, serialization proceeds far enough to
-                // reach a pre-existing, unrelated round-trip quirk in how a
-                // single-byte binary_t value is re-encoded.
-                std::vector<std::uint8_t> const input
-                {
-                    0x5b, 0x5b, 0x24, 0x42, 0x23, 0x5b, 0x69, 0x01, 0x5d, 0x5b, 0x5b, 0x5d, 0x7b, 0x55, 0x0b,
-                    0x5f, 0x41, 0x72, 0x72, 0x61, 0x79, 0x44, 0x61, 0x74, 0x61, 0x5f, 0x54, 0x55, 0x0b, 0x5f,
-                    0x41, 0x72, 0x72, 0x61, 0x79, 0x53, 0x69, 0x7a, 0x65, 0x5f, 0x5a, 0x55, 0x0b, 0x5f, 0x41,
-                    0x72, 0x72, 0x61, 0x79, 0x54, 0x79, 0x70, 0x65, 0x5f, 0x54, 0x7d, 0x5d
-                };
-                json const j1 = json::from_bjdata(input);
-
-                // to_bjdata() must not throw (this is what #5398 fixes)
-                std::vector<std::uint8_t> vec2;
-                CHECK_NOTHROW(vec2 = json::to_bjdata(j1, false, false));
-
-                // parsing back a plain (non-optimized) array of bytes cannot
-                // recover that it used to be a binary_t: from_bjdata() has no
-                // way to distinguish "array of uint8 numbers" from "array of
-                // bytes" unless the compact "$U#" array header is used, so
-                // the binary_t collapses into a plain JSON array
-                json const j2 = json::from_bjdata(vec2);
-                CHECK(j1 != j2);
-                CHECK(j2 == json({{91}, json::array(), {{"_ArrayData_", true}, {"_ArraySize_", nullptr}, {"_ArrayType_", true}}}));
-
-                // re-serializing j2 no longer goes through the dedicated
-                // binary_t writer (which always uses the 'U' marker for raw
-                // bytes); the now-plain number 91 goes through the generic
-                // smallest-type writer instead, which - like the rest of the
-                // UBJSON/BJData writer, and unchanged by this fix - prefers
-                // the 'i' (int8) marker over 'U' (uint8) for values that fit
-                // both. Both markers are valid BJData and both decode back to
-                // 91, so this is not byte-for-byte identical to vec2, but it
-                // is value-stable: parsing it again reproduces j2 exactly.
-                std::vector<std::uint8_t> const vec3 = json::to_bjdata(j2, false, false);
-                CHECK(json::from_bjdata(vec3) == j2);
-            }
-
            SECTION("ndarray whose dimensions overflow stays as object")
            {
                // the product of the dimensions wraps around std::size_t to 0
@@ -2835,7 +2743,7 @@ TEST_CASE("BJData")
                // a single dimension that does not fit into std::size_t is
                // rejected for the same reason (only observable where
                // std::size_t is narrower than 64 bit)
-                json j_huge = json({{"_ArrayData_", json::array()}, {"_ArraySize_", {18446744073709551615ull, 2}}, {"_ArrayType_", "uint8"}});
+                json j_huge = json({{"_ArrayData_", json::array()}, {"_ArraySize_", {18446744073709551615ull}}, {"_ArrayType_", "uint8"}});
                CHECK(json::from_bjdata(json::to_bjdata(j_huge), true, true) == j_huge);

                // a well-formed ndarray is still encoded as one
@@ -2878,146 +2786,42 @@ TEST_CASE("BJData")
                // object encoding that still round-trips (see GitHub issue #5403)

                // an unsigned element that does not fit uint8
-                json const j_uint8 = json({{"_ArrayType_", "uint8"}, {"_ArraySize_", {2, 1}}, {"_ArrayData_", {1, 256}}});
+                json const j_uint8 = json({{"_ArrayType_", "uint8"}, {"_ArraySize_", {2}}, {"_ArrayData_", {1, 256}}});
                const auto out_uint8 = json::to_bjdata(j_uint8);
                CHECK(out_uint8.at(0) == '{');
                CHECK(json::from_bjdata(out_uint8) == j_uint8);

                // a signed element that does not fit int8
-                json const j_int8 = json({{"_ArrayType_", "int8"}, {"_ArraySize_", {2, 1}}, {"_ArrayData_", {1, 200}}});
+                json const j_int8 = json({{"_ArrayType_", "int8"}, {"_ArraySize_", {2}}, {"_ArrayData_", {1, 200}}});
                const auto out_int8 = json::to_bjdata(j_int8);
                CHECK(out_int8.at(0) == '{');
                CHECK(json::from_bjdata(out_int8) == j_int8);

                // a negative element is likewise out of range for an
                // unsigned _ArrayType_
-                json const j_uint16_neg = json({{"_ArrayType_", "uint16"}, {"_ArraySize_", {2, 1}}, {"_ArrayData_", {1, -1}}});
+                json const j_uint16_neg = json({{"_ArrayType_", "uint16"}, {"_ArraySize_", {2}}, {"_ArrayData_", {1, -1}}});
                const auto out_uint16_neg = json::to_bjdata(j_uint16_neg);
                CHECK(out_uint16_neg.at(0) == '{');
                CHECK(json::from_bjdata(out_uint16_neg) == j_uint16_neg);

                // a double element that overflows to infinity when narrowed
                // to the "single" (float) precision named by _ArrayType_
-                json const j_single = json({{"_ArrayType_", "single"}, {"_ArraySize_", {2, 1}}, {"_ArrayData_", {1.5, 1e40}}});
+                json const j_single = json({{"_ArrayType_", "single"}, {"_ArraySize_", {2}}, {"_ArrayData_", {1.5, 1e40}}});
                const auto out_single = json::to_bjdata(j_single);
                CHECK(out_single.at(0) == '{');
                CHECK(json::from_bjdata(out_single) == j_single);

                // in-range boundary values still use the compact ndarray encoding
-                json const j_uint8_ok = json({{"_ArrayType_", "uint8"}, {"_ArraySize_", {2, 1}}, {"_ArrayData_", {0, 255}}});
-                CHECK(json::to_bjdata(j_uint8_ok) == std::vector<uint8_t>({'[', '$', 'U', '#', '[', 'i', 2, 'i', 1, ']', 0, 255}));
+                json const j_uint8_ok = json({{"_ArrayType_", "uint8"}, {"_ArraySize_", {2}}, {"_ArrayData_", {0, 255}}});
+                CHECK(json::to_bjdata(j_uint8_ok) == std::vector<uint8_t>({'[', '$', 'U', '#', '[', 'i', 2, ']', 0, 255}));

-                json const j_int8_ok = json({{"_ArrayType_", "int8"}, {"_ArraySize_", {2, 1}}, {"_ArrayData_", {-128, 127}}});
-                CHECK(json::to_bjdata(j_int8_ok) == std::vector<uint8_t>({'[', '$', 'i', '#', '[', 'i', 2, 'i', 1, ']', 0x80, 0x7F}));
+                json const j_int8_ok = json({{"_ArrayType_", "int8"}, {"_ArraySize_", {2}}, {"_ArrayData_", {-128, 127}}});
+                CHECK(json::to_bjdata(j_int8_ok) == std::vector<uint8_t>({'[', '$', 'i', '#', '[', 'i', 2, ']', 0x80, 0x7F}));

-                json const j_single_ok = json({{"_ArrayType_", "single"}, {"_ArraySize_", {2, 1}}, {"_ArrayData_", {1.5, -1.5}}});
+                json const j_single_ok = json({{"_ArrayType_", "single"}, {"_ArraySize_", {1}}, {"_ArrayData_", {1.5}}});
                const auto out_single_ok = json::to_bjdata(j_single_ok);
                CHECK(out_single_ok.at(0) == '[');
-                CHECK(json::from_bjdata(out_single_ok) == json({{"_ArrayType_", "single"}, {"_ArraySize_", {2, 1}}, {"_ArrayData_", {1.5f, -1.5f}}}));
-            }
-
-            SECTION("ndarray that would not be read back as an annotated object stays as object")
-            {
-                // the reader only restores an annotated object from an ND-array
-                // with at least two non-zero dimensions that is not a 1xN row
-                // vector; any other shape is read back as a plain array. Writing
-                // such an object as an ND-array would drop its annotation, so it
-                // falls back to a plain object encoding that round-trips.
-                for (const char* text :
-                        {
-                            R"({"_ArrayType_":"int16","_ArraySize_":[],"_ArrayData_":[]})",
-                            R"({"_ArrayType_":"int16","_ArraySize_":[2],"_ArrayData_":[1,2]})",
-                            R"({"_ArrayType_":"int16","_ArraySize_":[1,2],"_ArrayData_":[1,2]})",
-                            R"({"_ArrayType_":"int16","_ArraySize_":[0],"_ArrayData_":[]})",
-                            R"({"_ArrayType_":"int16","_ArraySize_":[2,0],"_ArrayData_":[]})",
-                            R"({"_ArrayType_":"int16","_ArraySize_":[0,2],"_ArrayData_":[]})"
-                        })
-                {
-                    CAPTURE(text);
-                    const json j = json::parse(text);
-                    for (const bool use_size :
-                            {
-                                false, true
-                            })
-                    {
-                        const auto out = json::to_bjdata(j, use_size, use_size);
-                        CHECK(out.at(0) == '{');
-                        CHECK(json::from_bjdata(out) == j);
-                    }
-                }
-
-                // a genuine ND-array still uses the compact encoding and round-trips
-                const json j_2d = json::parse(R"({"_ArrayType_":"int16","_ArraySize_":[2,1],"_ArrayData_":[1,2]})");
-                const auto out_2d = json::to_bjdata(j_2d);
-                CHECK(out_2d.at(0) == '[');
-                CHECK(json::from_bjdata(out_2d) == j_2d);
-            }
-
-            SECTION("ndarray with non-array _ArrayData_ stays as object")
-            {
-                // the elements are written from _ArrayData_ as a flat list, so it
-                // has to be an array: null has size 0, any other scalar has size 1,
-                // and iterating an object visits its values, so each of these could
-                // match the dimensions and be encoded as an unrelated ND-array
-                for (const char* text :
-                        {
-                            R"({"_ArrayType_":"int16","_ArraySize_":[2,1],"_ArrayData_":null})",
-                            R"({"_ArrayType_":"int16","_ArraySize_":[2,1],"_ArrayData_":{"a":1,"b":2}})",
-                            R"({"_ArrayType_":"int16","_ArraySize_":[1],"_ArrayData_":5})",
-                            R"({"_ArrayType_":"int16","_ArraySize_":[],"_ArrayData_":null})"
-                        })
-                {
-                    CAPTURE(text);
-                    const json j = json::parse(text);
-                    const auto out = json::to_bjdata(j);
-                    CHECK(out.at(0) == '{');
-                    CHECK(json::from_bjdata(out) == j);
-                }
-
-                // OSS-Fuzz issue 563659413: an empty binary _ArraySize_ is written
-                // as a plain object and read back as an empty array, after which
-                // the object with a null _ArrayData_ was encoded as an empty
-                // ND-array and re-read as [], so a second round trip lost the value
-                const std::vector<uint8_t> input =
-                {
-                    '{', 'U', 11, '_', 'A', 'r', 'r', 'a', 'y', 'D', 'a', 't', 'a', '_', 'Z',
-                    'U', 11, '_', 'A', 'r', 'r', 'a', 'y', 'T', 'y', 'p', 'e', '_', 'S', 'i', 5, 'i', 'n', 't', '1', '6',
-                    'U', 11, '_', 'A', 'r', 'r', 'a', 'y', 'S', 'i', 'z', 'e', '_', '[', '$', 'B', '#', '[', ']', '}'
-                };
-                const json j1 = json::from_bjdata(input);
-                const json j2 = json::from_bjdata(json::to_bjdata(j1, false, false));
-                CHECK(j2 == json::parse(R"({"_ArrayType_":"int16","_ArraySize_":[],"_ArrayData_":null})"));
-                CHECK(json::from_bjdata(json::to_bjdata(j2, false, false)) == j2);
-            }
-
-            SECTION("ndarray with _ArrayType_ \"byte\" is gated by the BJData draft version")
-            {
-                // the 'B' (byte) marker used by _ArrayType_ "byte" is only defined
-                // by BJData Draft 3; Draft 2 (the default) has no such marker, so
-                // emitting it unconditionally produced a stream that a Draft 2
-                // reader could not parse as intended (see GitHub issue #5404).
-                // Two dimensions are used so that a successfully written ndarray
-                // round-trips back into the annotated object (a single dimension
-                // is, by the BJData ndarray convention, read back as a plain
-                // binary value rather than the annotated object, same as every
-                // other single-dimension ndarray of a non-"byte" type is read
-                // back as a plain array instead of the annotated object).
-                json const j_byte = json({{"_ArrayType_", "byte"}, {"_ArraySize_", {2, 3}}, {"_ArrayData_", {1, 2, 3, 4, 5, 6}}});
-
-                // default (Draft 2): falls back to a plain object and round-trips
-                const auto out_draft2 = json::to_bjdata(j_byte);
-                CHECK(out_draft2.at(0) == '{');
-                CHECK(json::from_bjdata(out_draft2) == j_byte);
-
-                // explicit Draft 2: same as the default
-                const auto out_draft2_explicit = json::to_bjdata(j_byte, true, true, json::bjdata_version_t::draft2);
-                CHECK(out_draft2_explicit.at(0) == '{');
-                CHECK(json::from_bjdata(out_draft2_explicit) == j_byte);
-
-                // Draft 3 explicitly selected: still uses the compact 'B' ndarray encoding
-                const auto out_draft3 = json::to_bjdata(j_byte, true, true, json::bjdata_version_t::draft3);
-                CHECK(out_draft3 == std::vector<uint8_t>({'[', '$', 'B', '#', '[', '$', 'i', '#', 'i', 2, 2, 3, 1, 2, 3, 4, 5, 6}));
-                CHECK(json::from_bjdata(out_draft3) == j_byte);
+                CHECK(json::from_bjdata(out_single_ok) == json({1.5f}));
            }
        }
    }
@@ -3088,6 +2892,23 @@ TEST_CASE("BJData")
                CHECK(json::from_bjdata(vl, true, false).is_discarded());
            }

+            SECTION("invalid UTF-8 in string (see #5529)")
+            {
+                // a BJData string of length 2 whose bytes are not valid
+                // UTF-8 (0xC0 0xAE is an overlong encoding of '.') must be
+                // rejected at decode time, matching every other kind of
+                // malformed binary input, rather than only failing later
+                // when the resulting value is dumped
+                std::vector<uint8_t> const v = {'S', 'i', 0x02, 0xc0, 0xae};
+                json _;
+                CHECK_THROWS_WITH_AS(_ = json::from_bjdata(v), "[json.exception.parse_error.113] parse error at byte 5: syntax error while parsing BJData string: invalid string: ill-formed UTF-8 byte", json::parse_error&);
+                CHECK(json::from_bjdata(v, true, false).is_discarded());
+
+                // valid UTF-8 must still round-trip
+                const json j = "h\xc3\xa9llo, w\xc3\xb6rld! \xe6\x97\xa5\xe6\x9c\xac\xe8\xaa\x9e"; // héllo, wörld! 日本語
+                CHECK(json::from_bjdata(json::to_bjdata(j)) == j);
+            }
+
            SECTION("parse bjdata markers in ubjson")
            {
                // create a single-character string for all number types
@@ -1,167 +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
-
-#include "doctest_compatibility.h"
-
-// This file tests the opt-in JSON_BRACE_INIT_COPY_SEMANTICS, so it defines the
-// macro itself rather than relying on a -D flag, and runs in every build.
-#ifdef JSON_BRACE_INIT_COPY_SEMANTICS
-    #undef JSON_BRACE_INIT_COPY_SEMANTICS
-#endif
-
-#define JSON_BRACE_INIT_COPY_SEMANTICS 1
-
-#include <nlohmann/json.hpp>
-using nlohmann::json;
-
-#include <array>
-#include <list>
-#include <map>
-#include <string>
-#include <tuple>
-#include <utility>
-#include <vector>
-
-#define STRINGIZE_EX(x) #x
-#define STRINGIZE(x) STRINGIZE_EX(x)
-
-TEST_CASE("JSON_BRACE_INIT_COPY_SEMANTICS")
-{
-    SECTION("the macro is part of the ABI tag")
-    {
-        const std::string ns = STRINGIZE(NLOHMANN_JSON_NAMESPACE);
-        // other tags may come before it, e.g. json_abi_ldvcmp_bics
-        CHECK(ns.find("_bics") != std::string::npos);
-    }
-
-    SECTION("single-element brace initialization copies the element (#5074)")
-    {
-        json const j_obj = {{"key", "value"}, {"num", 42}};
-        json const j_arr = {1, 2, 3};
-
-        // object: brace init copies instead of wrapping
-        json const j1{j_obj};
-        CHECK(j1.is_object());
-        CHECK(j1 == j_obj);
-
-        // array: brace init copies instead of wrapping
-        json const j2{j_arr};
-        CHECK(j2.is_array());
-        CHECK(j2.size() == 3);
-        CHECK(j2 == j_arr);
-
-        // this applies to any single element, not only to JSON values
-        json const j3{true};
-        CHECK(j3.is_boolean());
-
-        json const j4{42};
-        CHECK(j4.is_number_integer());
-
-        json const j5 = {1};
-        CHECK(j5 == 1);
-
-        json const j6 = {"text"};
-        CHECK(j6 == "text");
-
-        json const j7 = {{1, 2}};
-        CHECK(j7 == json::array({1, 2}));
-    }
-
-    SECTION("what the macro does not change")
-    {
-        // lists with more than one element are unaffected
-        json const j1 = {1, 2};
-        CHECK(j1.is_array());
-        CHECK(j1.size() == 2);
-
-        // a single [string, value] pair still describes an object
-        json const j2 = {{"key", "value"}};
-        CHECK(j2.is_object());
-        CHECK(j2["key"] == "value");
-
-        // json::array() always creates an array
-        json const j3 = json::array({1});
-        CHECK(j3.is_array());
-        CHECK(j3.size() == 1);
-        CHECK(j3[0] == 1);
-
-        json const j_obj = {{"key", "value"}};
-        json const j4 = json::array({j_obj});
-        CHECK(j4.is_array());
-        CHECK(j4.size() == 1);
-        CHECK(j4[0] == j_obj);
-    }
-
-    SECTION("conversions build the same values as without the macro")
-    {
-        SECTION("one-element std::tuple")
-        {
-            json const j1 = std::tuple<int> {5};
-            CHECK(j1.dump() == "[5]");
-            CHECK(std::get<0>(j1.get<std::tuple<int>>()) == 5);
-
-            json const j2 = std::tuple<std::string> {"text"};
-            CHECK(j2.dump() == "[\"text\"]");
-            CHECK(std::get<0>(j2.get<std::tuple<std::string>>()) == "text");
-
-            json const j3 = std::tuple<json> {json::array({1, 2})};
-            CHECK(j3.dump() == "[[1,2]]");
-
-            // as without the macro, a [string, value] pair becomes an object
-            // member (see the known limitation documented for std::pair)
-            json const j4 = std::tuple<std::pair<std::string, int>> {{"a", 1}};
-            CHECK(j4.dump() == "{\"a\":1}");
-        }
-
-        SECTION("tuples with more elements")
-        {
-            json const j1 = std::tuple<int, std::string> {1, "a"};
-            CHECK(j1.dump() == "[1,\"a\"]");
-
-            json const j2 = std::tuple<> {};
-            CHECK(j2.dump() == "[]");
-        }
-
-        SECTION("one-element containers")
-        {
-            json const j1 = std::vector<int> {1};
-            CHECK(j1.dump() == "[1]");
-            CHECK(j1.get<std::vector<int>>() == std::vector<int> {1});
-
-            std::array<int, 1> const arr = {{1}};
-            json const j2 = arr;
-            CHECK(j2.dump() == "[1]");
-
-            json const j3 = std::list<std::string> {"a"};
-            CHECK(j3.dump() == "[\"a\"]");
-
-            json const j4 = std::map<std::string, int> {{"a", 1}};
-            CHECK(j4.dump() == "{\"a\":1}");
-
-            json const j5 = std::map<int, int> {{1, 2}};
-            CHECK(j5.dump() == "[[1,2]]");
-        }
-
-        SECTION("std::pair")
-        {
-            json const j = std::pair<int, int> {1, 2};
-            CHECK(j.dump() == "[1,2]");
-            CHECK((j.get<std::pair<int, int>>() == std::pair<int, int> {1, 2}));
-        }
-
-        SECTION("items()")
-        {
-            json j_obj = {{"key", 1}};
-            for (const auto& el : j_obj.items())
-            {
-                json const j = el;
-                CHECK(j.dump() == "{\"key\":1}");
-            }
-        }
-    }
-}
@@ -49,7 +49,7 @@ using huge_binary_json = nlohmann::basic_json <
 // for *object keys* (e.g. "s" or "nested" below). Only the designated test
 // value is meant to lie about its size - if every huge_string_t (including
 // keys) reported a huge size, the running totals computed while walking the
-// BSON document (see calc_bson_sizes in binary_writer.hpp)
+// BSON document (see calc_bson_object_size & friends in binary_writer.hpp)
 // would need more than 32 bits, and on platforms where std::size_t is only
 // 32 bits wide that arithmetic would silently wrap around, producing wrong
 // (or even unguarded) lengths. The fake size is therefore opt-in via
@@ -199,6 +199,32 @@ TEST_CASE("BSON")
        CHECK_THROWS_WITH_AS(_ = json::from_bson(v), "[json.exception.parse_error.112] parse error at byte 10: syntax error while parsing BSON string: string length must be at least 1, is -2147483648", json::parse_error&);
    }

+    SECTION("invalid UTF-8 in string (see #5529)")
+    {
+        // a BSON document with a string field "k" whose value bytes are not
+        // valid UTF-8 (0xC0 0xAE is an overlong encoding of '.') must be
+        // rejected at decode time, matching every other kind of malformed
+        // binary input, rather than only failing later when the resulting
+        // value is dumped
+        std::vector<std::uint8_t> const v =
+        {
+            0x0F, 0x00, 0x00, 0x00, // size (little endian)
+            0x02, /// entry: string (UTF-8)
+            'k', 0x00, // key "k"
+            0x03, 0x00, 0x00, 0x00, // string length (including trailing zero byte)
+            0xc0, 0xae, // ill-formed UTF-8
+            0x00, // string terminator
+            0x00 // end marker
+        };
+        json _;
+        CHECK_THROWS_WITH_AS(_ = json::from_bson(v), "[json.exception.parse_error.113] parse error at byte 13: syntax error while parsing BSON string: invalid string: ill-formed UTF-8 byte", json::parse_error&);
+        CHECK(json::from_bson(v, true, false).is_discarded());
+
+        // valid UTF-8 must still round-trip
+        const json j = {{"k", "h\xc3\xa9llo, w\xc3\xb6rld! \xe6\x97\xa5\xe6\x9c\xac\xe8\xaa\x9e"}}; // héllo, wörld! 日本語
+        CHECK(json::from_bson(json::to_bson(j)) == j);
+    }
+
    SECTION("objects")
    {
        SECTION("empty object")
@@ -791,15 +817,6 @@ TEST_CASE("BSON")
    }
 }

-TEST_CASE("regression test - BSON binary subtype rejects a value that doesn't fit a single byte")
-{
-    json const doc255 = {{"b", json::binary({1, 2}, 255)}};
-    CHECK(json::from_bson(json::to_bson(doc255))["b"].get_binary().subtype() == 255);
-
-    CHECK_THROWS_AS(json::to_bson(json{{"b", json::binary({1, 2}, 256)}}), json::out_of_range);
-    CHECK_THROWS_WITH_AS(json::to_bson(json{{"b", json::binary({1, 2}, 300)}}), "[json.exception.out_of_range.415] subtype 300 is too large for the BSON binary subtype (max 255)", json::out_of_range);
-}
-
 TEST_CASE("BSON input/output_adapters")
 {
    const json json_representation =
@@ -1697,67 +1714,3 @@ TEST_CASE("BSON roundtrips" * doctest::skip())
        }
    }
 }
-
-TEST_CASE("BSON: deeply nested values")
-{
-    SECTION("documents and arrays round-trip at every depth")
-    {
-        // nested documents and arrays, with siblings on every level, so
-        // every length prefix covers entries of both kinds
-        json value = "leaf";
-        for (std::size_t depth = 0; depth <= 300; ++depth)
-        {
-            CAPTURE(depth);
-            const json document = {{"value", value}, {"n", depth}};
-            CHECK(json::from_bson(json::to_bson(document)) == document);
-
-value = depth % 2 == 0 ? json{{"a", std::move(value)}, {"b", {1, "x"}}} :
-            json::array({std::move(value), depth, json::object()});
-        }
-    }
-
-    SECTION("a key containing U+0000 is rejected before anything is written")
-    {
-        json value = json::object({{std::string("bad\0key", 7), 1}});
-        for (std::size_t depth = 0; depth < 200; ++depth)
-        {
-            value = json{{"a", {{"b", 1}}}, {"z", std::move(value)}};
-        }
-        std::vector<std::uint8_t> output;
-        CHECK_THROWS_AS(json::to_bson(value, output), json::out_of_range&);
-        CHECK(output.empty());
-    }
-
-    SECTION("values nested too deeply for the call stack (#5392)")
-    {
-        // serializing recursed once per nesting level, and computed every
-        // nested document's length by walking everything below it again.
-        // The values are only parsed, serialized and walked, never copied or
-        // compared, since those recurse too.
-        const std::size_t depth = 100000;
-        for (const bool objects :
-                {
-                    false, true
-                })
-        {
-            CAPTURE(objects);
-            std::string text = "{\"a\":";
-            for (std::size_t i = 0; i < depth; ++i)
-            {
-                text += objects ? "{\"a\":" : "[";
-            }
-            text += "1";
-            text.append(depth, objects ? '}' : ']');
-            text += "}";
-
-            const auto bson = json::to_bson(json::parse(text));
-            const auto result = json::from_bson(bson);
-            const json* p = &result.at("a");
-            for (std::size_t i = 0; i < depth; ++i)
-            {
-                p = objects ? &p->at("a") : &p->at(0);
-            }
-            CHECK(*p == 1);
-        }
-    }
-}
@@ -42,39 +42,6 @@ TEST_CASE("byte_container_with_subtype")
        CHECK(container.subtype() == static_cast<subtype_type>(-1));
    }

-    SECTION("move semantics")
-    {
-        // the rvalue-reference constructor (without a subtype) must actually move
-        // the passed-in container rather than copy it; comparing the buffer address
-        // before and after is a stronger check than just observing the source is
-        // empty afterward, since a copy-then-clear could also leave it empty
-        {
-            std::vector<std::uint8_t> bytes = {{0xCA, 0xFE, 0xBA, 0xBE}};
-            const auto* const data_ptr = bytes.data();
-
-            nlohmann::byte_container_with_subtype<std::vector<std::uint8_t>> container(std::move(bytes));
-
-            CHECK(container.size() == 4);
-            CHECK(container.data() == data_ptr);
-            CHECK(!container.has_subtype());
-            CHECK(bytes.empty()); // NOLINT(bugprone-use-after-move,clang-analyzer-cplusplus.Move,hicpp-invalid-access-moved)
-        }
-
-        // same check for the rvalue-reference constructor that also takes a subtype
-        {
-            std::vector<std::uint8_t> bytes = {{0xCA, 0xFE, 0xBA, 0xBE}};
-            const auto* const data_ptr = bytes.data();
-
-            nlohmann::byte_container_with_subtype<std::vector<std::uint8_t>> container(std::move(bytes), 42);
-
-            CHECK(container.size() == 4);
-            CHECK(container.data() == data_ptr);
-            CHECK(container.has_subtype());
-            CHECK(container.subtype() == 42);
-            CHECK(bytes.empty()); // NOLINT(bugprone-use-after-move,clang-analyzer-cplusplus.Move,hicpp-invalid-access-moved)
-        }
-    }
-
    SECTION("comparisons")
    {
        std::vector<std::uint8_t> const bytes = {{0xCA, 0xFE, 0xBA, 0xBE}};
@@ -1833,6 +1833,27 @@ TEST_CASE("CBOR")
            CHECK(json::from_cbor(std::vector<uint8_t>({0xa1, 0xff, 0x01}), true, false).is_discarded());
        }

+        SECTION("invalid UTF-8 in string (see #5529)")
+        {
+            // a two-character text string (major type 3) whose bytes are not
+            // valid UTF-8 (0xC0 0xAE is an overlong encoding of '.') must be
+            // rejected at decode time, matching every other kind of
+            // malformed binary input, rather than only failing later when
+            // the resulting value is dumped
+            json _;
+            CHECK_THROWS_WITH_AS(_ = json::from_cbor(std::vector<uint8_t>({0x62, 0xc0, 0xae})), "[json.exception.parse_error.113] parse error at byte 3: syntax error while parsing CBOR string: invalid string: ill-formed UTF-8 byte", json::parse_error&);
+            CHECK(json::from_cbor(std::vector<uint8_t>({0x62, 0xc0, 0xae}), true, false).is_discarded());
+
+            // a CBOR byte string (major type 2) with the very same bytes is
+            // NOT text and must still be accepted as-is
+            CHECK_NOTHROW(_ = json::from_cbor(std::vector<uint8_t>({0x42, 0xc0, 0xae})));
+            CHECK(_ == json::binary(std::vector<std::uint8_t>({0xc0, 0xae})));
+
+            // valid UTF-8 must still round-trip
+            const json j = "h\xc3\xa9llo, w\xc3\xb6rld! \xe6\x97\xa5\xe6\x9c\xac\xe8\xaa\x9e"; // héllo, wörld! 日本語
+            CHECK(json::from_cbor(json::to_cbor(j)) == j);
+        }
+
        SECTION("strict mode")
        {
            std::vector<uint8_t> const vec = {0xf6, 0xf6};
@@ -8,14 +8,6 @@

 #include "doctest_compatibility.h"

-// capture whether JSON_STRICT_NUL_HANDLING was enabled on the command line
-// (e.g. -DJSON_STRICT_NUL_HANDLING=1) *before* including json.hpp, since the
-// library #undefs JSON_STRICT_NUL_HANDLING itself once the header has been
-// fully processed (see include/nlohmann/detail/macro_unscope.hpp)
-#if defined(JSON_STRICT_NUL_HANDLING) && (JSON_STRICT_NUL_HANDLING == 1)
-    #define JSON_TEST_STRICT_NUL_HANDLING_ENABLED 1
-#endif
-
 #define JSON_TESTS_PRIVATE
 #include <nlohmann/json.hpp>
 using nlohmann::json;
@@ -25,8 +17,6 @@ using nlohmann::json;

 #include <valarray>
 #include <algorithm>
-#include <cstdio>
-#include <fstream>
 #include <list>
 #include <sstream>
 #include <string>
@@ -553,88 +543,6 @@ TEST_CASE("parser class")
            }
        }

-        SECTION("NUL byte handling (issue #5530, JSON_STRICT_NUL_HANDLING)")
-        {
-            // by default, a NUL byte anywhere in the input (not inside a quoted
-            // string, which is covered above) is silently treated the same as
-            // real end of input; JSON_STRICT_NUL_HANDLING (off by default, see
-            // docs/mkdocs/docs/api/macros/json_strict_nul_handling.md) makes a
-            // NUL byte an error like any other unexpected byte instead.
-            //
-            // The two sections below are mutually exclusive: this whole test
-            // binary is compiled once, with JSON_STRICT_NUL_HANDLING either
-            // left at its default or forced to 1 (e.g. by the dedicated
-            // ci_test_strict_nul_handling CI target), so only the section
-            // matching the actual, compiled-in behavior can pass.
-#if !defined(JSON_TEST_STRICT_NUL_HANDLING_ENABLED)
-            SECTION("default behavior (macro not enabled)")
-            {
-                // a NUL byte after a complete value silently truncates the input
-                std::string s = "123";
-                s.push_back('\0');
-                s += "4";
-                CHECK(json::parse(s) == json(123));
-                CHECK(json::accept(s));
-
-                // parsing from a string literal is unaffected either way
-                CHECK(json::parse("123") == json(123));
-            }
-#endif
-
-#if defined(JSON_TEST_STRICT_NUL_HANDLING_ENABLED)
-            SECTION("opt-in strict behavior (JSON_STRICT_NUL_HANDLING == 1)")
-            {
-                // a NUL byte after a complete value is now a parse error,
-                // instead of silently truncating the input
-                {
-                    std::string s = "123";
-                    s.push_back('\0');
-                    json _; // NOLINT(readability-identifier-naming)
-                    CHECK_THROWS_WITH_AS(_ = json::parse(s),
-                                         "[json.exception.parse_error.101] parse error at line 1, column 4: syntax error while parsing value - invalid literal; last read: '123<U+0000>'; expected end of input",
-                                         json::parse_error&);
-                    CHECK_FALSE(json::accept(s));
-                }
-
-                // a NUL byte where a value is expected is now a parse error,
-                // instead of being treated the same as an empty input
-                {
-                    const std::string s(1, '\0');
-                    json _; // NOLINT(readability-identifier-naming)
-                    CHECK_THROWS_WITH_AS(_ = json::parse(s),
-                                         "[json.exception.parse_error.101] parse error at line 1, column 1: syntax error while parsing value - invalid literal; last read: '<U+0000>'",
-                                         json::parse_error&);
-                    CHECK_FALSE(json::accept(s));
-                }
-
-                // a NUL byte inside a // comment no longer stops the comment
-                // scan early; scanning continues correctly past it
-                {
-                    std::string s = "1 // a";
-                    s.push_back('\0');
-                    s += "b\n";
-                    CHECK(json::parse(s, nullptr, true, true) == json(1));
-                    CHECK(json::accept(s, true, true));
-                }
-
-                // a NUL byte inside a /* */ comment no longer stops the
-                // comment scan early either
-                {
-                    std::string s = "1 /* a";
-                    s.push_back('\0');
-                    s += "b */ ";
-                    CHECK(json::parse(s, nullptr, true, true) == json(1));
-                    CHECK(json::accept(s, true, true));
-                }
-
-                // regression guard: parsing from a string literal (which
-                // carries a compiler-appended trailing '\0') still works,
-                // even though a NUL byte is now rejected everywhere else
-                CHECK(json::parse("123") == json(123));
-            }
-#endif
-        }
-
        SECTION("number")
        {
            SECTION("integers")
@@ -1984,13 +1892,7 @@ TEST_CASE("parser class")

        SECTION("from std::array")
        {
-            // NOTE: this array is sized to exactly the length of "true" (unlike
-            // the trailing-NUL-tolerant default behavior elsewhere in this file,
-            // see the "NUL byte handling" section above); a size of 5 here would
-            // leave a value-initialized trailing 0x00 element that is only
-            // silently accepted as end-of-input by default and would fail under
-            // JSON_STRICT_NUL_HANDLING
-            std::array<uint8_t, 4> v { {'t', 'r', 'u', 'e'} };
+            std::array<uint8_t, 5> v { {'t', 'r', 'u', 'e'} };
            json j;
            json::parser(nlohmann::detail::input_adapter(std::begin(v), std::end(v))).parse(true, j);
            CHECK(j == json(true));
@@ -2131,17 +2033,7 @@ TEST_CASE("parser class")
    {
        json _;
        CHECK_THROWS_WITH_AS(_ = json::parse("/a", nullptr, true, true), "[json.exception.parse_error.101] parse error at line 1, column 2: syntax error while parsing value - invalid comment; expecting '/' or '*' after '/'; last read: '/a'", json::parse_error);
-        // "/*" is a string literal, so it carries a compiler-appended trailing
-        // '\0'; by default that NUL is read like any other byte and shows up
-        // in "last read", but JSON_STRICT_NUL_HANDLING trims exactly that one
-        // trailing byte from a char array (see
-        // docs/mkdocs/docs/api/macros/json_strict_nul_handling.md), so it no
-        // longer appears in the message in that state
-#if defined(JSON_TEST_STRICT_NUL_HANDLING_ENABLED)
-        CHECK_THROWS_WITH_AS(_ = json::parse("/*", nullptr, true, true), "[json.exception.parse_error.101] parse error at line 1, column 3: syntax error while parsing value - invalid comment; missing closing '*/'; last read: '/*'", json::parse_error);
-#else
        CHECK_THROWS_WITH_AS(_ = json::parse("/*", nullptr, true, true), "[json.exception.parse_error.101] parse error at line 1, column 3: syntax error while parsing value - invalid comment; missing closing '*/'; last read: '/*<U+0000>'", json::parse_error);
-#endif
    }

 #if JSON_DIAGNOSTIC_POSITIONS
@@ -2367,6 +2259,86 @@ TEST_CASE("parser class")
 #endif
 }

+#if JSON_DIAGNOSTIC_POSITIONS
+
+TEST_CASE("diagnostic positions: value lifetime")
+{
+    SECTION("copy constructor copies positions, recursively")
+    {
+        const std::string s = R"({"a":1,"b":[1,2,3]})";
+        const json a = json::parse(s);
+        const json b = a; // NOLINT(performance-unnecessary-copy-initialization)
+
+        CHECK(b.start_pos() == a.start_pos());
+        CHECK(b.end_pos() == a.end_pos());
+        CHECK(b["b"].start_pos() == a["b"].start_pos());
+        CHECK(b["b"].end_pos() == a["b"].end_pos());
+    }
+
+    SECTION("move constructor resets the moved-from value to npos")
+    {
+        const std::string s = R"({"a":1,"b":[1,2,3]})";
+        json a = json::parse(s);
+        const auto a_start = a.start_pos();
+        const auto a_end = a.end_pos();
+
+        const json b(std::move(a));
+
+        CHECK(b.start_pos() == a_start);
+        CHECK(b.end_pos() == a_end);
+
+        CHECK(a.start_pos() == std::string::npos); // NOLINT(bugprone-use-after-move,clang-analyzer-cplusplus.Move)
+        CHECK(a.end_pos() == std::string::npos); // NOLINT(bugprone-use-after-move,clang-analyzer-cplusplus.Move)
+    }
+
+    SECTION("swap() exchanges positions along with the values")
+    {
+        // basic_json::swap() (and the friend swap() that forwards to it) used
+        // to swap only m_data.m_type/m_data.m_value, leaving
+        // start_position/end_position untouched -- unlike copy-assignment's
+        // operator=(basic_json), which swaps positions as part of its
+        // copy-and-swap implementation. After swap(a, b), each value ended up
+        // with the *other* value's content but its *own* original position.
+        // This is now fixed so that swap() is consistent with copy-assignment.
+        json a = json::parse(R"({"a":1})");
+        json b = json::parse(R"([1,2,3,4,5])");
+        const auto a_start = a.start_pos();
+        const auto a_end = a.end_pos();
+        const auto b_start = b.start_pos();
+        const auto b_end = b.end_pos();
+        // lengths (and thus end positions) differ, which is enough to tell
+        // after the swap whether positions actually moved with the values
+        CHECK(a_end != b_end);
+
+        using std::swap;
+        swap(a, b);
+
+        CHECK(a == json::parse(R"([1,2,3,4,5])"));
+        CHECK(b == json::parse(R"({"a":1})"));
+
+        CHECK(a.start_pos() == b_start);
+        CHECK(a.end_pos() == b_end);
+        CHECK(b.start_pos() == a_start);
+        CHECK(b.end_pos() == a_end);
+
+        // member swap() behaves the same as the free function
+        json c = json::parse(R"({"a":1})");
+        json d = json::parse(R"([1,2,3,4,5])");
+        const auto c_start = c.start_pos();
+        const auto c_end = c.end_pos();
+        const auto d_start = d.start_pos();
+        const auto d_end = d.end_pos();
+
+        c.swap(d);
+
+        CHECK(c.start_pos() == d_start);
+        CHECK(c.end_pos() == d_end);
+        CHECK(d.start_pos() == c_start);
+        CHECK(d.end_pos() == c_end);
+    }
+}
+#endif
+
 // this test relies on parse errors being thrown, so it is skipped when
 // exceptions are disabled (json::parse aborts instead of throwing there)
 #if !defined(JSON_NOEXCEPTION)
@@ -2473,329 +2445,3 @@ TEST_CASE("last-read diagnostics are identical across input adapters")
    }
 }
 #endif // !defined(JSON_NOEXCEPTION)
-
-// this test characterizes the current (documented-by-example, not otherwise
-// specified) behavior of JSON_DIAGNOSTIC_POSITIONS positions with respect to
-// value lifetime (copy/move/swap/mutation), the various input adapters, and
-// user-driven SAX usage. It is regression protection, not a behavior
-// specification: if any of these checks fail after a change to json.hpp,
-// that change deliberately altered observable behavior and the test (and
-// this comment) should be updated accordingly, rather than "fixed" blindly.
-#if JSON_DIAGNOSTIC_POSITIONS
-TEST_CASE("diagnostic positions: value lifetime, input adapters, and SAX")
-{
-    SECTION("value lifetime")
-    {
-        SECTION("copy constructor copies positions, recursively")
-        {
-            // basic_json(const basic_json&) (json.hpp, around line 1192) copies
-            // start_position/end_position for the value itself; nested values
-            // are copied via their own copy constructor (through the copied
-            // object/array container), so positions are preserved throughout
-            // the whole tree.
-            const std::string s = R"({"a":1,"b":[1,2,3]})";
-            const json a = json::parse(s);
-            const json b = a; // NOLINT(performance-unnecessary-copy-initialization)
-
-            CHECK(b.start_pos() == a.start_pos());
-            CHECK(b.end_pos() == a.end_pos());
-            CHECK(b["b"].start_pos() == a["b"].start_pos());
-            CHECK(b["b"].end_pos() == a["b"].end_pos());
-            CHECK(b["b"][0].start_pos() == a["b"][0].start_pos());
-            CHECK(b["b"][0].end_pos() == a["b"][0].end_pos());
-
-            // sanity: the positions are meaningful (not all npos)
-            CHECK(b.start_pos() == 0);
-            CHECK(b.end_pos() == s.size());
-        }
-
-        SECTION("move constructor resets the moved-from value to npos")
-        {
-            // basic_json(basic_json&&) (json.hpp, around line 1265) copies
-            // other's start_position/end_position into *this and then resets
-            // other's to npos (see the cppcheck-suppress[accessForwarded]
-            // annotation there, which flags this reset as worth a second
-            // look). Only the top-level moved-from value is affected; its
-            // (moved-away) children are gone along with it.
-            const std::string s = R"({"a":1,"b":[1,2,3]})";
-            json a = json::parse(s);
-            const auto a_start = a.start_pos();
-            const auto a_end = a.end_pos();
-            const auto nested_start = a["b"].start_pos();
-            const auto nested_end = a["b"].end_pos();
-
-            const json b(std::move(a));
-
-            // the destination retains the original positions, recursively
-            CHECK(b.start_pos() == a_start);
-            CHECK(b.end_pos() == a_end);
-            CHECK(b["b"].start_pos() == nested_start);
-            CHECK(b["b"].end_pos() == nested_end);
-
-            // the moved-from value is reset to a null and reports npos
-            CHECK(a.is_null()); // NOLINT(bugprone-use-after-move,clang-analyzer-cplusplus.Move)
-            CHECK(a.start_pos() == std::string::npos); // NOLINT(bugprone-use-after-move,clang-analyzer-cplusplus.Move)
-            CHECK(a.end_pos() == std::string::npos); // NOLINT(bugprone-use-after-move,clang-analyzer-cplusplus.Move)
-        }
-
-        SECTION("swap() exchanges positions along with values")
-        {
-            // basic_json::swap() (json.hpp, around line 3626, and the friend
-            // swap() that forwards to it) swaps start_position/end_position
-            // together with m_data.m_type and m_data.m_value, so after
-            // swap(a, b) each variable's position describes its own new
-            // content, consistent with copy-assignment's
-            // operator=(basic_json) (json.hpp, around line 1291), which also
-            // swaps positions as part of its copy-and-swap implementation.
-            json a = json::parse(R"({"a":1})");
-            json b = json::parse(R"([1,2,3,4,5])");
-            const auto a_start = a.start_pos();
-            const auto a_end = a.end_pos();
-            const auto b_start = b.start_pos();
-            const auto b_end = b.end_pos();
-            // both start at 0 (root values start right away), but their
-            // lengths (and thus end positions) differ, which is enough to
-            // tell after the swap whether positions actually moved with
-            // the values
-            CHECK(a_end != b_end);
-
-            using std::swap;
-            swap(a, b);
-
-            // values were exchanged as expected ...
-            CHECK(a == json::parse(R"([1,2,3,4,5])"));
-            CHECK(b == json::parse(R"({"a":1})"));
-
-            // ... and so were positions: each variable now carries the
-            // other's original position, describing its own new content
-            CHECK(a.start_pos() == b_start);
-            CHECK(a.end_pos() == b_end);
-            CHECK(b.start_pos() == a_start);
-            CHECK(b.end_pos() == a_end);
-
-            // member swap() behaves the same as the free function
-            json c = json::parse(R"({"a":1})");
-            json d = json::parse(R"([1,2,3,4,5])");
-            const auto c_start = c.start_pos();
-            const auto c_end = c.end_pos();
-            const auto d_start = d.start_pos();
-            const auto d_end = d.end_pos();
-
-            c.swap(d);
-
-            CHECK(c.start_pos() == d_start);
-            CHECK(c.end_pos() == d_end);
-            CHECK(d.start_pos() == c_start);
-            CHECK(d.end_pos() == c_end);
-        }
-
-        SECTION("mutating a parsed document leaves positions of unrelated values untouched")
-        {
-            // Positions are recorded once, during parsing, and are not
-            // recomputed on mutation. As a consequence, after a mutation the
-            // parent's own recorded span may no longer describe its current
-            // (serialized) content -- it still describes what was originally
-            // parsed. This is characterized here as current behavior, not
-            // asserted to be desirable or specified.
-            SECTION("operator[] adding a new object key")
-            {
-                const std::string s = R"({"a":1})";
-                json j = json::parse(s);
-                const auto root_start = j.start_pos();
-                const auto root_end = j.end_pos();
-                const auto a_start = j["a"].start_pos();
-                const auto a_end = j["a"].end_pos();
-
-                j["c"] = 42;
-
-                // the newly-added value was never parsed, so it has no position
-                CHECK(j["c"].start_pos() == std::string::npos);
-                CHECK(j["c"].end_pos() == std::string::npos);
-
-                // the existing sibling's position is unaffected
-                CHECK(j["a"].start_pos() == a_start);
-                CHECK(j["a"].end_pos() == a_end);
-
-                // the parent's own recorded span is left as-is (now stale:
-                // it still reflects the original, shorter `{"a":1}` string)
-                CHECK(j.start_pos() == root_start);
-                CHECK(j.end_pos() == root_end);
-            }
-
-            SECTION("push_back on a parsed array")
-            {
-                const std::string s = R"([1,2,3])";
-                json j = json::parse(s);
-                const auto root_start = j.start_pos();
-                const auto root_end = j.end_pos();
-                const auto first_start = j[0].start_pos();
-
-                j.push_back(4);
-
-                CHECK(j.back().start_pos() == std::string::npos);
-                CHECK(j.back().end_pos() == std::string::npos);
-                CHECK(j[0].start_pos() == first_start);
-                CHECK(j.start_pos() == root_start);
-                CHECK(j.end_pos() == root_end);
-            }
-
-            SECTION("erase on a parsed array shifts elements but keeps their own positions")
-            {
-                const std::string s = R"([1,2,3])";
-                json j = json::parse(s);
-                const auto second_start = j[1].start_pos();
-                const auto third_start = j[2].start_pos();
-                const auto root_start = j.start_pos();
-                const auto root_end = j.end_pos();
-
-                j.erase(0);
-
-                // remaining elements moved down an index, but each one still
-                // reports the position it had *before* the erase (i.e. its
-                // position in the original source string, not a
-                // recalculated one)
-                CHECK(j[0].start_pos() == second_start);
-                CHECK(j[1].start_pos() == third_start);
-
-                // the parent's own recorded span is again left as-is
-                CHECK(j.start_pos() == root_start);
-                CHECK(j.end_pos() == root_end);
-            }
-        }
-    }
-
-    SECTION("input adapters")
-    {
-        SECTION("wide string input: positions count transcoded UTF-8 bytes, not wide characters")
-        {
-            // 'é' (U+00E9) is a single code unit in a wchar_t/UTF-16 string, but
-            // transcodes to 2 bytes in UTF-8; the lexer only ever sees the
-            // transcoded UTF-8 byte stream, so reported positions are byte
-            // offsets into that UTF-8 stream, not indices into the original
-            // std::wstring.
-            // é (rather than a literal 'é' byte sequence in this source
-            // file) so the wide-string literal's meaning does not depend on
-            // the compiler's assumed source character set (MSVC, without
-            // /utf-8, would otherwise decode the raw UTF-8 bytes using the
-            // system code page instead of as UTF-8)
-            const std::wstring ws = L"{\"a\":\"\u00e9\u00e9\"}";
-            CHECK(ws.size() == 10); // 10 wide characters
-
-            const json j = json::parse(ws);
-            CHECK(j.start_pos() == 0);
-            // the transcoded UTF-8 form is 2 bytes longer than the wide string,
-            // because each of the two 'é' characters becomes 2 UTF-8 bytes
-            CHECK(j.end_pos() == 12);
-            CHECK(j.end_pos() != ws.size());
-
-            const json& a = j["a"];
-            CHECK(a.start_pos() == 5);
-            CHECK(a.end_pos() == 11);
-        }
-
-        SECTION("BOM-prefixed input: start_pos() reflects the skipped 3-byte BOM")
-        {
-            const std::string s = "\xEF\xBB\xBF{\"a\":1}";
-            const json j = json::parse(s);
-
-            // the lexer silently skips the BOM before parsing the value, so
-            // the root value's recorded span starts right after it
-            CHECK(j.start_pos() == 3);
-            CHECK(j.end_pos() == s.size());
-        }
-
-        SECTION("std::istringstream: positions are consistent, not npos")
-        {
-            const std::string s = R"({"a":1,"b":2})";
-            std::istringstream ss(s);
-            const json j = json::parse(ss);
-
-            CHECK(j.start_pos() == 0);
-            CHECK(j.end_pos() == s.size());
-            CHECK(j["a"].start_pos() == 5);
-        }
-
-        SECTION("std::ifstream: positions are consistent, not npos")
-        {
-            const std::string s = R"({"a":1,"b":2})";
-            {
-                std::ofstream file("unit-class_parser_diagnostic_positions.tmp");
-                file << s;
-            }
-
-            {
-                std::ifstream f("unit-class_parser_diagnostic_positions.tmp");
-                const json j = json::parse(f);
-
-                CHECK(j.start_pos() == 0);
-                CHECK(j.end_pos() == s.size());
-                CHECK(j["a"].start_pos() == 5);
-            }
-
-            static_cast<void>(std::remove("unit-class_parser_diagnostic_positions.tmp"));
-        }
-
-        SECTION("iterator-pair input: positions are consistent, not npos")
-        {
-            const std::string s = R"({"a":1,"b":2})";
-            const json j = json::parse(s.begin(), s.end());
-
-            CHECK(j.start_pos() == 0);
-            CHECK(j.end_pos() == s.size());
-            CHECK(j["a"].start_pos() == 5);
-        }
-
-        SECTION("binary formats have no text positions")
-        {
-            // binary formats (CBOR, MessagePack, UBJSON, BSON, BJData) are
-            // parsed via detail::binary_reader, which never sets
-            // start_position/end_position on the values it produces (they
-            // have no notion of a text offset), so every value's position
-            // stays at its default of npos.
-            const json src = json::parse(R"({"a":1,"b":[1,2]})");
-
-            const json from_cbor = json::from_cbor(json::to_cbor(src));
-            CHECK(from_cbor.start_pos() == std::string::npos);
-            CHECK(from_cbor.end_pos() == std::string::npos);
-            CHECK(from_cbor["a"].start_pos() == std::string::npos);
-            CHECK(from_cbor["b"][0].start_pos() == std::string::npos);
-
-            const json from_msgpack = json::from_msgpack(json::to_msgpack(src));
-            CHECK(from_msgpack.start_pos() == std::string::npos);
-            CHECK(from_msgpack.end_pos() == std::string::npos);
-
-            const json from_ubjson = json::from_ubjson(json::to_ubjson(src));
-            CHECK(from_ubjson.start_pos() == std::string::npos);
-            CHECK(from_ubjson.end_pos() == std::string::npos);
-
-            const json from_bson_val = json::from_bson(json::to_bson(src));
-            CHECK(from_bson_val.start_pos() == std::string::npos);
-            CHECK(from_bson_val.end_pos() == std::string::npos);
-        }
-    }
-
-    SECTION("user-driven SAX consumers with no lexer report npos")
-    {
-        // json::parse() internally wires up its json_sax_dom_parser with a
-        // pointer to its own lexer (see parser.hpp), which is how positions
-        // get set at all. A user who constructs a json_sax_dom_parser
-        // directly (e.g. to drive it via json::sax_parse()) and does not
-        // supply a lexer pointer gets a consumer with m_lexer_ref == nullptr;
-        // every "if (m_lexer_ref)" guard in json_sax.hpp is then skipped, so
-        // every value it produces keeps its default, unset position (npos).
-        // This was previously true but silently unasserted (operator==
-        // ignores positions), see #5420.
-        json result;
-        nlohmann::detail::json_sax_dom_parser<json, nlohmann::detail::string_input_adapter_type> sdp(result);
-        const std::string s = R"({"a":1,"b":[1,2,3]})";
-        CHECK(json::sax_parse(s, &sdp));
-
-        CHECK(result.start_pos() == std::string::npos);
-        CHECK(result.end_pos() == std::string::npos);
-        CHECK(result["a"].start_pos() == std::string::npos);
-        CHECK(result["a"].end_pos() == std::string::npos);
-        CHECK(result["b"][0].start_pos() == std::string::npos);
-        CHECK(result["b"][0].end_pos() == std::string::npos);
-    }
-}
-#endif
@@ -1792,40 +1792,6 @@ TEST_CASE("std::filesystem::path")
 }
 #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
-
 TEST_CASE("std::optional")
 {
    SECTION("null")
@@ -8,14 +8,6 @@

 #include "doctest_compatibility.h"

-// capture whether JSON_STRICT_NUL_HANDLING was enabled on the command line
-// (e.g. -DJSON_STRICT_NUL_HANDLING=1) *before* including json.hpp, since the
-// library #undefs JSON_STRICT_NUL_HANDLING itself once the header has been
-// fully processed (see include/nlohmann/detail/macro_unscope.hpp)
-#if defined(JSON_STRICT_NUL_HANDLING) && (JSON_STRICT_NUL_HANDLING == 1)
-    #define JSON_TEST_STRICT_NUL_HANDLING_ENABLED 1
-#endif
-
 #include <nlohmann/json.hpp>
 using nlohmann::json;
 #ifdef JSON_TEST_NO_GLOBAL_UDLS
@@ -331,23 +323,6 @@ TEST_CASE("deserialization")
            CHECK(j == json({"foo", 1, 2, 3, false, {{"one", 1}}}));
        }

-        SECTION("operator>> with a NUL byte after the value (issue #5530)")
-        {
-            // operator>> parses non-strictly (it does not require the whole
-            // stream to be consumed), so a NUL byte following a complete
-            // value is simply left unread on the stream and never reaches
-            // the "expected end of input" check that JSON_STRICT_NUL_HANDLING
-            // affects; this holds regardless of the macro (verified below for
-            // the opt-in state as well)
-            std::string data = "123";
-            data.push_back('\0');
-            std::istringstream ss(data);
-            json j;
-            ss >> j;
-            CHECK(j == json(123));
-            CHECK(ss.good());
-        }
-
        SECTION("user-defined string literal")
        {
            CHECK("[\"foo\",1,2,3,false,{\"one\":1}]"_json == json({"foo", 1, 2, 3, false, {{"one", 1}}}));
@@ -430,27 +405,6 @@ TEST_CASE("deserialization")
            CHECK_THROWS_WITH_AS(ss >> j, "[json.exception.parse_error.101] parse error at line 1, column 29: syntax error while parsing array - unexpected end of input; expected ']'", json::parse_error&);
        }

-#if defined(JSON_TEST_STRICT_NUL_HANDLING_ENABLED)
-        SECTION("operator>> with a NUL byte where a value is expected (JSON_STRICT_NUL_HANDLING == 1, issue #5530)")
-        {
-            // a trailing NUL byte *after* a complete value is unaffected by the
-            // macro (see the successful-deserialization "operator>> with a NUL
-            // byte after the value" section above): operator>> parses
-            // non-strictly and never reaches the "expected end of input" check
-            // that the macro changes. A NUL byte where a *value* is expected,
-            // however, goes through the same token dispatch as any other input
-            // and is affected: with the macro enabled it now raises
-            // parse_error.101 (like any other unrecognized byte) instead of
-            // being silently treated the same as an empty stream.
-            std::string const data(1, '\0');
-            std::istringstream ss(data);
-            json j;
-            CHECK_THROWS_WITH_AS(ss >> j,
-                                 "[json.exception.parse_error.101] parse error at line 1, column 1: syntax error while parsing value - invalid literal; last read: '<U+0000>'",
-                                 json::parse_error&);
-        }
-#endif
-
        SECTION("user-defined string literal")
        {
            CHECK_THROWS_WITH_AS("[\"foo\",1,2,3,false,{\"one\":1}"_json, "[json.exception.parse_error.101] parse error at line 1, column 29: syntax error while parsing array - unexpected end of input; expected ']'", json::parse_error&);
@@ -499,11 +453,7 @@ TEST_CASE("deserialization")

            SECTION("from std::array")
            {
-                // sized to exactly the length of "true": a size of 5 would leave
-                // a value-initialized trailing 0x00 element that is only
-                // silently accepted as end-of-input by default and would fail
-                // under JSON_STRICT_NUL_HANDLING
-                std::array<uint8_t, 4> const v { {'t', 'r', 'u', 'e'} };
+                std::array<uint8_t, 5> const v { {'t', 'r', 'u', 'e'} };
                CHECK(json::parse(v) == json(true));
                CHECK(json::accept(v));

@@ -599,9 +549,7 @@ TEST_CASE("deserialization")

            SECTION("from std::array")
            {
-                // sized to exactly the length of "true", see the analogous
-                // "from std::array" section above for why
-                std::array<uint8_t, 4> v { {'t', 'r', 'u', 'e'} };
+                std::array<uint8_t, 5> v { {'t', 'r', 'u', 'e'} };
                CHECK(json::parse(std::begin(v), std::end(v)) == json(true));
                CHECK(json::accept(std::begin(v), std::end(v)));

@@ -75,72 +75,6 @@ TEST_CASE("Better diagnostics with positions")
        CHECK(j.end_pos() == root.size());
    }

-    SECTION("copying keeps the positions of nested values (#5387)")
-    {
-        // Values nested deeper than the copy constructor's descent bound are
-        // copied without the call stack, on a path that has to carry the
-        // positions over itself; shallower ones copy their containers, which
-        // bring the positions along. Both sides of the bound are checked here.
-        const auto check_copy = [](std::size_t depth, bool objects)
-        {
-            CAPTURE(depth)
-            CAPTURE(objects)
-
-            const std::string opening = objects ? R"({"a":)" : "[";
-            const std::string closing = objects ? "}" : "]";
-
-            std::string text;
-            for (std::size_t i = 0; i < depth; ++i)
-            {
-                text += opening;
-            }
-            text += "12";
-            for (std::size_t i = 0; i < depth; ++i)
-            {
-                text += closing;
-            }
-
-            const json original = json::parse(text);
-            const json copy(original); // NOLINT(performance-unnecessary-copy-initialization)
-
-            const json* o = &original;
-            const json* c = &copy;
-            for (std::size_t level = 0; level <= depth; ++level)
-            {
-                CAPTURE(level)
-                REQUIRE(c->start_pos() == o->start_pos());
-                REQUIRE(c->end_pos() == o->end_pos());
-
-                if (level < depth)
-                {
-                    o = objects ? &o->at("a") : &o->at(0);
-                    c = objects ? &c->at("a") : &c->at(0);
-                }
-            }
-        };
-
-        const auto check_arrays = [&check_copy](std::size_t depth)
-        {
-            check_copy(depth, false);
-        };
-        const auto check_objects = [&check_copy](std::size_t depth)
-        {
-            check_copy(depth, true);
-        };
-
-        check_arrays(1);
-        check_arrays(127);
-        check_arrays(128);
-        check_arrays(129);
-        check_arrays(300);
-
-        check_objects(1);
-        check_objects(127);
-        check_objects(128);
-        check_objects(129);
-        check_objects(300);
-    }
-
    SECTION("JSON patch add to primitive parent (#4292)")
    {
        // the JSON Patch "add" target /foo/bar/baz has a string parent
@@ -274,63 +274,6 @@ TEST_CASE("Regression tests for extended diagnostics")
        CHECK(j1["string"] == "t");
    }

-    SECTION("Regression test for issue #5387 - copying keeps the parents of nested values")
-    {
-        // A value nested deeper than the copy constructor's descent bound is
-        // copied without the call stack. Every container that path creates has
-        // to have the parents of its children set, or the JSON Pointer in the
-        // diagnostic is cut short.
-        const std::size_t depth = 300;
-
-        SECTION("objects")
-        {
-            json j = "not a number";
-            std::string pointer;
-            for (std::size_t i = 0; i < depth; ++i)
-            {
-                j = json{{"a", j}};
-                pointer += "/a";
-            }
-
-            json const copy(j); // NOLINT(performance-unnecessary-copy-initialization)
-
-            const json* inner = &copy;
-            for (std::size_t i = 0; i < depth; ++i)
-            {
-                inner = &inner->at("a");
-            }
-
-            std::string const expected = "[json.exception.type_error.302] (" + pointer + ") type must be number, but is string";
-            int i = 0;
-            CHECK_THROWS_WITH_AS(i = inner->get<int>(), expected.c_str(), json::type_error);
-            CHECK(i == 0);
-        }
-
-        SECTION("arrays")
-        {
-            json j = "not a number";
-            std::string pointer;
-            for (std::size_t i = 0; i < depth; ++i)
-            {
-                j = json::array({j});
-                pointer += "/0";
-            }
-
-            json const copy(j); // NOLINT(performance-unnecessary-copy-initialization)
-
-            const json* inner = &copy;
-            for (std::size_t i = 0; i < depth; ++i)
-            {
-                inner = &inner->at(0);
-            }
-
-            std::string const expected = "[json.exception.type_error.302] (" + pointer + ") type must be number, but is string";
-            int i = 0;
-            CHECK_THROWS_WITH_AS(i = inner->get<int>(), expected.c_str(), json::type_error);
-            CHECK(i == 0);
-        }
-    }
-
    SECTION("Regression test - swap(array_t&)/swap(object_t&) must update JSON_DIAGNOSTICS parent pointers")
    {
        // swap(array_t&)
@@ -363,52 +306,3 @@ TEST_CASE("Regression tests for extended diagnostics")
    }
 }

-TEST_CASE("Better diagnostics past the descent bound of update() and merge_patch()")
-{
-    // Both merge objects nested more than detail::recursion_depth_limit()
-    // (128) levels deep without recursing; the values they add or replace
-    // there must still know their parents.
-    // The values are built rather than parsed, so that the expected messages
-    // carry no byte positions under JSON_DIAGNOSTIC_POSITIONS.
-    const std::size_t depth = 200;
-    json target = {{"x", 1}};
-    json patch = {{"y", 2}};
-    std::string path;
-    for (std::size_t i = 0; i < depth; ++i)
-    {
-        target = json{{"a", std::move(target)}};
-        patch = json{{"a", std::move(patch)}};
-        path += "/a";
-    }
-    const std::string expected_x = "[json.exception.type_error.304] (" + path + "/x) cannot use at() with number";
-    const std::string expected_y = "[json.exception.type_error.304] (" + path + "/y) cannot use at() with number";
-
-    SECTION("update()")
-    {
-        json j = target;
-        j.update(patch, true);
-
-        // walk down through const references, which leave m_parent alone
-        const json* p = &j;
-        for (std::size_t i = 0; i < depth; ++i)
-        {
-            p = &p->at("a");
-        }
-        CHECK_THROWS_WITH_AS(p->at("x").at(0), expected_x.c_str(), json::type_error);
-        CHECK_THROWS_WITH_AS(p->at("y").at(0), expected_y.c_str(), json::type_error);
-    }
-
-    SECTION("merge_patch()")
-    {
-        json j = target;
-        j.merge_patch(patch);
-
-        const json* p = &j;
-        for (std::size_t i = 0; i < depth; ++i)
-        {
-            p = &p->at("a");
-        }
-        CHECK_THROWS_WITH_AS(p->at("x").at(0), expected_x.c_str(), json::type_error);
-        CHECK_THROWS_WITH_AS(p->at("y").at(0), expected_y.c_str(), json::type_error);
-    }
-}
@@ -13,78 +13,6 @@ using json = nlohmann::json;
 using ordered_json = nlohmann::ordered_json;

 #include <set>
-#include <string>
-
-namespace
-{
-// how detail::hash defines the hash of an array or object: the seeds of the
-// elements, combined in order. Recursive, so only usable on values nested a
-// few hundred levels deep - which is exactly what is needed to check that the
-// iterative path taken below detail::recursion_depth_limit() computes the same.
-template<typename BasicJsonType>
-std::size_t reference_hash(const BasicJsonType& j)
-{
-    using nlohmann::detail::combine;
-    using string_t = typename BasicJsonType::string_t;
-
-    if (!j.is_structured())
-    {
-        return std::hash<BasicJsonType> {}(j);
-    }
-
-    auto seed = combine(static_cast<std::size_t>(j.type()), j.size());
-    for (const auto& element : j.items())
-    {
-        if (j.is_object())
-        {
-            seed = combine(seed, std::hash<string_t> {}(element.key()));
-        }
-        seed = combine(seed, reference_hash(element.value()));
-    }
-    return seed;
-}
-
-// a value nested `depth` levels deep, with siblings on every level
-template<typename BasicJsonType>
-BasicJsonType nested(const std::size_t depth, const bool objects)
-{
-    BasicJsonType value = "leaf";
-    for (std::size_t i = 0; i < depth; ++i)
-    {
-        if (objects)
-        {
-            value = BasicJsonType{{"before", i}, {"nested", std::move(value)}, {"after", {i, "x"}}};
-        }
-        else
-        {
-            value = BasicJsonType::array({i, std::move(value), BasicJsonType::object({{"k", i}})});
-        }
-    }
-    return value;
-}
-
-std::string nested_text(const std::size_t depth, const bool objects)
-{
-    std::string text;
-    if (objects)
-    {
-        text.reserve((6 * depth) + 1);
-        for (std::size_t i = 0; i < depth; ++i)
-        {
-            text += "{\"a\":";
-        }
-        text += "1";
-        text.append(depth, '}');
-    }
-    else
-    {
-        text.assign(depth, '[');
-        text += "1";
-        text.append(depth, ']');
-    }
-    return text;
-}
-} // namespace

 TEST_CASE("hash<nlohmann::json>")
 {
@@ -183,44 +111,3 @@ TEST_CASE("hash<nlohmann::ordered_json>")

    CHECK(hashes.size() == 21);
 }
-
-TEST_CASE("hash of deeply nested values")
-{
-    SECTION("hashing past the descent bound computes the same values")
-    {
-        // every depth on either side of where the iterative path takes over
-        for (std::size_t depth = 0; depth <= (2 * nlohmann::detail::recursion_depth_limit()) + 10; ++depth)
-        {
-            CAPTURE(depth);
-            const auto arrays = nested<json>(depth, false);
-            const auto objects = nested<json>(depth, true);
-            const auto ordered = nested<ordered_json>(depth, true);
-            CHECK(std::hash<json> {}(arrays) == reference_hash(arrays));
-            CHECK(std::hash<json> {}(objects) == reference_hash(objects));
-            CHECK(std::hash<ordered_json> {}(ordered) == reference_hash(ordered));
-        }
-    }
-
-    SECTION("values nested too deeply for the call stack (#5545)")
-    {
-        // recursing once per level used to exhaust the call stack here; the
-        // values are only parsed and hashed, never copied or compared, since
-        // those recurse as well
-        const std::size_t depth = 100000;
-        for (const bool objects :
-                {
-                    false, true
-                })
-        {
-            CAPTURE(objects);
-            const auto text = nested_text(depth, objects);
-            const auto a = json::parse(text);
-            const auto b = json::parse(text);
-            CHECK(std::hash<json> {}(a) == std::hash<json> {}(b));
-
-            const auto c = ordered_json::parse(text);
-            const auto d = ordered_json::parse(text);
-            CHECK(std::hash<ordered_json> {}(c) == std::hash<ordered_json> {}(d));
-        }
-    }
-}
@@ -672,102 +672,6 @@ TEST_CASE("JSON patch")
        }
    }

-    SECTION("patch_inplace")
-    {
-        SECTION("happy path: patch_inplace mirrors patch() on success")
-        {
-            // mirrors "A.5. Replacing a Value" above, but applies the patch with
-            // patch_inplace() to a mutable copy instead of using patch()'s
-            // returned copy
-            json doc = R"(
-                    {
-                        "baz": "qux",
-                        "foo": "bar"
-                    }
-                )"_json;
-
-            json const patch = R"(
-                    [
-                        { "op": "replace", "path": "/baz", "value": "boo" }
-                    ]
-                )"_json;
-
-            json const expected = R"(
-                    {
-                        "baz": "boo",
-                        "foo": "bar"
-                    }
-                )"_json;
-
-            doc.patch_inplace(patch);
-            CHECK(doc == expected);
-        }
-
-        // this test relies on the "test" operation actually throwing so the
-        // partial-application state can be observed right after the throw
-        // point; under JSON_NOEXCEPTION, JSON_THROW() calls std::abort()
-        // instead (there is no C++ exception to throw), and doctest's
-        // CHECK_THROWS_AS() is compiled out to a no-op that never even
-        // invokes the given expression (see doctest's "--no-throw" test
-        // filter, which ci_test_noexceptions passes) -- so patch()/
-        // patch_inplace() would never be called at all and the follow-up
-        // state assertions below would fail against the untouched original
-#if !defined(JSON_NOEXCEPTION)
-        SECTION("distinguishing contract vs patch(): partial application on failure")
-        {
-            // Unlike patch(), which is all-or-nothing because it applies the
-            // patch to an internal copy that is simply discarded when an
-            // exception is thrown (leaving the original untouched no matter
-            // what), patch_inplace() mutates the document it is called on
-            // directly and immediately, operation by operation. So if a JSON
-            // Patch fails partway through, whatever operations already
-            // succeeded remain applied -- the document is left in a partially
-            // patched state. This is empirically verified current behavior,
-            // not just documented intent, and is pinned here as such.
-            json const original = R"(
-                    {
-                        "baz": "qux",
-                        "foo": "bar"
-                    }
-                )"_json;
-
-            // the first operation ("replace") succeeds; the second ("test")
-            // fails because the value at "/baz" no longer (and never did)
-            // equal "not boo"
-            json const patch = R"(
-                    [
-                        { "op": "replace", "path": "/baz", "value": "boo" },
-                        { "op": "test", "path": "/baz", "value": "not boo" }
-                    ]
-                )"_json;
-
-            // patch() never modifies the object it is called on -- it always
-            // operates on (and returns) a separate copy, so the original is
-            // left completely untouched, regardless of success or failure.
-            // copy_for_patch is intentionally a real copy, not a reference
-            // to `original`: the whole point of this check is to catch a
-            // hypothetical future regression where patch() *does* mutate its
-            // receiver. Using a reference here would make the assertion
-            // below compare `original` to itself -- trivially true even if
-            // such a bug existed -- which is exactly what a static analyzer
-            // can't see when it suggests "this copy is never modified, use
-            // a reference instead".
-            json copy_for_patch = original; // NOLINT(performance-unnecessary-copy-initialization)
-            CHECK_THROWS_AS(copy_for_patch.patch(patch), json::other_error&);
-            CHECK(copy_for_patch == original);
-
-            // patch_inplace(), in contrast, already applied the successful
-            // "replace" operation to the document before the "test" operation
-            // threw -- that change is not rolled back
-            json doc = original;
-            CHECK_THROWS_AS(doc.patch_inplace(patch), json::other_error&);
-            CHECK(doc != original);
-            CHECK(doc.at("baz") == "boo");
-            CHECK(doc.at("foo") == "bar");
-        }
-#endif // !defined(JSON_NOEXCEPTION)
-    }
-
    SECTION("errors")
    {
        SECTION("unknown operation")
@@ -12,7 +12,6 @@
 using nlohmann::json;

 #include <algorithm>
-#include <string>

 TEST_CASE("tests on very large JSONs")
 {
@@ -28,153 +27,3 @@ TEST_CASE("tests on very large JSONs")
    }
 }

-namespace
-{
-
-// Descend a chain of single-element containers and return the value at its end,
-// reporting the number of levels traversed in @a depth.
-//
-// The values in the test case below are nested far deeper than the call stack
-// can follow, so they must not be inspected with operator== or dump(): both are
-// still recursive and would overflow the stack themselves.
-const json* innermost_value(const json& j, std::size_t& depth)
-{
-    const json* current = &j;
-    depth = 0;
-
-    while ((current->is_array() || current->is_object()) && !current->empty())
-    {
-        current = current->is_array()
-                  ? &current->front()
-                  : &current->begin().value();
-        ++depth;
-    }
-
-    return current;
-}
-
-} // namespace
-
-TEST_CASE("tests on deeply nested JSONs")
-{
-    // deep enough to exhaust the call stack, but small enough to stay cheap:
-    // parsing is iterative, so building the values below costs little
-    const std::size_t depth = 100000;
-
-    SECTION("issue #5387 - stack overflow in the copy constructor")
-    {
-        SECTION("array")
-        {
-            const json j = json::parse(std::string(depth, '[') + '0' + std::string(depth, ']'));
-
-            const json copy(j); // NOLINT(performance-unnecessary-copy-initialization): the copy is what is tested
-
-            std::size_t copy_depth = 0;
-            CHECK(*innermost_value(copy, copy_depth) == 0);
-            CHECK(copy_depth == depth);
-        }
-
-        SECTION("object")
-        {
-            std::string s;
-            s.reserve((6 * depth) + 1);
-            for (std::size_t i = 0; i < depth; ++i)
-            {
-                s += "{\"a\":";
-            }
-            s += '1';
-            s.append(depth, '}');
-
-            const json j = json::parse(s);
-
-            const json copy(j); // NOLINT(performance-unnecessary-copy-initialization): the copy is what is tested
-
-            std::size_t copy_depth = 0;
-            CHECK(*innermost_value(copy, copy_depth) == 1);
-            CHECK(copy_depth == depth);
-        }
-
-        SECTION("copy assignment")
-        {
-            // operator=(basic_json) takes its argument by value, so the deep
-            // copy happens in the copy constructor
-            const json j = json::parse(std::string(depth, '[') + '0' + std::string(depth, ']'));
-
-            json target;
-            target = j;
-
-            std::size_t target_depth = 0;
-            CHECK(*innermost_value(target, target_depth) == 0);
-            CHECK(target_depth == depth);
-        }
-
-        SECTION("depths around the bound of the recursive descent")
-        {
-            // The copy constructor descends into a bounded number of levels and
-            // completes whatever is below that without the call stack. Cover
-            // every depth around that bound, so that the two ways of copying
-            // are known to meet cleanly - wherever the bound is set.
-            for (std::size_t d = 1; d <= 300; ++d)
-            {
-                CAPTURE(d);
-
-                const json array = json::parse(std::string(d, '[') + '0' + std::string(d, ']'));
-                const json array_copy(array); // NOLINT(performance-unnecessary-copy-initialization): the copy is what is tested
-                std::size_t array_depth = 0;
-                CHECK(*innermost_value(array_copy, array_depth) == 0);
-                CHECK(array_depth == d);
-
-                std::string object_text;
-                for (std::size_t i = 0; i < d; ++i)
-                {
-                    object_text += "{\"a\":";
-                }
-                object_text += '1';
-                object_text.append(d, '}');
-
-                const json object = json::parse(object_text);
-                const json object_copy(object); // NOLINT(performance-unnecessary-copy-initialization): the copy is what is tested
-                std::size_t object_depth = 0;
-                CHECK(*innermost_value(object_copy, object_depth) == 1);
-                CHECK(object_depth == d);
-            }
-        }
-
-        SECTION("a value that is deep in one place only")
-        {
-            json j = json::object();
-            j["shallow"] = 1;
-            j["deep"] = json::parse(std::string(depth, '[') + '0' + std::string(depth, ']'));
-            j["also_shallow"] = json::array({1, 2, 3});
-
-            const json copy(j);
-
-            CHECK(copy["shallow"] == 1);
-            CHECK(copy["also_shallow"] == json::array({1, 2, 3}));
-
-            std::size_t deep_depth = 0;
-            CHECK(*innermost_value(copy["deep"], deep_depth) == 0);
-            CHECK(deep_depth == depth);
-        }
-
-        SECTION("the copy is independent of the original")
-        {
-            const json j = json::parse(std::string(depth, '[') + '0' + std::string(depth, ']'));
-
-            json copy(j);
-
-            // reach the innermost value without recursing and replace it
-            json* current = &copy;
-            while (current->is_array() && !current->empty())
-            {
-                current = &current->front();
-            }
-            *current = 42;
-
-            std::size_t unused = 0;
-            CHECK(*innermost_value(copy, unused) == 42);
-            CHECK(*innermost_value(j, unused) == 0);
-        }
-    }
-}
-
@@ -14,60 +14,6 @@ using nlohmann::json;
    using namespace nlohmann::literals; // NOLINT(google-build-using-namespace)
 #endif

-#include <string>
-
-namespace
-{
-// RFC 7396's MergePatch, written recursively as in the RFC; only usable on
-// values nested a few hundred levels deep
-void reference_merge_patch(json& target, const json& patch)
-{
-    if (!patch.is_object())
-    {
-        target = patch;
-        return;
-    }
-    if (!target.is_object())
-    {
-        target = json::object();
-    }
-    for (auto it = patch.begin(); it != patch.end(); ++it)
-    {
-        if (it.value().is_null())
-        {
-            target.erase(it.key());
-        }
-        else
-        {
-            reference_merge_patch(target[it.key()], it.value());
-        }
-    }
-}
-
-// objects nested `depth` levels deep under the key "a", with members that
-// differ by `variant` on the way down
-std::string nested_objects(const std::size_t depth, const int variant)
-{
-    std::string text;
-    for (std::size_t i = 0; i < depth; ++i)
-    {
-        text += "{";
-        if ((i + static_cast<std::size_t>(variant)) % 3 == 0)
-        {
-            text += "\"s" + std::to_string(variant) + "\":" + std::to_string(i) + ",";
-        }
-        if (variant == 2 && i % 5 == 0)
-        {
-            text += "\"s0\":null,";
-        }
-        text += "\"a\":";
-    }
-    text += variant == 1 ? "{\"x\":1,\"y\":null}" : "{\"y\":2}";
-    text.append(depth, '}');
-    return text;
-}
-} // namespace
-
 TEST_CASE("JSON Merge Patch")
 {
    SECTION("examples from RFC 7396")
@@ -296,52 +242,3 @@ TEST_CASE("JSON Merge Patch")
        }
    }
 }
-
-TEST_CASE("JSON Merge Patch on deeply nested values")
-{
-    SECTION("patching past the descent bound gives the same result")
-    {
-        // every depth on either side of where the iterative version takes
-        // over (detail::recursion_depth_limit(), 128)
-        for (std::size_t depth = 0; depth <= 300; ++depth)
-        {
-            CAPTURE(depth);
-            for (int variant = 0; variant < 3; ++variant)
-            {
-                CAPTURE(variant);
-                const json patch = json::parse(nested_objects(depth, variant));
-
-                json result = json::parse(nested_objects(depth, (variant + 1) % 3));
-                json expected = result;
-                result.merge_patch(patch);
-                reference_merge_patch(expected, patch);
-                CHECK(result == expected);
-
-                // a target that is not an object, and an empty one
-                json from_null;
-                from_null.merge_patch(patch);
-                json expected_from_null;
-                reference_merge_patch(expected_from_null, patch);
-                CHECK(from_null == expected_from_null);
-            }
-        }
-    }
-
-    SECTION("patches nested too deeply for the call stack (#5393)")
-    {
-        // 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(depth, 0));
-        target.merge_patch(json::parse(nested_objects(depth, 1)));
-
-        const json* p = &target;
-        for (std::size_t i = 0; i < depth; ++i)
-        {
-            p = &p->at("a");
-        }
-        // {"y":2} patched with {"x":1,"y":null}
-        CHECK(p->size() == 1);
-        CHECK(p->at("x") == 1);
-    }
-}
@@ -11,53 +11,6 @@
 #include <nlohmann/json.hpp>
 using nlohmann::json;

-#include <string>
-
-namespace
-{
-// update(source, true) as documented, written recursively; only usable on
-// values nested a few hundred levels deep
-void reference_update(json& target, const json& source)
-{
-    for (auto it = source.begin(); it != source.end(); ++it)
-    {
-        const auto existing = target.find(it.key());
-        if (it.value().is_object() && existing != target.end() && existing->is_object())
-        {
-            reference_update(*existing, it.value());
-        }
-        else
-        {
-            target[it.key()] = it.value();
-        }
-    }
-}
-
-// objects nested `depth` levels deep under the key "a", with members that
-// differ by `variant` on the way down
-std::string nested_objects(const std::size_t depth, const int variant)
-{
-    std::string text;
-    for (std::size_t i = 0; i < depth; ++i)
-    {
-        text += "{";
-        if ((i + static_cast<std::size_t>(variant)) % 3 == 0)
-        {
-            text += "\"s" + std::to_string(variant) + "\":" + std::to_string(i) + ",";
-        }
-        if (variant == 2 && i % 5 == 0)
-        {
-            // an object replacing a primitive, which is not merged
-            text += "\"s0\":{\"o\":1},";
-        }
-        text += "\"a\":";
-    }
-    text += variant == 1 ? "{\"x\":1}" : "{\"y\":2}";
-    text.append(depth, '}');
-    return text;
-}
-} // namespace
-
 TEST_CASE("modifiers")
 {
    SECTION("clear()")
@@ -688,20 +641,6 @@ TEST_CASE("modifiers")
                CHECK_THROWS_WITH_AS(j_array.insert(j_array.end(), j_other_array.begin(), j_other_array2.end()), "[json.exception.invalid_iterator.210] iterators do not fit",
                                     json::invalid_iterator&);
            }
-
-            SECTION("iterators not pointing into an array")
-            {
-                json j_object2 = {{"k", 1}, {"l", 2}};
-                json j_primitive = 5;
-                json j_null;
-
-                CHECK_THROWS_WITH_AS(j_array.insert(j_array.begin(), j_object2.begin(), j_object2.end()), "[json.exception.invalid_iterator.202] iterators first and last must point to arrays",
-                                     json::invalid_iterator&);
-                CHECK_THROWS_WITH_AS(j_array.insert(j_array.begin(), j_primitive.begin(), j_primitive.end()), "[json.exception.invalid_iterator.202] iterators first and last must point to arrays",
-                                     json::invalid_iterator&);
-                CHECK_THROWS_WITH_AS(j_array.insert(j_array.begin(), j_null.begin(), j_null.end()), "[json.exception.invalid_iterator.202] iterators first and last must point to arrays",
-                                     json::invalid_iterator&);
-            }
        }

        SECTION("range for object")
@@ -1035,44 +974,3 @@ TEST_CASE("modifiers")
        }
    }
 }
-
-TEST_CASE("update() on deeply nested values")
-{
-    SECTION("merging past the descent bound gives the same result")
-    {
-        // every depth on either side of where the iterative version takes
-        // over (detail::recursion_depth_limit(), 128)
-        for (std::size_t depth = 0; depth <= 300; ++depth)
-        {
-            CAPTURE(depth);
-            for (int variant = 0; variant < 3; ++variant)
-            {
-                CAPTURE(variant);
-                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);
-                CHECK(result == expected);
-            }
-        }
-    }
-
-    SECTION("objects nested too deeply for the call stack (#5545)")
-    {
-        // 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(depth, 0));
-        target.update(json::parse(nested_objects(depth, 1)), true);
-
-        const json* p = &target;
-        for (std::size_t i = 0; i < depth; ++i)
-        {
-            p = &p->at("a");
-        }
-        CHECK(p->size() == 2);
-        CHECK(p->at("x") == 1);
-        CHECK(p->at("y") == 2);
-    }
-}
@@ -1554,6 +1554,27 @@ TEST_CASE("MessagePack")
            CHECK(json::from_msgpack(std::vector<uint8_t>({0x81, 0xff, 0x01}), true, false).is_discarded());
        }

+        SECTION("invalid UTF-8 in string (see #5529)")
+        {
+            // a fixstr of length 2 (0xA0 | 2) whose bytes are not valid UTF-8
+            // (0xC0 0xAE is an overlong encoding of '.') must be rejected at
+            // decode time, matching every other kind of malformed binary
+            // input, rather than only failing later when the resulting
+            // value is dumped
+            json _;
+            CHECK_THROWS_WITH_AS(_ = json::from_msgpack(std::vector<uint8_t>({0xa2, 0xc0, 0xae})), "[json.exception.parse_error.113] parse error at byte 3: syntax error while parsing MessagePack string: invalid string: ill-formed UTF-8 byte", json::parse_error&);
+            CHECK(json::from_msgpack(std::vector<uint8_t>({0xa2, 0xc0, 0xae}), true, false).is_discarded());
+
+            // a MessagePack bin8 blob with the very same bytes is NOT text
+            // and must still be accepted as-is
+            CHECK_NOTHROW(_ = json::from_msgpack(std::vector<uint8_t>({0xc4, 0x02, 0xc0, 0xae})));
+            CHECK(_ == json::binary(std::vector<std::uint8_t>({0xc0, 0xae})));
+
+            // valid UTF-8 must still round-trip
+            const json j = "h\xc3\xa9llo, w\xc3\xb6rld! \xe6\x97\xa5\xe6\x9c\xac\xe8\xaa\x9e"; // héllo, wörld! 日本語
+            CHECK(json::from_msgpack(json::to_msgpack(j)) == j);
+        }
+
        SECTION("strict mode")
        {
            std::vector<uint8_t> const vec = {0xc0, 0xc0};
@@ -1682,21 +1703,6 @@ TEST_CASE("issue #5405 - array reserve for definite-length MessagePack arrays")
    }
 }

-TEST_CASE("regression test - MessagePack ext type rejects a subtype that doesn't fit a single byte")
-{
-    // subtype 0-255 must still round-trip correctly (regression guard, pre-existing behavior)
-    CHECK(json::from_msgpack(json::to_msgpack(json::binary({1, 2}, 0))).get_binary().subtype() == 0);
-    CHECK(json::from_msgpack(json::to_msgpack(json::binary({1, 2}, 200))).get_binary().subtype() == 200);
-    CHECK(json::from_msgpack(json::to_msgpack(json::binary({1, 2}, 255))).get_binary().subtype() == 255);
-
-    // a subtype > 255 must throw instead of silently truncating
-    CHECK_THROWS_AS(json::to_msgpack(json::binary({1, 2}, 256)), json::out_of_range);
-    CHECK_THROWS_WITH_AS(json::to_msgpack(json::binary({1, 2}, 70000)), "[json.exception.out_of_range.415] subtype 70000 is too large for the MessagePack ext type (max 255)", json::out_of_range);
-
-    // a binary value with no subtype at all must be unaffected
-    CHECK(json::from_msgpack(json::to_msgpack(json::binary({1, 2}))).get_binary().has_subtype() == false);
-}
-
 // use this testcase outside [hide] to run it with Valgrind
 TEST_CASE("MessagePack nesting does not consume the call stack")
 {
@@ -70,7 +70,7 @@ TEST_CASE("check_for_mem_leak_on_adl_to_json-2")
    }
 }

-TEST_CASE("check_for_mem_leak_on_adl_to_json-3")
+TEST_CASE("check_for_mem_leak_on_adl_to_json-2")
 {
    try
    {
@@ -1,91 +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 translation unit is a dedicated, small compile-and-run check for two
-// configuration macros that (per #5423) were never exercised anywhere in the
-// test matrix:
-// - JSON_NO_IO, which removes the library's <istream>/<ostream> support
-//   (operator<<, operator>>, and the stream-based overloads of dump()/parse())
-// - the JSON_THROW_USER / JSON_TRY_USER / JSON_CATCH_USER trio, which lets a
-//   user replace the library's internal exception handling
-//
-// Both macros are about excluding/replacing a facility the library would
-// otherwise pull in on its own, and defining one has no bearing on the other,
-// so -- to keep the test matrix small -- they are exercised together in a
-// single dedicated file instead of two.
-//
-// JSON_NO_IO requires this file itself to never rely on <iostream>/<sstream>;
-// only string-based parsing/dumping is used below.
-#define JSON_NO_IO 1
-
-// The user-supplied exception macros below are a *conforming* replacement:
-// they simply forward to the real throw/try/catch keywords (via a counter so
-// the test can assert each macro was actually invoked, not just defined), so
-// every exception-related behavior the library relies on internally --
-// including rethrowing std::out_of_range as json::out_of_range in at() --
-// keeps working exactly as it would with the library's own default macros.
-static int json_throw_user_call_count = 0; // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
-
-#define JSON_THROW_USER(exception) do { ++json_throw_user_call_count; throw (exception); } while (false) // NOLINT(cppcoreguidelines-macro-usage)
-#define JSON_TRY_USER try // NOLINT(cppcoreguidelines-macro-usage)
-#define JSON_CATCH_USER(exception) catch (exception) // NOLINT(cppcoreguidelines-macro-usage)
-
-#include "doctest_compatibility.h"
-
-#include <nlohmann/json.hpp>
-using json = nlohmann::json;
-
-TEST_CASE("JSON_NO_IO")
-{
-    // everything that does not touch <istream>/<ostream> must keep working:
-    // parsing from and dumping to std::string
-    const json j = json::parse(R"({"a":[1,2,3],"b":true})");
-    CHECK(j.dump() == R"({"a":[1,2,3],"b":true})");
-    CHECK(j.at("a").size() == 3);
-    CHECK(j.at("b").get<bool>() == true);
-}
-
-// this test relies on CHECK_THROWS_AS() actually invoking the guarded
-// expression so json_throw_user_call_count gets bumped and can be observed
-// afterwards; doctest's "--no-throw" test filter (which ci_test_noexceptions
-// passes, together with a global -DJSON_NOEXCEPTION added to CMAKE_CXX_FLAGS
-// for every translation unit in that build, this file included) compiles
-// CHECK_THROWS_AS() out to a no-op that never even invokes the given
-// expression -- so json::parse()/at() below would never be called at all and
-// the call-count assertions would fail even though our JSON_THROW_USER
-// override (which always really throws, regardless of JSON_NOEXCEPTION) would
-// have worked fine on its own
-#if !defined(JSON_NOEXCEPTION)
-TEST_CASE("JSON_THROW_USER, JSON_TRY_USER, JSON_CATCH_USER")
-{
-    json_throw_user_call_count = 0;
-
-    // json::parse() is [[nodiscard]] (JSON_HEDLEY_WARN_UNUSED_RESULT); under
-    // GCC in C++11 mode that expands to __attribute__((warn_unused_result)),
-    // which -- unlike a [[nodiscard]] attribute proper -- GCC does not
-    // consider satisfied by doctest's CHECK_THROWS_AS() wrapping the
-    // expression in a (void) cast, so the discarded return value would still
-    // be flagged under -Werror=unused-result; assign it to discard it instead,
-    // matching the established `json _ = json::parse(...)` pattern used
-    // elsewhere in the test suite (see unit-class_parser.cpp)
-    json _; // NOLINT(readability-identifier-naming)
-
-    // a parse error goes through JSON_THROW directly, i.e., through our
-    // JSON_THROW_USER override
-    CHECK_THROWS_AS(_ = json::parse("this is not JSON"), json::parse_error&);
-    CHECK(json_throw_user_call_count > 0);
-
-    // at() on an out-of-range array index internally catches std::out_of_range
-    // (JSON_TRY_USER/JSON_CATCH_USER) and rethrows it as json::out_of_range
-    // (JSON_THROW_USER again), so this exercises all three macros together
-    const int count_before = json_throw_user_call_count;
-    const json arr = json::array({1, 2, 3});
-    CHECK_THROWS_AS(arr.at(10), json::out_of_range&);
-    CHECK(json_throw_user_call_count > count_before);
-}
-#endif
@@ -81,118 +81,3 @@ TEST_CASE("regression test for issue #3732 - iteration_proxy_value<iter_impl<ord
    };
    static_cast<void>(fn);
 }
-
-TEST_CASE("copying an ordered_json with nested values")
-{
-    // ordered_map is backed by a vector, so copying an object that has
-    // structured values takes a different route than copying a std::map-backed
-    // one; see https://github.com/nlohmann/json/issues/5387
-    ordered_json oj;
-    oj["z"] = 1;
-    oj["a"]["y"] = 2;
-    oj["a"]["b"]["x"] = 3;
-    oj["m"] = {1, 2, {{"w", 4}}};
-
-    const ordered_json copy(oj);
-
-    SECTION("the copy is equal to the original")
-    {
-        CHECK(copy == oj);
-        CHECK(copy.dump() == oj.dump());
-    }
-
-    SECTION("the key order is preserved at every level")
-    {
-        CHECK(copy.dump() == R"({"z":1,"a":{"y":2,"b":{"x":3}},"m":[1,2,{"w":4}]})");
-    }
-
-    SECTION("the copy is independent of the original")
-    {
-        ordered_json mutated(oj);
-        mutated["a"]["b"]["x"] = 99;
-
-        CHECK(oj["a"]["b"]["x"] == 3);
-        CHECK(mutated["a"]["b"]["x"] == 99);
-    }
-}
-
-TEST_CASE("regression test - diff() must account for ordered_json member order")
-{
-    SECTION("pure reorder, no value changes")
-    {
-        ordered_json a = {{"a", 1}, {"b", 2}};
-        ordered_json b = {{"b", 2}, {"a", 1}};
-        CHECK(a != b); // order-sensitive equality
-        CHECK(a.patch(ordered_json::diff(a, b)) == b);
-    }
-
-    SECTION("new key must land at the front")
-    {
-        ordered_json c = {{"b", 2}};
-        ordered_json e = {{"a", 1}, {"b", 2}};
-        CHECK(c.patch(ordered_json::diff(c, e)) == e);
-    }
-
-    SECTION("reorder plus a value change on one of the reordered keys")
-    {
-        ordered_json a = {{"a", 1}, {"b", 2}};
-        ordered_json b = {{"b", 20}, {"a", 1}};
-        CHECK(a != b);
-        CHECK(a.patch(ordered_json::diff(a, b)) == b);
-    }
-
-    SECTION("reorder plus a deleted key")
-    {
-        ordered_json a = {{"a", 1}, {"b", 2}, {"c", 3}};
-        ordered_json b = {{"b", 2}, {"a", 1}};
-        CHECK(a != b);
-        CHECK(a.patch(ordered_json::diff(a, b)) == b);
-    }
-
-    SECTION("reorder plus a nested value that itself needs a recursive diff")
-    {
-        ordered_json a = {{"a", {{"x", 1}, {"y", 2}}}, {"b", 2}};
-        ordered_json b = {{"b", 2}, {"a", {{"x", 1}, {"y", 99}}}};
-        CHECK(a != b);
-        CHECK(a.patch(ordered_json::diff(a, b)) == b);
-    }
-
-    SECTION("three or more keys shuffled into a different order")
-    {
-        ordered_json a = {{"a", 1}, {"b", 2}, {"c", 3}, {"d", 4}};
-        ordered_json b = {{"d", 4}, {"b", 2}, {"a", 1}, {"c", 3}};
-        CHECK(a != b);
-        CHECK(a.patch(ordered_json::diff(a, b)) == b);
-    }
-
-    SECTION("matching order still produces a minimal patch (fast path unaffected)")
-    {
-        ordered_json a = {{"a", 1}, {"b", 2}, {"c", 3}};
-        ordered_json b = {{"a", 1}, {"b", 20}, {"c", 3}};
-        auto p = ordered_json::diff(a, b);
-        // only the changed value should be touched, not a wholesale remove+add
-        CHECK(p.size() == 1);
-        CHECK(p[0]["op"] == "replace");
-        CHECK(p[0]["path"] == "/b");
-        CHECK(a.patch(p) == b);
-    }
-
-    SECTION("plain json (std::map-backed) is unaffected by same-key-different-insertion-order")
-    {
-        json a;
-        a["b"] = 2;
-        a["a"] = 1;
-
-        json b;
-        b["a"] = 1;
-        b["b"] = 2;
-
-        // std::map iteration is always sorted by key, so a == b regardless of
-        // insertion order, and diff() must still produce the same minimal
-        // (empty) result as before this fix
-        CHECK(a == b);
-        auto p = json::diff(a, b);
-        CHECK(p.empty());
-        CHECK(a.patch(p) == b);
-    }
-}
@@ -1,489 +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-FileCopyrightText: 2018 Vitaliy Manushkin <agri@akamo.info>
-// SPDX-License-Identifier: MIT
-
-// This file closes a test-coverage gap described in GitHub issue #5421:
-// nlohmann::ordered_json (and other non-default basic_json specializations,
-// such as the alt_string-based one from unit-alt-string.cpp) were never
-// exercised through the binary formats (CBOR/MessagePack/UBJSON/BSON/BJData)
-// or through flatten()/unflatten()/diff()/patch()/merge_patch().
-
-#include "doctest_compatibility.h"
-
-#include <nlohmann/json.hpp>
-
-#include <cstdint>
-#include <string>
-#include <utility>
-#include <vector>
-
-using nlohmann::json;
-using nlohmann::ordered_json;
-
-/////////////////////////////////////////////////////////////////////////////
-// alt_json: a second, independent copy of the custom-string_t basic_json
-// specialization defined in unit-alt-string.cpp.
-//
-// It is duplicated here (rather than shared via a header) because every
-// unit-*.cpp file in this test suite is compiled into its own standalone
-// executable (see tests/CMakeLists.txt), so there is no ODR concern in
-// having the same class name defined in multiple translation units.
-//
-// Two members had to be added relative to the original alt_string
-// (a constructor from std::string, and a find(char, pos) overload) because
-// the original type was never used with the binary writers/readers before
-// this file: BSON's array/document writer converts std::to_string() results
-// and checks for embedded NUL characters via find(char), and the UBJSON/BSON
-// high-precision-number path constructs the SAX string_t argument from a
-// std::string. Neither path is exercised anywhere else in the test suite for
-// this type, which is presumably why the gap was never noticed.
-/////////////////////////////////////////////////////////////////////////////
-
-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)
-
-class alt_string
-{
-  public:
-    using value_type = std::string::value_type;
-
-    static constexpr auto npos = (std::numeric_limits<std::size_t>::max)();
-
-    alt_string(const char* str): str_impl(str) {}
-    alt_string(const char* str, std::size_t count): str_impl(str, count) {}
-    alt_string(std::string str): str_impl(std::move(str)) {}
-    alt_string(size_t count, char chr): str_impl(count, chr) {}
-    alt_string() = default;
-
-    alt_string& append(char ch)
-    {
-        str_impl.push_back(ch);
-        return *this;
-    }
-
-    alt_string& append(const alt_string& str)
-    {
-        str_impl.append(str.str_impl);
-        return *this;
-    }
-
-    alt_string& append(const char* s, std::size_t length)
-    {
-        str_impl.append(s, length);
-        return *this;
-    }
-
-    void push_back(char c)
-    {
-        str_impl.push_back(c);
-    }
-
-    template <typename op_type>
-    bool operator==(const op_type& op) const
-    {
-        return str_impl == op;
-    }
-
-    bool operator==(const alt_string& op) const
-    {
-        return str_impl == op.str_impl;
-    }
-
-    template <typename op_type>
-    bool operator!=(const op_type& op) const
-    {
-        return str_impl != op;
-    }
-
-    bool operator!=(const alt_string& op) const
-    {
-        return str_impl != op.str_impl;
-    }
-
-    std::size_t size() const noexcept
-    {
-        return str_impl.size();
-    }
-
-    void resize(std::size_t n)
-    {
-        str_impl.resize(n);
-    }
-
-    void resize(std::size_t n, char c)
-    {
-        str_impl.resize(n, c);
-    }
-
-    template <typename op_type>
-    bool operator<(const op_type& op) const noexcept
-    {
-        return str_impl < op;
-    }
-
-    bool operator<(const alt_string& op) const noexcept
-    {
-        return str_impl < op.str_impl;
-    }
-
-    const char* c_str() const
-    {
-        return str_impl.c_str();
-    }
-
-    char& operator[](std::size_t index)
-    {
-        return str_impl[index];
-    }
-
-    const char& operator[](std::size_t index) const
-    {
-        return str_impl[index];
-    }
-
-    char& back()
-    {
-        return str_impl.back();
-    }
-
-    const char& back() const
-    {
-        return str_impl.back();
-    }
-
-    void clear()
-    {
-        str_impl.clear();
-    }
-
-    const value_type* data() const
-    {
-        return str_impl.data();
-    }
-
-    bool empty() const
-    {
-        return str_impl.empty();
-    }
-
-    std::size_t find(const alt_string& str, std::size_t pos = 0) const
-    {
-        return str_impl.find(str.str_impl, pos);
-    }
-
-    // needed by binary_writer's BSON support, which probes string keys for
-    // embedded NUL characters via find(char)
-    std::size_t find(char c, std::size_t pos = 0) const
-    {
-        return str_impl.find(c, pos);
-    }
-
-    std::size_t find_first_of(char c, std::size_t pos = 0) const
-    {
-        return str_impl.find_first_of(c, pos);
-    }
-
-    alt_string substr(std::size_t pos = 0, std::size_t count = npos) const
-    {
-        const std::string s = str_impl.substr(pos, count);
-        return {s.data(), s.size()};
-    }
-
-    alt_string& replace(std::size_t pos, std::size_t count, const alt_string& str)
-    {
-        str_impl.replace(pos, count, str.str_impl);
-        return *this;
-    }
-
-    void reserve(std::size_t new_cap = 0)
-    {
-        str_impl.reserve(new_cap);
-    }
-
-  private:
-    std::string str_impl {}; // NOLINT(readability-redundant-member-init)
-
-    friend bool operator<(const char* /*op1*/, const alt_string& /*op2*/) noexcept;
-};
-
-void int_to_string(alt_string& target, std::size_t value)
-{
-    target = std::to_string(value).c_str();
-}
-
-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
-{
-
-// collects the object keys of j, in iteration order
-std::vector<std::string> collect_keys(const ordered_json& j)
-{
-    std::vector<std::string> result;
-    for (auto it = j.cbegin(); it != j.cend(); ++it)
-    {
-        result.push_back(it.key());
-    }
-    return result;
-}
-
-// a nested object/array value with keys inserted in non-alphabetical order,
-// used to check both round-trip equality and (for ordered_json) that
-// insertion order survives a trip through a binary format
-ordered_json make_rich_ordered_json()
-{
-    ordered_json j;
-    j["zebra"] = 1;
-    j["apple"] = ordered_json::array({1, 2, 3});
-    j["mango"]["z_nested"] = true;
-    j["mango"]["a_nested"] = nullptr;
-    j["banana"] = "some text";
-    j["cherry"] = 3.14;
-    return j;
-}
-
-alt_json make_rich_alt_json()
-{
-    alt_json j;
-    j["zebra"] = 1;
-    j["apple"] = alt_json::array({1, 2, 3});
-    j["mango"]["z_nested"] = true;
-    j["mango"]["a_nested"] = nullptr;
-    j["banana"] = "some text";
-    j["cherry"] = 3.14;
-    return j;
-}
-
-} // namespace
-
-TEST_CASE("ordered_json across binary formats")
-{
-    const ordered_json original = make_rich_ordered_json();
-    const std::vector<std::string> original_keys = collect_keys(original);
-    const std::vector<std::string> original_mango_keys = collect_keys(original["mango"]);
-
-    SECTION("CBOR")
-    {
-        const auto bytes = ordered_json::to_cbor(original);
-        const auto restored = ordered_json::from_cbor(bytes);
-        CHECK(restored == original);
-        CHECK(collect_keys(restored) == original_keys);
-        CHECK(collect_keys(restored["mango"]) == original_mango_keys);
-    }
-
-    SECTION("MessagePack")
-    {
-        const auto bytes = ordered_json::to_msgpack(original);
-        const auto restored = ordered_json::from_msgpack(bytes);
-        CHECK(restored == original);
-        CHECK(collect_keys(restored) == original_keys);
-        CHECK(collect_keys(restored["mango"]) == original_mango_keys);
-    }
-
-    SECTION("UBJSON")
-    {
-        const auto bytes = ordered_json::to_ubjson(original);
-        const auto restored = ordered_json::from_ubjson(bytes);
-        CHECK(restored == original);
-        CHECK(collect_keys(restored) == original_keys);
-        CHECK(collect_keys(restored["mango"]) == original_mango_keys);
-    }
-
-    SECTION("BSON")
-    {
-        const auto bytes = ordered_json::to_bson(original);
-        const auto restored = ordered_json::from_bson(bytes);
-        CHECK(restored == original);
-        CHECK(collect_keys(restored) == original_keys);
-        CHECK(collect_keys(restored["mango"]) == original_mango_keys);
-    }
-
-    SECTION("BJData")
-    {
-        const auto bytes = ordered_json::to_bjdata(original);
-        const auto restored = ordered_json::from_bjdata(bytes);
-        CHECK(restored == original);
-        CHECK(collect_keys(restored) == original_keys);
-        CHECK(collect_keys(restored["mango"]) == original_mango_keys);
-    }
-}
-
-TEST_CASE("alt_json (custom string_t) across binary formats")
-{
-    const alt_json original = make_rich_alt_json();
-
-    SECTION("CBOR")
-    {
-        const auto bytes = alt_json::to_cbor(original);
-        const auto restored = alt_json::from_cbor(bytes);
-        CHECK(restored == original);
-    }
-
-    SECTION("MessagePack")
-    {
-        const auto bytes = alt_json::to_msgpack(original);
-        const auto restored = alt_json::from_msgpack(bytes);
-        CHECK(restored == original);
-    }
-
-    SECTION("UBJSON")
-    {
-        const auto bytes = alt_json::to_ubjson(original);
-        const auto restored = alt_json::from_ubjson(bytes);
-        CHECK(restored == original);
-    }
-
-    SECTION("BSON")
-    {
-        const auto bytes = alt_json::to_bson(original);
-        const auto restored = alt_json::from_bson(bytes);
-        CHECK(restored == original);
-    }
-
-    SECTION("BJData")
-    {
-        const auto bytes = alt_json::to_bjdata(original);
-        const auto restored = alt_json::from_bjdata(bytes);
-        CHECK(restored == original);
-    }
-}
-
-TEST_CASE("ordered_json operator== is sensitive to key order")
-{
-    // Unlike nlohmann::json (whose object_t is a std::map, so equality never
-    // depends on insertion order), ordered_json's object_t (ordered_map) is a
-    // std::vector<std::pair<Key, T>> under the hood, and does not define its
-    // own operator==: it inherits std::vector's element-wise comparison. As a
-    // result, two ordered_json objects holding the very same key/value pairs
-    // in different insertion order compare *unequal*. This is the property
-    // that makes the round-trip `CHECK(restored == original)` checks above a
-    // meaningful order-preservation check by themselves (the explicit
-    // collect_keys() comparisons make that check explicit/readable, and
-    // guard against this operator== behavior ever changing).
-    ordered_json a;
-    a["x"] = 1;
-    a["y"] = 2;
-
-    ordered_json b;
-    b["y"] = 2;
-    b["x"] = 1;
-
-    CHECK(a.size() == b.size());
-    CHECK(a["x"] == b["x"]);
-    CHECK(a["y"] == b["y"]);
-    CHECK_FALSE(a == b);
-}
-
-TEST_CASE("duplicate keys in a binary-encoded object")
-{
-    // CBOR encoding of a map with two entries under the same key "a": {"a": 1, "a": 2}
-    const std::vector<std::uint8_t> cbor_bytes
-    {
-        0xA2, 0x61, 'a', 0x01, 0x61, 'a', 0x02
-    };
-
-    // Both json (std::map, via operator[]) and ordered_json (ordered_map, via
-    // operator[]) build binary-decoded objects by looking up/creating the
-    // entry for each incoming key and then assigning the value into it. This
-    // means a repeated key does *not* produce two entries in either case;
-    // instead, the *first* occurrence's position is kept (relevant only for
-    // ordered_json) while the *last* occurrence's value wins (for both) --
-    // this matches operator[]'s "assign the referenced slot" semantics, and
-    // is worth noting because it differs from the initializer-list
-    // construction path (`ordered_json{{"a",1},{"a",2}}`), which builds
-    // through insert()/emplace() and therefore keeps the *first* value, not
-    // the last (see the "There are no dup keys..." case in
-    // unit-ordered_json.cpp).
-    const auto j = json::from_cbor(cbor_bytes);
-    const auto oj = ordered_json::from_cbor(cbor_bytes);
-
-    CHECK(j.size() == 1);
-    CHECK(oj.size() == 1);
-    CHECK(j["a"] == 2);
-    CHECK(oj["a"] == 2);
-    CHECK(j == json(oj));
-}
-
-TEST_CASE("ordered_json through flatten/unflatten")
-{
-    const ordered_json original = make_rich_ordered_json();
-    const std::vector<std::string> original_keys = collect_keys(original);
-    const std::vector<std::string> original_mango_keys = collect_keys(original["mango"]);
-
-    const ordered_json flat = original.flatten();
-    const ordered_json unflattened = flat.unflatten();
-
-    CHECK(unflattened == original);
-    // flatten() walks the value depth-first in iteration order and
-    // unflatten() re-inserts each flattened key via operator[] in the flat
-    // object's iteration order, so for ordered_json the original key order
-    // (both top-level and nested) is preserved end-to-end.
-    CHECK(collect_keys(unflattened) == original_keys);
-    CHECK(collect_keys(unflattened["mango"]) == original_mango_keys);
-}
-
-TEST_CASE("ordered_json through diff/patch/patch_inplace")
-{
-    ordered_json original;
-    original["one"] = 1;
-    original["two"] = 2;
-    original["three"] = 3;
-
-    ordered_json target = original;
-    target["one"] = 100;      // replace
-    target.erase("two");      // remove
-    target["four"] = 4;       // add
-
-    const ordered_json patch = ordered_json::diff(original, target);
-
-    SECTION("patch")
-    {
-        const ordered_json patched = original.patch(patch);
-        CHECK(patched == target);
-    }
-
-    SECTION("patch_inplace")
-    {
-        ordered_json copy = original;
-        copy.patch_inplace(patch);
-        CHECK(copy == target);
-    }
-}
-
-TEST_CASE("ordered_json through merge_patch")
-{
-    ordered_json original;
-    original["a"] = 1;
-    original["b"] = 2;
-
-    const ordered_json patch = {{"b", nullptr}, {"c", 3}};
-
-    original.merge_patch(patch);
-
-    ordered_json expected;
-    expected["a"] = 1;
-    expected["c"] = 3;
-
-    CHECK(original == expected);
-    CHECK(collect_keys(original) == collect_keys(expected));
-}
@@ -606,11 +606,7 @@ TEST_CASE("regression tests 2")
    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 auto s = std::as_bytes(std::span(DATA));
        const json j = json::parse(s);
        CHECK(j.dump() == "\"Hello, world!\"");
    }
@@ -767,106 +763,4 @@ TEST_CASE("regression tests 2")

 }

-TEST_CASE("regression test - parser callback must not lose a duplicate key's prior value")
-{
-    // a callback that rejects only the scalar value 2
-    const json::parser_callback_t drop_value_2 = [](int /*depth*/, json::parse_event_t ev, json & v) noexcept
-    {
-        return !(ev == json::parse_event_t::value && v == 2);
-    };
-
-    SECTION("duplicate key, second (scalar) value rejected - prior value is restored")
-    {
-        const json j = json::parse(R"({"a":1,"a":2})", drop_value_2);
-        CHECK(j.dump() == "{\"a\":1}");
-    }
-
-    SECTION("duplicate key, second value is an object rejected at object_end - prior value is restored")
-    {
-        const json j = json::parse(R"({"a":1,"a":{"x":2}})",
-                                   [](int depth, json::parse_event_t ev, json& /*parsed*/) noexcept
-        {
-            return !(ev == json::parse_event_t::object_end && depth == 1);
-        });
-        CHECK(j.dump() == "{\"a\":1}");
-    }
-
-    SECTION("duplicate key, second value is an array rejected at array_end - prior value is restored")
-    {
-        const json j = json::parse(R"({"a":1,"a":[9,9]})",
-                                   [](int depth, json::parse_event_t ev, json& /*parsed*/) noexcept
-        {
-            return !(ev == json::parse_event_t::array_end && depth == 1);
-        });
-        CHECK(j.dump() == "{\"a\":1}");
-    }
-
-    SECTION("duplicate key, second value accepted (scalar) - last value wins")
-    {
-        const json j = json::parse(R"({"a":1,"a":2})", [](int, json::parse_event_t, json&) noexcept
-        {
-            return true;
-        });
-        CHECK(j.dump() == "{\"a\":2}");
-    }
-
-    SECTION("duplicate key, second value accepted (object) - last value wins")
-    {
-        const json j = json::parse(R"({"a":1,"a":{"x":2}})", [](int, json::parse_event_t, json&) noexcept
-        {
-            return true;
-        });
-        CHECK(j.dump() == "{\"a\":{\"x\":2}}");
-    }
-
-    SECTION("brand new (non-duplicate) key, value rejected - member is fully absent")
-    {
-        const json j = json::parse(R"({"a":1,"b":2})", drop_value_2);
-        CHECK(j.dump() == "{\"a\":1}");
-    }
-
-    SECTION("duplicate key nested two levels deep")
-    {
-        const json j = json::parse(R"({"outer":{"a":1,"a":2}})", drop_value_2);
-        CHECK(j.dump() == "{\"outer\":{\"a\":1}}");
-    }
-
-    SECTION("three occurrences of the same key - middle rejected, last accepted")
-    {
-        const json j = json::parse(R"({"k":1,"k":2,"k":3})", drop_value_2);
-        CHECK(j.dump() == "{\"k\":3}");
-    }
-}
-
-TEST_CASE("regression test - excessive binary container size honors allow_exceptions=false")
-{
-    // CBOR array with declared length 2^63
-    const std::vector<std::uint8_t> cbor = {0x9b, 0x80, 0, 0, 0, 0, 0, 0, 0};
-    // CBOR map with declared length 2^63
-    const std::vector<std::uint8_t> cbor_m = {0xbb, 0x80, 0, 0, 0, 0, 0, 0, 0};
-    // UBJSON array with declared length 2^63-1
-    const std::vector<std::uint8_t> ubj = {'[', '#', 'L', 0x7f, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
-    // BJData array with declared length 2^63-1 (little endian)
-    const std::vector<std::uint8_t> bjd = {'[', '#', 'L', 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f};
-
-    // allow_exceptions=false must report failure instead of throwing/aborting
-    CHECK(json::from_cbor(cbor, true, false).is_discarded());
-    CHECK(json::from_cbor(cbor_m, true, false).is_discarded());
-    CHECK(json::from_ubjson(ubj, true, false).is_discarded());
-    CHECK(json::from_bjdata(bjd, true, false).is_discarded());
-
-    // allow_exceptions=true (the default) must still throw exactly as before.
-    // The exact message text is not checked here: on platforms where
-    // std::size_t is 32-bit, the CBOR reader's own length-narrowing check
-    // (get_cbor_container_size(), unrelated to this fix) intercepts a
-    // declared length of 2^63 before it ever reaches the check this test
-    // targets, with different (but equally valid, and already correct)
-    // wording -- see unit-cbor.cpp for coverage of that message.
-    json _;
-    CHECK_THROWS_AS(_ = json::from_cbor(cbor), json::out_of_range);
-
-    // regression guard: a genuinely truncated CBOR input must remain discarded
-    CHECK(json::from_cbor(std::vector<std::uint8_t> {0x9b, 0, 0, 0, 0, 0, 0, 0, 0x02}, true, false).is_discarded());
-}
-
 DOCTEST_CLANG_SUPPRESS_WARNING_POP
@@ -18,14 +18,6 @@
 // for some reason including this after the json header leads to linker errors with VS 2017...
 #include <locale>

-// 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
-
 #define JSON_TESTS_PRIVATE
 #include <nlohmann/json.hpp>
 using json = nlohmann::json;
@@ -474,7 +466,6 @@ TEST_CASE("regression tests 3")
        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
@@ -508,7 +499,6 @@ TEST_CASE("regression tests 3")
        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")
    {
@@ -658,6 +648,33 @@ TEST_CASE("regression test #5074 - portable workaround for single-element brace
    CHECK(j[0] == j_obj);
 }

+#if defined(JSON_BRACE_INIT_COPY_SEMANTICS) && (JSON_BRACE_INIT_COPY_SEMANTICS == 1)
+TEST_CASE("regression test #5074 - single-element brace init with JSON_BRACE_INIT_COPY_SEMANTICS")
+{
+    // with JSON_BRACE_INIT_COPY_SEMANTICS: single-element brace init copies/moves
+    json const j_obj = {{"key", "value"}, {"num", 42}};
+    json const j_arr = {1, 2, 3};
+
+    // object: brace init copies instead of wrapping
+    json const j1{j_obj};
+    CHECK(j1.is_object());
+    CHECK(j1 == j_obj);
+
+    // array: brace init copies instead of wrapping
+    json const j2{j_arr};
+    CHECK(j2.is_array());
+    CHECK(j2.size() == 3);
+    CHECK(j2 == j_arr);
+
+    // primitives still work as initializer lists
+    json const j3{true};
+    CHECK(j3.is_boolean());
+
+    json const j4{42};
+    CHECK(j4.is_number_integer());
+}
+#endif
+
 struct Example_5122
 {
    float b = 2;
@@ -522,19 +522,6 @@ TEST_CASE("indentation is written straight into the write buffer")
        CHECK(json::parse(out) == j);
    }

-    SECTION("binary values are indented the same way")
-    {
-        // a binary value is serialized as an object with "bytes" and
-        // "subtype" keys; the byte array itself is always written compactly
-        // (see dump_byte()), so only the surrounding object's indentation
-        // goes through put_indent()
-        const json j = json::binary({1, 2, 3}, 128);
-        CHECK(j.dump(2000) == "{\n" + std::string(2000, ' ') + "\"bytes\": [1, 2, 3],\n"
-              + std::string(2000, ' ') + "\"subtype\": 128\n}");
-        CHECK(j.dump(2000, '\t') == "{\n" + std::string(2000, '\t') + "\"bytes\": [1, 2, 3],\n"
-              + std::string(2000, '\t') + "\"subtype\": 128\n}");
-    }
-
    SECTION("indentation is unchanged for ordinary widths")
    {
        const json j = {{"a", {1, 2}}, {"b", nullptr}};
@@ -17,7 +17,6 @@

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

 // JSON_HAS_CPP_20 (do not remove; see note at top of file)
 #if JSON_HAS_STD_FORMAT
@@ -53,23 +52,6 @@ TEST_CASE("std::formatter<nlohmann::json>")
        CHECK(std::format("{:2}", j) == j.dump(2));
        CHECK(std::format("{:#2}", j) == j.dump(2));
        CHECK(std::format("{:8}", j) == j.dump(8));
-        // multi-digit widths must accumulate every digit, not just the first
-        CHECK(std::format("{:12}", j) == j.dump(12));
-        CHECK(std::format("{:#12}", j) == j.dump(12));
-        CHECK(std::format("{:10}", j) == j.dump(10));
-    }
-
-    SECTION("bare alignment with no fill character defaults to a space indent character")
-    {
-        const json j = {{"foo", 1}, {"bar", {1, 2, 3}}};
-        // without a preceding fill character, the alignment character itself must not
-        // be mistaken for the indent character -- the default space is kept
-        CHECK(std::format("{:<}", j) == j.dump());
-        CHECK(std::format("{:>}", j) == j.dump());
-        CHECK(std::format("{:^}", j) == j.dump());
-        CHECK(std::format("{:<3}", j) == j.dump(3, ' '));
-        CHECK(std::format("{:>3}", j) == j.dump(3, ' '));
-        CHECK(std::format("{:^3}", j) == j.dump(3, ' '));
    }

    SECTION("fill-and-align sets the indent character, like dump(indent, indent_char)")
@@ -111,16 +93,4 @@ TEST_CASE("std::formatter<nlohmann::json>")
    }
 }

-TEST_CASE("std::formatter<nlohmann::ordered_json>")
-{
-    // spot-check a non-default basic_json instantiation, since the formatter
-    // is written against the generic NLOHMANN_BASIC_JSON_TPL_DECLARATION
-    // template and must actually instantiate (and behave correctly) for
-    // template arguments other than nlohmann::json
-    const ordered_json j = {{"foo", 1}, {"bar", {1, 2, 3}}};
-    CHECK(std::format("{}", j) == j.dump());
-    CHECK(std::format("{:#}", j) == j.dump(4));
-    CHECK(std::format("{:2}", j) == j.dump(2));
-}
-
 #endif
@@ -1927,6 +1927,23 @@ TEST_CASE("UBJSON")
                std::vector<uint8_t> const v0 = {'S', 'i', 0};
                CHECK(json::from_ubjson(v0) == json(""));
            }
+
+            SECTION("invalid UTF-8 in string (see #5529)")
+            {
+                // a UBJSON string of length 2 whose bytes are not valid
+                // UTF-8 (0xC0 0xAE is an overlong encoding of '.') must be
+                // rejected at decode time, matching every other kind of
+                // malformed binary input, rather than only failing later
+                // when the resulting value is dumped
+                std::vector<uint8_t> const v = {'S', 'i', 0x02, 0xc0, 0xae};
+                json _;
+                CHECK_THROWS_WITH_AS(_ = json::from_ubjson(v), "[json.exception.parse_error.113] parse error at byte 5: syntax error while parsing UBJSON string: invalid string: ill-formed UTF-8 byte", json::parse_error&);
+                CHECK(json::from_ubjson(v, true, false).is_discarded());
+
+                // valid UTF-8 must still round-trip
+                const json j = "h\xc3\xa9llo, w\xc3\xb6rld! \xe6\x97\xa5\xe6\x9c\xac\xe8\xaa\x9e"; // héllo, wörld! 日本語
+                CHECK(json::from_ubjson(json::to_ubjson(j)) == j);
+            }
        }

        SECTION("array")
@@ -306,8 +306,8 @@ TEST_CASE("Unicode (3/5)" * doctest::skip())
                        {
                            for (int byte4 = 0x00; byte4 <= 0xFF; ++byte4)
                            {
-                                // skip correct fourth byte
-                                if (0x80 <= byte4 && byte4 <= 0xBF)
+                                // skip fourth second byte
+                                if (0x80 <= byte3 && byte3 <= 0xBF)
                                {
                                    continue;
                                }
@@ -307,7 +307,7 @@ TEST_CASE("Unicode (4/5)" * doctest::skip())
                            for (int byte4 = 0x00; byte4 <= 0xFF; ++byte4)
                            {
                                // skip correct fourth byte
-                                if (0x80 <= byte4 && byte4 <= 0xBF)
+                                if (0x80 <= byte3 && byte3 <= 0xBF)
                                {
                                    continue;
                                }
@@ -307,7 +307,7 @@ TEST_CASE("Unicode (5/5)" * doctest::skip())
                            for (int byte4 = 0x00; byte4 <= 0xFF; ++byte4)
                            {
                                // skip correct fourth byte
-                                if (0x80 <= byte4 && byte4 <= 0xBF)
+                                if (0x80 <= byte3 && byte3 <= 0xBF)
                                {
                                    continue;
                                }
@@ -20,7 +20,7 @@ if __name__ == '__main__':

    namespaces = ['nlohmann']
    abi_prefix = 'json_abi'
-    abi_tags = ['_diag', '_ldvcmp', '_dp', '_bics']
+    abi_tags = ['_diag', '_ldvcmp']
    version = '_v' + args.version.replace('.', '_')
    inline_namespaces = []

--- a/Show More
+++ b/Show More