Grow the json_view dump's output in steps and compare raw-number dumps

- The output string reserves the size estimate (the source extent) and grows in steps of 64 KiB within it, instead of being resized to the estimate at once: resize() zero-fills, and for a pretty-printed source the estimate is far larger than the compact output. citm_catalog dump: 342 -> 283 us on x86-64, 144 -> 134 us on Apple M1. - bench_corpus compares the dump with source numbers with yyjson writing numbers read as raw text (YYJSON_READ_NUMBER_AS_RAW); both write the same bytes. Signed-off-by: Niels Lohmann <mail@nlohmann.me>
Scan strings vector-first on x86-64 and avoid a stall when nesting
2026-10-07 15:07:13 +00:00 · 2026-10-06 08:41:16 +02:00 · 2026-10-06 07:22:15 +02:00 · 2026-10-05 22:28:58 +02:00 · 2026-10-05 20:25:36 +02:00 · 2026-10-05 20:16:24 +02:00
140 changed files with 6845 additions and 15647 deletions
@@ -205,9 +205,6 @@ API of the 3.x.y version is broken. This includes:
 - Changing access specifiers.
 - Changing default arguments.

-What is and is not covered by this guarantee is described in the
-[roadmap](https://json.nlohmann.me/community/roadmap/#api-stability).
-
 Although these guidelines may seem restrictive, they are essential for maintaining the library’s utility.

 Breaking changes may be introduced when they are guarded with a feature macro such as
@@ -16,9 +16,6 @@ only_commits:

 environment:
  matrix:
-    # The Visual Studio 2017 jobs compile everything with /std:c++17, so they
-    # only build the C++17 variant of each test, split into two jobs each to
-    # stay below AppVeyor's 60-minute limit per job.
    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
      configuration: Debug
      platform: x86
@@ -37,13 +34,7 @@ environment:
      configuration: Release
      platform: x86
      CXX_FLAGS: "/permissive- /std:c++17 /utf-8 /W4 /WX"
-      CMAKE_OPTIONS: "-DJSON_TestStandards=17 -DJSON_TestShard=0/2"
-      GENERATOR: Visual Studio 15 2017
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
-      configuration: Release
-      platform: x86
-      CXX_FLAGS: "/permissive- /std:c++17 /utf-8 /W4 /WX"
-      CMAKE_OPTIONS: "-DJSON_TestStandards=17 -DJSON_TestShard=1/2"
+      CMAKE_OPTIONS: ""
      GENERATOR: Visual Studio 15 2017

    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
@@ -64,13 +55,7 @@ environment:
      configuration: Release
      platform: x64
      CXX_FLAGS: "/permissive- /std:c++17 /Zc:__cplusplus /utf-8 /W4 /WX"
-      CMAKE_OPTIONS: "-DJSON_TestStandards=17 -DJSON_TestShard=0/2"
-      GENERATOR: Visual Studio 15 2017
-    - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
-      configuration: Release
-      platform: x64
-      CXX_FLAGS: "/permissive- /std:c++17 /Zc:__cplusplus /utf-8 /W4 /WX"
-      CMAKE_OPTIONS: "-DJSON_TestStandards=17 -DJSON_TestShard=1/2"
+      CMAKE_OPTIONS: ""
      GENERATOR: Visual Studio 15 2017

 init:
@@ -81,10 +66,15 @@ install:
  - if "%platform%"=="x86"    set GENERATOR_PLATFORM=Win32

 before_build:
-  - cmake . -G "%GENERATOR%" -A "%GENERATOR_PLATFORM%" -DCMAKE_CXX_FLAGS="%CXX_FLAGS%" -DCMAKE_IGNORE_PATH="C:/Program Files/Git/usr/bin" -DJSON_BuildTests=On %CMAKE_OPTIONS%
+  - cmake . -G "%GENERATOR%" -A "%GENERATOR_PLATFORM%" -DCMAKE_CXX_FLAGS="%CXX_FLAGS%" -DCMAKE_IGNORE_PATH="C:/Program Files/Git/usr/bin" -DJSON_BuildTests=On "%CMAKE_OPTIONS%"

 build_script:
  - cmake --build . --config "%configuration%" --parallel 2

 test_script:
-  - ctest -C "%configuration%" --parallel 2 --output-on-failure
+  - if "%configuration%"=="Release" ctest -C "%configuration%" --parallel 2 --output-on-failure
+  # On Debug builds, skip test-unicode_all
+  # as it is extremely slow to run and cause
+  # occasional timeouts on AppVeyor.
+  # More info: https://github.com/nlohmann/json/pull/1570
+  - if "%configuration%"=="Debug" ctest --exclude-regex "test-unicode" -C "%configuration%" --parallel 2 --output-on-failure
@@ -52,6 +52,7 @@ labels:
    - "single_include/nlohmann/json_view\\.hpp"
    - "tests/src/unit-json_view.*"
    - "tests/src/fuzzer-(parse_json_view|json_view_image)\\.cpp"
+    - "tests/benchmarks/json_view/.*"
    - "tools/amalgamate/config_json_view\\.json"
    - "docs/mkdocs/docs/features/json_view\\.md"
    - "docs/mkdocs/docs/api/basic_json_(document|view)/.*"
@@ -0,0 +1,78 @@
+name: "json_view benchmarks"
+
+# On demand only: runs the comparison of json_view with yyjson, simdjson, and
+# Boost.JSON (tests/benchmarks/json_view/compare.py) on GitHub-hosted runners,
+# for numbers from x86-64 and AArch64 Linux. It runs when started by hand, or
+# when a pull request gets the label "benchmark" (on both architectures, with
+# GCC and the default settings). Shared runners are noisy: the results show
+# where json_view stands, but published numbers need a quiet machine (see
+# tests/benchmarks/json_view/README.md).
+
+on:
+  pull_request:
+    types: [labeled]
+  workflow_dispatch:
+    inputs:
+      runner:
+        description: "Runner image"
+        type: choice
+        options:
+          - ubuntu-24.04
+          - ubuntu-24.04-arm
+        default: ubuntu-24.04
+      compiler:
+        description: "Compiler"
+        type: choice
+        options:
+          - g++
+          - clang++
+        default: g++
+      native:
+        description: "Compile for the runner's CPU (-march=native)"
+        type: boolean
+        default: false
+      rounds:
+        description: "Rounds of bench_view"
+        type: number
+        default: 30
+
+permissions:
+  contents: read
+
+jobs:
+  compare:
+    if: github.event_name == 'workflow_dispatch' || github.event.label.name == 'benchmark'
+    strategy:
+      matrix:
+        runner: ${{ fromJSON(github.event_name == 'workflow_dispatch' && format('["{0}"]', inputs.runner) || '["ubuntu-24.04", "ubuntu-24.04-arm"]') }}
+    runs-on: ${{ matrix.runner }}
+    steps:
+      - name: Harden Runner
+        uses: step-security/harden-runner@e14015d583714f6e62063499dc959a02595150a1 # v2.21.1
+        with:
+          egress-policy: audit
+
+      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
+        with:
+          persist-credentials: false
+
+      - name: Download test data
+        run: |
+          cmake -S . -B build -DJSON_BuildTests=On
+          cmake --build build --target download_test_data
+
+      - name: Run the comparison
+        env:
+          CXX: ${{ inputs.compiler || 'g++' }}
+          CC: ${{ inputs.compiler == 'clang++' && 'clang' || 'gcc' }}
+          ROUNDS: ${{ inputs.rounds || 30 }}
+          NATIVE: ${{ inputs.native && '--native' || '' }}
+        run: python3 tests/benchmarks/json_view/compare.py --data build/test_files --download --rounds "$ROUNDS" $NATIVE
+
+      - name: Summary
+        run: cat tests/benchmarks/json_view/results/*.md >> "$GITHUB_STEP_SUMMARY"
+
+      - uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
+        with:
+          name: json_view-benchmarks-${{ matrix.runner }}-${{ inputs.compiler || 'g++' }}
+          path: tests/benchmarks/json_view/results/
@@ -17,11 +17,11 @@ permissions:
  contents: read

 jobs:
-  macos-15:
-    runs-on: macos-15 # https://github.com/actions/runner-images/blob/main/images/macos/macos-15-Readme.md
+  macos-14:
+    runs-on: macos-14 # https://github.com/actions/runner-images/blob/main/images/macos/macos-14-Readme.md
    strategy:
      matrix:
-        xcode: ['16.0', '16.1', '16.2', '16.3', '16.4', '26.0.1', '26.1.1', '26.2', '26.3']
+        xcode: ['15.0.1', '15.1', '15.2', '15.3', '15.4']
    env:
      DEVELOPER_DIR: /Applications/Xcode_${{ matrix.xcode }}.app/Contents/Developer

@@ -36,11 +36,11 @@ jobs:
      - name: Test
        run: cd build ; ctest -j 10 --output-on-failure

-  macos-26:
-    runs-on: macos-26 # https://github.com/actions/runner-images/blob/main/images/macos/macos-26-arm64-Readme.md
+  macos-15:
+    runs-on: macos-15 # https://github.com/actions/runner-images/blob/main/images/macos/macos-15-Readme.md
    strategy:
      matrix:
-        xcode: ['26.4.1', '26.5', '26.6']
+        xcode: ['16.0', '16.1', '16.2', '16.3', '16.4', '26.0.1']
    env:
      DEVELOPER_DIR: /Applications/Xcode_${{ matrix.xcode }}.app/Contents/Developer

@@ -71,38 +71,3 @@ jobs:
        run: cmake --build build --parallel 10
      - name: Test
        run: cd build ; ctest -j 10 --output-on-failure
-
-  swiftpm:
-    runs-on: macos-15
-    steps:
-      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
-        with:
-          persist-credentials: false
-      - name: Check that Package.swift resolves without a deprecation warning
-        run: swift package dump-package
-      - name: Build the SwiftPM documentation example against this checkout
-        run: |
-          mkdir -p /tmp/json-swiftpm-consumer/Sources/MyLibrary
-          cp docs/mkdocs/docs/integration/swift/example.cpp /tmp/json-swiftpm-consumer/Sources/MyLibrary/example.cpp
-          cat > /tmp/json-swiftpm-consumer/Package.swift << EOF
-          // swift-tools-version: 5.9
-          import PackageDescription
-
-          let package = Package(
-              name: "MyPackage",
-              dependencies: [
-                  .package(path: "${{ github.workspace }}")
-              ],
-              targets: [
-                  .target(
-                      name: "MyLibrary",
-                      dependencies: [
-                          .product(name: "json", package: "json")
-                      ],
-                      publicHeadersPath: "."
-                  )
-              ]
-          )
-          EOF
-          cd /tmp/json-swiftpm-consumer
-          swift build
@@ -107,7 +107,7 @@ jobs:
    container: ubuntu:24.04
    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_disabletuplereferenceconversion, ci_test_skiplibraryversioncheck, ci_test_simdutf, ci_test_strict_nul_handling, ci_test_delete_deprecated_functions, 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_disableenumserialization, ci_test_disabletuplereferenceconversion, ci_test_skiplibraryversioncheck, ci_test_simdutf, ci_test_strict_nul_handling, ci_test_no_thread_local]
    steps:
      - name: Install build-essential
        run: apt-get update ; apt-get install -y build-essential unzip wget git
@@ -209,7 +209,7 @@ jobs:
    strategy:
      matrix:
        # older GCC docker images (4, 5, 6) fail to check out code
-        compiler: ['7', '8', '9', '10', '11', '12', '13', '14', '15', '16', 'latest']
+        compiler: ['7', '8', '9', '10', '11', '12', '13', '14', '15', 'latest']
    container: gcc:${{ matrix.compiler }}
    steps:
      - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 # v7.0.1
@@ -178,7 +178,7 @@ jobs:
      - name: Build
        run: cmake --build build --parallel 10
      - name: Test
-        run: cd build ; ctest -j 10 -C Debug --output-on-failure
+        run: cd build ; ctest -j 10 -C Debug --exclude-regex "test-unicode" --output-on-failure

  clang-cl-12:
    runs-on: windows-2022
@@ -195,7 +195,7 @@ jobs:
      - name: Build
        run: cmake --build build --config Debug --parallel 10
      - name: Test
-        run: cd build ; ctest -j 10 -C Debug --output-on-failure
+        run: cd build ; ctest -j 10 -C Debug --exclude-regex "test-unicode" --output-on-failure

  ci_module_cpp20:
    runs-on: windows-2022
@@ -1,7 +1,5 @@
 {
  "_comment": "Used by the ci_infer CMake target (#5715 item 4b). fail-on-issue makes CI fail on Infer findings; disable-issue-type is a type-level baseline for the ~174 pre-existing findings (all PULSE_UNNECESSARY_COPY*/PULSE_RESOURCE_LEAK/PULSE_CONST_REFABLE, mostly in test code) triaged in run https://github.com/nlohmann/json/actions/runs/35829411620 on commit 1054b2097, so CI fails only on a NEW issue type. Remove an entry here once its findings have been fixed or explicitly accepted.",
-  "_comment_pulse": "Pulse stops exploring paths after pulse-max-disjuncts (default 20). With the default, basic_json::replace_value() (destroy + assert_invariant) exceeds the limit, Pulse loses the stored type, and reports false NULLPTR_DEREFERENCE findings for get_ptr() results in tests/src/unit-pointer_access.cpp.",
-  "pulse-max-disjuncts": 40,
  "fail-on-issue": true,
  "disable-issue-type": [
    "PULSE_UNNECESSARY_COPY_ASSIGNMENT",
@@ -0,0 +1,36 @@
+Format: https://www.debian.org/doc/packaging-manuals/copyright-format/1.0/
+Upstream-Name: json
+Upstream-Contact: Niels Lohmann <mail@nlohmann.me>
+Source: https://github.com/nlohmann/json
+
+Files: *
+Copyright: 2013-2026 Niels Lohmann <https://nlohmann.me>
+License: MIT
+
+Files: include/nlohmann/thirdparty/hedley.hpp
+Copyright: 2016-2021 Evan Nemerson <evan@nemerson.com>
+License: CC0
+
+Files: include/nlohmann/detail/meta/cpp_future.hpp
+Copyright: 2013-2026 Niels Lohmann <https://nlohmann.me> and 2018 The Abseil Authors
+License: MIT AND Apache-2.0
+
+Files: tests/thirdparty/doctest/*
+Copyright: 2016-2023 Viktor Kirilov
+License: MIT
+
+Files: tests/thirdparty/fifo_map/*
+Copyright: 2015-2017 Niels Lohmann
+License: MIT
+
+Files: tests/thirdparty/imapdl/*
+Copyright: 2017 Georg Sauthoff <mail@gms.tf>
+License: GPL-3.0-only
+
+Files: tools/amalgamate/*
+Copyright: 2012 Erik Edlund <erik.edlund@32767.se>
+License: BSD-3-Clause
+
+Files: tools/gdb_pretty_printer/*
+Copyright: 2020 Hannes Domani <https://github.com/ssbssa>
+License: MIT
@@ -105,7 +105,6 @@ cc_library(
    name = "singleheader-json",
    hdrs = [
        "single_include/nlohmann/json.hpp",
-        "single_include/nlohmann/json_fwd.hpp",
        "single_include/nlohmann/json_view.hpp",
    ],
    includes = ["single_include"],
@@ -10,5 +10,5 @@ title: "JSON for Modern C++"
 version: 3.12.0
 date-released: 2025-04-07
 license: MIT
-repository-code: "https://github.com/nlohmann/json"
+repository-code: "https://github.com/nlohmann"
 url: https://json.nlohmann.me
@@ -42,11 +42,8 @@ endif()
 ## OPTIONS
 ##

-# Build the tests by default only for the main project and only if the tests
-# directory exists (the release archive json.tar.xz does not contain it).
 # VERSION_GREATER_EQUAL is not available in older CMake (< 3.7)
-if(${MAIN_PROJECT} AND (${CMAKE_VERSION} VERSION_EQUAL 3.13 OR ${CMAKE_VERSION} VERSION_GREATER 3.13)
-   AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/tests/CMakeLists.txt")
+if(${MAIN_PROJECT} AND (${CMAKE_VERSION} VERSION_EQUAL 3.13 OR ${CMAKE_VERSION} VERSION_GREATER 3.13))
    set(JSON_BuildTests_INIT ON)
 else()
    set(JSON_BuildTests_INIT OFF)
@@ -65,7 +62,6 @@ option(JSON_MultipleHeaders                "Use non-amalgamated version of the l
 option(JSON_SystemInclude                  "Include as system headers (skip for clang-tidy)." OFF)
 option(JSON_StrictNulHandling              "Build with strict NUL-byte handling enabled." OFF)
 option(JSON_StrictBinaryUTF8               "Build with UTF-8 checks in the CBOR, UBJSON, BJData, and BSON writers enabled." OFF)
-option(JSON_DeleteDeprecatedFunctions      "Delete the deprecated functions instead of only deprecating them." OFF)

 if (JSON_CI)
    include(ci)
@@ -127,10 +123,6 @@ if (JSON_StrictBinaryUTF8)
    message(STATUS "Strict UTF-8 checks in binary writers enabled (JSON_STRICT_BINARY_UTF8=1)")
 endif()

-if (JSON_DeleteDeprecatedFunctions)
-    message(STATUS "Deprecated functions are deleted (JSON_DELETE_DEPRECATED_FUNCTIONS=1)")
-endif()
-
 if (JSON_Diagnostic_Positions)
    message(STATUS "Diagnostic positions enabled (JSON_DIAGNOSTIC_POSITIONS=1)")
 endif()
@@ -167,7 +159,6 @@ target_compile_definitions(
    $<$<BOOL:${JSON_LegacyDiscardedValueComparison}>:JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON=1>
    $<$<BOOL:${JSON_StrictNulHandling}>:JSON_STRICT_NUL_HANDLING=1>
    $<$<BOOL:${JSON_StrictBinaryUTF8}>:JSON_STRICT_BINARY_UTF8=1>
-    $<$<BOOL:${JSON_DeleteDeprecatedFunctions}>:JSON_DELETE_DEPRECATED_FUNCTIONS=1>
 )

 target_include_directories(
@@ -196,19 +196,19 @@ Further documentation:

 ## REUSE

-### `REUSE.toml`
+### `.reuse/dep5`

 The file defines the licenses of certain third-party components in the repository. The root `Makefile` contains a target `reuse` that checks for compliance.

 Further documentation:

- [REUSE.toml](https://reuse.software/spec-3.3/#reusetoml)
+- [DEP5](https://reuse.software/spec-3.2/#dep5-deprecated)
 - [reuse command-line tool](https://pypi.org/project/reuse/)
 - [documentation of linting](https://reuse.readthedocs.io/en/stable/man/reuse-lint.html)
 - [REUSE](http://reuse.software)

 > [!IMPORTANT]
-> The filename `REUSE.toml` is predetermined by REUSE. Alternatively, a `.reuse/dep5` file (deprecated) can be used.
+> The filename `.reuse/dep5` is predetermined by REUSE. Alternatively, a `REUSE.toml` file can be used.

 ### `.reuse/templates`

@@ -7,9 +7,6 @@
 # find GNU sed to use `-i` parameter
 SED:=$(shell command -v gsed || which sed)

-# find GNU tar to use `--sort` and `--pax-option` parameters
-TAR:=$(shell command -v gtar || which tar)
-

 ##########################################################################
 # source files
@@ -184,8 +181,8 @@ ChangeLog.md:
 # archive is created according to the advices of <https://reproducible-builds.org/docs/archives/>.
 json.tar.xz:
 	mkdir json
-	rsync -R $(shell find LICENSE.MIT nlohmann_json.natvis CMakeLists.txt cmake/*.in include single_include src/modules -type f) json
-	$(TAR) --sort=name --mtime="@$(shell git log -1 --pretty=%ct)" --owner=0 --group=0 --numeric-owner --pax-option=exthdr.name=%d/PaxHeaders/%f,delete=atime,delete=ctime --create --file - json | xz --compress -9e --threads=2 - > json.tar.xz
+	rsync -R $(shell find LICENSE.MIT nlohmann_json.natvis CMakeLists.txt cmake/*.in include single_include -type f) json
+	gtar --sort=name --mtime="@$(shell git log -1 --pretty=%ct)" --owner=0 --group=0 --numeric-owner --pax-option=exthdr.name=%d/PaxHeaders/%f,delete=atime,delete=ctime --create --file - json | xz --compress -9e --threads=2 - > json.tar.xz
 	rm -fr json

 # We use `-X` to make the resulting ZIP file reproducible, see
@@ -6,7 +6,7 @@ import PackageDescription
 let package = Package(
    name: "nlohmann-json",
     platforms: [
-        .iOS(.v12), .macOS(.v10_13), .tvOS(.v12), .watchOS(.v9), .visionOS(.v1)
+        .iOS(.v12), .macOS(.v10_13), .tvOS(.v12), .watchOS(.v4), .visionOS(.v1)
    ],
    products: [
        .library(name: "json", targets: ["json"])
@@ -7,7 +7,7 @@
 [![Coverage Status](https://coveralls.io/repos/github/nlohmann/json/badge.svg?branch=develop)](https://coveralls.io/github/nlohmann/json?branch=develop)
 [![Coverity Scan Build Status](https://scan.coverity.com/projects/5550/badge.svg)](https://scan.coverity.com/projects/nlohmann-json)
 [![Codacy Badge](https://app.codacy.com/project/badge/Grade/e0d1a9d5d6fd46fcb655c4cb930bb3e8)](https://app.codacy.com/gh/nlohmann/json/dashboard?utm_source=gh&utm_medium=referral&utm_content=&utm_campaign=Badge_grade)
-[![Fuzzing Status](https://oss-fuzz-build-logs.storage.googleapis.com/badges/json.svg)](https://issues.oss-fuzz.com/issues?q=project:json)
+[![Fuzzing Status](https://oss-fuzz-build-logs.storage.googleapis.com/badges/json.svg)](https://bugs.chromium.org/p/oss-fuzz/issues/list?sort=-opened&can=1&q=proj:json)
 [![Try online](https://img.shields.io/badge/try-online-blue.svg)](https://wandbox.org/permlink/1mp10JbaANo6FUc7)
 [![Documentation](https://img.shields.io/badge/docs-mkdocs-blue.svg)](https://json.nlohmann.me)
 [![GitHub license](https://img.shields.io/badge/license-MIT-blue.svg)](https://raw.githubusercontent.com/nlohmann/json/develop/LICENSE.MIT)
@@ -1210,18 +1210,15 @@ language bindings, format converters, and the like. See the curated [Ecosystem](

 Though it's 2026 already, the support for C++11 is still a bit sparse. Currently, the following compilers are known to work:

- GCC 4.8 - 16.2 (and possibly later)
- Clang 3.4 - 22.1 (and possibly later)
- Apple Clang 15.0 - 21.0 (and possibly later)
- Intel C++ Compiler Classic (icpc) 2021.10
- Intel oneAPI DPC++/C++ Compiler (icpx) 2025.3 (and possibly later)
- NVIDIA CUDA Compiler (nvcc) 11.8 - 12.6 (and possibly later)
- NVIDIA HPC SDK C++ Compiler (nvc++) 25.5 (and possibly later)
- Microsoft Visual C++ 2015 / MSVC 19.0 (and possibly later)
- Microsoft Visual C++ 2017 / MSVC 19.16 (and possibly later)
- Microsoft Visual C++ 2019 / MSVC 19.29 (and possibly later)
- Microsoft Visual C++ 2022 / MSVC 19.44 (and possibly later)
- Microsoft Visual C++ 2026 / MSVC 19.51 (and possibly later)
+- GCC 4.8 - 14.2 (and possibly later)
+- Clang 3.4 - 21.0 (and possibly later)
+- Apple Clang 9.1 - 16.0 (and possibly later)
+- Intel C++ Compiler 17.0.2 (and possibly later)
+- Nvidia CUDA Compiler 11.0.221 (and possibly later)
+- Microsoft Visual C++ 2015 / Build Tools 14.0.25123.0 (and possibly later)
+- Microsoft Visual C++ 2017 / Build Tools 15.5.180.51428 (and possibly later)
+- Microsoft Visual C++ 2019 / Build Tools 16.3.1+1def00d3d (and possibly later)
+- Microsoft Visual C++ 2022 / Build Tools 19.30.30709.0 (and possibly later)

 I would be happy to learn about other compilers/versions.

@@ -1415,7 +1412,7 @@ The library is compliant to version 3.3 of the [**REUSE specification**](https:/

 - Every source file contains an SPDX copyright header.
 - The full text of all licenses used in the repository can be found in the `LICENSES` folder.
- File `REUSE.toml` contains an overview of all files' copyrights and licenses.
+- File `.reuse/dep5` contains an overview of all files' copyrights and licenses.
 - Run `pipx run reuse lint` to verify the project's REUSE compliance and `pipx run reuse spdx` to generate a SPDX SBOM.

 ## Contact
@@ -1,52 +0,0 @@
-version = 1
-SPDX-PackageName = "json"
-SPDX-PackageSupplier = "Niels Lohmann <mail@nlohmann.me>"
-SPDX-PackageDownloadLocation = "https://github.com/nlohmann/json"
-
-[[annotations]]
-path = "**"
-precedence = "aggregate"
-SPDX-FileCopyrightText = "2013-2026 Niels Lohmann <https://nlohmann.me>"
-SPDX-License-Identifier = "MIT"
-
-[[annotations]]
-path = "include/nlohmann/thirdparty/hedley.hpp"
-precedence = "aggregate"
-SPDX-FileCopyrightText = "2016-2021 Evan Nemerson <evan@nemerson.com>"
-SPDX-License-Identifier = "CC0"
-
-[[annotations]]
-path = "include/nlohmann/detail/meta/cpp_future.hpp"
-precedence = "aggregate"
-SPDX-FileCopyrightText = "2013-2026 Niels Lohmann <https://nlohmann.me> and 2018 The Abseil Authors"
-SPDX-License-Identifier = "MIT AND Apache-2.0"
-
-[[annotations]]
-path = "tests/thirdparty/doctest/**"
-precedence = "aggregate"
-SPDX-FileCopyrightText = "2016-2023 Viktor Kirilov"
-SPDX-License-Identifier = "MIT"
-
-[[annotations]]
-path = "tests/thirdparty/fifo_map/**"
-precedence = "aggregate"
-SPDX-FileCopyrightText = "2015-2017 Niels Lohmann"
-SPDX-License-Identifier = "MIT"
-
-[[annotations]]
-path = "tests/thirdparty/imapdl/**"
-precedence = "aggregate"
-SPDX-FileCopyrightText = "2017 Georg Sauthoff <mail@gms.tf>"
-SPDX-License-Identifier = "GPL-3.0-only"
-
-[[annotations]]
-path = "tools/amalgamate/**"
-precedence = "aggregate"
-SPDX-FileCopyrightText = "2012 Erik Edlund <erik.edlund@32767.se>"
-SPDX-License-Identifier = "BSD-3-Clause"
-
-[[annotations]]
-path = "tools/gdb_pretty_printer/**"
-precedence = "aggregate"
-SPDX-FileCopyrightText = "2020 Hannes Domani <https://github.com/ssbssa>"
-SPDX-License-Identifier = "MIT"
@@ -249,20 +249,6 @@ add_custom_target(ci_test_strict_nul_handling
    COMMENT "Compile and test with strict NUL-byte handling enabled"
 )

-###############################################################################
-# Delete the deprecated functions.
-###############################################################################
-
-add_custom_target(ci_test_delete_deprecated_functions
-    COMMAND ${CMAKE_COMMAND}
-    -DCMAKE_BUILD_TYPE=Debug -GNinja
-    -DJSON_BuildTests=ON -DJSON_FastTests=ON -DJSON_DeleteDeprecatedFunctions=ON
-    -S${PROJECT_SOURCE_DIR} -B${PROJECT_BINARY_DIR}/build_delete_deprecated_functions
-    COMMAND ${CMAKE_COMMAND} --build ${PROJECT_BINARY_DIR}/build_delete_deprecated_functions
-    COMMAND cd ${PROJECT_BINARY_DIR}/build_delete_deprecated_functions && ${CMAKE_CTEST_COMMAND} --parallel ${N} --output-on-failure
-    COMMENT "Compile and test with the deprecated functions deleted"
-)
-
 ###############################################################################
 # Disable global UDLs.
 ###############################################################################
@@ -376,7 +362,7 @@ add_custom_target(ci_test_coverage
 # Sanitizers.
 ###############################################################################

-set(CLANG_CXX_FLAGS_SANITIZER "-g -O1 -fsanitize=address -fsanitize=undefined -fsanitize=integer -fsanitize=nullability -fno-omit-frame-pointer -fno-sanitize-recover=all -fno-sanitize=unsigned-integer-overflow -fno-sanitize=unsigned-shift-base -fsanitize-ignorelist=${PROJECT_SOURCE_DIR}/cmake/clang_sanitizer_ignorelist.txt")
+set(CLANG_CXX_FLAGS_SANITIZER "-g -O1 -fsanitize=address -fsanitize=undefined -fsanitize=integer -fsanitize=nullability -fno-omit-frame-pointer -fno-sanitize-recover=all -fno-sanitize=unsigned-integer-overflow -fno-sanitize=unsigned-shift-base")

 add_custom_target(ci_test_clang_sanitizer
    COMMAND CXX=${CLANG_TOOL} CXXFLAGS=${CLANG_CXX_FLAGS_SANITIZER} ${CMAKE_COMMAND}
@@ -459,14 +445,13 @@ add_custom_target(ci_test_single_header
 # Valgrind.
 ###############################################################################

-# The Unicode test (~17M assertions) is too slow under Valgrind.
 add_custom_target(ci_test_valgrind
    COMMAND CXX=${GCC_TOOL} ${CMAKE_COMMAND}
        -DCMAKE_BUILD_TYPE=Debug -GNinja
        -DJSON_BuildTests=ON -DJSON_Valgrind=ON
        -S${PROJECT_SOURCE_DIR} -B${PROJECT_BINARY_DIR}/build_valgrind
    COMMAND ${CMAKE_COMMAND} --build ${PROJECT_BINARY_DIR}/build_valgrind
-    COMMAND cd ${PROJECT_BINARY_DIR}/build_valgrind && ${CMAKE_CTEST_COMMAND} -L valgrind --exclude-regex "test-unicode" --parallel ${N} --output-on-failure
+    COMMAND cd ${PROJECT_BINARY_DIR}/build_valgrind && ${CMAKE_CTEST_COMMAND} -L valgrind --parallel ${N} --output-on-failure
    COMMENT "Compile and test with Valgrind"
 )

@@ -723,7 +708,7 @@ ci_get_cmake(4.0.0  CMAKE_4_0_0_BINARY)
 # the tests require CMake 3.13 or later, so they are excluded for CMake 3.5.0
 set(JSON_CMAKE_FLAGS_3_5_0 JSON_Diagnostics JSON_Diagnostic_Positions JSON_GlobalUDLs JSON_ImplicitConversions JSON_DisableEnumSerialization
    JSON_LegacyDiscardedValueComparison JSON_Install JSON_MultipleHeaders JSON_SystemInclude JSON_Valgrind
-    JSON_StrictNulHandling JSON_StrictBinaryUTF8 JSON_DeleteDeprecatedFunctions)
+    JSON_StrictNulHandling JSON_StrictBinaryUTF8)
 set(JSON_CMAKE_FLAGS_3_31_6 JSON_BuildTests ${JSON_CMAKE_FLAGS_3_5_0})
 set(JSON_CMAKE_FLAGS_4_0_0 JSON_BuildTests ${JSON_CMAKE_FLAGS_3_5_0})

@@ -791,7 +776,7 @@ foreach(COMPILER g++-4.8 g++-4.9 g++-5 g++-6 g++-7 g++-8 g++-9 g++-10 g++-11 cla
                -S${PROJECT_SOURCE_DIR} -B${PROJECT_BINARY_DIR}/build_compiler_${COMPILER}
                ${ADDITIONAL_FLAGS}
            COMMAND ${CMAKE_COMMAND} --build ${PROJECT_BINARY_DIR}/build_compiler_${COMPILER}
-            COMMAND cd ${PROJECT_BINARY_DIR}/build_compiler_${COMPILER} && ${CMAKE_CTEST_COMMAND} --parallel ${N} --output-on-failure
+            COMMAND cd ${PROJECT_BINARY_DIR}/build_compiler_${COMPILER} && ${CMAKE_CTEST_COMMAND} --parallel ${N} --exclude-regex "test-unicode" --output-on-failure
            COMMENT "Compile and test with ${COMPILER}"
        )
    endif()
@@ -805,7 +790,7 @@ add_custom_target(ci_test_compiler_default
        -S${PROJECT_SOURCE_DIR} -B${PROJECT_BINARY_DIR}/build_compiler_default
        ${ADDITIONAL_FLAGS}
    COMMAND ${CMAKE_COMMAND} --build ${PROJECT_BINARY_DIR}/build_compiler_default --parallel ${N}
-    COMMAND cd ${PROJECT_BINARY_DIR}/build_compiler_default && ${CMAKE_CTEST_COMMAND} --parallel ${N} -LE git_required --output-on-failure
+    COMMAND cd ${PROJECT_BINARY_DIR}/build_compiler_default && ${CMAKE_CTEST_COMMAND} --parallel ${N} --exclude-regex "test-unicode" -LE git_required --output-on-failure
    COMMENT "Compile and test with default C++ compiler"
 )

@@ -843,7 +828,7 @@ add_custom_target(ci_icpc
        -DJSON_BuildTests=ON -DJSON_FastTests=ON
        -S${PROJECT_SOURCE_DIR} -B${PROJECT_BINARY_DIR}/build_icpc
    COMMAND ${CMAKE_COMMAND} --build ${PROJECT_BINARY_DIR}/build_icpc
-    COMMAND cd ${PROJECT_BINARY_DIR}/build_icpc && ${CMAKE_CTEST_COMMAND} --parallel ${N} --output-on-failure
+    COMMAND cd ${PROJECT_BINARY_DIR}/build_icpc && ${CMAKE_CTEST_COMMAND} --parallel ${N} --exclude-regex "test-unicode" --output-on-failure
    COMMENT "Compile and test with ICPC"
 )

@@ -854,7 +839,7 @@ add_custom_target(ci_icpx
        -DJSON_BuildTests=ON -DJSON_FastTests=ON
        -S${PROJECT_SOURCE_DIR} -B${PROJECT_BINARY_DIR}/build_icpx
    COMMAND ${CMAKE_COMMAND} --build ${PROJECT_BINARY_DIR}/build_icpx
-    COMMAND cd ${PROJECT_BINARY_DIR}/build_icpx && ${CMAKE_CTEST_COMMAND} --parallel ${N} --output-on-failure
+    COMMAND cd ${PROJECT_BINARY_DIR}/build_icpx && ${CMAKE_CTEST_COMMAND} --parallel ${N} --exclude-regex "test-unicode" --output-on-failure
    COMMENT "Compile and test with ICPX (Intel oneAPI DPC++/C++)"
 )

@@ -890,7 +875,7 @@ add_custom_target(ci_nvhpc
    COMMAND ${CMAKE_COMMAND} --build ${PROJECT_BINARY_DIR}/build_nvhpc
    # the pipes are escaped so the surrounding shell passes them to ctest verbatim
    # instead of treating them as shell pipe operators
-    COMMAND cd ${PROJECT_BINARY_DIR}/build_nvhpc && ${CMAKE_CTEST_COMMAND} --parallel ${N} --exclude-regex "test-comparison_cpp20\\|test-comparison_legacy_cpp20\\|test-constructor1_cpp11\\|test-deserialization_cpp20" --output-on-failure
+    COMMAND cd ${PROJECT_BINARY_DIR}/build_nvhpc && ${CMAKE_CTEST_COMMAND} --parallel ${N} --exclude-regex "test-unicode\\|test-comparison_cpp20\\|test-comparison_legacy_cpp20\\|test-constructor1_cpp11\\|test-deserialization_cpp20" --output-on-failure
    COMMENT "Compile and test with NVIDIA HPC SDK (nvc++)"
 )

@@ -1,8 +0,0 @@
-# Sanitizer ignore list for ci_test_clang_sanitizer (-fsanitize-ignorelist).
-#
-# libstdc++ 14's <format> declares `_Scanner(basic_string_view<_CharT>, size_t __nargs = -1)`, so every std::format
-# call converts -1 to size_t, which -fsanitize=integer reports as implicit-integer-sign-change. This is
-# https://gcc.gnu.org/bugzilla/show_bug.cgi?id=119429, not a bug in this library. Only that check and only <format> are
-# excluded, so implicit sign changes in the library and the tests are still reported.
-[implicit-integer-sign-change]
-src:*/include/c++/*/format
@@ -48,7 +48,6 @@ cc_library(
    name = "singleheader-json",
    hdrs = [
        "single_include/nlohmann/json.hpp",
-        "single_include/nlohmann/json_fwd.hpp",
        "single_include/nlohmann/json_view.hpp",
    ],
    includes = ["single_include"],
@@ -64,7 +64,7 @@ if(MODE STREQUAL "undef")
    # recipe is self-contained and its output is byte-stable across reruns.
    # The embedded SPDX tags below are part of the *generated* file's
    # content, not a REUSE header for this .cmake script itself (which is
-    # already covered by the blanket path = "**" rule in REUSE.toml) -- keep
+    # already covered by the blanket "Files: *" rule in .reuse/dep5) -- keep
    # them wrapped in REUSE-IgnoreStart/End so `reuse lint` does not try to
    # parse "MIT\n")" as this file's own SPDX-License-Identifier value.
    # REUSE-IgnoreStart
@@ -131,7 +131,6 @@ INSERT INTO searchIndex(name, type, path) VALUES ('basic_json::to_string', 'Meth
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json::to_ubjson', 'Function', 'api/basic_json/to_ubjson/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json::value', 'Method', 'api/basic_json/value/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json::value_t', 'Enum', 'api/basic_json/value_t/index.html');
-INSERT INTO searchIndex(name, type, path) VALUES ('basic_json::with_t', 'Type', 'api/basic_json/with_t/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json::~basic_json', 'Method', 'api/basic_json/~basic_json/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_document', 'Class', 'api/basic_json_document/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('basic_json_document::basic_json_document', 'Constructor', 'api/basic_json_document/basic_json_document/index.html');
@@ -292,7 +291,6 @@ INSERT INTO searchIndex(name, type, path) VALUES ('Supported Macros', 'Guide', '
 INSERT INTO searchIndex(name, type, path) VALUES ('JSON_ASSERT', 'Macro', 'api/macros/json_assert/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('JSON_BRACE_INIT_COPY_SEMANTICS', 'Macro', 'api/macros/json_brace_init_copy_semantics/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('JSON_CATCH_USER', 'Macro', 'api/macros/json_throw_user/index.html');
-INSERT INTO searchIndex(name, type, path) VALUES ('JSON_DELETE_DEPRECATED_FUNCTIONS', 'Macro', 'api/macros/json_delete_deprecated_functions/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('JSON_DIAGNOSTICS', 'Macro', 'api/macros/json_diagnostics/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('JSON_DIAGNOSTIC_POSITIONS', 'Macro', 'api/macros/json_diagnostic_positions/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('JSON_DISABLE_ENUM_SERIALIZATION', 'Macro', 'api/macros/json_disable_enum_serialization/index.html');
@@ -323,7 +321,6 @@ INSERT INTO searchIndex(name, type, path) VALUES ('JSON_TRY_USER', 'Macro', 'api
 INSERT INTO searchIndex(name, type, path) VALUES ('JSON_USE_GLOBAL_UDLS', 'Macro', 'api/macros/json_use_global_udls/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('JSON_USE_IMPLICIT_CONVERSIONS', 'Macro', 'api/macros/json_use_implicit_conversions/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON', 'Macro', 'api/macros/json_use_legacy_discarded_value_comparison/index.html');
-INSERT INTO searchIndex(name, type, path) VALUES ('JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS', 'Macro', 'api/macros/json_use_objects_for_enum_keyed_maps/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('JSON_USE_SIMDUTF', 'Macro', 'api/macros/json_use_simdutf/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('Macros', 'Macro', 'api/macros/index.html');
 INSERT INTO searchIndex(name, type, path) VALUES ('NLOHMANN_DEFINE_DERIVED_TYPE_INTRUSIVE', 'Macro', 'api/macros/nlohmann_define_derived_type/index.html');
@@ -9,10 +9,10 @@ enum class cbor_tag_handler_t
 };
 ```

-This enumeration is used in [`from_cbor`](from_cbor.md) and [`sax_parse`](sax_parse.md) to choose how to treat tags:
+This enumeration is used in the [`from_cbor`](from_cbor.md) function to choose how to treat tags:

 error
-:   report a parse error in case of a tag (the `from_cbor` overloads throw a `parse_error` exception by default)
+:   throw a `parse_error` exception in case of a tag

 ignore
 :   ignore tags
@@ -8,7 +8,7 @@ static basic_json diff(const basic_json& source,
 Creates a [JSON Patch](http://jsonpatch.com) so that value `source` can be changed into the value `target` by calling
 [`patch`](patch.md) function.

-For two JSON values `source` and `target`, the following code always yields `#!cpp true`:
+For two JSON values `source` and `target`, the following code yields always `#!cpp true`:
 ```cpp
 source.patch(diff(source, target)) == target;
 ```
@@ -27,7 +27,7 @@ a JSON patch to convert the `source` to `target`

 ## Exception safety

-Strong guarantee: `source` and `target` are never modified.
+Strong guarantee: if an exception is thrown, there are no changes in the JSON value.

 ## Complexity

@@ -120,12 +120,3 @@ Linear in the size of the input.
 - 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.
 - Added `error_handler` parameter in version 3.13.0.
-
-!!! warning "Deprecation"
-
-    - Overload (2) replaces calls to `from_bjdata` with a pointer and a length as first two parameters, which has been
-      deprecated in version 3.13.0. This overload will be removed in version 4.0.0. Please replace all calls like
-      `#!cpp from_bjdata(ptr, len, ...);` with `#!cpp from_bjdata(ptr, ptr+len, ...);`.
-
-    You should be warned by your compiler with a `-Wdeprecated-declarations` warning if you are using a deprecated
-    function.
@@ -106,12 +106,3 @@ Linear in the size of the input.
 ## Version history

 - Added in version 3.13.0.
-
-!!! warning "Deprecation"
-
-    - Overload (2) replaces calls to `from_bon8` with a pointer and a length as first two parameters, which has been
-      deprecated in version 3.13.0. This overload will be removed in version 4.0.0. Please replace all calls like
-      `#!cpp from_bon8(ptr, len, ...);` with `#!cpp from_bon8(ptr, ptr+len, ...);`.
-
-    You should be warned by your compiler with a `-Wdeprecated-declarations` warning if you are using a deprecated
-    function.
@@ -109,9 +109,6 @@ The class satisfies the following concept requirements:
 - **initializer_list_t** - type for initializer lists of `basic_json` values
 - [**input_format_t**](input_format_t.md) - type to choose the format to parse
 - [**json_sax_t**](../json_sax/index.md) - type for SAX events
- [**with_object_t, with_array_t, with_string_t, with_boolean_t, with_integers_t, with_float_t, with_allocator_t,
-  with_json_serializer_t, with_binary_t, with_base_class_t**](with_t.md) - types to create a `basic_json` type with
-  one (or two) replaced template parameters

 ### Exceptions

@@ -56,10 +56,6 @@ This implementation does exactly follow this approach, as it uses double precisi
 smaller than `-1.79769313486232e+308` and values greater than `1.79769313486232e+308` will be stored as NaN internally
 and be serialized to `null`.

-During deserialization (from JSON text or any of the binary formats), a finite number that does not fit into
-`number_float_t` is rejected with [`out_of_range.406`](../../home/exceptions.md#jsonexceptionout_of_range406), for
-example a double-precision number in a binary format when `number_float_t` is `#!cpp float`.
-
 ### Storage

 Floating-point number values are stored directly inside a `basic_json` type.
@@ -47,9 +47,8 @@ With the default values for `NumberIntegerType` (`std::int64_t`), the default va

 When the default type is used, the maximal integer number that can be stored is `9223372036854775807` (INT64_MAX) and
 the minimal integer number that can be stored is `-9223372036854775808` (INT64_MIN). Integer numbers that are out of
-range will yield over/underflow when used in a constructor. During deserialization (from JSON text or any of the binary
-formats), too large or small integer numbers will automatically be stored as [`number_unsigned_t`](number_unsigned_t.md)
-or [`number_float_t`](number_float_t.md).
+range will yield over/underflow when used in a constructor. During deserialization, too large or small integer numbers
+will automatically be stored as [`number_unsigned_t`](number_unsigned_t.md) or [`number_float_t`](number_float_t.md).

 [RFC 8259](https://tools.ietf.org/html/rfc8259) further states:
 > Note that when such software is used, numbers that are integers and are in the range [-2<sup>53</sup>+1, 2<sup>53</sup>-1] are
@@ -48,9 +48,8 @@ With the default values for `NumberUnsignedType` (`std::uint64_t`), the default

 When the default type is used, the maximal integer number that can be stored is `18446744073709551615` (UINT64_MAX) and
 the minimal integer number that can be stored is `0`. Integer numbers that are out of range will yield over/underflow
-when used in a constructor. During deserialization (from JSON text or any of the binary formats), too large or small
-integer numbers will automatically be stored as [`number_integer_t`](number_integer_t.md) or
-[`number_float_t`](number_float_t.md).
+when used in a constructor. During deserialization, too large or small integer numbers will automatically be stored
+as [`number_integer_t`](number_integer_t.md) or [`number_float_t`](number_float_t.md).

 [RFC 8259](https://tools.ietf.org/html/rfc8259) further states:
 > Note that when such software is used, numbers that are integers and are in the range [-2<sup>53</sup>+1, 2<sup>53</sup>-1] are
@@ -8,8 +8,7 @@ static bool sax_parse(InputType&& i,
                      input_format_t format = input_format_t::json,
                      const bool strict = true,
                      const bool ignore_comments = false,
-                      const bool ignore_trailing_commas = false,
-                      const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error);
+                      const bool ignore_trailing_commas = false);

 // (2)
 template<class IteratorType, class SAX, class SentinelType = IteratorType>
@@ -18,14 +17,13 @@ static bool sax_parse(IteratorType first, SentinelType last,
                      input_format_t format = input_format_t::json,
                      const bool strict = true,
                      const bool ignore_comments = false,
-                      const bool ignore_trailing_commas = false,
-                      const cbor_tag_handler_t tag_handler = cbor_tag_handler_t::error);
+                      const bool ignore_trailing_commas = false);
 ```

 Read from input and generate SAX events

 1. Read from a compatible input.
-2. Read from a pair of character iterators, or an iterator and a sentinel of a different type (C++20 ranges support).
+2. Read from a pair of character iterators, or an iterator and a sentinel of a different type (C++20 ranges support)
    
    The value_type of the iterator must be an integral type with a size of 1, 2, or 4 bytes, which will be interpreted
    respectively as UTF-8, UTF-16, and UTF-32. If `SentinelType` differs from `IteratorType`, it must be comparable to
@@ -84,10 +82,6 @@ The SAX event lister must follow the interface of [`json_sax`](../json_sax/index
 :   whether trailing commas in arrays or objects should be ignored and treated like whitespace (`#!cpp true`) or yield a parse error
    (`#!cpp false`); (optional, `#!cpp false` by default)

-`tag_handler` (in)
-:   how to handle CBOR tags; see [`cbor_tag_handler_t`](cbor_tag_handler_t.md). Ignored for formats other than CBOR
-    (optional, `cbor_tag_handler_t::error` by default).
-
 `first` (in)
 :   iterator to the start of a character range

@@ -143,7 +137,6 @@ A UTF-8 byte order mark is silently ignored.
 - Added in version 3.2.0.
 - Ignoring comments via `ignore_comments` added in version 3.9.0.
 - Added `ignore_trailing_commas` in version 3.13.0.
- Added `tag_handler` in version 3.13.0.
 - Extended container support (1) to include types with lvalue-only ADL `begin`/`end` (matching `std::begin`/`std::end` semantics) in version 3.13.0.
 - Extended overload (2) to accept heterogeneous iterator+sentinel pairs (C++20 ranges support) in version 3.13.0.
 - `JSON_PRECISE_STREAM_POSITION` added in version 3.13.0 to optionally leave a `#!cpp std::istream` positioned right
@@ -68,8 +68,6 @@ Strong guarantee: if an exception is thrown, there are no changes in the JSON va
 - Throws [type_error.316](../../home/exceptions.md#jsonexceptiontype_error316) if a string or object key in `j` is
  not valid UTF-8 and `error_handler` is `strict` (the default only if
  [`JSON_STRICT_BINARY_UTF8`](../macros/json_strict_binary_utf8.md) is enabled)
- Throws [type_error.321](../../home/exceptions.md#jsonexceptiontype_error321) if `j` or a value nested in it is
-  discarded; example: `"cannot serialize discarded value to BJData"`

 ## Complexity

@@ -121,6 +119,4 @@ Linear in the size of the JSON value `j`.
 - BJData version parameter (for draft3 binary encoding) added in version 3.12.0.
 - Added `error_handler` parameter in version 3.13.0. Its default, `keep`, writes the bytes of a string or object key
  that is not valid UTF-8 unchanged, as before; `strict` (the default if
-  [`JSON_STRICT_BINARY_UTF8`](../macros/json_strict_binary_utf8.md) is enabled) throws `type_error.316`.
- Throws `type_error.321` for a discarded value since version 3.13.0; previously, a discarded value nested in an
-  array or object was silently skipped, producing invalid BJData.
+  [`JSON_STRICT_BINARY_UTF8`](../macros/json_strict_binary_utf8.md) is enabled) throws `type_error.316`.
@@ -58,9 +58,6 @@ Strong guarantee: if an exception is thrown, there are no changes in the JSON va
 - Throws [type_error.316](../../home/exceptions.md#jsonexceptiontype_error316) if a string or object key is
  not valid UTF-8 and `error_handler` is `strict` (the default only if
  [`JSON_STRICT_BINARY_UTF8`](../macros/json_strict_binary_utf8.md) is enabled)
- Throws [type_error.321](../../home/exceptions.md#jsonexceptiontype_error321) if a value nested in `j` is discarded
-  (the top-level value itself is covered by `type_error.317` above, since it must be an object); example:
-  `"cannot serialize discarded value to BSON"`

 ## Complexity

@@ -113,8 +110,6 @@ pass before anything is written.
 - Throws `out_of_range.412` and `out_of_range.415` since version 3.13.0.
 - Linear in the size of `j`, and no longer limited by the call stack for deeply nested values, since version 3.13.0.
 - `out_of_range.415` is now detected before anything is written, like the other exceptions above, since version 3.13.0.
- Throws `type_error.321` for a discarded value nested in `j` since version 3.13.0; previously, it was silently
-  skipped, producing a document whose declared size did not match what was actually written.
 - Added `error_handler` parameter in version 3.13.0. Its default, `keep`, writes the bytes of a string or object key
  that is not valid UTF-8 unchanged, as before; `strict` (the default if
  [`JSON_STRICT_BINARY_UTF8`](../macros/json_strict_binary_utf8.md) is enabled) throws `type_error.316` before anything
@@ -49,8 +49,6 @@ Strong guarantee: if an exception is thrown, there are no changes in the JSON va
 - Throws [type_error.316](../../home/exceptions.md#jsonexceptiontype_error316) if a string or object key in `j` is
  not valid UTF-8 and `error_handler` is `strict` (the default only if
  [`JSON_STRICT_BINARY_UTF8`](../macros/json_strict_binary_utf8.md) is enabled)
- Throws [type_error.321](../../home/exceptions.md#jsonexceptiontype_error321) if `j` or a value nested in it is
-  discarded; example: `"cannot serialize discarded value to CBOR"`

 ## Complexity

@@ -88,5 +86,3 @@ Linear in the size of the JSON value `j`.
 - Added `error_handler` parameter in version 3.13.0. Its default, `keep`, writes the bytes of a string or object key
  that is not valid UTF-8 unchanged, as before; `strict` (the default if
  [`JSON_STRICT_BINARY_UTF8`](../macros/json_strict_binary_utf8.md) is enabled) throws `type_error.316`.
- Throws `type_error.321` for a discarded value since version 3.13.0; previously, a discarded value nested in an
-  array or object was silently skipped, producing invalid CBOR.
@@ -54,8 +54,6 @@ Strong guarantee: if an exception is thrown, there are no changes in the JSON va
  `"subtype 70000 is too large for the MessagePack ext type (max 255)"`
 - Throws [type_error.316](../../home/exceptions.md#jsonexceptiontype_error316) if a string or object key in `j` is
  not valid UTF-8 and `error_handler` is `strict`
- Throws [type_error.321](../../home/exceptions.md#jsonexceptiontype_error321) if `j` or a value nested in it is
-  discarded; example: `"cannot serialize discarded value to MessagePack"`

 ## Complexity

@@ -110,5 +108,3 @@ Linear in the size of the JSON value `j`.
 - Fixed in version 3.13.0 to serialize `number_integer_t`/`number_unsigned_t` pairs of different width correctly;
  before, integers could be serialized with the wrong value if `number_integer_t` was narrower than
  `number_unsigned_t`.
- Throws `type_error.321` for a discarded value since version 3.13.0; previously, a discarded value nested in an
-  array or object was silently skipped, producing invalid MessagePack.
@@ -61,8 +61,6 @@ Strong guarantee: if an exception is thrown, there are no changes in the JSON va
 - Throws [type_error.316](../../home/exceptions.md#jsonexceptiontype_error316) if a string or object key in `j` is
  not valid UTF-8 and `error_handler` is `strict` (the default only if
  [`JSON_STRICT_BINARY_UTF8`](../macros/json_strict_binary_utf8.md) is enabled)
- Throws [type_error.321](../../home/exceptions.md#jsonexceptiontype_error321) if `j` or a value nested in it is
-  discarded; example: `"cannot serialize discarded value to UBJSON"`

 ## Complexity

@@ -114,5 +112,3 @@ Linear in the size of the JSON value `j`.
 - Added `error_handler` parameter in version 3.13.0. Its default, `keep`, writes the bytes of a string or object key
  that is not valid UTF-8 unchanged, as before; `strict` (the default if
  [`JSON_STRICT_BINARY_UTF8`](../macros/json_strict_binary_utf8.md) is enabled) throws `type_error.316`.
- Throws `type_error.321` for a discarded value since version 3.13.0; previously, a discarded value nested in an
-  array or object was silently skipped, producing invalid UBJSON.
@@ -1,136 +0,0 @@
-# <small>nlohmann::basic_json::</small>with_t
-
-Member alias templates `with_object_t`, `with_array_t`, `with_string_t`, `with_boolean_t`, `with_integers_t`,
-`with_float_t`, `with_allocator_t`, `with_json_serializer_t`, `with_binary_t`, and `with_base_class_t`.
-
-```cpp
-template<template<typename, typename, typename...> class ObjectType2>
-using with_object_t = basic_json<ObjectType2, ArrayType, StringType, BooleanType,
-      NumberIntegerType, NumberUnsignedType, NumberFloatType,
-      AllocatorType, JSONSerializer, BinaryType, CustomBaseClass>;
-
-template<template<typename, typename...> class ArrayType2>
-using with_array_t = basic_json<ObjectType, ArrayType2, StringType, BooleanType,
-      NumberIntegerType, NumberUnsignedType, NumberFloatType,
-      AllocatorType, JSONSerializer, BinaryType, CustomBaseClass>;
-
-template<class StringType2>
-using with_string_t = basic_json<ObjectType, ArrayType, StringType2, BooleanType,
-      NumberIntegerType, NumberUnsignedType, NumberFloatType,
-      AllocatorType, JSONSerializer, BinaryType, CustomBaseClass>;
-
-template<class BooleanType2>
-using with_boolean_t = basic_json<ObjectType, ArrayType, StringType, BooleanType2,
-      NumberIntegerType, NumberUnsignedType, NumberFloatType,
-      AllocatorType, JSONSerializer, BinaryType, CustomBaseClass>;
-
-template<class NumberIntegerType2, class NumberUnsignedType2>
-using with_integers_t = basic_json<ObjectType, ArrayType, StringType, BooleanType,
-      NumberIntegerType2, NumberUnsignedType2, NumberFloatType,
-      AllocatorType, JSONSerializer, BinaryType, CustomBaseClass>;
-
-template<class NumberFloatType2>
-using with_float_t = basic_json<ObjectType, ArrayType, StringType, BooleanType,
-      NumberIntegerType, NumberUnsignedType, NumberFloatType2,
-      AllocatorType, JSONSerializer, BinaryType, CustomBaseClass>;
-
-template<template<typename> class AllocatorType2>
-using with_allocator_t = basic_json<ObjectType, ArrayType, StringType, BooleanType,
-      NumberIntegerType, NumberUnsignedType, NumberFloatType,
-      AllocatorType2, JSONSerializer, BinaryType, CustomBaseClass>;
-
-template<template<typename, typename = void> class JSONSerializer2>
-using with_json_serializer_t = basic_json<ObjectType, ArrayType, StringType, BooleanType,
-      NumberIntegerType, NumberUnsignedType, NumberFloatType,
-      AllocatorType, JSONSerializer2, BinaryType, CustomBaseClass>;
-
-template<class BinaryType2>
-using with_binary_t = basic_json<ObjectType, ArrayType, StringType, BooleanType,
-      NumberIntegerType, NumberUnsignedType, NumberFloatType,
-      AllocatorType, JSONSerializer, BinaryType2, CustomBaseClass>;
-
-template<class CustomBaseClass2>
-using with_base_class_t = basic_json<ObjectType, ArrayType, StringType, BooleanType,
-      NumberIntegerType, NumberUnsignedType, NumberFloatType,
-      AllocatorType, JSONSerializer, BinaryType, CustomBaseClass2>;
-```
-
-These member alias templates make it easier to create a `basic_json` type that is identical to the current type except
-for one (or, in the case of `with_integers_t`, two) of its [template parameters](index.md#template-parameters).
-Spelling out all 11 template parameters of `basic_json` just to change a single one is verbose and error-prone; these
-aliases only require the replacement type(s).
-
-with_object_t&lt;ObjectType2&gt;
-:   replaces `ObjectType`
-
-with_array_t&lt;ArrayType2&gt;
-:   replaces `ArrayType`
-
-with_string_t&lt;StringType2&gt;
-:   replaces `StringType`
-
-with_boolean_t&lt;BooleanType2&gt;
-:   replaces `BooleanType`
-
-with_integers_t&lt;NumberIntegerType2, NumberUnsignedType2&gt;
-:   replaces both `NumberIntegerType` and `NumberUnsignedType`; the two are combined into a single alias because they
-    are usually changed together (for instance, when switching to fixed-width integer types)
-
-with_float_t&lt;NumberFloatType2&gt;
-:   replaces `NumberFloatType`
-
-with_allocator_t&lt;AllocatorType2&gt;
-:   replaces `AllocatorType`
-
-with_json_serializer_t&lt;JSONSerializer2&gt;
-:   replaces `JSONSerializer`
-
-with_binary_t&lt;BinaryType2&gt;
-:   replaces `BinaryType`
-
-with_base_class_t&lt;CustomBaseClass2&gt;
-:   replaces `CustomBaseClass`; see also [`json_base_class_t`](json_base_class_t.md)
-
-## Notes
-
-All other template parameters are kept unchanged, so the resulting type still uses, for instance, the same
-`ObjectType` unless `with_object_t` itself is used.
-
-The aliases are members of every `basic_json` specialization, including [`ordered_json`](../ordered_json.md), and the
-type they produce is again a `basic_json` specialization. They can therefore be chained to replace several template
-parameters at once:
-
-```cpp
-using my_json = nlohmann::json::with_integers_t<int, unsigned int>::with_float_t<float>;
-using my_ordered_json = nlohmann::ordered_json::with_string_t<std::wstring>;
-```
-
-The result is the same type as spelling out all template parameters, so the order of the chained aliases does not
-matter. For instance, `nlohmann::json::with_object_t<nlohmann::ordered_map>` is `nlohmann::ordered_json`.
-
-## Examples
-
-??? example
-
-    The following code shows how `with_object_t` can be used to create a JSON type that stores object elements in a
-    `std::map` and therefore keeps them sorted by key, unlike the default type which preserves insertion order
-    only when `nlohmann::ordered_json` is used.
-
-    ```cpp
-    --8<-- "examples/with_t.cpp"
-    ```
-
-    Output:
-
-    ```json
-    --8<-- "examples/with_t.output"
-    ```
-
-## See also
-
- [basic_json](index.md#template-parameters) - the template parameters that can be replaced
- [json_base_class_t](json_base_class_t.md) - the type used for `CustomBaseClass`
-
-## Version history
-
- Added in version 3.13.0.
@@ -60,13 +60,6 @@ header. See also the [macro overview page](../../features/macros.md).
 - [**JSON_DISABLE_ENUM_SERIALIZATION**](json_disable_enum_serialization.md) - switch off default serialization/deserialization functions for enums
 - [**JSON_DISABLE_TUPLE_REFERENCE_CONVERSION**](json_disable_tuple_reference_conversion.md) - switch off conversion from a one-element tuple of a JSON reference
 - [**JSON_USE_IMPLICIT_CONVERSIONS**](json_use_implicit_conversions.md) - control implicit conversions
- [**JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS**](json_use_objects_for_enum_keyed_maps.md) - opt in to storing maps with enum
-  keys as objects
-
-## Deprecated functions
-
- [**JSON_DELETE_DEPRECATED_FUNCTIONS**](json_delete_deprecated_functions.md) - opt in to deleting the deprecated
-  functions ahead of their removal in version 4.0.0

 ## Comparison behavior

@@ -50,11 +50,9 @@ The default value is `0` (disabled — existing behavior is preserved).
    ```

    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 *written as a braced list*, such as `{{"key", "value"}}`, which still
-    creates an object, are not affected. This exception is based on how the pair is written, not on the shape of its
-    value: an existing JSON value that happens to be a two-element array with a string as its first element, such as
-    `json arr = {"key", 42};`, is still copied by `json j{arr};` rather than turned into an object. The library's own
-    conversions are not affected either: for example, `std::tuple<int>{5}` still becomes `[5]`.
+    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"

@@ -1,96 +0,0 @@
-# JSON_DELETE_DEPRECATED_FUNCTIONS
-
-```cpp
-#define JSON_DELETE_DEPRECATED_FUNCTIONS /* value */
-```
-
-When defined to `1`, all [deprecated functions](../../community/roadmap.md#removal-of-deprecated-functions) of the
-library are declared as deleted (`= delete`) instead of only being marked as deprecated. Code that still calls one of
-them no longer compiles. This way, you can find all calls that need to be replaced before version 4.0.0 removes these
-functions; the [migration guide](../../integration/migration_guide.md#replace-deprecated-functions) describes how.
-
-A deleted function, unlike a removed one, still takes part in overload resolution. A call that would select it
-therefore fails to compile instead of silently selecting another overload. This matters for the deprecated
-`from_*(ptr, len)` overloads of [`from_cbor`](../basic_json/from_cbor.md), [`from_msgpack`](../basic_json/from_msgpack.md),
-[`from_ubjson`](../basic_json/from_ubjson.md), [`from_bjdata`](../basic_json/from_bjdata.md),
-[`from_bon8`](../basic_json/from_bon8.md), and [`from_bson`](../basic_json/from_bson.md): without them, a call like
-`from_cbor(ptr, len)` would compile, read `ptr` as a NUL-terminated string, and convert `len` to the `strict` parameter.
-
-The macro does not affect the deprecated legacy comparison of discarded values, which is controlled by
-[`JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON`](json_use_legacy_discarded_value_comparison.md).
-
-## Default definition
-
-The default value is `0` (disabled, the deprecated functions can still be called, and the compiler warns about it).
-
-```cpp
-#define JSON_DELETE_DEPRECATED_FUNCTIONS 0
-```
-
-## Notes
-
-!!! info "CMake option"
-
-    The macro can also be set with the CMake option
-    [`JSON_DeleteDeprecatedFunctions`](../../integration/cmake.md#json_deletedeprecatedfunctions) (`OFF` by default).
-
-!!! warning "Opt-in only"
-
-    This macro must be defined **before** including `<nlohmann/json.hpp>`. Defining it after the include has no
-    effect. Define it for the whole project to avoid different declarations of the same class in different
-    translation units.
-
-!!! note "ABI compatibility"
-
-    The macro only turns calls that compile into calls that do not; it does not change the layout or the behavior of
-    any type. Its value is therefore not encoded in the [namespace](../../features/namespace.md).
-
-## Examples
-
-??? example "Example: default behavior (macro not defined)"
-
-    Without the macro, the deprecated overload is called, and the compiler warns about it:
-
-    ```cpp
-    #include <nlohmann/json.hpp>
-
-    using json = nlohmann::json;
-
-    int main()
-    {
-        const std::vector<std::uint8_t> v = {0x82, 0x01, 0x02};
-        auto j = json::from_cbor(v.data(), v.size());
-        // warning: 'from_cbor' is deprecated: Since 3.8.0; use from_cbor(ptr, ptr + len)
-    }
-    ```
-
-??? example "Example: deleted deprecated functions (macro defined to 1)"
-
-    With the macro, the call does not compile:
-
-    ```cpp
-    #define JSON_DELETE_DEPRECATED_FUNCTIONS 1
-    #include <nlohmann/json.hpp>
-
-    using json = nlohmann::json;
-
-    int main()
-    {
-        const std::vector<std::uint8_t> v = {0x82, 0x01, 0x02};
-        auto j = json::from_cbor(v.data(), v.size());
-        // error: call to deleted function 'from_cbor'
-    }
-    ```
-
-## See also
-
- [Roadmap: removal of deprecated functions](../../community/roadmap.md#removal-of-deprecated-functions) - the
-  deprecated functions and the version they were deprecated in
- [Migration guide: replace deprecated functions](../../integration/migration_guide.md#replace-deprecated-functions) -
-  how to replace each deprecated function
-
-## Version history
-
- Added in version 3.13.0.
- Planned to be removed in version 4.0.0, which removes the deprecated functions. The deprecated `from_*(ptr, len)`
-  overloads stay deleted in version 4.0.0.
@@ -112,4 +112,3 @@ The default value is `0` (disabled — existing behavior is preserved).
 ## Version history

 - Added in version 3.13.0.
- Planned to become the default (with the macro removed) in version 4.0.0.
@@ -44,7 +44,7 @@ By default, implicit conversions are enabled.

 ## Examples

-??? example "Example: implicit and explicit conversions"
+??? example "Example: implicit conversion"

    This is an example for an implicit conversion:

@@ -1,139 +0,0 @@
-# JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS
-
-```cpp
-#define JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS /* value */
-```
-
-When defined to `1`, maps whose keys are enums (such as `std::map<E, T>` or `std::unordered_map<E, T>`) are stored as
-JSON objects, using the enum's own conversion for the keys. By default, they are stored as arrays of `[key, value]`
-pairs.
-
-## Default definition
-
-The default value is `0` (disabled — existing behavior is preserved).
-
-```cpp
-#define JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS 0
-```
-
-## Notes
-
-!!! note "Background"
-
-    JSON object keys are strings, so a map is only stored as an object if its keys can be converted to a string type.
-    Enums are not, even if [`NLOHMANN_JSON_SERIALIZE_ENUM`](nlohmann_json_serialize_enum.md) maps them to strings, so a
-    map with enum keys becomes an array of `[key, value]` pairs:
-
-    ```json
-    [["stopped", "aa"], ["completed", "bb"]]
-    ```
-
-    With this macro, the same map becomes an object
-    (see [#4378](https://github.com/nlohmann/json/issues/4378)):
-
-    ```json
-    {"completed": "bb", "stopped": "aa"}
-    ```
-
-!!! note "Maps with non-unique keys"
-
-    Maps that allow duplicate keys, such as `std::multimap<E, T>` or `std::unordered_multimap<E, T>`, are not affected
-    by the macro and are still stored as arrays of `[key, value]` pairs, as an object cannot hold duplicate keys.
-
-!!! note "Reading"
-
-    Reading is not affected by the macro: a map with enum keys can always be read from both an array of pairs and an
-    object. For the latter, each key is converted to the enum with its `from_json` function, e.g., the one defined by
-    [`NLOHMANN_JSON_SERIALIZE_ENUM`](nlohmann_json_serialize_enum.md). Data written without the macro can therefore
-    still be read after enabling it.
-
-!!! warning "Keys must serialize to distinct strings"
-
-    Each key is converted with the enum's `to_json` function. If a key is not converted to a string (for instance, an
-    enum without [`NLOHMANN_JSON_SERIALIZE_ENUM`](nlohmann_json_serialize_enum.md), which is stored as an integer, or an
-    enumerator mapped to `nullptr`), [`type_error.302`](../../home/exceptions.md#jsonexceptiontype_error302) is thrown.
-    If two keys are converted to the same string (for instance, because
-    [`NLOHMANN_JSON_SERIALIZE_ENUM`](nlohmann_json_serialize_enum.md) maps an unlisted enumerator to the first entry),
-    [`type_error.318`](../../home/exceptions.md#jsonexceptiontype_error318) is thrown. In both cases, the target value
-    is not changed.
-
-!!! warning "Opt-in only"
-
-    This macro must be defined **before** including `<nlohmann/json.hpp>`. Defining it after the include has no effect.
-
-!!! note "ABI compatibility"
-
-    The value of this macro is encoded in the [namespace](../../features/namespace.md) (tag `_ekmo`), 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.
-
-## Examples
-
-??? example "Example: default behavior (macro not defined)"
-
-    Without the macro, a map with enum keys is stored as an array of pairs:
-
-    ```cpp
-    #include <map>
-    #include <nlohmann/json.hpp>
-
-    using json = nlohmann::json;
-
-    enum TaskState { TS_STOPPED, TS_RUNNING, TS_COMPLETED };
-
-    NLOHMANN_JSON_SERIALIZE_ENUM(TaskState, {
-        {TS_STOPPED, "stopped"},
-        {TS_RUNNING, "running"},
-        {TS_COMPLETED, "completed"},
-    })
-
-    int main()
-    {
-        std::map<TaskState, std::string> m = {{TS_STOPPED, "aa"}, {TS_COMPLETED, "bb"}};
-
-        json j = m;
-        // j is [["stopped","aa"],["completed","bb"]]
-    }
-    ```
-
-??? example "Example: objects for enum-keyed maps (macro defined to 1)"
-
-    With the macro, the same map is stored as an object:
-
-    ```cpp
-    #define JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS 1
-    #include <map>
-    #include <nlohmann/json.hpp>
-
-    using json = nlohmann::json;
-
-    enum TaskState { TS_STOPPED, TS_RUNNING, TS_COMPLETED };
-
-    NLOHMANN_JSON_SERIALIZE_ENUM(TaskState, {
-        {TS_STOPPED, "stopped"},
-        {TS_RUNNING, "running"},
-        {TS_COMPLETED, "completed"},
-    })
-
-    int main()
-    {
-        std::map<TaskState, std::string> m = {{TS_STOPPED, "aa"}, {TS_COMPLETED, "bb"}};
-
-        json j = m;
-        // j is {"completed":"bb","stopped":"aa"}
-
-        auto m2 = j.get<std::map<TaskState, std::string>>();
-        // m2 == m
-    }
-    ```
-
-## See also
-
- [Specializing enum conversion](../../features/enum_conversion.md)
- [**NLOHMANN_JSON_SERIALIZE_ENUM**](nlohmann_json_serialize_enum.md) - serialize/deserialize an enum
- [**NLOHMANN_JSON_SERIALIZE_ENUM_STRICT**](nlohmann_json_serialize_enum_strict.md) - serialize/deserialize an enum with
-  exceptions
-
-## Version history
-
- Added in version 3.13.0.
@@ -41,9 +41,6 @@ inline void from_json(const BasicJsonType& j, type& e);
      conversion. Select this default pair carefully. See example 1 below.
    - If an enum or JSON value is specified in multiple conversions, the first matching conversion from the top of the
      list will be returned when converting to or from JSON. See example 2 below.
-    - Maps with enum keys (e.g., `std::map<ENUM_TYPE, T>`) are stored as arrays of `[key, value]` pairs by default.
-      Define [`JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS`](json_use_objects_for_enum_keyed_maps.md) to store them as objects
-      with the converted keys. Such maps can be read from both forms.

 ## Examples

@@ -83,7 +80,6 @@ inline void from_json(const BasicJsonType& j, type& e);
 - [Specializing enum conversion](../../features/enum_conversion.md)
 - [`NLOHMANN_JSON_SERIALIZE_ENUM_STRICT`](./nlohmann_json_serialize_enum_strict.md)
 - [`JSON_DISABLE_ENUM_SERIALIZATION`](json_disable_enum_serialization.md)
- [`JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS`](json_use_objects_for_enum_keyed_maps.md)

 ## Version history

@@ -44,9 +44,6 @@ inline void from_json(const BasicJsonType& j, type& e);
      `"enum value out of range for <type>"`.
    - If an enum or JSON value is specified in multiple conversions, the first matching conversion from the top of the
      list will be returned when converting to or from JSON. See example 2 below.
-    - Maps with enum keys (e.g., `std::map<ENUM_TYPE, T>`) are stored as arrays of `[key, value]` pairs by default.
-      Define [`JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS`](json_use_objects_for_enum_keyed_maps.md) to store them as objects
-      with the converted keys. Such maps can be read from both forms.

 ## Examples

@@ -102,7 +99,6 @@ inline void from_json(const BasicJsonType& j, type& e);
 - [Specializing enum conversion](../../features/enum_conversion.md)
 - [`NLOHMANN_JSON_SERIALIZE_ENUM`](./nlohmann_json_serialize_enum.md)
 - [`JSON_DISABLE_ENUM_SERIALIZATION`](json_disable_enum_serialization.md)
- [`JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS`](json_use_objects_for_enum_keyed_maps.md)

 ## Version history

@@ -21,18 +21,17 @@ Note: Some modern features (like C++20 ranges or filesystem support) may be disa
      
        | Compiler                                     | Architecture | Operating System                  | CI        |
        |----------------------------------------------|--------------|-----------------------------------|-----------|
+        | AppleClang 15.0.0.15000040; Xcode 15.0.1     | arm64        | macOS 14.7.2 (Sonoma)             | GitHub    |
+        | AppleClang 15.0.0.15000100; Xcode 15.1       | arm64        | macOS 14.7.2 (Sonoma)             | GitHub    |
+        | AppleClang 15.0.0.15000100; Xcode 15.2       | arm64        | macOS 14.7.2 (Sonoma)             | GitHub    |
+        | AppleClang 15.0.0.15000309; Xcode 15.3       | arm64        | macOS 14.7.2 (Sonoma)             | GitHub    |
+        | AppleClang 15.0.0.15000309; Xcode 15.4       | arm64        | macOS 14.7.2 (Sonoma)             | GitHub    |
        | AppleClang 16.0.0.16000026; Xcode 16         | arm64        | macOS 15.2 (Sequoia)              | GitHub    |
        | AppleClang 16.0.0.16000026; Xcode 16.1       | arm64        | macOS 15.2 (Sequoia)              | GitHub    |
        | AppleClang 16.0.0.16000026; Xcode 16.2       | arm64        | macOS 15.2 (Sequoia)              | GitHub    |
        | AppleClang 17.0.0.17000013; Xcode 16.3       | arm64        | macOS 15.5 (Sequoia)              | GitHub    |
        | AppleClang 17.0.0.17000013; Xcode 16.4       | arm64        | macOS 15.5 (Sequoia)              | GitHub    |
        | AppleClang 17.0.0.17000319; Xcode 26.0.1     | arm64        | macOS 15.5 (Sequoia)              | GitHub    |
-        | AppleClang 17.0.0.17000404; Xcode 26.1.1     | arm64        | macOS 15.7.9 (Sequoia)            | GitHub    |
-        | AppleClang 17.0.0.17000603; Xcode 26.2       | arm64        | macOS 15.7.9 (Sequoia)            | GitHub    |
-        | AppleClang 17.0.0.17000604; Xcode 26.3       | arm64        | macOS 15.7.9 (Sequoia)            | GitHub    |
-        | AppleClang 21.0.0.21000099; Xcode 26.4.1     | arm64        | macOS 26.6.2 (Tahoe)              | GitHub    |
-        | AppleClang 21.0.0.21000101; Xcode 26.5       | arm64        | macOS 26.6.2 (Tahoe)              | GitHub    |
-        | AppleClang 21.0.0.21000101; Xcode 26.6       | arm64        | macOS 26.6.2 (Tahoe)              | GitHub    |
        | Clang 3.4.2                                  | x86_64       | Ubuntu 22.04.1 LTS                | GitHub    |
        | Clang 3.5.2                                  | x86_64       | Ubuntu 22.04.1 LTS                | GitHub    |
        | Clang 3.6.2                                  | x86_64       | Ubuntu 22.04.1 LTS                | GitHub    |
@@ -90,7 +89,7 @@ Note: Some modern features (like C++20 ranges or filesystem support) may be disa
        | GNU 13.3.0                                   | x86_64       | Ubuntu 22.04.1 LTS                | GitHub    |
        | GNU 14.2.0                                   | x86_64       | Ubuntu 22.04.1 LTS                | GitHub    |
        | GNU 15.1.0                                   | x86_64       | Ubuntu 22.04.1 LTS                | GitHub    |
-        | GNU 16.2.0                                   | x86_64       | Ubuntu 22.04.1 LTS                | GitHub    |
+        | GNU 16.1.0                                   | x86_64       | Ubuntu 22.04.1 LTS                | GitHub    |
        | GNU 16.1.0                                   | arm64        | Ubuntu 24.04                      | GitHub    |
        | icpc (ICC) 2021.10.0 20230609                | x86_64       | Ubuntu 22.04 LTS                  | GitHub    |
        | icpx (Intel oneAPI DPC++/C++) 2025.3.2       | x86_64       | Ubuntu 24.04 LTS                  | GitHub    |
@@ -25,7 +25,9 @@ work items are tracked in the [GitHub milestones](https://github.com/nlohmann/js

 ## What the project will not do

- **Break the public API of version 3.x.** See [API stability](#api-stability) for what this covers.
+- **Break the public API of version 3.x.** See the
+  [contribution guidelines](https://github.com/nlohmann/json/blob/develop/.github/CONTRIBUTING.md#break-the-public-api)
+  for what counts as a breaking change.
 - **Require a newer C++ standard than C++11.**
 - **Break JSON conformance** or enable non-standard extensions by default.
 - **Add dependencies** or require a build step. The library remains header-only, and the single header
@@ -33,32 +35,6 @@ work items are tracked in the [GitHub milestones](https://github.com/nlohmann/js
 - **Trade simplicity for speed or memory efficiency.** Performance improvements are welcome, but the library is not
  meant to compete with the fastest JSON libraries, see [Design goals](../home/design_goals.md).

-## API stability
-
-Releases follow [semantic versioning](https://semver.org): a minor or patch release of version 3.x does not break code
-that uses the public API. In particular, a 3.x release does not:
-
- change the signature of a function (its parameter types, return type, number of parameters, or the const-ness of a
-  member function);
- remove or rename a function or class;
- change which exceptions a function throws, or the [exception ids](../home/exceptions.md);
- change access specifiers or default arguments.
-
-Exceptions to these rules, for instance when fixing a bug requires changing the exception a function throws, are
-documented in the [release notes](../home/releases.md).
-
-The following are **not** part of the public API and may change in any release, including patch releases:
-
- The text of exception messages returned by `what()`. Use the [exception id](../home/exceptions.md) to tell errors
-  apart.
- The ABI, including `sizeof(basic_json)` and the memory layout of its values. Recompile your code when you upgrade the
-  library. The [versioned inline namespace](../features/namespace.md) turns mixing versions into a link error.
- Everything in namespace `nlohmann::detail`, and macros and type traits that are not documented in the
-  [API reference](../api/basic_json/index.md).
-
-Changes that would break the public API are only added behind a macro whose default keeps the 3.x behavior, see
-[Version 4.0](#version-40).
-
 ## Version 4.0

 There is no release date for version 4.0 yet. Proposals that need a major version, for instance stricter type
@@ -88,8 +64,6 @@ The following macros guard changes that are planned to become the default in ver
 | [`JSON_PRECISE_STREAM_POSITION`](../api/macros/json_precise_stream_position.md)                                  | `0`         | `1`: reading from a stream does not consume the character after a number                                                      | –                                                                                                                  | 3.13.0 |
 | [`JSON_STRICT_NUL_HANDLING`](../api/macros/json_strict_nul_handling.md)                                          | `0`         | `1`: a NUL byte in the input is a parse error instead of the end of input                                                     | [`JSON_StrictNulHandling`](../integration/cmake.md#json_strictnulhandling)                                         | 3.13.0 |
 | [`JSON_STRICT_BINARY_UTF8`](../api/macros/json_strict_binary_utf8.md)                                            | `0`         | `1`: `to_cbor`, `to_ubjson`, `to_bjdata`, and `to_bson` throw for strings that are not valid UTF-8 by default                 | [`JSON_StrictBinaryUTF8`](../integration/cmake.md#json_strictbinaryutf8)                                           | 3.13.0 |
-| [`JSON_DISABLE_TUPLE_REFERENCE_CONVERSION`](../api/macros/json_disable_tuple_reference_conversion.md)            | `0`         | `1`: a `basic_json` value can no longer be created from a one-element tuple of a reference to it, such as `std::forward_as_tuple(j)`| [`JSON_DisableTupleReferenceConversion`](../integration/cmake.md#json_disabletuplereferenceconversion)             | 3.13.0 |
-| [`JSON_DELETE_DEPRECATED_FUNCTIONS`](../api/macros/json_delete_deprecated_functions.md)                          | `0`         | removed: the deprecated functions are removed (see below); the `from_*(ptr, len)` overloads stay deleted                      | [`JSON_DeleteDeprecatedFunctions`](../integration/cmake.md#json_deletedeprecatedfunctions)                         | 3.13.0 |

 For example, the following makes a 3.x release behave like version 4.0 with respect to these changes:

@@ -101,8 +75,6 @@ For example, the following makes a 3.x release behave like version 4.0 with resp
 #define JSON_PRECISE_STREAM_POSITION 1
 #define JSON_STRICT_NUL_HANDLING 1
 #define JSON_STRICT_BINARY_UTF8 1
-#define JSON_DISABLE_TUPLE_REFERENCE_CONVERSION 1
-#define JSON_DELETE_DEPRECATED_FUNCTIONS 1
 #include <nlohmann/json.hpp>
 ```

@@ -112,13 +84,8 @@ way to achieve this.
 ### Removal of deprecated functions

 Version 4.0 will remove all deprecated functions. Compiling with deprecation warnings enabled shows which of them your
-code still uses. Defining [`JSON_DELETE_DEPRECATED_FUNCTIONS`](../api/macros/json_delete_deprecated_functions.md) to
-`1` turns these warnings into errors, as the deprecated functions are then deleted. The
-[migration guide](../integration/migration_guide.md#replace-deprecated-functions) shows how to replace each of them.
-
-The `from_*` overloads taking a pointer and a length are not removed in version 4.0, but stay deleted. Without them, a
-call like `from_cbor(ptr, len)` would still compile: it would read `ptr` as a NUL-terminated string and convert `len`
-to the `strict` parameter.
+code still uses. The [migration guide](../integration/migration_guide.md#replace-deprecated-functions) shows how to
+replace each of them.

 | Deprecated                                                                                                                                                                                                                                         | Since  | Migration                                                                        |
 |----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------|----------------------------------------------------------------------------------|
@@ -130,7 +97,6 @@ to the `strict` parameter.
 | [`json_pointer::operator string_t`](../api/json_pointer/operator_string_t.md)                                                                                                                                                                      | 3.11.0 | [JSON Pointers](../integration/migration_guide.md#json-pointers)                 |
 | [`json_pointer`](../api/json_pointer/index.md) with a `basic_json` type as template argument, and the overloads of `value`, `contains`, `operator[]`, and `at` accepting such a pointer                                                           | 3.11.0 | [JSON Pointers](../integration/migration_guide.md#json-pointers)                 |
 | Comparing a [`json_pointer`](../api/json_pointer/index.md) with a string via [`operator==`](../api/json_pointer/operator_eq.md) or [`operator!=`](../api/json_pointer/operator_ne.md)                                                              | 3.11.2 | [JSON Pointers](../integration/migration_guide.md#json-pointers)                 |
-| [`from_bjdata`](../api/basic_json/from_bjdata.md) and [`from_bon8`](../api/basic_json/from_bon8.md) with `(ptr, len)`                                                                                                                              | 3.13.0 | [Parsing](../integration/migration_guide.md#parsing)                             |

 The deprecated legacy comparison of discarded values is controlled by a macro and therefore listed in the table above.

@@ -13,7 +13,19 @@ class visitor_adaptor_with_metadata
    void do_visit(const Ptr& ptr, const Fnc& fnc) const;
 };

-using json = nlohmann::json::with_base_class_t<visitor_adaptor_with_metadata>;
+using json = nlohmann::basic_json <
+             std::map,
+             std::vector,
+             std::string,
+             bool,
+             std::int64_t,
+             std::uint64_t,
+             double,
+             std::allocator,
+             nlohmann::adl_serializer,
+             std::vector<std::uint8_t>,
+             visitor_adaptor_with_metadata
+             >;

 template <class Fnc>
 void visitor_adaptor_with_metadata::visit(const Fnc& fnc) const
@@ -1,18 +0,0 @@
-#include <iostream>
-#include <map>
-#include <nlohmann/json.hpp>
-
-// a JSON type that stores objects in a std::map (which keeps keys sorted)
-// instead of the default ordered associative container
-using sorted_json = nlohmann::json::with_object_t<std::map>;
-
-int main()
-{
-    sorted_json j;
-    j["c"] = 1;
-    j["a"] = 2;
-    j["b"] = 3;
-
-    // keys are sorted, because std::map is used to store the object
-    std::cout << j.dump() << std::endl;
-}
@@ -1 +0,0 @@
-{"a":2,"b":3,"c":1}
@@ -131,7 +131,6 @@ The library maps CBOR types to JSON value types as follows:
 | Byte string            | binary          | 0x59       |
 | Byte string            | binary          | 0x5A       |
 | Byte string            | binary          | 0x5B       |
-| Byte string            | binary          | 0x5F       |
 | UTF-8 string           | string          | 0x60..0x77 |
 | UTF-8 string           | string          | 0x78       |
 | UTF-8 string           | string          | 0x79       |
@@ -157,9 +156,6 @@ The library maps CBOR types to JSON value types as follows:
 | Single-Precision Float | number_float    | 0xFA       |
 | Double-Precision Float | number_float    | 0xFB       |

-Indefinite-length UTF-8 strings (0x7F) and byte strings (0x5F) are supported. Each chunk must be a definite-length
-string of the same major type, as required by [RFC 8949, Section 3.2.3](https://www.rfc-editor.org/rfc/rfc8949.html#section-3.2.3).
-
 !!! warning "Incomplete mapping"

    The mapping is **incomplete** in the sense that not all CBOR types can be converted to a JSON value. The following CBOR types are not supported and will yield parse errors:
@@ -172,9 +168,9 @@ string of the same major type, as required by [RFC 8949, Section 3.2.3](https://
 !!! warning "Negative integer overflow"

    CBOR negative integers (major type 1) are decoded as `-1 - n`. If the encoded magnitude `n` is too large for the
-    result to fit into `number_integer_t` (`std::int64_t` by default), the result is stored as `number_float_t`, like
-    a too small integer in JSON text. For example, `-18446744073709551616` (`0x3B` followed by eight `0xFF` bytes) is
-    stored as `-1.8446744073709552e+19`.
+    result to fit into `number_integer_t` (`std::int64_t` by default), parsing fails with a
+    [`parse_error.112`](../../home/exceptions.md#jsonexceptionparse_error112) exception rather than overflowing
+    silently.

 !!! warning "Object keys"

@@ -58,23 +58,6 @@ assert(jPi.get<TaskState>() == TS_INVALID );
    --8<-- "examples/nlohmann_json_serialize_enum.output"
    ```

-## Maps with enum keys
-
-By default, maps with enum keys, such as `std::map<TaskState, std::string>`, are stored as arrays of `[key, value]`
-pairs, because JSON object keys must be strings. Define
-[`JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS`](../api/macros/json_use_objects_for_enum_keyed_maps.md) before including the
-library to store them as objects, with the keys converted by the enum's `to_json()` function:
-
-```cpp
-std::map<TaskState, std::string> m = {{TS_STOPPED, "aa"}, {TS_COMPLETED, "bb"}};
-
-json j = m;
-// default:                                   [["stopped","aa"],["completed","bb"]]
-// with JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS: {"completed":"bb","stopped":"aa"}
-```
-
-Either form can be read back, with or without the macro.
-
 ## Notes

 Just as in [Arbitrary Type Conversions](arbitrary_types.md) above,
@@ -23,17 +23,6 @@ This macro overrides [`#!cpp catch`](https://en.cppreference.com/w/cpp/language/

 See [full documentation of `JSON_CATCH_USER(exception)`](../api/macros/json_throw_user.md).

-## `JSON_DELETE_DEPRECATED_FUNCTIONS`
-
-When defined to `1`, all deprecated functions are declared as deleted instead of only being marked as deprecated, so
-code that still calls them no longer compiles. This way, you can find all calls that need to be replaced before version
-4.0.0 removes these functions.
-
-The macro can also be set with the CMake option
-[`JSON_DeleteDeprecatedFunctions`](../integration/cmake.md#json_deletedeprecatedfunctions) (`OFF` by default).
-
-See [full documentation of `JSON_DELETE_DEPRECATED_FUNCTIONS`](../api/macros/json_delete_deprecated_functions.md).
-
 ## `JSON_DIAGNOSTICS`

 This macro enables extended diagnostics for exception messages. Possible values are `1` to enable or `0` to disable
@@ -97,8 +86,7 @@ See [full documentation of `JSON_DISABLE_ENUM_SERIALIZATION`](../api/macros/json
 ## `JSON_DISABLE_TUPLE_REFERENCE_CONVERSION`

 When defined to `1`, a JSON value can no longer be created from a one-element `std::tuple` holding a reference to a JSON
-value, such as the result of `std::forward_as_tuple(j)`. This lets `std::tuple` convert such tuples element-wise. This
-is planned to become the default in version 4.0.0.
+value, such as the result of `std::forward_as_tuple(j)`. This lets `std::tuple` convert such tuples element-wise.

 See [full documentation of `JSON_DISABLE_TUPLE_REFERENCE_CONVERSION`](../api/macros/json_disable_tuple_reference_conversion.md).

@@ -210,13 +198,6 @@ default.

 See [full documentation of `JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON`](../api/macros/json_use_legacy_discarded_value_comparison.md).

-## `JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS`
-
-When defined to `1`, maps with enum keys (e.g., `std::map<E, T>`) are stored as objects, using the enum's conversion for
-the keys, instead of arrays of `[key, value]` pairs. It is switched off (`0`) by default.
-
-See [full documentation of `JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS`](../api/macros/json_use_objects_for_enum_keyed_maps.md).
-
 ## `JSON_USE_SIMDUTF`

 When defined, UTF-8 validation of JSON strings read from contiguous byte input is delegated to the
@@ -21,8 +21,6 @@ The complete default namespace name is derived as follows:
    - [`JSON_PRECISE_STREAM_POSITION`](../api/macros/json_precise_stream_position.md) defined non-zero appends `_psp`.
    - [`JSON_STRICT_NUL_HANDLING`](../api/macros/json_strict_nul_handling.md) defined non-zero appends `_snul`.
    - [`JSON_STRICT_BINARY_UTF8`](../api/macros/json_strict_binary_utf8.md) defined non-zero appends `_sbu8`.
-    - [`JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS`](../api/macros/json_use_objects_for_enum_keyed_maps.md) defined non-zero
-      appends `_ekmo`.
 - 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.
@@ -55,7 +55,7 @@ always use the scalar path regardless of this macro.

 Parsing always produces SAX events internally; [`parse`](../api/basic_json/parse.md) simply feeds them to a consumer
 that builds a complete `basic_json` value tree (a DOM) in memory. For documents too large to comfortably hold as
-a DOM, three alternatives avoid building it:
+a DOM, two alternatives avoid building it:

 - Implement the [SAX interface](parsing/sax_interface.md) directly and pass it to
  [`sax_parse`](../api/basic_json/sax_parse.md); only the parts of the input you choose to keep ever become
@@ -64,12 +64,6 @@ a DOM, three alternatives avoid building it:
  discard finished elements as soon as they are handled, so memory usage stays bounded by one element (plus the
  unparsed remainder of the input) instead of the whole document -- see the [recipe for streaming a large homogeneous
  array](parsing/parser_callbacks.md#recipe-streaming-a-large-homogeneous-array).
- Parse into a [`json_document`](json_view.md) (`#!cpp <nlohmann/json_view.hpp>`) instead of a `basic_json`. It keeps
-  the input text and builds a flat index of 16 bytes per value; strings and numbers are not copied, but read from the
-  text when needed. Read-only [views](../api/basic_json_view/index.md) give the familiar element access, and only the
-  parts you [`materialize()`](../api/basic_json_view/materialize.md) become `basic_json` values. A document that
-  borrows the text instead of owning a copy needs the text to outlive it; see
-  [choosing between `json`, the SAX interface, and `json_view`](json_view.md#choosing-between-json-ordered_json-the-sax-interface-and-json_view).

 If the data is naturally record-oriented, consider [JSON Lines](parsing/json_lines.md) instead of one large JSON
 document: reading and parsing it line by line with `#!cpp std::getline` means only one line's value is ever in memory
@@ -215,7 +209,6 @@ those headers are then never processed by the compiler at all.
 - [Architecture](../home/architecture.md) - how input adapters, the lexer, and the serializer fit together
 - [Parsing](parsing/index.md) - the available parsing functions and inputs
 - [SAX interface](parsing/sax_interface.md) - parse without building a DOM
- [Zero-copy JSON views](json_view.md) - parse into a flat index of the text and read it without building a DOM
 - [Binary formats](binary_formats/index.md) - compact alternatives to JSON text
 - [Object Order](object_order.md) - `json` vs. `ordered_json` and other `ObjectType` choices
 - [Template Parameter Requirements](types/template_parameters.md) - custom container and allocator types
@@ -331,6 +331,9 @@ An unexpected byte was read in a [binary format](../features/binary_formats/inde
    [json.exception.parse_error.112] parse error at byte 15: syntax error while parsing BSON binary: byte array length cannot be negative, is -1
    ```
    ```
+    [json.exception.parse_error.112] parse error at byte 9: syntax error while parsing CBOR value: negative integer overflow
+    ```
+    ```
    [json.exception.parse_error.112] parse error at byte 5: syntax error while parsing BSON document: document size 6 does not match the number of bytes read (5)
    ```

@@ -613,9 +616,6 @@ During implicit or explicit value conversion, the JSON type must be compatible w
    [json.exception.type_error.302] type must be string, but is object
    ```

-This exception is also thrown with [`JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS`](../api/macros/json_use_objects_for_enum_keyed_maps.md)
-if a key of a map with enum keys is not converted to a string, for instance, because the enum is stored as an integer.
-
 ### json.exception.type_error.303

 To retrieve a reference to a value stored in a `basic_json` object with `get_ref`, the type of the reference must match the value type. For instance, for a JSON array, the `ReferenceType` must be `array_t &`.
@@ -808,19 +808,6 @@ The dynamic type of the object cannot be represented in the requested serializat

    Encapsulate the JSON value in an object. That is, instead of serializing `#!json true`, serialize `#!json {"value": true}`

-### json.exception.type_error.318
-
-With [`JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS`](../api/macros/json_use_objects_for_enum_keyed_maps.md), a map with enum
-keys is stored as an object. This exception is thrown if two of its keys are converted to the same string, so one of the
-entries would be lost. This happens, for instance, if [`NLOHMANN_JSON_SERIALIZE_ENUM`](../api/macros/nlohmann_json_serialize_enum.md)
-does not list an enumerator and it is therefore converted like the first listed one.
-
-!!! failure "Example message"
-
-    ```
-    [json.exception.type_error.318] duplicate object key 'red'
-    ```
-
 ### json.exception.type_error.319

 [`basic_json_document::set`](../api/basic_json_document/set.md) and
@@ -859,20 +846,6 @@ exception on a big-endian target, since the image format is little-endian only.

    This exception was added in version 3.13.0, together with [images](../features/json_view.md#images).

-### json.exception.type_error.321
-
-A discarded value (one created by [`parse()`](../api/basic_json/parse.md) with a callback that returns `false` for the
-value, or by default-constructing a [`basic_json`](../api/basic_json/index.md) with
-[`value_t::discarded`](../api/basic_json/value_t.md)) was passed to a binary serialization function, either directly or
-nested in an array or object. There is no way to represent a discarded value in CBOR, MessagePack, UBJSON, BJData, or BSON.
-
-!!! failure "Example message"
-
-    Serializing `#!json [1, 2]` to CBOR, where the second element was discarded by a parser callback:
-    ```
-    [json.exception.type_error.321] cannot serialize discarded value to CBOR
-    ```
-
 ## Out of range

 This exception is thrown in case a library function is called on an input parameter that exceeds the expected range, for instance, in the case of array indices or nonexisting object keys.
@@ -945,18 +918,13 @@ The JSON Patch operations 'remove' and 'add' cannot be applied to the root eleme

 ### json.exception.out_of_range.406

-A parsed number could not be stored without changing it to NaN or INF. For the binary formats, this happens when a
-finite floating-point number does not fit into [`number_float_t`](../api/basic_json/number_float_t.md), for example a
-double-precision number when `number_float_t` is `#!cpp float`.
+A parsed number could not be stored as without changing it to NaN or INF.

-!!! failure "Example messages"
+!!! failure "Example message"

    ```
    number overflow parsing '10E1000'
    ```
-    ```
-    [json.exception.out_of_range.406] syntax error while parsing CBOR value: number overflow
-    ```

 ### json.exception.out_of_range.407

@@ -126,18 +126,12 @@ automatically download a release as a dependency at configure time.

 ### `JSON_BuildTests`

-Build the unit tests when [`BUILD_TESTING`](https://cmake.org/cmake/help/latest/command/enable_testing.html) is enabled. This option is `ON` by default if the library's CMake project is the top project and the `tests` directory exists (the release archive `json.tar.xz` does not contain it). That is, when integrating the library as described above, the test suite is not built unless explicitly switched on with this option.
+Build the unit tests when [`BUILD_TESTING`](https://cmake.org/cmake/help/latest/command/enable_testing.html) is enabled. This option is `ON` by default if the library's CMake project is the top project. That is, when integrating the library as described above, the test suite is not built unless explicitly switched on with this option.

 ### `JSON_CI`

 Enable CI build targets. The exact targets are used during the several CI steps and are subject to change without notice. This option is `OFF` by default.

-### `JSON_DeleteDeprecatedFunctions`
-
-Delete the deprecated functions instead of only deprecating them by defining the macro
-[`JSON_DELETE_DEPRECATED_FUNCTIONS`](../api/macros/json_delete_deprecated_functions.md). This option is `OFF` by
-default.
-
 ### `JSON_Diagnostics`

 Enable [extended diagnostic messages](../home/exceptions.md#extended-diagnostic-messages) by defining macro [`JSON_DIAGNOSTICS`](../api/macros/json_diagnostics.md). This option is `OFF` by default.
@@ -14,13 +14,6 @@ deprecations are annotated with
 [`HEDLEY_DEPRECATED_FOR`](https://nemequ.github.io/hedley/api-reference.html#HEDLEY_DEPRECATED_FOR) to report which
 function to use instead.

-!!! tip "Find all calls of deprecated functions"
-
-    Define [`JSON_DELETE_DEPRECATED_FUNCTIONS`](../api/macros/json_delete_deprecated_functions.md) to `1` (or set the
-    CMake option [`JSON_DeleteDeprecatedFunctions`](cmake.md#json_deletedeprecatedfunctions)) to delete all deprecated
-    functions. Every remaining call then fails to compile, even if deprecation warnings are disabled, so your code is
-    ready for version 4.0.0 once it compiles with the macro.
-
 ### Parsing

 - Function `friend std::istream& operator<<(basic_json&, std::istream&)` is deprecated since 3.0.0. Please use
@@ -48,10 +41,8 @@ function to use instead.
  [`from_ubjson`](../api/basic_json/from_ubjson.md), and [`from_bson`](../api/basic_json/from_bson.md)) via initializer
  lists is deprecated since 3.8.0. Instead, pass two iterators; for instance, call `from_cbor(ptr, ptr+len)` instead of
  `from_cbor({ptr, len})`. Likewise, passing a pointer and a length as two separate arguments to `from_cbor`,
-  `from_msgpack`, `from_ubjson`, and `from_bson` is deprecated since 3.8.0, and to
-  [`from_bjdata`](../api/basic_json/from_bjdata.md) and [`from_bon8`](../api/basic_json/from_bon8.md) since 3.13.0; call
-  `from_cbor(ptr, ptr+len)` instead of `from_cbor(ptr, len)`. These overloads will not be removed in version 4.0.0, but
-  deleted, so a call like `from_cbor(ptr, len)` cannot compile and convert `len` to the `strict` parameter.
+  `from_msgpack`, `from_ubjson`, and `from_bson` is deprecated since 3.8.0; call `from_cbor(ptr, ptr+len)` instead of
+  `from_cbor(ptr, len)`.

    === "Deprecated"
  
@@ -233,7 +233,6 @@ nav:
          - 'update': api/basic_json/update.md
          - 'value': api/basic_json/value.md
          - 'value_t': api/basic_json/value_t.md
-          - 'with_t': api/basic_json/with_t.md
      - basic_json_document:
          - 'Overview': api/basic_json_document/index.md
          - '(Constructor)': api/basic_json_document/basic_json_document.md
@@ -367,7 +366,6 @@ nav:
          - 'JSON_BRACE_INIT_COPY_SEMANTICS': api/macros/json_brace_init_copy_semantics.md
          - 'JSON_CATCH_USER, JSON_THROW_USER, JSON_TRY_USER': api/macros/json_throw_user.md
          - 'JSON_DIAGNOSTICS': api/macros/json_diagnostics.md
-          - 'JSON_DELETE_DEPRECATED_FUNCTIONS': api/macros/json_delete_deprecated_functions.md
          - 'JSON_DIAGNOSTIC_POSITIONS': api/macros/json_diagnostic_positions.md
          - 'JSON_DISABLE_ENUM_SERIALIZATION': api/macros/json_disable_enum_serialization.md
          - 'JSON_DISABLE_TUPLE_REFERENCE_CONVERSION': api/macros/json_disable_tuple_reference_conversion.md
@@ -389,7 +387,6 @@ nav:
          - '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
-          - 'JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS': api/macros/json_use_objects_for_enum_keyed_maps.md
          - 'JSON_USE_SIMDUTF': api/macros/json_use_simdutf.md
          - 'JSON_VIEW_NO_SIMD': api/macros/json_view_no_simd.md
          - 'JSON_VIEW_USE_SSSE3': api/macros/json_view_use_ssse3.md
@@ -6,7 +6,7 @@ mkdocs-material==9.7.7                             # theme for mkdocs
 mkdocs-material-extensions==1.3.1                   # extensions
 mkdocs-minify-plugin==0.8.0                         # plugin "minify"
 mkdocs-redirects==1.2.3                             # plugin "redirects"
-mkdocs-htmlproofer-plugin==1.6.0                    # plugin "htmlproofer"
+mkdocs-htmlproofer-plugin==1.5.0                    # plugin "htmlproofer"
 mkdocs-llmstxt==0.5.0                               # plugin "llmstxt"

 PyYAML==6.0.3                                       # linter
@@ -1454,9 +1454,9 @@
      }
    },
    "node_modules/source-map-js": {
-      "version": "1.2.2",
-      "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.2.tgz",
-      "integrity": "sha512-KGj/8Y43x35aZVDtt+J4mK1hoLGHULMYfSkODJNQjNDC3oW1PqPoxMwo0pLUsWM/UEGzON/NxeHywEfNXNP3Vw==",
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.1.tgz",
+      "integrity": "sha512-UXWMKhLOwVKb728IUtQPXxfYU+usdybtUrK/8uGE8CQMvrhOpwvzDBwj0QhSL7MQc7vIsISBG8VQ8+IDQxpfQA==",
      "license": "BSD-3-Clause",
      "engines": {
        "node": ">=0.10.0"
@@ -50,10 +50,6 @@
    #define JSON_STRICT_BINARY_UTF8 0
 #endif

-#ifndef JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS
-    #define JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS 0
-#endif
-
 #if JSON_DIAGNOSTICS
    #define NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS _diag
 #else
@@ -96,20 +92,14 @@
    #define NLOHMANN_JSON_ABI_TAG_STRICT_BINARY_UTF8
 #endif

-#if JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS
-    #define NLOHMANN_JSON_ABI_TAG_OBJECTS_FOR_ENUM_KEYED_MAPS _ekmo
-#else
-    #define NLOHMANN_JSON_ABI_TAG_OBJECTS_FOR_ENUM_KEYED_MAPS
-#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, e, f, g, h) json_abi ## a ## b ## c ## d ## e ## f ## g ## h
-#define NLOHMANN_JSON_ABI_TAGS_CONCAT(a, b, c, d, e, f, g, h) \
-    NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b, c, d, e, f, g, h)
+#define NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b, c, d, e, f, g) json_abi ## a ## b ## c ## d ## e ## f ## g
+#define NLOHMANN_JSON_ABI_TAGS_CONCAT(a, b, c, d, e, f, g) \
+    NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b, c, d, e, f, g)

 #define NLOHMANN_JSON_ABI_TAGS                                       \
    NLOHMANN_JSON_ABI_TAGS_CONCAT(                                   \
@@ -119,8 +109,7 @@
            NLOHMANN_JSON_ABI_TAG_BRACE_INIT_COPY_SEMANTICS,         \
            NLOHMANN_JSON_ABI_TAG_PRECISE_STREAM_POSITION,           \
            NLOHMANN_JSON_ABI_TAG_STRICT_NUL_HANDLING,               \
-            NLOHMANN_JSON_ABI_TAG_STRICT_BINARY_UTF8,                \
-            NLOHMANN_JSON_ABI_TAG_OBJECTS_FOR_ENUM_KEYED_MAPS)
+            NLOHMANN_JSON_ABI_TAG_STRICT_BINARY_UTF8)

 // Construct the namespace version component
 #define NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT_EX(major, minor, patch) \
@@ -172,7 +172,7 @@ inline void from_json(const BasicJsonType& j, EnumType& e)
          typename BasicJsonType::number_unsigned_t, underlying_type>::type;
    value_type val;
    get_arithmetic_value(j, val);
-    e = static_cast<EnumType>(bool_aware_static_cast<underlying_type>(val));
+    e = static_cast<EnumType>(static_cast<underlying_type>(val));
 }
 #endif  // JSON_DISABLE_ENUM_SERIALIZATION

@@ -530,40 +530,11 @@ void from_json_pair_array_to_map(const BasicJsonType& j, MapType& m)
    }
 }

-// read a map with enum keys from an object, using the enum's own from_json for
-// the keys (e.g., from NLOHMANN_JSON_SERIALIZE_ENUM); this is the form written
-// with JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS
-template<typename BasicJsonType, typename Map>
-inline bool from_json_enum_keyed_object(const BasicJsonType& j, Map& m, std::true_type /*key is enum*/)
-{
-    if (!j.is_object())
-    {
-        return false;
-    }
-    m.clear();
-    for (const auto& p : *j.template get_ptr<const typename BasicJsonType::object_t*>())
-    {
-        m.emplace(BasicJsonType(p.first).template get<typename Map::key_type>(), p.second.template get<typename Map::mapped_type>());
-    }
-    return true;
-}
-
-template<typename BasicJsonType, typename Map>
-inline bool from_json_enum_keyed_object(const BasicJsonType& /*j*/, Map& /*m*/, std::false_type /*key is enum*/)
-{
-    return false;
-}
-
 template < typename BasicJsonType, typename Key, typename Value, typename Compare, typename Allocator,
           typename = enable_if_t < !std::is_constructible <
                                        typename BasicJsonType::string_t, Key >::value >>
 void from_json(const BasicJsonType& j, std::map<Key, Value, Compare, Allocator>& m)
 {
-    // NOLINTNEXTLINE(modernize-type-traits) we use C++11
-    if (from_json_enum_keyed_object(j, m, std::is_enum<Key> {}))
-    {
-        return;
-    }
    from_json_pair_array_to_map(j, m);
 }

@@ -572,11 +543,6 @@ template < typename BasicJsonType, typename Key, typename Value, typename Hash,
                                        typename BasicJsonType::string_t, Key >::value >>
 void from_json(const BasicJsonType& j, std::unordered_map<Key, Value, Hash, KeyEqual, Allocator>& m)
 {
-    // NOLINTNEXTLINE(modernize-type-traits) we use C++11
-    if (from_json_enum_keyed_object(j, m, std::is_enum<Key> {}))
-    {
-        return;
-    }
    from_json_pair_array_to_map(j, m);
 }

@@ -329,8 +329,8 @@ boundaries compute_boundaries(FloatType value)
 //
 //      -e <= 60   or   e >= -60 := alpha

-JSON_INLINE_VARIABLE constexpr int kAlpha = -60;
-JSON_INLINE_VARIABLE constexpr int kGamma = -32;
+constexpr int kAlpha = -60;
+constexpr int kGamma = -32;

 struct cached_power // c = f * 2^e ~= 10^k
 {
@@ -13,6 +13,7 @@
    #include <optional> // optional
 #endif

+#include <algorithm> // copy
 #include <iterator> // begin, end
 #include <memory> // allocator_traits
 #include <string> //  basic_string, char_traits
@@ -22,7 +23,6 @@
 #include <valarray> // valarray
 #include <vector> // vector

-#include <nlohmann/detail/exceptions.hpp>
 #include <nlohmann/detail/iterators/iteration_proxy.hpp>
 #include <nlohmann/detail/meta/cpp_future.hpp>
 #include <nlohmann/detail/meta/std_fs.hpp>
@@ -38,14 +38,10 @@ namespace detail
 //////////////////

 /*
- * Note all external_constructor<>::construct functions need to store the new
- * value with j.replace_value(), which destroys the old one to avoid a memory
- * leak in case j contains an allocated value (e.g., a string). See bug issue
+ * Note all external_constructor<>::construct functions need to call
+ * j.m_data.m_value.destroy(j.m_data.m_type) to avoid a memory leak in case j contains an
+ * allocated value (e.g., a string). See bug issue
 * https://github.com/nlohmann/json/issues/2865 for more information.
- *
- * A value that has to be allocated is created before the old one is destroyed:
- * were it the other way around, an exception while creating the new value would
- * leave j with the type of the new value, but the pointer to the destroyed old one.
 */

 template<value_t> struct external_constructor;
@@ -56,7 +52,10 @@ struct external_constructor<value_t::boolean>
    template<typename BasicJsonType>
    static void construct(BasicJsonType& j, typename BasicJsonType::boolean_t b) noexcept
    {
-        j.replace_value(value_t::boolean, b);
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::boolean;
+        j.m_data.m_value = b;
+        j.assert_invariant();
    }
 };

@@ -66,15 +65,19 @@ struct external_constructor<value_t::string>
    template<typename BasicJsonType>
    static void construct(BasicJsonType& j, const typename BasicJsonType::string_t& s)
    {
-        const typename BasicJsonType::json_value value(s);
-        j.replace_value(value_t::string, value);
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::string;
+        j.m_data.m_value = s;
+        j.assert_invariant();
    }

    template<typename BasicJsonType>
    static void construct(BasicJsonType& j, typename BasicJsonType::string_t&& s)
    {
-        const typename BasicJsonType::json_value value(std::move(s));
-        j.replace_value(value_t::string, value);
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::string;
+        j.m_data.m_value = std::move(s);
+        j.assert_invariant();
    }

    template < typename BasicJsonType, typename CompatibleStringType,
@@ -82,8 +85,10 @@ struct external_constructor<value_t::string>
                             int > = 0 >
    static void construct(BasicJsonType& j, const CompatibleStringType& str)
    {
-        const typename BasicJsonType::json_value value(j.template create<typename BasicJsonType::string_t>(str));
-        j.replace_value(value_t::string, value);
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::string;
+        j.m_data.m_value.string = j.template create<typename BasicJsonType::string_t>(str);
+        j.assert_invariant();
    }
 };

@@ -93,15 +98,19 @@ struct external_constructor<value_t::binary>
    template<typename BasicJsonType>
    static void construct(BasicJsonType& j, const typename BasicJsonType::binary_t& b)
    {
-        const typename BasicJsonType::json_value value(b);
-        j.replace_value(value_t::binary, value);
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::binary;
+        j.m_data.m_value = typename BasicJsonType::binary_t(b);
+        j.assert_invariant();
    }

    template<typename BasicJsonType>
    static void construct(BasicJsonType& j, typename BasicJsonType::binary_t&& b)
    {
-        const typename BasicJsonType::json_value value(std::move(b));
-        j.replace_value(value_t::binary, value);
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::binary;
+        j.m_data.m_value = typename BasicJsonType::binary_t(std::move(b));
+        j.assert_invariant();
    }
 };

@@ -111,7 +120,10 @@ struct external_constructor<value_t::number_float>
    template<typename BasicJsonType>
    static void construct(BasicJsonType& j, typename BasicJsonType::number_float_t val) noexcept
    {
-        j.replace_value(value_t::number_float, val);
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::number_float;
+        j.m_data.m_value = val;
+        j.assert_invariant();
    }
 };

@@ -121,7 +133,10 @@ struct external_constructor<value_t::number_unsigned>
    template<typename BasicJsonType>
    static void construct(BasicJsonType& j, typename BasicJsonType::number_unsigned_t val) noexcept
    {
-        j.replace_value(value_t::number_unsigned, val);
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::number_unsigned;
+        j.m_data.m_value = val;
+        j.assert_invariant();
    }
 };

@@ -131,7 +146,10 @@ struct external_constructor<value_t::number_integer>
    template<typename BasicJsonType>
    static void construct(BasicJsonType& j, typename BasicJsonType::number_integer_t val) noexcept
    {
-        j.replace_value(value_t::number_integer, val);
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::number_integer;
+        j.m_data.m_value = val;
+        j.assert_invariant();
    }
 };

@@ -141,15 +159,21 @@ struct external_constructor<value_t::array>
    template<typename BasicJsonType>
    static void construct(BasicJsonType& j, const typename BasicJsonType::array_t& arr)
    {
-        const typename BasicJsonType::json_value value(arr);
-        j.replace_value(value_t::array, value);
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::array;
+        j.m_data.m_value = arr;
+        j.set_parents();
+        j.assert_invariant();
    }

    template<typename BasicJsonType>
    static void construct(BasicJsonType& j, typename BasicJsonType::array_t&& arr)
    {
-        const typename BasicJsonType::json_value value(std::move(arr));
-        j.replace_value(value_t::array, value);
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::array;
+        j.m_data.m_value = std::move(arr);
+        j.set_parents();
+        j.assert_invariant();
    }

    template < typename BasicJsonType, typename CompatibleArrayType,
@@ -163,23 +187,39 @@ struct external_constructor<value_t::array>
        using std::begin;
        using std::end;

-        const typename BasicJsonType::json_value value(j.template create<typename BasicJsonType::array_t>(begin(arr), end(arr)));
-        j.replace_value(value_t::array, value);
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::array;
+        j.m_data.m_value.array = j.template create<typename BasicJsonType::array_t>(begin(arr), end(arr));
+        j.set_parents();
+        j.assert_invariant();
    }

    template<typename BasicJsonType>
    static void construct(BasicJsonType& j, const std::vector<bool>& arr)
    {
-        const typename BasicJsonType::json_value value(j.template create<typename BasicJsonType::array_t>(arr.begin(), arr.end()));
-        j.replace_value(value_t::array, value);
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::array;
+        j.m_data.m_value = value_t::array;
+        j.m_data.m_value.array->reserve(arr.size());
+        for (const bool x : arr)
+        {
+            j.m_data.m_value.array->push_back(x);
+            j.set_parent(j.m_data.m_value.array->back());
+        }
+        j.assert_invariant();
    }

    template<typename BasicJsonType, typename T,
             enable_if_t<std::is_convertible<T, BasicJsonType>::value, int> = 0>
    static void construct(BasicJsonType& j, const std::valarray<T>& arr)
    {
-        const typename BasicJsonType::json_value value(j.template create<typename BasicJsonType::array_t>(std::begin(arr), std::end(arr)));
-        j.replace_value(value_t::array, value);
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::array;
+        j.m_data.m_value = value_t::array;
+        j.m_data.m_value.array->resize(arr.size());
+        std::copy(std::begin(arr), std::end(arr), j.m_data.m_value.array->begin());
+        j.set_parents();
+        j.assert_invariant();
    }

 #if JSON_HAS_RANGE_VIEW_CONVERSION
@@ -187,15 +227,18 @@ struct external_constructor<value_t::array>
             enable_if_t<is_compatible_range_view<std::remove_cvref_t<CompatibleArrayType>>::value, int> = 0>
    static void construct(BasicJsonType& j, CompatibleArrayType && arr)
    {
-        // no range constructor: a view's begin() and end() may have different
-        // types, and the view may only be iterable once
-        typename BasicJsonType::array_t elements;
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::array;
+        j.m_data.m_value = value_t::array;
        for (auto&& x : std::forward<CompatibleArrayType>(arr))
        {
-            elements.push_back(x);
+            j.m_data.m_value.array->push_back(x);
        }
-        const typename BasicJsonType::json_value value(std::move(elements));
-        j.replace_value(value_t::array, value);
+        // set the parents only once all elements are in place: a push_back
+        // that reallocates moves the earlier elements, which does not keep
+        // their parent pointers
+        j.set_parents();
+        j.assert_invariant();
    }
 #endif
 };
@@ -206,15 +249,21 @@ struct external_constructor<value_t::object>
    template<typename BasicJsonType>
    static void construct(BasicJsonType& j, const typename BasicJsonType::object_t& obj)
    {
-        const typename BasicJsonType::json_value value(obj);
-        j.replace_value(value_t::object, value);
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::object;
+        j.m_data.m_value = obj;
+        j.set_parents();
+        j.assert_invariant();
    }

    template<typename BasicJsonType>
    static void construct(BasicJsonType& j, typename BasicJsonType::object_t&& obj)
    {
-        const typename BasicJsonType::json_value value(std::move(obj));
-        j.replace_value(value_t::object, value);
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::object;
+        j.m_data.m_value = std::move(obj);
+        j.set_parents();
+        j.assert_invariant();
    }

    template < typename BasicJsonType, typename CompatibleObjectType,
@@ -224,8 +273,11 @@ struct external_constructor<value_t::object>
        using std::begin;
        using std::end;

-        const typename BasicJsonType::json_value value(j.template create<typename BasicJsonType::object_t>(begin(obj), end(obj)));
-        j.replace_value(value_t::object, value);
+        j.m_data.m_value.destroy(j.m_data.m_type);
+        j.m_data.m_type = value_t::object;
+        j.m_data.m_value.object = j.template create<typename BasicJsonType::object_t>(begin(obj), end(obj));
+        j.set_parents();
+        j.assert_invariant();
    }
 };

@@ -234,20 +286,9 @@ struct external_constructor<value_t::object>
 /////////////

 #ifdef JSON_HAS_CPP_17
-// whether storing the value of a std::optional<T> cannot throw; MSVC 2017
-// evaluates std::is_nothrow_assignable as true even if T's to_json throws, so
-// the exception would call std::terminate (#5642)
-#if defined(_MSC_VER) && !defined(__clang__) && _MSC_VER < 1920
-    template<typename BasicJsonType, typename T>
-    using is_nothrow_optional_to_json = std::false_type;
-#else
-    template<typename BasicJsonType, typename T>
-    using is_nothrow_optional_to_json = std::is_nothrow_assignable<BasicJsonType&, const T&>;
-#endif
-
 template<typename BasicJsonType, typename T,
         enable_if_t<std::is_constructible<BasicJsonType, T>::value, int> = 0>
-void to_json(BasicJsonType& j, const std::optional<T>& opt) noexcept(is_nothrow_optional_to_json<BasicJsonType, T>::value)
+void to_json(BasicJsonType& j, const std::optional<T>& opt) noexcept(std::is_nothrow_assignable<BasicJsonType&, const T&>::value)
 {
    if (opt.has_value())
    {
@@ -323,7 +364,7 @@ inline void to_json(BasicJsonType& j, EnumType e) noexcept
 {
    using underlying_type = typename std::underlying_type<EnumType>::type;
    static constexpr value_t integral_value_t = std::is_unsigned<underlying_type>::value ? value_t::number_unsigned : value_t::number_integer;
-    external_constructor<integral_value_t>::construct(j, bool_aware_static_cast<underlying_type>(e));
+    external_constructor<integral_value_t>::construct(j, static_cast<underlying_type>(e));
 }
 #endif  // JSON_DISABLE_ENUM_SERIALIZATION

@@ -343,9 +384,6 @@ template < typename BasicJsonType, typename CompatibleArrayType,
                         !is_basic_json<CompatibleArrayType>::value
 #if JSON_HAS_RANGE_VIEW_CONVERSION
    && !is_compatible_range_view<CompatibleArrayType>::value
-#endif
-#if JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS
-    && !is_enum_keyed_map<CompatibleArrayType>::value
 #endif
                         ,
                         int > = 0 >
@@ -400,33 +438,6 @@ inline void to_json(BasicJsonType& j, const CompatibleObjectType& obj)
    external_constructor<value_t::object>::construct(j, obj);
 }

-#if JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS
-// store a map with enum keys as an object, using the enum's own to_json for the
-// keys (e.g., from NLOHMANN_JSON_SERIALIZE_ENUM); without the macro, such maps
-// are stored as arrays of [key, value] pairs
-template < typename BasicJsonType, typename EnumKeyedMap,
-           enable_if_t < is_enum_keyed_map<EnumKeyedMap>::value&& !is_basic_json<EnumKeyedMap>::value, int > = 0 >
-inline void to_json(BasicJsonType& j, const EnumKeyedMap& map)
-{
-    typename BasicJsonType::object_t obj;
-    for (const auto& p : map)
-    {
-        BasicJsonType key = p.first;
-        if (JSON_HEDLEY_UNLIKELY(!key.is_string()))
-        {
-            JSON_THROW(type_error::create(302, concat("type must be string, but is ", key.type_name()), &key));
-        }
-
-        auto& key_string = *key.template get_ptr<typename BasicJsonType::string_t*>();
-        if (JSON_HEDLEY_UNLIKELY(!obj.emplace(key_string, BasicJsonType(p.second)).second))
-        {
-            JSON_THROW(type_error::create(318, concat("duplicate object key '", key_string, "'"), &key));
-        }
-    }
-    external_constructor<value_t::object>::construct(j, std::move(obj));
-}
-#endif
-
 template<typename BasicJsonType>
 inline void to_json(BasicJsonType& j, typename BasicJsonType::object_t&& obj)
 {
@@ -221,7 +221,7 @@ class lexer : public lexer_base<BasicJsonType>
    // scan functions
    /////////////////////

-    /// contiguous input: try to decode the 4 hex digits following `\\u`
+    /// contiguous input: try to decode the 4 hex digits following `\u`
    /// directly from the input buffer via hex_codepoint(), instead of 4 calls
    /// to get(). On success, advances the adapter and the position counters
    /// exactly as those 4 get() calls would (a hex digit is never '\n', so
@@ -2070,39 +2070,6 @@ scan_number_done:
        // read the next character and ignore whitespace
        skip_whitespace();

-        return scan_after_whitespace();
-    }
-
-    /*!
-    @brief scan the next token when the caller expects a separator (':' or
-           ',') most of the time
-
-    After an object key the next token is almost always ':', after a value
-    inside an object or array almost always ','. Testing for that character
-    first is a compare and a well-predicted branch, where the switch in
-    scan_after_whitespace() is an indirect jump through a table. Anything else
-    goes through the switch, so the result is the same as scan()'s.
-
-    May only be called after scan() has run once (the BOM check is skipped).
-    */
-    token_type scan_expecting(token_type expected_type)
-    {
-        JSON_ASSERT(expected_type == token_type::name_separator || expected_type == token_type::value_separator);
-        JSON_ASSERT(position.chars_read_total > 0);
-        const char_int_type expected_char = static_cast<unsigned char>((expected_type == token_type::name_separator) ? ':' : ',');
-        skip_whitespace();
-        if (JSON_HEDLEY_LIKELY(current == expected_char))
-        {
-            return expected_type;
-        }
-        return scan_after_whitespace();
-    }
-
-  private:
-    /// the part of scan() after the leading whitespace: skip comments and
-    /// scan the token that starts with current
-    token_type scan_after_whitespace()
-    {
        // ignore comments
        while (ignore_comments && current == '/')
        {
@@ -2182,6 +2149,7 @@ scan_number_done:
        }
    }

+  private:
    /// input adapter
    InputAdapterType ia;

@@ -260,7 +260,7 @@ class parser
                        }

                        // parse separator (:)
-                        if (JSON_HEDLEY_UNLIKELY(!get_token_expecting(token_type::name_separator)))
+                        if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::name_separator))
                        {
                            return sax->parse_error(m_lexer.get_position(),
                                                    m_lexer.get_token_string(),
@@ -423,7 +423,7 @@ class parser
            {
                // comma -> next value
                // or end of array (ignore_trailing_commas = true)
-                if (get_token_expecting(token_type::value_separator))
+                if (get_token() == token_type::value_separator)
                {
                    // parse a new value
                    get_token();
@@ -463,7 +463,7 @@ class parser

            // comma -> next value
            // or end of object (ignore_trailing_commas = true)
-            if (get_token_expecting(token_type::value_separator))
+            if (get_token() == token_type::value_separator)
            {
                get_token();

@@ -484,7 +484,7 @@ class parser
                    }

                    // parse separator (:)
-                    if (JSON_HEDLEY_UNLIKELY(!get_token_expecting(token_type::name_separator)))
+                    if (JSON_HEDLEY_UNLIKELY(get_token() != token_type::name_separator))
                    {
                        return sax->parse_error(m_lexer.get_position(),
                                                m_lexer.get_token_string(),
@@ -528,13 +528,6 @@ class parser
        return last_token = m_lexer.scan();
    }

-    /// get next token from lexer; true if it is the separator @a expected_type
-    /// (name_separator or value_separator), which it usually is
-    bool get_token_expecting(token_type expected_type)
-    {
-        return (last_token = m_lexer.scan_expecting(expected_type)) == expected_type;
-    }
-
    std::string exception_message(const token_type expected, const std::string& context)
    {
        std::string error_msg = "syntax error ";
@@ -88,13 +88,9 @@ class json_pointer
    /// @sa https://json.nlohmann.me/api/json_pointer/operator_string_t/
    JSON_HEDLEY_DEPRECATED_FOR(3.11.0, to_string())
    operator string_t() const
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-        = delete;
-#else
    {
        return to_string();
    }
-#endif

 #ifndef JSON_NO_IO
    /// @brief write string representation of the JSON pointer to stream
@@ -1033,13 +1029,9 @@ class json_pointer
    /// @sa https://json.nlohmann.me/api/json_pointer/operator_eq/
    JSON_HEDLEY_DEPRECATED_FOR(3.11.2, operator==(json_pointer))
    bool operator==(const string_t& rhs) const
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-        = delete;
-#else
    {
        return *this == json_pointer(rhs);
    }
-#endif

    /// @brief 3-way compares two JSON pointers
    template<typename RefStringTypeRhs>
@@ -1117,26 +1109,18 @@ template<typename RefStringTypeLhs,
 JSON_HEDLEY_DEPRECATED_FOR(3.11.2, operator==(json_pointer, json_pointer))
 inline bool operator==(const json_pointer<RefStringTypeLhs>& lhs,
                       const StringType& rhs)
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-    = delete;
-#else
 {
    return lhs == json_pointer<RefStringTypeLhs>(rhs);
 }
-#endif

 template<typename RefStringTypeRhs,
         typename StringType = typename json_pointer<RefStringTypeRhs>::string_t>
 JSON_HEDLEY_DEPRECATED_FOR(3.11.2, operator==(json_pointer, json_pointer))
 inline bool operator==(const StringType& lhs,
                       const json_pointer<RefStringTypeRhs>& rhs)
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-    = delete;
-#else
 {
    return json_pointer<RefStringTypeRhs>(lhs) == rhs;
 }
-#endif

 template<typename RefStringTypeLhs, typename RefStringTypeRhs>
 inline bool operator!=(const json_pointer<RefStringTypeLhs>& lhs,
@@ -1150,26 +1134,18 @@ template<typename RefStringTypeLhs,
 JSON_HEDLEY_DEPRECATED_FOR(3.11.2, operator!=(json_pointer, json_pointer))
 inline bool operator!=(const json_pointer<RefStringTypeLhs>& lhs,
                       const StringType& rhs)
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-    = delete;
-#else
 {
    return !(lhs == rhs);
 }
-#endif

 template<typename RefStringTypeRhs,
         typename StringType = typename json_pointer<RefStringTypeRhs>::string_t>
 JSON_HEDLEY_DEPRECATED_FOR(3.11.2, operator!=(json_pointer, json_pointer))
 inline bool operator!=(const StringType& lhs,
                       const json_pointer<RefStringTypeRhs>& rhs)
-#if JSON_DELETE_DEPRECATED_FUNCTIONS
-    = delete;
-#else
 {
    return !(lhs == rhs);
 }
-#endif

 template<typename RefStringTypeLhs, typename RefStringTypeRhs>
 inline bool operator<(const json_pointer<RefStringTypeLhs>& lhs,
@@ -34,7 +34,6 @@ class json_ref

    json_ref(std::initializer_list<json_ref> init)
        : owned_value(init)
-        , braced_list(true)
    {}

    template <
@@ -70,17 +69,9 @@ class json_ref
        return &** this;
    }

-    /// whether the value was written as a braced list, such as {"key", 1},
-    /// rather than given as a value
-    bool is_braced_list() const noexcept
-    {
-        return braced_list;
-    }
-
  private:
    mutable value_type owned_value = nullptr;
    value_type const* value_ref = nullptr;
-    bool braced_list = false;
 };

 }  // namespace detail
@@ -888,10 +888,6 @@
    #define JSON_DISABLE_ENUM_SERIALIZATION 0
 #endif

-#ifndef JSON_DELETE_DEPRECATED_FUNCTIONS
-    #define JSON_DELETE_DEPRECATED_FUNCTIONS 0
-#endif
-
 #ifndef JSON_DISABLE_TUPLE_REFERENCE_CONVERSION
    #define JSON_DISABLE_TUPLE_REFERENCE_CONVERSION 0
 #endif
@@ -45,8 +45,6 @@
    #undef JSON_PRECISE_STREAM_POSITION
    #undef JSON_STRICT_NUL_HANDLING
    #undef JSON_STRICT_BINARY_UTF8
-    #undef JSON_DELETE_DEPRECATED_FUNCTIONS
-    #undef JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS
 #endif

 #include <nlohmann/thirdparty/hedley/hedley_undef.hpp>
@@ -438,30 +438,6 @@ template<typename BasicJsonType, typename CompatibleObjectType>
 struct is_compatible_object_type
    : is_compatible_object_type_impl<BasicJsonType, CompatibleObjectType> {};

-template<typename T>
-using insert_result_t = decltype(std::declval<T&>().insert(std::declval<const value_type_t<T>&>()));
-
-template<typename T>
-using insert_result_second_t = decltype(std::declval<T&>().insert(std::declval<const value_type_t<T>&>()).second);
-
-// a map-like type (std::map, std::unordered_map, ...) whose keys are enums; see
-// JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS
-template<typename T, typename = void>
-struct is_enum_keyed_map : std::false_type {};
-
-template<typename T>
-struct is_enum_keyed_map <
-    T, enable_if_t < is_detected<mapped_type_t, T>::value&&
-    is_detected<key_type_t, T>::value >>
-{
-    // maps with non-unique keys (std::multimap, std::unordered_multimap, ...)
-    // are excluded, because an object cannot hold duplicate keys; they are
-    // detected by insert() returning an iterator instead of a pair<iterator, bool>
-    // NOLINTNEXTLINE(modernize-type-traits) we use C++11
-    static constexpr bool value = std::is_enum<typename T::key_type>::value &&
-                                  !(is_detected<insert_result_t, T>::value && !is_detected<insert_result_second_t, T>::value);
-};
-
 template<typename BasicJsonType, typename ConstructibleObjectType,
         typename = void>
 struct is_constructible_object_type_impl : std::false_type {};
@@ -906,21 +882,6 @@ T conditional_static_cast(U value)
    return value;
 }

-// like conditional_static_cast, but converts to bool by comparing with zero,
-// because MSVC 2015 warns about any conversion to bool (C4800), even with an
-// explicit cast; used for enums whose underlying type is bool
-template < typename T, typename U, enable_if_t < !std::is_same<T, bool>::value, int > = 0 >
-T bool_aware_static_cast(U value)
-{
-    return conditional_static_cast<T>(value);
-}
-
-template<typename T, typename U, enable_if_t<std::is_same<T, bool>::value, int> = 0>
-bool bool_aware_static_cast(U value)
-{
-    return value != U();
-}
-
 template<typename... Types>
 using all_integral = conjunction<std::is_integral<Types>...>;

@@ -127,7 +127,6 @@ class binary_writer
    @throw type_error.316 if a string value or an object key is not valid
           UTF-8
    @throw type_error.317 if @a j is not an object
-    @throw type_error.321 if a value nested in @a j is discarded
    */
    void write_bson(const BasicJsonType& j)
    {
@@ -159,7 +158,6 @@ class binary_writer
    @param[in] j  JSON value to serialize
    @throw type_error.316 if a string value or an object key is not valid
           UTF-8
-    @throw type_error.321 if @a j or a value nested in it is discarded
    */
    void write_cbor(const BasicJsonType& j)
    {
@@ -324,7 +322,7 @@ class binary_writer

            case value_t::discarded:
            default:
-                throw_on_discarded(j, "CBOR");
+                break;
        }
    }

@@ -384,7 +382,6 @@ class binary_writer

    /*!
    @param[in] j  JSON value to serialize
-    @throw type_error.321 if @a j or a value nested in it is discarded
    */
    void write_msgpack(const BasicJsonType& j)
    {
@@ -658,7 +655,7 @@ class binary_writer

            case value_t::discarded:
            default:
-                throw_on_discarded(j, "MessagePack");
+                break;
        }
    }

@@ -671,7 +668,6 @@ class binary_writer
    @param[in] bjdata_version  which BJData version to use, default is draft2
    @throw type_error.316 if a string value or an object key is not valid
           UTF-8
-    @throw type_error.321 if @a j or a value nested in it is discarded
    */
    void write_ubjson(const BasicJsonType& j, const bool use_count,
                      const bool use_type, const bool add_prefix = true,
@@ -905,7 +901,7 @@ class binary_writer

            case value_t::discarded:
            default:
-                throw_on_discarded(j, use_bjdata ? "BJData" : "UBJSON");
+                break;
        }
    }

@@ -925,17 +921,6 @@ class binary_writer
    }

  private:
-    /*!
-    @brief throws because @a j is discarded and cannot be serialized
-    @throw type_error.321 always
-    */
-    JSON_HEDLEY_NO_RETURN static void throw_on_discarded(const BasicJsonType& j, const char* format_name)
-    {
-        static_cast<void>(j); // unused when JSON_NOEXCEPTION is defined
-        static_cast<void>(format_name);
-        JSON_THROW(type_error::create(321, concat("cannot serialize discarded value to ", format_name), &j));
-    }
-
    //////////
    // BSON //
    //////////
@@ -1187,7 +1172,6 @@ class binary_writer
           into a byte, before anything is written
    @throw type_error.316 if @a j is a string that is not valid UTF-8, before
           anything is written
-    @throw type_error.321 if @a j is discarded
    */
    std::size_t calc_bson_value_size(const BasicJsonType& j)
    {
@@ -1214,12 +1198,10 @@ class binary_writer
            case value_t::null:
                return 0ul;

-            case value_t::discarded:
-                throw_on_discarded(j, "BSON");
-
            // LCOV_EXCL_START
            case value_t::object:
            case value_t::array:
+            case value_t::discarded:
            default:
                JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert)
                return 0ul;
@@ -1256,12 +1238,10 @@ class binary_writer
            case value_t::null:
                return write_bson_null(name);

-            case value_t::discarded:
-                throw_on_discarded(j, "BSON");
-
            // LCOV_EXCL_START
            case value_t::object:
            case value_t::array:
+            case value_t::discarded:
            default:
                JSON_ASSERT(false); // NOLINT(cert-dcl03-c,hicpp-static-assert,misc-static-assert)
                return;
@@ -1328,8 +1308,6 @@ class binary_writer
           byte, before anything is written
    @throw type_error.316 if a string value or a key is not valid UTF-8,
           before anything is written
-    @throw type_error.321 if a value nested in @a document is discarded,
-           before anything is written
    */
    std::size_t calc_bson_sizes(const BasicJsonType& document, std::vector<std::size_t>& nested_sizes)
    {
@@ -164,12 +164,14 @@ class builder
        if (p[1] == '/')
        {
            p += 2;
-            // (as in parse(), a null byte is the end of the input, so it is
-            // left for the caller to see)
            while (p != e && *p != '\n' && *p != '\r' && !(NulIsEnd && *p == 0))
            {
                ++p;
            }
+            if (NulIsEnd && p != e && *p == 0)
+            {
+                ++p; // as in parse(), a null byte ends the comment like a line break
+            }
            return p;
        }
        if (p[1] == '*')
@@ -31,7 +31,11 @@ namespace view
 {

 /// append-only output buffer: writes through a raw pointer into a string that
-/// is resized ahead, and trimmed by finish()
+/// is resized ahead, and trimmed by finish(). The estimate is reserved, and the
+/// string grows in steps of 64 KiB within it: resize() fills the new bytes
+/// with zeros (before C++23, a string cannot grow without), and a small step
+/// is filled while the writer is about to use it, in the cache, instead of
+/// filling the whole estimate in memory first.
 template<typename StringType>
 class output_buffer
 {
@@ -75,17 +79,49 @@ class output_buffer
        m_pos += n;
    }

+    /// the write position and the end of the writable space, for a writer
+    /// that keeps the position in a local variable (set_cursor() hands it back)
+    char* cursor() const noexcept
+    {
+        return m_pos;
+    }
+
+    char* limit() const noexcept
+    {
+        return m_end;
+    }
+
+    void set_cursor(char* p) noexcept
+    {
+        m_pos = p;
+    }
+
  private:
+    /// the size of a growth step (a function: std::min() takes a reference,
+    /// which a static constexpr member does not have before C++17)
+    static constexpr std::size_t step() noexcept
+    {
+        return 65536;
+    }
+
    static StringType& sized(StringType& out, std::size_t estimate)
    {
-        out.resize((std::max)(estimate, static_cast<std::size_t>(64)));
+        out.reserve(estimate);
+        out.resize((std::min)((std::max)(estimate, static_cast<std::size_t>(64)), step()));
        return out;
    }

    NLOHMANN_VIEW_NOINLINE void grow(std::size_t n)
    {
        const auto used = static_cast<std::size_t>(m_pos - m_out.data());
-        m_out.resize((std::max)(m_out.size() * 2, used + n + 256));
+        // (a step does not go beyond the reserved estimate, so that a good
+        // estimate is never copied to a larger allocation)
+        const std::size_t size = (std::max)((std::min)(m_out.size() + step(), m_out.capacity()), used + n + 256);
+        if (size > m_out.capacity())
+        {
+            m_out.reserve((std::max)(m_out.capacity() * 2, size));
+        }
+        m_out.resize(size);
        m_pos = &m_out[0] + used;
        m_end = &m_out[0] + m_out.size();
    }
@@ -95,6 +131,105 @@ class output_buffer
    char* m_end;
 };

+/// The length of the run at s that dump() writes unchanged without
+/// ensure_ascii: all bytes but quotes, backslashes, and control characters.
+/// Unlike detail::string_bulk_run(), non-ASCII bytes are not validated: the
+/// strings of a document are valid UTF-8 (a damaged image loaded with
+/// image_check::bounds can have others, which are then written unchanged).
+inline std::size_t plain_output_run(const unsigned char* s, std::size_t n) noexcept
+{
+    constexpr std::uint64_t ones = 0x0101010101010101ull;
+    constexpr std::uint64_t high = 0x8080808080808080ull;
+    std::size_t i = 0;
+    for (; i + 8 <= n; i += 8)
+    {
+        const std::uint64_t v = read_eight_bytes(s + i);
+        const std::uint64_t q = v ^ 0x2222222222222222ull; // '"'
+        const std::uint64_t b = v ^ 0x5C5C5C5C5C5C5C5Cull; // '\\'
+        const std::uint64_t stop = (((q - ones) & ~q) | ((b - ones) & ~b) | ((v - 0x2020202020202020ull) & ~v)) & high;
+        if (stop != 0)
+        {
+            // the lowest flagged byte is the first stop: borrows only flag bytes above a true one
+            return i + (static_cast<std::size_t>(count_trailing_zeros(stop)) / 8);
+        }
+    }
+    for (; i < n; ++i)
+    {
+        if (s[i] == '"' || s[i] == '\\' || s[i] < 0x20)
+        {
+            return i;
+        }
+    }
+    return n;
+}
+
+/// A stack that starts in a buffer of the caller (a local array) and moves to
+/// the heap (a vector of the caller) only when that is full, so that dumps of
+/// shallow documents need no allocation. The top is a pointer, as in
+/// std::vector. The address of the stack never escapes (the growth gets the
+/// vector and returns the new storage), so its pointers stay in registers.
+template<typename T>
+class small_stack
+{
+  public:
+    small_stack(T* buffer, std::size_t capacity, std::vector<T>& heap) noexcept
+        : m_begin(buffer), m_top(buffer), m_end(buffer + capacity), m_heap(&heap)
+    {}
+    small_stack(const small_stack&) = delete;
+    small_stack(small_stack&&) = delete;
+    small_stack& operator=(const small_stack&) = delete;
+    small_stack& operator=(small_stack&&) = delete;
+    ~small_stack() = default;
+
+    NLOHMANN_VIEW_ALWAYS_INLINE void push_back(const T& x)
+    {
+        if (NLOHMANN_VIEW_UNLIKELY(m_top == m_end))
+        {
+            const std::size_t used = size();
+            const std::size_t capacity = 2 * static_cast<std::size_t>(m_end - m_begin);
+            m_begin = grow(*m_heap, m_begin, used, capacity);
+            m_top = m_begin + used;
+            m_end = m_begin + capacity;
+        }
+        *m_top++ = x;
+    }
+
+    NLOHMANN_VIEW_ALWAYS_INLINE T& back() noexcept
+    {
+        return m_top[-1];
+    }
+
+    NLOHMANN_VIEW_ALWAYS_INLINE void pop_back() noexcept
+    {
+        --m_top;
+    }
+
+    NLOHMANN_VIEW_ALWAYS_INLINE bool empty() const noexcept
+    {
+        return m_top == m_begin;
+    }
+
+    NLOHMANN_VIEW_ALWAYS_INLINE std::size_t size() const noexcept
+    {
+        return static_cast<std::size_t>(m_top - m_begin);
+    }
+
+  private:
+    /// the used entries moved to heap storage of the given capacity
+    NLOHMANN_VIEW_NOINLINE static T* grow(std::vector<T>& heap, const T* begin, std::size_t used, std::size_t capacity)
+    {
+        std::vector<T> bigger(capacity);
+        std::copy(begin, begin + used, bigger.begin());
+        heap.swap(bigger);
+        return heap.data();
+    }
+
+    T* m_begin;
+    T* m_top;
+    T* m_end;
+    std::vector<T>* m_heap;
+};
+
 /// how the view's dump() writes a value
 struct dump_style
 {
@@ -129,6 +264,18 @@ class view_serializer

    void dump(const node* root)
    {
+        if (!m_style.pretty && !m_style.ensure_ascii)
+        {
+            if (m_style.source_numbers)
+            {
+                dump_compact<true>(root);
+            }
+            else
+            {
+                dump_compact<false>(root);
+            }
+            return;
+        }
        struct frame
        {
            const node* pos; ///< next element, or key of the next member
@@ -136,7 +283,9 @@ class view_serializer
            bool object;
            bool first;  ///< nothing written yet
        };
-        std::vector<frame> stack;
+        std::array<frame, 32> buffer; // NOLINT(cppcoreguidelines-pro-type-member-init,hicpp-member-init): written before read
+        std::vector<frame> heap;
+        small_stack<frame> stack(buffer.data(), buffer.size(), heap);
        const node* n = root;
        for (;;)
        {
@@ -207,6 +356,289 @@ class view_serializer
    }

  private:
+    /*!
+    @brief the compact output without ensure_ascii (the default dump())
+
+    The same walk as dump(), with the write position in a local variable
+    (stores through char pointers would otherwise force a reload of the
+    buffer's members after each one), and with strings and number tokens of
+    the source copied by fixed-size moves of 32 bytes where the source has
+    that many bytes left, instead of a library call per token. The buffer
+    keeps 64 bytes of slack for the overshoot.
+    */
+    /// a string that is not a plain string of the source (decoded, or written
+    /// by an edit), without ensure_ascii: runs without characters to escape
+    /// are copied
+    NLOHMANN_VIEW_NOINLINE void write_decoded(const node& n)
+    {
+        const auto* const s = reinterpret_cast<const unsigned char*>(m_doc.str(n)); // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast)
+        m_out.put('"');
+        for (std::size_t i = 0; i < n.len;)
+        {
+            const std::size_t run = plain_output_run(s + i, n.len - i);
+            if (run != 0)
+            {
+                m_out.put(reinterpret_cast<const char*>(s + i), run); // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast)
+                i += run;
+                continue;
+            }
+            write_codepoint<false>(s[i], s + i, 1); // a quote, a backslash, or a control character
+            ++i;
+        }
+        m_out.put('"');
+    }
+
+    /// the copies of dump_compact() that are not fixed-size moves (long
+    /// strings, or near the end of the source); out of line, so that the
+    /// compiler does not merge the fixed-size moves into this call
+    NLOHMANN_VIEW_NOINLINE static void copy_long(char* to, const char* from, std::size_t n) noexcept
+    {
+        std::memcpy(to, from, n);
+    }
+
+    template<bool SourceNumbers>
+    void dump_compact(const node* root)
+    {
+        struct frame
+        {
+            const node* pos; ///< (editable documents) next element, or key of the next member
+            const node* end;
+            bool object;
+        };
+        std::array<frame, 32> buffer; // NOLINT(cppcoreguidelines-pro-type-member-init,hicpp-member-init): written before read
+        std::vector<frame> heap;
+        small_stack<frame> stack(buffer.data(), buffer.size(), heap);
+        const char* const src = m_doc.src;
+        const char* const src_end = src + m_doc.size;
+        char* w = m_out.cursor();
+        char* lim = m_out.limit();
+        // room for n bytes and the slack
+        const auto room = [&](std::size_t n)
+        {
+            if (NLOHMANN_VIEW_UNLIKELY(static_cast<std::size_t>(lim - w) < n + 64))
+            {
+                m_out.set_cursor(w);
+                m_out.reserve(n + 64);
+                w = m_out.cursor();
+                lim = m_out.limit();
+            }
+        };
+        // copy n bytes of the source (after room(n))
+        const auto copy = [&](const char* from, std::size_t n)
+        {
+            if (n <= 32 && src_end - from >= 32)
+            {
+                std::memcpy(w, from, 32);
+            }
+            else if (n <= 256 && src_end - from >= static_cast<std::ptrdiff_t>(n) + 32)
+            {
+                for (std::size_t i = 0; i < n; i += 32)
+                {
+                    std::memcpy(w + i, from + i, 32);
+                }
+            }
+            else
+            {
+                copy_long(w, from, n);
+            }
+            w += n;
+        };
+        // a literal of n bytes (after room(n))
+        const auto literal = [&](const char* text, std::size_t n)
+        {
+            std::memcpy(w, text, n);
+            w += n;
+        };
+        // a string that is not a plain string of the source (out of line, so
+        // that the cursor stays in a register here)
+        const auto escaped = [&](const node & n)
+        {
+            m_out.set_cursor(w);
+            write_decoded(n);
+            w = m_out.cursor();
+            lim = m_out.limit();
+        };
+
+        // Read-only documents: the elements of a container follow it in the
+        // node array, so the walk goes through the array in order, and a
+        // frame only needs the end of its container. Editable documents: the
+        // elements of a moved container live elsewhere, so a frame keeps the
+        // position of the next element (see navigation).
+        // The innermost open container is kept in registers (cur; end ==
+        // nullptr: none), the stack holds the ones around it.
+        frame cur{nullptr, nullptr, false};
+        const node* n = root;
+        for (;;)
+        {
+            // write the value at n (read-only documents: and advance n)
+            bool opened = false;
+            switch (static_cast<value_t>(n->kind))
+            {
+                case value_t::string:
+                    if ((n->flags & node_flags::storage) == 0)
+                    {
+                        room(n->len + 2);
+                        *w++ = '"';
+                        copy(src + n->off, n->len);
+                        *w++ = '"';
+                    }
+                    else
+                    {
+                        escaped(*n);
+                    }
+                    break;
+                case value_t::number_integer:
+                case value_t::number_unsigned:
+                {
+                    const std::uint32_t len = number_length(*n);
+                    room(len);
+                    if (Editable && (n->flags & node_flags::storage) != 0)
+                    {
+                        copy_long(w, m_doc.str(*n), len); // a canonical token written by an edit
+                        w += len;
+                        break;
+                    }
+                    const char* const token = src + n->off;
+                    if (!SourceNumbers && NLOHMANN_VIEW_UNLIKELY(len == 2 && token[0] == '-' && token[1] == '0'))
+                    {
+                        *w++ = '0'; // parse() reads -0 as the integer 0
+                    }
+                    else
+                    {
+                        copy(token, len);
+                    }
+                    break;
+                }
+                case value_t::number_float:
+                    if (SourceNumbers && (n->flags & node_flags::storage) != node_flags::edited)
+                    {
+                        room(n->len);
+                        copy(src + n->off, n->len);
+                    }
+                    else if (std::is_same<number_float_t, double>::value)
+                    {
+                        room(64);
+                        w = write_double_at(w, *n);
+                    }
+                    else
+                    {
+                        m_out.set_cursor(w);
+                        write_float_node(*n);
+                        w = m_out.cursor();
+                        lim = m_out.limit();
+                    }
+                    break;
+                case value_t::boolean:
+                    room(8);
+                    if ((n->flags & node_flags::is_true) != 0)
+                    {
+                        literal("true", 4);
+                    }
+                    else
+                    {
+                        literal("false", 5);
+                    }
+                    break;
+                case value_t::object:
+                case value_t::array:
+                {
+                    const bool object = n->kind == static_cast<std::uint8_t>(value_t::object);
+                    room(8);
+                    if (n->len == 0)
+                    {
+                        literal(object ? "{}" : "[]", 2);
+                    }
+                    else
+                    {
+                        *w++ = object ? '{' : '[';
+                        stack.push_back(cur);
+                        if (Editable)
+                        {
+                            cur = frame{nav::first(m_doc, n), nav::end(m_doc, n), object};
+                        }
+                        else
+                        {
+                            cur = frame{nullptr, n + n->next, object};
+                        }
+                        opened = true;
+                    }
+                    break;
+                }
+                case value_t::null:
+                    room(8);
+                    literal("null", 4);
+                    break;
+                case value_t::binary:    // LCOV_EXCL_LINE (not in a document)
+                case value_t::discarded: // LCOV_EXCL_LINE
+                default:                 // LCOV_EXCL_LINE
+                    break;               // LCOV_EXCL_LINE
+            }
+            if (!Editable)
+            {
+                ++n; // the next node: the first element of an opened container, or the node after a scalar
+            }
+
+            // go to the next value: close finished containers, then separate
+            // (a container just opened has an element)
+            if (!opened)
+            {
+                for (;;)
+                {
+                    if (cur.end == nullptr)
+                    {
+                        m_out.set_cursor(w);
+                        m_out.finish();
+                        return;
+                    }
+                    if ((Editable ? cur.pos : n) != cur.end)
+                    {
+                        break;
+                    }
+                    room(1);
+                    *w++ = cur.object ? '}' : ']';
+                    cur = stack.back();
+                    stack.pop_back();
+                }
+                room(1);
+                *w++ = ',';
+            }
+            const node* const at = Editable ? cur.pos : n;
+            if (cur.object)
+            {
+                const node& key = *at;
+                if ((key.flags & node_flags::storage) == 0)
+                {
+                    room(key.len + 3);
+                    *w++ = '"';
+                    copy(src + key.off, key.len);
+                    w[0] = '"';
+                    w[1] = ':';
+                    w += 2;
+                }
+                else
+                {
+                    escaped(key);
+                    room(1);
+                    *w++ = ':';
+                }
+                if (Editable)
+                {
+                    n = nav::value(at + 1);
+                    cur.pos = document_data::after(at + 1);
+                }
+                else
+                {
+                    ++n;
+                }
+            }
+            else if (Editable)
+            {
+                n = nav::value(at);
+                cur.pos = document_data::after(at);
+            }
+        }
+    }
+
    void newline(std::size_t level)
    {
        if (m_style.pretty)
@@ -258,7 +690,7 @@ class view_serializer
                }
                else
                {
-                    write_float(float_value<number_float_t>(m_doc, n));
+                    write_float_node(n);
                }
                break;
            case value_t::object:    // LCOV_EXCL_LINE (containers are written by dump())
@@ -270,6 +702,83 @@ class view_serializer
        }
    }

+    /// a float node as dump() writes it
+    void write_float_node(const node& n)
+    {
+        write_float_node(n, std::is_same<number_float_t, double> {});
+    }
+
+    void write_float_node(const node& n, std::false_type /*other*/)
+    {
+        write_float(float_value<number_float_t>(m_doc, n));
+    }
+
+    void write_float_node(const node& n, std::true_type /*double*/)
+    {
+        m_out.reserve(64);
+        m_out.set_cursor(write_double_at(m_out.cursor(), n));
+    }
+
+    /*!
+    @brief (doubles) the float at n as dump() writes it, at w (64 bytes of room)
+
+    A token of at most 15 significant digits is written from its digits,
+    without a conversion: two decimals of at most 15 digits are farther
+    apart than the rounding interval of a (normal) double (the argument
+    behind DBL_DIG), so the token's digits are the shortest ones of its
+    double, which the library's conversion writes (Zmij). Other tokens are
+    converted from the digits already read.
+    */
+    char* write_double_at(char* w, const node& n)
+    {
+        const unsigned int_digits = n.extra & 0xFFu;
+        const unsigned frac_digits = n.extra >> 8u;
+        if ((n.flags & node_flags::storage) != node_flags::edited && int_digits + frac_digits <= 19)
+        {
+            const auto* const first = reinterpret_cast<const unsigned char*>(m_doc.src + n.off); // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast)
+            const float_significand d = layout_decimal(first, first + n.len, int_digits, frac_digits, reinterpret_cast<const unsigned char*>(m_doc.src + m_doc.size)); // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast)
+            // (the exponent keeps the value far from subnormals and overflow)
+            if (d.w != 0 && d.w < 1000000000000000u && d.exponent >= -290 && d.exponent <= 290)
+            {
+                *w = '-';
+                w += d.negative ? 1 : 0;
+                // (without leading zeros, all digits of the token count)
+                const unsigned char lead = first[d.negative ? 1 : 0];
+                return lead != '0' ? ::nlohmann::detail::dtoa_impl::write_short_decimal(w, d.w, static_cast<int>(int_digits + frac_digits), static_cast<int>(d.exponent))
+                       : ::nlohmann::detail::dtoa_impl::write_short_decimal(w, d.w, static_cast<int>(d.exponent));
+            }
+            return write_double_value_at(w, decimal_to_float<double>(d)); // (without reading the token again)
+        }
+        return write_double_value_at(w, static_cast<double>(float_value<number_float_t>(m_doc, n)));
+    }
+
+    /// n bytes of text at w
+    static char* write_text_at(char* w, const char* text, std::size_t n) noexcept
+    {
+        std::memcpy(w, text, n);
+        return w + n;
+    }
+
+    /// a double as dump() writes it, at w (64 bytes of room)
+    static char* write_double_value_at(char* w, double x)
+    {
+        // (from the bits: without the checks of to_chars())
+        std::uint64_t bits = 0;
+        std::memcpy(&bits, &x, sizeof(bits));
+        if (NLOHMANN_VIEW_UNLIKELY((bits & 0x7FF0000000000000u) == 0x7FF0000000000000u))
+        {
+            return write_text_at(w, "null", 4);
+        }
+        *w = '-';
+        w += bits >> 63u;
+        bits &= ~(std::uint64_t{1} << 63u);
+        if (bits == 0)
+        {
+            return write_text_at(w, "0.0", 3);
+        }
+        return ::nlohmann::detail::dtoa_impl::write_shortest(w, ::nlohmann::detail::zmij::to_shortest(bits));
+    }
+
    /// as serializer::dump_float()
    void write_float(number_float_t x)
    {
@@ -592,8 +592,10 @@ class basic_json_view
        style.indent_char = indent_char;
        style.ensure_ascii = ensure_ascii;
        style.source_numbers = numbers == number_format::source;
-        // the compact text is about as long as the source text of the value
-        const std::size_t estimate = source_extent() + (style.pretty ? source_extent() / 2 : 0) + 64;
+        // the compact text is about as long as the source text of the value;
+        // the compact writer keeps 64 bytes of slack, so that it does not grow
+        // the buffer just before the end
+        const std::size_t estimate = source_extent() + (style.pretty ? source_extent() / 2 : 0) + 160;
        detail::view::view_serializer<BasicJsonType, Editable>(*m_doc, out, estimate, style).dump(m_node);
        return out;
    }
@@ -259,9 +259,6 @@ public:

        for (auto it = first; std::next(it, elements_affected) != Container::end(); ++it)
        {
-            // false positive: Infer's model of std::string keeps the buffer of a
-            // moved-from string, so it assumes a buffer is destroyed twice
-            // @infer-ignore USE_AFTER_DELETE
            it->~value_type(); // destroy but keep allocation
            new (&*it) value_type{std::move(*std::next(it, elements_affected))}; // "move" next element to it
        }
@@ -67,10 +67,6 @@
    #define JSON_STRICT_BINARY_UTF8 0
 #endif

-#ifndef JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS
-    #define JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS 0
-#endif
-
 #if JSON_DIAGNOSTICS
    #define NLOHMANN_JSON_ABI_TAG_DIAGNOSTICS _diag
 #else
@@ -113,20 +109,14 @@
    #define NLOHMANN_JSON_ABI_TAG_STRICT_BINARY_UTF8
 #endif

-#if JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS
-    #define NLOHMANN_JSON_ABI_TAG_OBJECTS_FOR_ENUM_KEYED_MAPS _ekmo
-#else
-    #define NLOHMANN_JSON_ABI_TAG_OBJECTS_FOR_ENUM_KEYED_MAPS
-#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, e, f, g, h) json_abi ## a ## b ## c ## d ## e ## f ## g ## h
-#define NLOHMANN_JSON_ABI_TAGS_CONCAT(a, b, c, d, e, f, g, h) \
-    NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b, c, d, e, f, g, h)
+#define NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b, c, d, e, f, g) json_abi ## a ## b ## c ## d ## e ## f ## g
+#define NLOHMANN_JSON_ABI_TAGS_CONCAT(a, b, c, d, e, f, g) \
+    NLOHMANN_JSON_ABI_TAGS_CONCAT_EX(a, b, c, d, e, f, g)

 #define NLOHMANN_JSON_ABI_TAGS                                       \
    NLOHMANN_JSON_ABI_TAGS_CONCAT(                                   \
@@ -136,8 +126,7 @@
            NLOHMANN_JSON_ABI_TAG_BRACE_INIT_COPY_SEMANTICS,         \
            NLOHMANN_JSON_ABI_TAG_PRECISE_STREAM_POSITION,           \
            NLOHMANN_JSON_ABI_TAG_STRICT_NUL_HANDLING,               \
-            NLOHMANN_JSON_ABI_TAG_STRICT_BINARY_UTF8,                \
-            NLOHMANN_JSON_ABI_TAG_OBJECTS_FOR_ENUM_KEYED_MAPS)
+            NLOHMANN_JSON_ABI_TAG_STRICT_BINARY_UTF8)

 // Construct the namespace version component
 #define NLOHMANN_JSON_NAMESPACE_VERSION_CONCAT_EX(major, minor, patch) \
@@ -1218,12 +1218,14 @@ class builder
        if (p[1] == '/')
        {
            p += 2;
-            // (as in parse(), a null byte is the end of the input, so it is
-            // left for the caller to see)
            while (p != e && *p != '\n' && *p != '\r' && !(NulIsEnd && *p == 0))
            {
                ++p;
            }
+            if (NulIsEnd && p != e && *p == 0)
+            {
+                ++p; // as in parse(), a null byte ends the comment like a line break
+            }
            return p;
        }
        if (p[1] == '*')
@@ -5407,7 +5409,11 @@ namespace view
 {

 /// append-only output buffer: writes through a raw pointer into a string that
-/// is resized ahead, and trimmed by finish()
+/// is resized ahead, and trimmed by finish(). The estimate is reserved, and the
+/// string grows in steps of 64 KiB within it: resize() fills the new bytes
+/// with zeros (before C++23, a string cannot grow without), and a small step
+/// is filled while the writer is about to use it, in the cache, instead of
+/// filling the whole estimate in memory first.
 template<typename StringType>
 class output_buffer
 {
@@ -5451,17 +5457,49 @@ class output_buffer
        m_pos += n;
    }

+    /// the write position and the end of the writable space, for a writer
+    /// that keeps the position in a local variable (set_cursor() hands it back)
+    char* cursor() const noexcept
+    {
+        return m_pos;
+    }
+
+    char* limit() const noexcept
+    {
+        return m_end;
+    }
+
+    void set_cursor(char* p) noexcept
+    {
+        m_pos = p;
+    }
+
  private:
+    /// the size of a growth step (a function: std::min() takes a reference,
+    /// which a static constexpr member does not have before C++17)
+    static constexpr std::size_t step() noexcept
+    {
+        return 65536;
+    }
+
    static StringType& sized(StringType& out, std::size_t estimate)
    {
-        out.resize((std::max)(estimate, static_cast<std::size_t>(64)));
+        out.reserve(estimate);
+        out.resize((std::min)((std::max)(estimate, static_cast<std::size_t>(64)), step()));
        return out;
    }

    NLOHMANN_VIEW_NOINLINE void grow(std::size_t n)
    {
        const auto used = static_cast<std::size_t>(m_pos - m_out.data());
-        m_out.resize((std::max)(m_out.size() * 2, used + n + 256));
+        // (a step does not go beyond the reserved estimate, so that a good
+        // estimate is never copied to a larger allocation)
+        const std::size_t size = (std::max)((std::min)(m_out.size() + step(), m_out.capacity()), used + n + 256);
+        if (size > m_out.capacity())
+        {
+            m_out.reserve((std::max)(m_out.capacity() * 2, size));
+        }
+        m_out.resize(size);
        m_pos = &m_out[0] + used;
        m_end = &m_out[0] + m_out.size();
    }
@@ -5471,6 +5509,105 @@ class output_buffer
    char* m_end;
 };

+/// The length of the run at s that dump() writes unchanged without
+/// ensure_ascii: all bytes but quotes, backslashes, and control characters.
+/// Unlike detail::string_bulk_run(), non-ASCII bytes are not validated: the
+/// strings of a document are valid UTF-8 (a damaged image loaded with
+/// image_check::bounds can have others, which are then written unchanged).
+inline std::size_t plain_output_run(const unsigned char* s, std::size_t n) noexcept
+{
+    constexpr std::uint64_t ones = 0x0101010101010101ull;
+    constexpr std::uint64_t high = 0x8080808080808080ull;
+    std::size_t i = 0;
+    for (; i + 8 <= n; i += 8)
+    {
+        const std::uint64_t v = read_eight_bytes(s + i);
+        const std::uint64_t q = v ^ 0x2222222222222222ull; // '"'
+        const std::uint64_t b = v ^ 0x5C5C5C5C5C5C5C5Cull; // '\\'
+        const std::uint64_t stop = (((q - ones) & ~q) | ((b - ones) & ~b) | ((v - 0x2020202020202020ull) & ~v)) & high;
+        if (stop != 0)
+        {
+            // the lowest flagged byte is the first stop: borrows only flag bytes above a true one
+            return i + (static_cast<std::size_t>(count_trailing_zeros(stop)) / 8);
+        }
+    }
+    for (; i < n; ++i)
+    {
+        if (s[i] == '"' || s[i] == '\\' || s[i] < 0x20)
+        {
+            return i;
+        }
+    }
+    return n;
+}
+
+/// A stack that starts in a buffer of the caller (a local array) and moves to
+/// the heap (a vector of the caller) only when that is full, so that dumps of
+/// shallow documents need no allocation. The top is a pointer, as in
+/// std::vector. The address of the stack never escapes (the growth gets the
+/// vector and returns the new storage), so its pointers stay in registers.
+template<typename T>
+class small_stack
+{
+  public:
+    small_stack(T* buffer, std::size_t capacity, std::vector<T>& heap) noexcept
+        : m_begin(buffer), m_top(buffer), m_end(buffer + capacity), m_heap(&heap)
+    {}
+    small_stack(const small_stack&) = delete;
+    small_stack(small_stack&&) = delete;
+    small_stack& operator=(const small_stack&) = delete;
+    small_stack& operator=(small_stack&&) = delete;
+    ~small_stack() = default;
+
+    NLOHMANN_VIEW_ALWAYS_INLINE void push_back(const T& x)
+    {
+        if (NLOHMANN_VIEW_UNLIKELY(m_top == m_end))
+        {
+            const std::size_t used = size();
+            const std::size_t capacity = 2 * static_cast<std::size_t>(m_end - m_begin);
+            m_begin = grow(*m_heap, m_begin, used, capacity);
+            m_top = m_begin + used;
+            m_end = m_begin + capacity;
+        }
+        *m_top++ = x;
+    }
+
+    NLOHMANN_VIEW_ALWAYS_INLINE T& back() noexcept
+    {
+        return m_top[-1];
+    }
+
+    NLOHMANN_VIEW_ALWAYS_INLINE void pop_back() noexcept
+    {
+        --m_top;
+    }
+
+    NLOHMANN_VIEW_ALWAYS_INLINE bool empty() const noexcept
+    {
+        return m_top == m_begin;
+    }
+
+    NLOHMANN_VIEW_ALWAYS_INLINE std::size_t size() const noexcept
+    {
+        return static_cast<std::size_t>(m_top - m_begin);
+    }
+
+  private:
+    /// the used entries moved to heap storage of the given capacity
+    NLOHMANN_VIEW_NOINLINE static T* grow(std::vector<T>& heap, const T* begin, std::size_t used, std::size_t capacity)
+    {
+        std::vector<T> bigger(capacity);
+        std::copy(begin, begin + used, bigger.begin());
+        heap.swap(bigger);
+        return heap.data();
+    }
+
+    T* m_begin;
+    T* m_top;
+    T* m_end;
+    std::vector<T>* m_heap;
+};
+
 /// how the view's dump() writes a value
 struct dump_style
 {
@@ -5505,6 +5642,18 @@ class view_serializer

    void dump(const node* root)
    {
+        if (!m_style.pretty && !m_style.ensure_ascii)
+        {
+            if (m_style.source_numbers)
+            {
+                dump_compact<true>(root);
+            }
+            else
+            {
+                dump_compact<false>(root);
+            }
+            return;
+        }
        struct frame
        {
            const node* pos; ///< next element, or key of the next member
@@ -5512,7 +5661,9 @@ class view_serializer
            bool object;
            bool first;  ///< nothing written yet
        };
-        std::vector<frame> stack;
+        std::array<frame, 32> buffer; // NOLINT(cppcoreguidelines-pro-type-member-init,hicpp-member-init): written before read
+        std::vector<frame> heap;
+        small_stack<frame> stack(buffer.data(), buffer.size(), heap);
        const node* n = root;
        for (;;)
        {
@@ -5583,6 +5734,289 @@ class view_serializer
    }

  private:
+    /*!
+    @brief the compact output without ensure_ascii (the default dump())
+
+    The same walk as dump(), with the write position in a local variable
+    (stores through char pointers would otherwise force a reload of the
+    buffer's members after each one), and with strings and number tokens of
+    the source copied by fixed-size moves of 32 bytes where the source has
+    that many bytes left, instead of a library call per token. The buffer
+    keeps 64 bytes of slack for the overshoot.
+    */
+    /// a string that is not a plain string of the source (decoded, or written
+    /// by an edit), without ensure_ascii: runs without characters to escape
+    /// are copied
+    NLOHMANN_VIEW_NOINLINE void write_decoded(const node& n)
+    {
+        const auto* const s = reinterpret_cast<const unsigned char*>(m_doc.str(n)); // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast)
+        m_out.put('"');
+        for (std::size_t i = 0; i < n.len;)
+        {
+            const std::size_t run = plain_output_run(s + i, n.len - i);
+            if (run != 0)
+            {
+                m_out.put(reinterpret_cast<const char*>(s + i), run); // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast)
+                i += run;
+                continue;
+            }
+            write_codepoint<false>(s[i], s + i, 1); // a quote, a backslash, or a control character
+            ++i;
+        }
+        m_out.put('"');
+    }
+
+    /// the copies of dump_compact() that are not fixed-size moves (long
+    /// strings, or near the end of the source); out of line, so that the
+    /// compiler does not merge the fixed-size moves into this call
+    NLOHMANN_VIEW_NOINLINE static void copy_long(char* to, const char* from, std::size_t n) noexcept
+    {
+        std::memcpy(to, from, n);
+    }
+
+    template<bool SourceNumbers>
+    void dump_compact(const node* root)
+    {
+        struct frame
+        {
+            const node* pos; ///< (editable documents) next element, or key of the next member
+            const node* end;
+            bool object;
+        };
+        std::array<frame, 32> buffer; // NOLINT(cppcoreguidelines-pro-type-member-init,hicpp-member-init): written before read
+        std::vector<frame> heap;
+        small_stack<frame> stack(buffer.data(), buffer.size(), heap);
+        const char* const src = m_doc.src;
+        const char* const src_end = src + m_doc.size;
+        char* w = m_out.cursor();
+        char* lim = m_out.limit();
+        // room for n bytes and the slack
+        const auto room = [&](std::size_t n)
+        {
+            if (NLOHMANN_VIEW_UNLIKELY(static_cast<std::size_t>(lim - w) < n + 64))
+            {
+                m_out.set_cursor(w);
+                m_out.reserve(n + 64);
+                w = m_out.cursor();
+                lim = m_out.limit();
+            }
+        };
+        // copy n bytes of the source (after room(n))
+        const auto copy = [&](const char* from, std::size_t n)
+        {
+            if (n <= 32 && src_end - from >= 32)
+            {
+                std::memcpy(w, from, 32);
+            }
+            else if (n <= 256 && src_end - from >= static_cast<std::ptrdiff_t>(n) + 32)
+            {
+                for (std::size_t i = 0; i < n; i += 32)
+                {
+                    std::memcpy(w + i, from + i, 32);
+                }
+            }
+            else
+            {
+                copy_long(w, from, n);
+            }
+            w += n;
+        };
+        // a literal of n bytes (after room(n))
+        const auto literal = [&](const char* text, std::size_t n)
+        {
+            std::memcpy(w, text, n);
+            w += n;
+        };
+        // a string that is not a plain string of the source (out of line, so
+        // that the cursor stays in a register here)
+        const auto escaped = [&](const node & n)
+        {
+            m_out.set_cursor(w);
+            write_decoded(n);
+            w = m_out.cursor();
+            lim = m_out.limit();
+        };
+
+        // Read-only documents: the elements of a container follow it in the
+        // node array, so the walk goes through the array in order, and a
+        // frame only needs the end of its container. Editable documents: the
+        // elements of a moved container live elsewhere, so a frame keeps the
+        // position of the next element (see navigation).
+        // The innermost open container is kept in registers (cur; end ==
+        // nullptr: none), the stack holds the ones around it.
+        frame cur{nullptr, nullptr, false};
+        const node* n = root;
+        for (;;)
+        {
+            // write the value at n (read-only documents: and advance n)
+            bool opened = false;
+            switch (static_cast<value_t>(n->kind))
+            {
+                case value_t::string:
+                    if ((n->flags & node_flags::storage) == 0)
+                    {
+                        room(n->len + 2);
+                        *w++ = '"';
+                        copy(src + n->off, n->len);
+                        *w++ = '"';
+                    }
+                    else
+                    {
+                        escaped(*n);
+                    }
+                    break;
+                case value_t::number_integer:
+                case value_t::number_unsigned:
+                {
+                    const std::uint32_t len = number_length(*n);
+                    room(len);
+                    if (Editable && (n->flags & node_flags::storage) != 0)
+                    {
+                        copy_long(w, m_doc.str(*n), len); // a canonical token written by an edit
+                        w += len;
+                        break;
+                    }
+                    const char* const token = src + n->off;
+                    if (!SourceNumbers && NLOHMANN_VIEW_UNLIKELY(len == 2 && token[0] == '-' && token[1] == '0'))
+                    {
+                        *w++ = '0'; // parse() reads -0 as the integer 0
+                    }
+                    else
+                    {
+                        copy(token, len);
+                    }
+                    break;
+                }
+                case value_t::number_float:
+                    if (SourceNumbers && (n->flags & node_flags::storage) != node_flags::edited)
+                    {
+                        room(n->len);
+                        copy(src + n->off, n->len);
+                    }
+                    else if (std::is_same<number_float_t, double>::value)
+                    {
+                        room(64);
+                        w = write_double_at(w, *n);
+                    }
+                    else
+                    {
+                        m_out.set_cursor(w);
+                        write_float_node(*n);
+                        w = m_out.cursor();
+                        lim = m_out.limit();
+                    }
+                    break;
+                case value_t::boolean:
+                    room(8);
+                    if ((n->flags & node_flags::is_true) != 0)
+                    {
+                        literal("true", 4);
+                    }
+                    else
+                    {
+                        literal("false", 5);
+                    }
+                    break;
+                case value_t::object:
+                case value_t::array:
+                {
+                    const bool object = n->kind == static_cast<std::uint8_t>(value_t::object);
+                    room(8);
+                    if (n->len == 0)
+                    {
+                        literal(object ? "{}" : "[]", 2);
+                    }
+                    else
+                    {
+                        *w++ = object ? '{' : '[';
+                        stack.push_back(cur);
+                        if (Editable)
+                        {
+                            cur = frame{nav::first(m_doc, n), nav::end(m_doc, n), object};
+                        }
+                        else
+                        {
+                            cur = frame{nullptr, n + n->next, object};
+                        }
+                        opened = true;
+                    }
+                    break;
+                }
+                case value_t::null:
+                    room(8);
+                    literal("null", 4);
+                    break;
+                case value_t::binary:    // LCOV_EXCL_LINE (not in a document)
+                case value_t::discarded: // LCOV_EXCL_LINE
+                default:                 // LCOV_EXCL_LINE
+                    break;               // LCOV_EXCL_LINE
+            }
+            if (!Editable)
+            {
+                ++n; // the next node: the first element of an opened container, or the node after a scalar
+            }
+
+            // go to the next value: close finished containers, then separate
+            // (a container just opened has an element)
+            if (!opened)
+            {
+                for (;;)
+                {
+                    if (cur.end == nullptr)
+                    {
+                        m_out.set_cursor(w);
+                        m_out.finish();
+                        return;
+                    }
+                    if ((Editable ? cur.pos : n) != cur.end)
+                    {
+                        break;
+                    }
+                    room(1);
+                    *w++ = cur.object ? '}' : ']';
+                    cur = stack.back();
+                    stack.pop_back();
+                }
+                room(1);
+                *w++ = ',';
+            }
+            const node* const at = Editable ? cur.pos : n;
+            if (cur.object)
+            {
+                const node& key = *at;
+                if ((key.flags & node_flags::storage) == 0)
+                {
+                    room(key.len + 3);
+                    *w++ = '"';
+                    copy(src + key.off, key.len);
+                    w[0] = '"';
+                    w[1] = ':';
+                    w += 2;
+                }
+                else
+                {
+                    escaped(key);
+                    room(1);
+                    *w++ = ':';
+                }
+                if (Editable)
+                {
+                    n = nav::value(at + 1);
+                    cur.pos = document_data::after(at + 1);
+                }
+                else
+                {
+                    ++n;
+                }
+            }
+            else if (Editable)
+            {
+                n = nav::value(at);
+                cur.pos = document_data::after(at);
+            }
+        }
+    }
+
    void newline(std::size_t level)
    {
        if (m_style.pretty)
@@ -5634,7 +6068,7 @@ class view_serializer
                }
                else
                {
-                    write_float(float_value<number_float_t>(m_doc, n));
+                    write_float_node(n);
                }
                break;
            case value_t::object:    // LCOV_EXCL_LINE (containers are written by dump())
@@ -5646,6 +6080,83 @@ class view_serializer
        }
    }

+    /// a float node as dump() writes it
+    void write_float_node(const node& n)
+    {
+        write_float_node(n, std::is_same<number_float_t, double> {});
+    }
+
+    void write_float_node(const node& n, std::false_type /*other*/)
+    {
+        write_float(float_value<number_float_t>(m_doc, n));
+    }
+
+    void write_float_node(const node& n, std::true_type /*double*/)
+    {
+        m_out.reserve(64);
+        m_out.set_cursor(write_double_at(m_out.cursor(), n));
+    }
+
+    /*!
+    @brief (doubles) the float at n as dump() writes it, at w (64 bytes of room)
+
+    A token of at most 15 significant digits is written from its digits,
+    without a conversion: two decimals of at most 15 digits are farther
+    apart than the rounding interval of a (normal) double (the argument
+    behind DBL_DIG), so the token's digits are the shortest ones of its
+    double, which the library's conversion writes (Zmij). Other tokens are
+    converted from the digits already read.
+    */
+    char* write_double_at(char* w, const node& n)
+    {
+        const unsigned int_digits = n.extra & 0xFFu;
+        const unsigned frac_digits = n.extra >> 8u;
+        if ((n.flags & node_flags::storage) != node_flags::edited && int_digits + frac_digits <= 19)
+        {
+            const auto* const first = reinterpret_cast<const unsigned char*>(m_doc.src + n.off); // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast)
+            const float_significand d = layout_decimal(first, first + n.len, int_digits, frac_digits, reinterpret_cast<const unsigned char*>(m_doc.src + m_doc.size)); // NOLINT(cppcoreguidelines-pro-type-reinterpret-cast)
+            // (the exponent keeps the value far from subnormals and overflow)
+            if (d.w != 0 && d.w < 1000000000000000u && d.exponent >= -290 && d.exponent <= 290)
+            {
+                *w = '-';
+                w += d.negative ? 1 : 0;
+                // (without leading zeros, all digits of the token count)
+                const unsigned char lead = first[d.negative ? 1 : 0];
+                return lead != '0' ? ::nlohmann::detail::dtoa_impl::write_short_decimal(w, d.w, static_cast<int>(int_digits + frac_digits), static_cast<int>(d.exponent))
+                       : ::nlohmann::detail::dtoa_impl::write_short_decimal(w, d.w, static_cast<int>(d.exponent));
+            }
+            return write_double_value_at(w, decimal_to_float<double>(d)); // (without reading the token again)
+        }
+        return write_double_value_at(w, static_cast<double>(float_value<number_float_t>(m_doc, n)));
+    }
+
+    /// n bytes of text at w
+    static char* write_text_at(char* w, const char* text, std::size_t n) noexcept
+    {
+        std::memcpy(w, text, n);
+        return w + n;
+    }
+
+    /// a double as dump() writes it, at w (64 bytes of room)
+    static char* write_double_value_at(char* w, double x)
+    {
+        // (from the bits: without the checks of to_chars())
+        std::uint64_t bits = 0;
+        std::memcpy(&bits, &x, sizeof(bits));
+        if (NLOHMANN_VIEW_UNLIKELY((bits & 0x7FF0000000000000u) == 0x7FF0000000000000u))
+        {
+            return write_text_at(w, "null", 4);
+        }
+        *w = '-';
+        w += bits >> 63u;
+        bits &= ~(std::uint64_t{1} << 63u);
+        if (bits == 0)
+        {
+            return write_text_at(w, "0.0", 3);
+        }
+        return ::nlohmann::detail::dtoa_impl::write_shortest(w, ::nlohmann::detail::zmij::to_shortest(bits));
+    }
+
    /// as serializer::dump_float()
    void write_float(number_float_t x)
    {
@@ -6564,8 +7075,10 @@ class basic_json_view
        style.indent_char = indent_char;
        style.ensure_ascii = ensure_ascii;
        style.source_numbers = numbers == number_format::source;
-        // the compact text is about as long as the source text of the value
-        const std::size_t estimate = source_extent() + (style.pretty ? source_extent() / 2 : 0) + 64;
+        // the compact text is about as long as the source text of the value;
+        // the compact writer keeps 64 bytes of slack, so that it does not grow
+        // the buffer just before the end
+        const std::size_t estimate = source_extent() + (style.pretty ? source_extent() / 2 : 0) + 160;
        detail::view::view_serializer<BasicJsonType, Editable>(*m_doc, out, estimate, style).dump(m_node);
        return out;
    }
@@ -8,7 +8,6 @@ set(JSON_SIMDUTF_VERSION 9.1.0 CACHE STRING "The simdutf version used by JSON_Te

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

 # using an env var, since this will also affect targets executing cmake (such as "ci_test_compiler_default")
 if (NOT "" STREQUAL "$ENV{JSON_FORCED_GLOBAL_COMPILE_OPTIONS}")
@@ -135,17 +134,12 @@ json_test_set_test_options(test-disabled_exceptions
        #$<$<CXX_COMPILER_ID:MSVC>:/EH>
 )

+# raise timeout of expensive Unicode test
+json_test_set_test_options(test-unicode4 TEST_PROPERTIES TIMEOUT 3000)
+
 # only the #972 regression test needs thirdparty/fifo_map on its include path
 json_test_set_test_options(test-regression1 LINK_LIBRARIES fifo_map_include)

-# GCC's false -Warray-bounds error with JSON_DIAGNOSTICS only shows up when optimizing (#5742).
-# -O3 makes the optimizer-driven warnings of the ci_test_gcc flag set (-Winline,
-# -Wsuggest-attribute=...) fire on the library's inline functions; they are not
-# what this test checks, so turn them off for it.
-json_test_set_test_options(test-diagnostics-optimized
-    COMPILE_OPTIONS $<$<CXX_COMPILER_ID:GNU>:-O3 -Werror=array-bounds -Wno-inline -Wno-suggest-attribute=pure -Wno-suggest-attribute=const>
-)
-
 #############################################################################
 # add unit tests
 #############################################################################
@@ -294,33 +288,6 @@ elseif(NOT json_32bit_test)
    list(FILTER files EXCLUDE REGEX src/unit-32bit.cpp)
 endif()

-# with JSON_TestShard=<index>/<count>, keep every <count>-th unit test file,
-# starting at <index> (the glob is sorted, so the split is stable)
-set(test_shard_index 0)
-if(NOT "${JSON_TestShard}" STREQUAL "")
-    if(NOT JSON_TestShard MATCHES "^([0-9]+)/([1-9][0-9]*)$")
-        message(FATAL_ERROR "JSON_TestShard must be <index>/<count>, e.g. 0/2, not '${JSON_TestShard}'.")
-    endif()
-    set(test_shard_index ${CMAKE_MATCH_1})
-    set(test_shard_count ${CMAKE_MATCH_2})
-    if(NOT test_shard_index LESS test_shard_count)
-        message(FATAL_ERROR "JSON_TestShard: the index must be less than the count, not '${JSON_TestShard}'.")
-    endif()
-    list(LENGTH files test_file_count)
-    set(shard_files "")
-    set(file_position 0)
-    foreach(file ${files})
-        math(EXPR file_shard "${file_position} % ${test_shard_count}")
-        if(file_shard EQUAL test_shard_index)
-            list(APPEND shard_files ${file})
-        endif()
-        math(EXPR file_position "${file_position} + 1")
-    endforeach()
-    set(files ${shard_files})
-    list(LENGTH files shard_file_count)
-    message(STATUS "Test shard ${JSON_TestShard}: ${shard_file_count} of ${test_file_count} unit test files")
-endif()
-
 foreach(file ${files})
    json_test_add_test_for(${file} MAIN test_main CXX_STANDARDS ${test_cxx_standards} ${test_force})
 endforeach()
@@ -338,9 +305,6 @@ if(json_32bit_test_only)
    return()
 endif()

-# the following variants of single test files are only built in the first shard
-if(test_shard_index EQUAL 0)
-
 # test legacy comparison of discarded values
 json_test_set_test_options(test-comparison_legacy
    COMPILE_DEFINITIONS JSON_USE_LEGACY_DISCARDED_VALUE_COMPARISON=1
@@ -387,7 +351,6 @@ if(CMAKE_SYSTEM_PROCESSOR MATCHES "^(x86_64|AMD64|amd64)$" AND NOT MSVC)
        MAIN test_main CXX_STANDARDS ${test_cxx_standards} ${test_force}
    )
 endif()
-endif()

 # *DO NOT* use json_test_set_test_options() below this line

@@ -48,10 +48,6 @@ TEST_CASE("default namespace")
        expected += "_sbu8";
 #endif

-#if JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS
-        expected += "_ekmo";
-#endif
-
        expected += "_v" STRINGIZE(NLOHMANN_JSON_VERSION_MAJOR);
        expected += "_" STRINGIZE(NLOHMANN_JSON_VERSION_MINOR);
        expected += "_" STRINGIZE(NLOHMANN_JSON_VERSION_PATCH) "::basic_json";
@@ -49,10 +49,6 @@ TEST_CASE("default namespace without version component")
        expected += "_sbu8";
 #endif

-#if JSON_USE_OBJECTS_FOR_ENUM_KEYED_MAPS
-        expected += "_ekmo";
-#endif
-
        expected += "::basic_json";

        // fallback for Clang
@@ -0,0 +1 @@
+build/
@@ -0,0 +1,90 @@
+# json_view compared with other libraries
+
+The in-tree benchmarks in [`tests/benchmarks`](../README.md) measure `json_document` against `json::parse` only. The
+programs here compare it with [yyjson](https://github.com/ibireme/yyjson),
+[simdjson](https://github.com/simdjson/simdjson), and [Boost.JSON](https://github.com/boostorg/json): the question
+users ask when they pick a library. They are not built by CMake or run by CI.
+
+## Reproducing the numbers
+
+`compare.py` builds the programs against `include/` of this checkout, runs them, and writes the results together with
+everything needed to reproduce them to `results/<date>-<host>.md` (and `.csv`): the date, the commit, the CPU, the
+OS, the compiler, the flags, and the versions of all libraries.
+
+```sh
+python3 tests/benchmarks/json_view/compare.py --data <json_test_data directory> [--native] [--rounds 30]
+```
+
+- `--data` is the downloaded [test data](https://github.com/nlohmann/json_test_data), e.g. the `test_files` directory
+  of a CMake build directory. It needs `nativejson-benchmark/{twitter,citm_catalog,canada}.json` and
+  `jeopardy/jeopardy.json`.
+- The other libraries come from the system: pkg-config, or Homebrew (`brew install yyjson simdjson boost`). With
+  `--download`, pinned releases are downloaded instead and checked against their SHA-256. Without Boost headers (or
+  with `--no-boost`), the Boost.JSON columns are skipped, and the results say so.
+- `--corpus file...` adds files to the corpus benchmark, e.g. those of
+  [simdjson-data](https://github.com/simdjson/simdjson-data) or the
+  [yyjson benchmark](https://github.com/ibireme/yyjson_benchmark).
+- Only the Python 3 standard library is used; a C++17 compiler is needed (`CXX` and `CC` are honored).
+
+For numbers worth publishing, use a quiet machine (see [Getting stable numbers](../README.md#getting-stable-numbers)),
+the default 30 rounds or more, and `--native` only if the other libraries were built for the same CPU.
+
+### On GitHub-hosted runners
+
+The workflow [json_view benchmarks](../../../.github/workflows/json_view_benchmarks.yml) runs `compare.py --download`
+on demand: by hand (Actions → "json_view benchmarks" → "Run workflow"), on an x86-64 or AArch64 Ubuntu runner with GCC
+or Clang, or when a pull request gets the label `benchmark`, on both architectures with GCC. The results appear as the
+job summary and as an artifact. Shared runners are noisy, so these numbers show
+where `json_view` stands on another architecture; they are not meant for publication.
+
+## What is measured
+
+`bench_view.cpp` runs four workloads on twitter, citm_catalog, canada, jeopardy, a single tweet (`status`), and a
+JSON-RPC request (`rpc`):
+
+| workload | what it does |
+|---|---|
+| parse | build and free a document |
+| traverse | parse, then visit every value, convert every number, touch every string and key |
+| select | parse, then read a few fields per record (e.g. id, user name, and retweet count of each tweet) |
+| dump | serialize a parsed document (compact) |
+
+`bench_corpus.cpp` runs parse, traverse, and dump on any list of files, so that no library is tuned to a handful of
+documents. Its dump also writes the numbers as they are in the input: `json_view` with `number_format::source`, and
+yyjson with numbers read as raw text (`YYJSON_READ_NUMBER_AS_RAW`), without converting them.
+
+`bench_edit.cpp` measures read-modify-write: parse, apply the same logical edits with each library's own API, and
+serialize (compact). Workloads: `patch` (a handful of edits at fixed places) and `update` (edits in every record).
+An editable `json_document` edits in place; yyjson copies its immutable document into a mutable one first
+(`yyjson_doc_mut_copy`); Boost.JSON and `json::parse` build mutable DOMs; simdjson cannot edit a document. All
+outputs are checked to describe the same value.
+
+Before anything is timed, all engines must accept each document and agree on the traversal: the number of values, the
+bytes of all strings and keys, and the sum of all numbers. All engines run interleaved in every round, and the best
+round is reported, as time and as a factor of the `json_view` time (below 1 means faster than `json_view`). Each timed
+call follows an untimed call of the same engine: otherwise the engine after `json::parse` pays for the allocator
+cleaning up the tens of thousands of nodes `json::parse` just freed (with glibc, this made `json_view` look 1.7 times
+slower on citm_catalog traverse).
+
+The engines do not all offer the same features, which the numbers should be read with:
+
+| engine | document | random access | editable | notes |
+|---|---|---|---|---|
+| `json_view` | immutable index into the text | yes | no | a fresh document per parse; "reused" parses into the same document |
+| yyjson | immutable (`yyjson_read`) | yes | via a mutable copy | |
+| simdjson DOM | immutable, parser reused | yes | no | "fresh" uses a new parser per parse |
+| simdjson On-Demand | none: forward-only, lazy | no | no | only traverse and select |
+| Boost.JSON | owning, mutable DOM | yes | yes | monotonic resource |
+| `json::parse` | owning, mutable DOM | yes | yes | |
+
+Reusing memory matters as much as the parser. simdjson DOM reuses its parser, so it writes into memory it already
+touched; a fresh `json_view` document or yyjson document gets new memory for every parse. On Linux, glibc returns large
+blocks to the system when they are freed, so every fresh parse of a large document pays a page fault per 4 KiB page:
+on x86-64 Linux, a fresh `json_view` parse of jeopardy took about twice as long as a reused one. On macOS on Apple
+silicon, with 16 KiB pages, the difference is much smaller. Compare "json_view (reused)" with "simdjson DOM", and the
+fresh `json_view` with "simdjson DOM (fresh)" and yyjson.
+
+## Published results
+
+Results are only published with the file `compare.py` wrote, which names the machine and the versions; see
+`results/`. Numbers from one machine and compiler do not carry over to another: rerun the script.
@@ -0,0 +1,342 @@
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  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
+
+// Corpus benchmark: the read-only workloads of bench_view.cpp on any list of
+// JSON files (for example the benchmark sets of simdjson and yyjson).
+//
+//   ./bench_corpus [--rounds N] file...
+//
+// For every file, all engines must accept it and agree on a traversal (value
+// count, string bytes, sum of numbers) before anything is timed. Workloads:
+// parse (build and free a document), traverse (visit every value, convert
+// every number), dump (compact), and for json_view also dump with the source
+// number text, compared with yyjson writing numbers read as raw text
+// (YYJSON_READ_NUMBER_AS_RAW). Results go to bench_corpus.csv.
+#include <nlohmann/json_view.hpp>
+
+#if JSON_VIEW_BENCH_BOOST
+    #include <boost/json.hpp>
+    #include <boost/json/src.hpp>
+#endif
+#include <simdjson.h>
+#include <yyjson.h>
+
+#include <algorithm>
+#include <chrono>
+#include <cmath>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <fstream>
+#include <functional>
+#include <sstream>
+#include <string>
+#include <vector>
+
+using nlohmann::json;
+using nlohmann::json_document;
+using nlohmann::json_view;
+
+static volatile double g_sink;
+
+struct stats
+{
+    double num = 0;
+    std::size_t str = 0, nodes = 0;
+};
+
+static void walk(json_view v, stats& st)
+{
+    ++st.nodes;
+    switch (v.type())
+    {
+        case json::value_t::object:
+            for (auto it = v.begin(); it != v.end(); ++it)
+            {
+                st.str += it.key().size();
+                walk(*it, st);
+            }
+            break;
+        case json::value_t::array:
+            for (const json_view e : v)
+            {
+                walk(e, st);
+            }
+            break;
+        case json::value_t::string:
+            st.str += v.get_string().size();
+            break;
+        case json::value_t::number_integer:
+            st.num += static_cast<double>(v.get<std::int64_t>());
+            break;
+        case json::value_t::number_unsigned:
+            st.num += static_cast<double>(v.get<std::uint64_t>());
+            break;
+        case json::value_t::number_float:
+            st.num += v.get<double>();
+            break;
+        default:
+            break;
+    }
+}
+
+static void walk(yyjson_val* v, stats& st)
+{
+    ++st.nodes;
+    switch (yyjson_get_type(v))
+    {
+        case YYJSON_TYPE_OBJ:
+        {
+            std::size_t idx, max;
+            yyjson_val* k, * val;
+            yyjson_obj_foreach(v, idx, max, k, val)
+            {
+                st.str += yyjson_get_len(k);
+                walk(val, st);
+            }
+            break;
+        }
+        case YYJSON_TYPE_ARR:
+        {
+            std::size_t idx, max;
+            yyjson_val* val;
+            yyjson_arr_foreach(v, idx, max, val)
+            {
+                walk(val, st);
+            }
+            break;
+        }
+        case YYJSON_TYPE_STR:
+            st.str += yyjson_get_len(v);
+            break;
+        case YYJSON_TYPE_NUM:
+            st.num += yyjson_is_sint(v) ? static_cast<double>(yyjson_get_sint(v)) : yyjson_is_uint(v) ? static_cast<double>(yyjson_get_uint(v)) : yyjson_get_real(v);
+            break;
+        default:
+            break;
+    }
+}
+
+static void walk(simdjson::dom::element e, stats& st)
+{
+    ++st.nodes;
+    switch (e.type())
+    {
+        case simdjson::dom::element_type::OBJECT:
+            for (auto f : simdjson::dom::object(e))
+            {
+                st.str += f.key.size();
+                walk(f.value, st);
+            }
+            break;
+        case simdjson::dom::element_type::ARRAY:
+            for (auto c : simdjson::dom::array(e))
+            {
+                walk(c, st);
+            }
+            break;
+        case simdjson::dom::element_type::STRING:
+            st.str += std::string_view(e).size();
+            break;
+        case simdjson::dom::element_type::INT64:
+            st.num += static_cast<double>(int64_t(e));
+            break;
+        case simdjson::dom::element_type::UINT64:
+            st.num += static_cast<double>(uint64_t(e));
+            break;
+        case simdjson::dom::element_type::DOUBLE:
+            st.num += double(e);
+            break;
+        default:
+            break;
+    }
+}
+
+#if JSON_VIEW_BENCH_BOOST
+static void walk(const boost::json::value& v, stats& st)
+{
+    ++st.nodes;
+    switch (v.kind())
+    {
+        case boost::json::kind::object:
+            for (const auto& kv : v.get_object())
+            {
+                st.str += kv.key().size();
+                walk(kv.value(), st);
+            }
+            break;
+        case boost::json::kind::array:
+            for (const auto& c : v.get_array())
+            {
+                walk(c, st);
+            }
+            break;
+        case boost::json::kind::string:
+            st.str += v.get_string().size();
+            break;
+        case boost::json::kind::int64:
+            st.num += static_cast<double>(v.get_int64());
+            break;
+        case boost::json::kind::uint64:
+            st.num += static_cast<double>(v.get_uint64());
+            break;
+        case boost::json::kind::double_:
+            st.num += v.get_double();
+            break;
+        default:
+            break;
+    }
+}
+#endif
+
+static std::string slurp(const std::string& p)
+{
+    std::ifstream f(p, std::ios::binary);
+    if (!f)
+    {
+        std::fprintf(stderr, "cannot open %s\n", p.c_str());
+        std::exit(1);
+    }
+    std::stringstream ss;
+    ss << f.rdbuf();
+    return ss.str();
+}
+
+static bool same(const stats& a, const stats& b)
+{
+    return a.nodes == b.nodes && a.str == b.str && (a.num == b.num || std::fabs(a.num - b.num) <= 1e-9 * std::fabs(a.num));
+}
+
+int main(int argc, char** argv)
+{
+    int rounds = 0; // 0: by size
+    std::vector<std::string> files;
+    for (int i = 1; i < argc; ++i)
+    {
+        if (std::strcmp(argv[i], "--rounds") == 0 && i + 1 < argc)
+        {
+            rounds = std::atoi(argv[++i]);
+        }
+        else
+        {
+            files.push_back(argv[i]);
+        }
+    }
+    std::FILE* csv = std::fopen("bench_corpus.csv", "w");
+    std::fprintf(csv, "file,bytes,workload,engine,ns\n");
+    json_document reused;
+    simdjson::dom::parser sj;
+    for (const auto& path : files)
+    {
+        const std::string s = slurp(path);
+        const std::string name = path.substr(path.rfind('/') + 1);
+        const simdjson::padded_string ps(s);
+
+        // all engines must agree before timing
+        stats a, b, c, d;
+        const json_document doc = json_document::parse(s);
+        walk(doc.root(), a);
+        yyjson_doc* y = yyjson_read(s.data(), s.size(), 0);
+        auto sjr = sj.parse(ps);
+#if JSON_VIEW_BENCH_BOOST
+        boost::json::parse_options opt;
+        opt.numbers = boost::json::number_precision::precise;
+        boost::json::monotonic_resource mr0;
+        const boost::json::value bv = boost::json::parse(s, &mr0, opt);
+#endif
+        if (y == nullptr || sjr.error())
+        {
+            std::printf("%-34s skipped (an engine rejects it)\n", name.c_str());
+            yyjson_doc_free(y);
+            continue;
+        }
+        walk(yyjson_doc_get_root(y), b);
+        walk(sjr.value_unsafe(), c);
+#if JSON_VIEW_BENCH_BOOST
+        walk(bv, d);
+#else
+        d = a;
+#endif
+        yyjson_doc_free(y);
+        const bool ok = same(a, b) && same(a, c) && same(a, d);
+
+        const int r = rounds > 0 ? rounds : static_cast<int>(std::max<std::size_t>(3, std::min<std::size_t>(60, 400000000 / (s.size() + 1))));
+        struct engine
+        {
+            std::string name;
+            std::function<void()> fn;
+        };
+        json_document vd = json_document::parse(s);
+        yyjson_doc* yd = yyjson_read(s.data(), s.size(), 0);
+        yyjson_doc* yd_raw = yyjson_read(s.data(), s.size(), YYJSON_READ_NUMBER_AS_RAW);
+        simdjson::dom::parser sjd;
+        const simdjson::dom::element se = sjd.parse(ps).value_unsafe();
+        const std::vector<std::pair<std::string, std::vector<engine>>> workloads =
+        {
+            {
+                "parse", {
+                    {"json_view", [&] { auto x = json_document::parse(s); g_sink = static_cast<double>(x.node_count()); }},
+                    {"json_view (reused)", [&] { reused.read(s); g_sink = static_cast<double>(reused.node_count()); }},
+                    {"yyjson", [&] { yyjson_doc* x = yyjson_read(s.data(), s.size(), 0); g_sink = static_cast<double>(yyjson_doc_get_val_count(x)); yyjson_doc_free(x); }},
+                    {"simdjson DOM", [&] { auto e = sj.parse(ps).value_unsafe(); g_sink = e.is_object(); }},
+                    {"simdjson DOM (fresh)", [&] { simdjson::dom::parser p; auto e = p.parse(ps).value_unsafe(); g_sink = e.is_object(); }},
+#if JSON_VIEW_BENCH_BOOST
+                    {"Boost.JSON", [&] { boost::json::monotonic_resource mr; auto v = boost::json::parse(s, &mr); g_sink = v.is_object(); }},
+#endif
+                }
+            },
+            {
+                "traverse", {
+                    {"json_view", [&] { auto x = json_document::parse(s); stats st; walk(x.root(), st); g_sink = st.num; }},
+                    {"yyjson", [&] { yyjson_doc* x = yyjson_read(s.data(), s.size(), 0); stats st; walk(yyjson_doc_get_root(x), st); g_sink = st.num; yyjson_doc_free(x); }},
+                    {"simdjson DOM", [&] { stats st; walk(sj.parse(ps).value_unsafe(), st); g_sink = st.num; }},
+#if JSON_VIEW_BENCH_BOOST
+                    {"Boost.JSON", [&] { boost::json::monotonic_resource mr; auto v = boost::json::parse(s, &mr); stats st; walk(v, st); g_sink = st.num; }},
+#endif
+                }
+            },
+            {
+                "dump", {
+                    {"json_view", [&] { std::string o = vd.root().dump(); g_sink = static_cast<double>(o.size()); }},
+                    {"yyjson", [&] { std::size_t n = 0; char* o = yyjson_write(yd, 0, &n); g_sink = static_cast<double>(n); std::free(o); }},
+                    {"simdjson DOM", [&] { std::string o = simdjson::to_string(se); g_sink = static_cast<double>(o.size()); }},
+                    {"json_view (source numbers)", [&] { std::string o = vd.root().dump(-1, ' ', false, json_view::number_format::source); g_sink = static_cast<double>(o.size()); }},
+                    {"yyjson (raw numbers)", [&] { std::size_t n = 0; char* o = yyjson_write(yd_raw, 0, &n); g_sink = static_cast<double>(n); std::free(o); }},
+                }
+            },
+        };
+        std::printf("%-34s %9zu B%s\n", name.c_str(), s.size(), ok ? "" : "  [ENGINES DISAGREE]");
+        for (const auto& wl : workloads)
+        {
+            std::vector<double> best(wl.second.size(), 1e300);
+            for (int i = 0; i < r; ++i)
+            {
+                for (std::size_t k = 0; k < wl.second.size(); ++k)
+                {
+                    // an untimed call first: whatever the previous engine left to the allocator
+                    // (e.g. thousands of freed json nodes) is cleaned up here, not in the timing
+                    wl.second[k].fn();
+                    const auto t0 = std::chrono::steady_clock::now();
+                    wl.second[k].fn();
+                    best[k] = std::min(best[k], std::chrono::duration<double, std::nano>(std::chrono::steady_clock::now() - t0).count());
+                }
+            }
+            std::printf("  %-9s", wl.first.c_str());
+            for (std::size_t k = 0; k < wl.second.size(); ++k)
+            {
+                std::printf("  %s %.2f GB/s (%.2fx)", wl.second[k].name.c_str(), static_cast<double>(s.size()) / best[k], best[k] / best[0]);
+                std::fprintf(csv, "%s,%zu,%s,%s,%.1f\n", name.c_str(), s.size(), wl.first.c_str(), wl.second[k].name.c_str(), best[k]);
+            }
+            std::printf("\n");
+            std::fflush(stdout);
+        }
+        yyjson_doc_free(yd);
+        yyjson_doc_free(yd_raw);
+    }
+    std::fclose(csv);
+}
@@ -0,0 +1,583 @@
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  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
+
+// Read-modify-write benchmark: parse a document, apply the same logical edits
+// with each library's own API, and serialize it (compact).
+//
+//   json_view     json_editable_document: edits in place, unchanged values stay in the index
+//   yyjson        yyjson_read + yyjson_doc_mut_copy (the way to edit a parsed document)
+//   Boost.JSON    parse into a mutable DOM (monotonic resource, precise numbers), serialize
+//   json::parse   nlohmann::json today
+// simdjson has no mutable document and is not part of this comparison.
+//
+// Workloads:
+//   patch   a handful of edits at fixed places (scalars, a new member, a new array element)
+//   update  edits in every record (twitter: 100 statuses, citm: 243 performances,
+//           canada: 480 rings, jeopardy: 216,930 questions): set scalars, erase a
+//           member, add a member (canada: replace the first point of every ring)
+//
+// Build: see README.md (same flags as bench_view.cpp).
+#include <nlohmann/json_view.hpp>
+
+#if JSON_VIEW_BENCH_BOOST
+    #include <boost/json.hpp>
+    #include <boost/json/src.hpp>
+#endif
+#include <yyjson.h>
+
+#include <algorithm>
+#include <chrono>
+#include <cstdio>
+#include <cstdlib>
+#include <fstream>
+#include <functional>
+#include <sstream>
+
+using nlohmann::json;
+using nlohmann::json_editable_document;
+using nlohmann::json_editable_view;
+#if JSON_VIEW_BENCH_BOOST
+    namespace bj = boost::json;
+#endif
+
+static volatile std::size_t g_sink;
+
+// ---------------- json_view ----------------
+
+static std::string edit_view(const std::string& name, const std::string& s, bool update)
+{
+    json_editable_document d = json_editable_document::parse(s);
+    const json_editable_view r = d.root();
+    if (name == "twitter")
+    {
+        if (update)
+        {
+            std::int64_t i = 0;
+            for (const json_editable_view st : r["statuses"])
+            {
+                d.set(st, "retweet_count", i++);
+                d.set(st, "favorited", true);
+                d.set(st, "text", "redacted");
+                d.erase(st, "entities");
+                d.set(st, "edited", true);
+            }
+        }
+        else
+        {
+            d.set(r["search_metadata"], "count", 200);
+            d.set(r["statuses"][0], "text", "patched");
+            d.set(r["statuses"][0]["user"], "followers_count", 1);
+            d.set(r["statuses"][99], "favorited", true);
+            d.set(r, "patched", true);
+        }
+    }
+    else if (name == "citm_catalog")
+    {
+        if (update)
+        {
+            for (const json_editable_view p : r["performances"])
+            {
+                d.set(p, "name", "performance");
+                d.set(p, "start", p["start"].get<std::int64_t>() + 1);
+                d.erase(p, "seatMapImage");
+                d.set(p, "edited", true);
+            }
+        }
+        else
+        {
+            d.set(r["events"]["138586341"], "name", "patched");
+            d.set(r["performances"][0], "start", 0);
+            d.set(r["venueNames"], "PLEYEL_PLEYEL", "Salle");
+            d.set(r, "patched", true);
+        }
+    }
+    else if (name == "canada")
+    {
+        const json_editable_view coords = r["features"][0]["geometry"]["coordinates"];
+        if (update)
+        {
+            for (const json_editable_view ring : coords)
+            {
+                d.set(ring, 0, json::array({0.5, 0.5}));
+            }
+        }
+        else
+        {
+            d.set(r["features"][0]["properties"], "name", "patched");
+            d.set(r, "type", "FeatureCollection2");
+            d.set(coords[0], 0, json::array({0.0, 0.0}));
+        }
+    }
+    else if (name == "jeopardy")
+    {
+        if (update)
+        {
+            for (const json_editable_view q : r)
+            {
+                d.set(q, "value", "$1");
+                d.erase(q, "air_date");
+            }
+        }
+        else
+        {
+            d.set(r[0], "value", "$0");
+            d.set(r[100000], "answer", "patched");
+            d.set(r[216929], "round", "x");
+            d.push_back(r, json::object({{"category", "NEW"}, {"value", "$5"}}));
+        }
+    }
+    else if (name == "status")
+    {
+        d.set(r, "retweet_count", 1);
+        d.set(r["user"], "name", "x");
+    }
+    else if (name == "rpc")
+    {
+        d.set(r, "id", 4);
+        d.set(r["params"], "subtrahend", 24);
+    }
+    return r.dump();
+}
+
+// ---------------- nlohmann::json ----------------
+
+static std::string edit_json(const std::string& name, const std::string& s, bool update)
+{
+    json r = json::parse(s);
+    if (name == "twitter")
+    {
+        if (update)
+        {
+            std::int64_t i = 0;
+            for (auto& st : r["statuses"])
+            {
+                st["retweet_count"] = i++;
+                st["favorited"] = true;
+                st["text"] = "redacted";
+                st.erase("entities");
+                st["edited"] = true;
+            }
+        }
+        else
+        {
+            r["search_metadata"]["count"] = 200;
+            r["statuses"][0]["text"] = "patched";
+            r["statuses"][0]["user"]["followers_count"] = 1;
+            r["statuses"][99]["favorited"] = true;
+            r["patched"] = true;
+        }
+    }
+    else if (name == "citm_catalog")
+    {
+        if (update)
+        {
+            for (auto& p : r["performances"])
+            {
+                p["name"] = "performance";
+                p["start"] = p["start"].get<std::int64_t>() + 1;
+                p.erase("seatMapImage");
+                p["edited"] = true;
+            }
+        }
+        else
+        {
+            r["events"]["138586341"]["name"] = "patched";
+            r["performances"][0]["start"] = 0;
+            r["venueNames"]["PLEYEL_PLEYEL"] = "Salle";
+            r["patched"] = true;
+        }
+    }
+    else if (name == "canada")
+    {
+        json& coords = r["features"][0]["geometry"]["coordinates"];
+        if (update)
+        {
+            for (auto& ring : coords)
+            {
+                ring[0] = json::array({0.5, 0.5});
+            }
+        }
+        else
+        {
+            r["features"][0]["properties"]["name"] = "patched";
+            r["type"] = "FeatureCollection2";
+            coords[0][0] = json::array({0.0, 0.0});
+        }
+    }
+    else if (name == "jeopardy")
+    {
+        if (update)
+        {
+            for (auto& q : r)
+            {
+                q["value"] = "$1";
+                q.erase("air_date");
+            }
+        }
+        else
+        {
+            r[0]["value"] = "$0";
+            r[100000]["answer"] = "patched";
+            r[216929]["round"] = "x";
+            r.push_back(json::object({{"category", "NEW"}, {"value", "$5"}}));
+        }
+    }
+    else if (name == "status")
+    {
+        r["retweet_count"] = 1;
+        r["user"]["name"] = "x";
+    }
+    else if (name == "rpc")
+    {
+        r["id"] = 4;
+        r["params"]["subtrahend"] = 24;
+    }
+    return r.dump();
+}
+
+// ---------------- yyjson ----------------
+
+static std::string edit_yyjson(const std::string& name, const std::string& s, bool update)
+{
+    yyjson_doc* idoc = yyjson_read(s.data(), s.size(), 0);
+    yyjson_mut_doc* d = yyjson_doc_mut_copy(idoc, nullptr);
+    yyjson_doc_free(idoc);
+    yyjson_mut_val* r = yyjson_mut_doc_get_root(d);
+    auto get = [](yyjson_mut_val * o, const char* k)
+    {
+        return yyjson_mut_obj_get(o, k);
+    };
+    if (name == "twitter")
+    {
+        yyjson_mut_val* sts = get(r, "statuses");
+        if (update)
+        {
+            std::size_t idx, max;
+            yyjson_mut_val* st;
+            std::int64_t i = 0;
+            yyjson_mut_arr_foreach(sts, idx, max, st)
+            {
+                yyjson_mut_set_sint(get(st, "retweet_count"), i++);
+                yyjson_mut_set_bool(get(st, "favorited"), true);
+                yyjson_mut_set_str(get(st, "text"), "redacted");
+                yyjson_mut_obj_remove_key(st, "entities");
+                yyjson_mut_obj_add_bool(d, st, "edited", true);
+            }
+        }
+        else
+        {
+            yyjson_mut_set_sint(get(get(r, "search_metadata"), "count"), 200);
+            yyjson_mut_val* s0 = yyjson_mut_arr_get(sts, 0);
+            yyjson_mut_set_str(get(s0, "text"), "patched");
+            yyjson_mut_set_sint(get(get(s0, "user"), "followers_count"), 1);
+            yyjson_mut_set_bool(get(yyjson_mut_arr_get(sts, 99), "favorited"), true);
+            yyjson_mut_obj_add_bool(d, r, "patched", true);
+        }
+    }
+    else if (name == "citm_catalog")
+    {
+        if (update)
+        {
+            std::size_t idx, max;
+            yyjson_mut_val* p;
+            yyjson_mut_arr_foreach(get(r, "performances"), idx, max, p)
+            {
+                yyjson_mut_set_str(get(p, "name"), "performance");
+                yyjson_mut_val* start = get(p, "start");
+                yyjson_mut_set_sint(start, yyjson_mut_get_sint(start) + 1);
+                yyjson_mut_obj_remove_key(p, "seatMapImage");
+                yyjson_mut_obj_add_bool(d, p, "edited", true);
+            }
+        }
+        else
+        {
+            yyjson_mut_set_str(get(get(get(r, "events"), "138586341"), "name"), "patched");
+            yyjson_mut_set_sint(get(yyjson_mut_arr_get(get(r, "performances"), 0), "start"), 0);
+            yyjson_mut_set_str(get(get(r, "venueNames"), "PLEYEL_PLEYEL"), "Salle");
+            yyjson_mut_obj_add_bool(d, r, "patched", true);
+        }
+    }
+    else if (name == "canada")
+    {
+        yyjson_mut_val* f0 = yyjson_mut_arr_get(get(r, "features"), 0);
+        yyjson_mut_val* coords = get(get(f0, "geometry"), "coordinates");
+        if (update)
+        {
+            static const double half[2] = {0.5, 0.5};
+            std::size_t idx, max;
+            yyjson_mut_val* ring;
+            yyjson_mut_arr_foreach(coords, idx, max, ring)
+            {
+                yyjson_mut_arr_replace(ring, 0, yyjson_mut_arr_with_real(d, half, 2));
+            }
+        }
+        else
+        {
+            static const double zero[2] = {0.0, 0.0};
+            yyjson_mut_set_str(get(get(f0, "properties"), "name"), "patched");
+            yyjson_mut_set_str(get(r, "type"), "FeatureCollection2");
+            yyjson_mut_arr_replace(yyjson_mut_arr_get(coords, 0), 0, yyjson_mut_arr_with_real(d, zero, 2));
+        }
+    }
+    else if (name == "jeopardy")
+    {
+        if (update)
+        {
+            std::size_t idx, max;
+            yyjson_mut_val* q;
+            yyjson_mut_arr_foreach(r, idx, max, q)
+            {
+                yyjson_mut_set_str(get(q, "value"), "$1");
+                yyjson_mut_obj_remove_key(q, "air_date");
+            }
+        }
+        else
+        {
+            yyjson_mut_set_str(get(yyjson_mut_arr_get(r, 0), "value"), "$0");
+            yyjson_mut_set_str(get(yyjson_mut_arr_get(r, 100000), "answer"), "patched");
+            yyjson_mut_set_str(get(yyjson_mut_arr_get(r, 216929), "round"), "x");
+            yyjson_mut_val* o = yyjson_mut_obj(d);
+            yyjson_mut_obj_add_str(d, o, "category", "NEW");
+            yyjson_mut_obj_add_str(d, o, "value", "$5");
+            yyjson_mut_arr_append(r, o);
+        }
+    }
+    else if (name == "status")
+    {
+        yyjson_mut_set_sint(get(r, "retweet_count"), 1);
+        yyjson_mut_set_str(get(get(r, "user"), "name"), "x");
+    }
+    else if (name == "rpc")
+    {
+        yyjson_mut_set_sint(get(r, "id"), 4);
+        yyjson_mut_set_sint(get(get(r, "params"), "subtrahend"), 24);
+    }
+    std::size_t n = 0;
+    char* out = yyjson_mut_write(d, 0, &n);
+    std::string result(out, n);
+    std::free(out);
+    yyjson_mut_doc_free(d);
+    return result;
+}
+
+#if JSON_VIEW_BENCH_BOOST
+// ---------------- Boost.JSON ----------------
+
+static std::string edit_boost(const std::string& name, const std::string& s, bool update)
+{
+    bj::monotonic_resource mr;
+    bj::parse_options opt;
+    opt.numbers = bj::number_precision::precise; // correctly rounded, like the others
+    bj::value v = bj::parse(s, &mr, opt);
+    bj::object* const obj = v.if_object(); // nullptr for jeopardy (an array)
+    if (name == "twitter")
+    {
+        bj::array& sts = (*obj)["statuses"].as_array();
+        if (update)
+        {
+            std::int64_t i = 0;
+            for (auto& e : sts)
+            {
+                bj::object& st = e.as_object();
+                st["retweet_count"] = i++;
+                st["favorited"] = true;
+                st["text"] = "redacted";
+                st.erase("entities");
+                st["edited"] = true;
+            }
+        }
+        else
+        {
+            (*obj)["search_metadata"].as_object()["count"] = 200;
+            bj::object& s0 = sts[0].as_object();
+            s0["text"] = "patched";
+            s0["user"].as_object()["followers_count"] = 1;
+            sts[99].as_object()["favorited"] = true;
+            (*obj)["patched"] = true;
+        }
+    }
+    else if (name == "citm_catalog")
+    {
+        if (update)
+        {
+            for (auto& e : (*obj)["performances"].as_array())
+            {
+                bj::object& p = e.as_object();
+                p["name"] = "performance";
+                p["start"] = p["start"].as_int64() + 1;
+                p.erase("seatMapImage");
+                p["edited"] = true;
+            }
+        }
+        else
+        {
+            (*obj)["events"].as_object()["138586341"].as_object()["name"] = "patched";
+            (*obj)["performances"].as_array()[0].as_object()["start"] = 0;
+            (*obj)["venueNames"].as_object()["PLEYEL_PLEYEL"] = "Salle";
+            (*obj)["patched"] = true;
+        }
+    }
+    else if (name == "canada")
+    {
+        bj::object& f0 = (*obj)["features"].as_array()[0].as_object();
+        bj::array& coords = f0["geometry"].as_object()["coordinates"].as_array();
+        if (update)
+        {
+            for (auto& ring : coords)
+            {
+                ring.as_array()[0] = bj::array({0.5, 0.5});
+            }
+        }
+        else
+        {
+            f0["properties"].as_object()["name"] = "patched";
+            (*obj)["type"] = "FeatureCollection2";
+            coords[0].as_array()[0] = bj::array({0.0, 0.0});
+        }
+    }
+    else if (name == "jeopardy")
+    {
+        bj::array& a = v.as_array();
+        if (update)
+        {
+            for (auto& e : a)
+            {
+                bj::object& q = e.as_object();
+                q["value"] = "$1";
+                q.erase("air_date");
+            }
+        }
+        else
+        {
+            a[0].as_object()["value"] = "$0";
+            a[100000].as_object()["answer"] = "patched";
+            a[216929].as_object()["round"] = "x";
+            a.push_back(bj::object({{"category", "NEW"}, {"value", "$5"}}));
+        }
+    }
+    else if (name == "status")
+    {
+        (*obj)["retweet_count"] = 1;
+        (*obj)["user"].as_object()["name"] = "x";
+    }
+    else if (name == "rpc")
+    {
+        (*obj)["id"] = 4;
+        (*obj)["params"].as_object()["subtrahend"] = 24;
+    }
+    return bj::serialize(v);
+}
+#endif
+
+// ---------------- harness ----------------
+
+static std::string slurp(const std::string& p)
+{
+    std::ifstream f(p, std::ios::binary);
+    if (!f)
+    {
+        std::fprintf(stderr, "cannot open %s\n", p.c_str());
+        std::exit(1);
+    }
+    std::stringstream ss;
+    ss << f.rdbuf();
+    return ss.str();
+}
+
+int main(int argc, char** argv)
+{
+    if (argc < 2)
+    {
+        std::fprintf(stderr, "usage: %s <json_test_data directory> [rounds] [document]\n", argv[0]);
+        return 1;
+    }
+    const std::string T = std::string(argv[1]) + "/";
+    const int rounds = argc > 2 ? std::atoi(argv[2]) : 20;
+    const std::string only = argc > 3 ? argv[3] : "";
+    struct doc
+    {
+        std::string name, text;
+        int batch;
+    };
+    std::vector<doc> docs;
+    for (const char* f :
+            {"nativejson-benchmark/twitter.json", "nativejson-benchmark/citm_catalog.json", "nativejson-benchmark/canada.json", "jeopardy/jeopardy.json"
+            })
+    {
+        std::string n = std::string(f).substr(std::string(f).find('/') + 1);
+        docs.push_back({n.substr(0, n.size() - 5), slurp(T + f), 1});
+    }
+    docs.push_back({"status", json::parse(docs[0].text)["statuses"][0].dump(), 200});
+    docs.push_back({"rpc", R"({"jsonrpc": "2.0", "method": "subtract", "params": {"minuend": 42, "subtrahend": 23}, "id": 3})", 5000});
+
+    using fn = std::string (*)(const std::string&, const std::string&, bool);
+    const std::vector<std::pair<std::string, fn>> engines =
+    {
+        {"json_view", edit_view}, {"yyjson", edit_yyjson},
+#if JSON_VIEW_BENCH_BOOST
+        {"Boost.JSON", edit_boost},
+#endif
+        {"json::parse", edit_json}
+    };
+
+    std::FILE* csv = std::fopen("bench_edit.csv", "w");
+    std::fprintf(csv, "doc,bytes,workload,engine,ns\n");
+    for (const auto& dc : docs)
+    {
+        if (!only.empty() && dc.name != only)
+        {
+            continue;
+        }
+        for (const bool update :
+                {
+                    false, true
+                })
+        {
+            if (update && (dc.name == "status" || dc.name == "rpc"))
+            {
+                continue;
+            }
+            // all engines must produce the same value
+            const json expected = json::parse(edit_json(dc.name, dc.text, update));
+            bool ok = true;
+            for (const auto& e : engines)
+            {
+                ok = ok && json::parse(e.second(dc.name, dc.text, update)) == expected;
+            }
+            std::vector<double> best(engines.size(), 1e300);
+            const int r = dc.text.size() > 10000000 ? std::max(3, rounds / 4) : rounds;
+            for (int i = 0; i < r; ++i)
+            {
+                for (std::size_t k = 0; k < engines.size(); ++k)
+                {
+                    // an untimed call first: whatever the previous engine left to the allocator
+                    // (e.g. thousands of freed json nodes) is cleaned up here, not in the timing
+                    g_sink = engines[k].second(dc.name, dc.text, update).size();
+                    const auto t0 = std::chrono::steady_clock::now();
+                    for (int b = 0; b < dc.batch; ++b)
+                    {
+                        g_sink = engines[k].second(dc.name, dc.text, update).size();
+                    }
+                    const double ns = std::chrono::duration<double, std::nano>(std::chrono::steady_clock::now() - t0).count() / dc.batch;
+                    best[k] = std::min(best[k], ns);
+                }
+            }
+            const char* wl = update ? "update" : "patch";
+            std::printf("%-13s %-7s %s", dc.name.c_str(), wl, ok ? "" : "[OUTPUT MISMATCH] ");
+            for (std::size_t k = 0; k < engines.size(); ++k)
+            {
+                const double us = best[k] / 1e3;
+                std::printf("  %s %.*fus (%.2fx)", engines[k].first.c_str(), us < 10 ? 3 : (us < 1000 ? 1 : 0), us, best[k] / best[0]);
+                std::fprintf(csv, "%s,%zu,%s,%s,%.1f\n", dc.name.c_str(), dc.text.size(), wl, engines[k].first.c_str(), best[k]);
+            }
+            std::printf("\n");
+            std::fflush(stdout);
+        }
+    }
+    std::fclose(csv);
+}
@@ -0,0 +1,749 @@
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  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
+
+// Same-feature-set benchmark: read-only JSON documents with random access.
+//
+//   json_view      nlohmann/json_view.hpp (fresh document per parse / reused)
+//   yyjson         yyjson_read(): immutable document, random access
+//   simdjson DOM   dom::parser (reused, as recommended; "fresh": a new parser
+//                  per parse): immutable, random access
+// references (different feature sets):
+//   simdjson OD    On-Demand: forward-only, lazy
+//   Boost.JSON     owning, mutable DOM (monotonic resource)
+//   json::parse    owning, mutable DOM (nlohmann today)
+//
+// Workloads: parse (build + free), traverse (visit everything, convert every
+// number, touch every string and key), select (a few fields per document),
+// dump (compact serialization of the parsed document).
+// All engines run interleaved in every round, each timed call after an untimed
+// one of the same engine; the best round is reported.
+#include <nlohmann/json_view.hpp>
+
+#if JSON_VIEW_BENCH_BOOST
+    #include <boost/json.hpp>
+    #include <boost/json/src.hpp>
+#endif
+#include <simdjson.h>
+#include <yyjson.h>
+
+#include <algorithm>
+#include <chrono>
+#include <cmath>
+#include <cstdio>
+#include <cstdlib>
+#include <fstream>
+#include <functional>
+#include <map>
+#include <sstream>
+
+using nlohmann::json;
+using nlohmann::json_document;
+using nlohmann::json_view;
+
+static volatile double g_sink;
+
+struct stats
+{
+    double num = 0;
+    std::size_t str = 0, nodes = 0;
+};
+
+// ---------------- traversal ----------------
+
+static void walk(json_view v, stats& st)
+{
+    ++st.nodes;
+    switch (v.type())
+    {
+        case json::value_t::object:
+            for (auto it = v.begin(); it != v.end(); ++it)
+            {
+                st.str += it.key().size();
+                walk(*it, st);
+            }
+            break;
+        case json::value_t::array:
+            for (const json_view e : v)
+            {
+                walk(e, st);
+            }
+            break;
+        case json::value_t::string:
+            st.str += v.get_string().size();
+            break;
+        case json::value_t::number_integer:
+            st.num += static_cast<double>(v.get<std::int64_t>());
+            break;
+        case json::value_t::number_unsigned:
+            st.num += static_cast<double>(v.get<std::uint64_t>());
+            break;
+        case json::value_t::number_float:
+            st.num += v.get<double>();
+            break;
+        default:
+            break;
+    }
+}
+
+static void walk(const json& j, stats& st)
+{
+    ++st.nodes;
+    switch (j.type())
+    {
+        case json::value_t::object:
+            for (const auto& kv : j.get_ref<const json::object_t&>())
+            {
+                st.str += kv.first.size();
+                walk(kv.second, st);
+            }
+            break;
+        case json::value_t::array:
+            for (const auto& e : j.get_ref<const json::array_t&>())
+            {
+                walk(e, st);
+            }
+            break;
+        case json::value_t::string:
+            st.str += j.get_ref<const std::string&>().size();
+            break;
+        case json::value_t::number_integer:
+            st.num += static_cast<double>(*j.get_ptr<const json::number_integer_t*>());
+            break;
+        case json::value_t::number_unsigned:
+            st.num += static_cast<double>(*j.get_ptr<const json::number_unsigned_t*>());
+            break;
+        case json::value_t::number_float:
+            st.num += *j.get_ptr<const json::number_float_t*>();
+            break;
+        default:
+            break;
+    }
+}
+
+static void walk(yyjson_val* v, stats& st)
+{
+    ++st.nodes;
+    switch (yyjson_get_type(v))
+    {
+        case YYJSON_TYPE_OBJ:
+        {
+            std::size_t idx, max;
+            yyjson_val* k, * val;
+            yyjson_obj_foreach(v, idx, max, k, val)
+            {
+                st.str += yyjson_get_len(k);
+                walk(val, st);
+            }
+            break;
+        }
+        case YYJSON_TYPE_ARR:
+        {
+            std::size_t idx, max;
+            yyjson_val* val;
+            yyjson_arr_foreach(v, idx, max, val)
+            {
+                walk(val, st);
+            }
+            break;
+        }
+        case YYJSON_TYPE_STR:
+            st.str += yyjson_get_len(v);
+            break;
+        case YYJSON_TYPE_NUM:
+            if (yyjson_is_sint(v))
+            {
+                st.num += static_cast<double>(yyjson_get_sint(v));
+            }
+            else if (yyjson_is_uint(v))
+            {
+                st.num += static_cast<double>(yyjson_get_uint(v));
+            }
+            else
+            {
+                st.num += yyjson_get_real(v);
+            }
+            break;
+        default:
+            break;
+    }
+}
+
+static void walk(simdjson::dom::element e, stats& st)
+{
+    ++st.nodes;
+    switch (e.type())
+    {
+        case simdjson::dom::element_type::OBJECT:
+            for (auto f : simdjson::dom::object(e))
+            {
+                st.str += f.key.size();
+                walk(f.value, st);
+            }
+            break;
+        case simdjson::dom::element_type::ARRAY:
+            for (auto c : simdjson::dom::array(e))
+            {
+                walk(c, st);
+            }
+            break;
+        case simdjson::dom::element_type::STRING:
+            st.str += std::string_view(e).size();
+            break;
+        case simdjson::dom::element_type::INT64:
+            st.num += static_cast<double>(int64_t(e));
+            break;
+        case simdjson::dom::element_type::UINT64:
+            st.num += static_cast<double>(uint64_t(e));
+            break;
+        case simdjson::dom::element_type::DOUBLE:
+            st.num += double(e);
+            break;
+        default:
+            break;
+    }
+}
+
+static void walk_od(simdjson::ondemand::value v, stats& st)
+{
+    ++st.nodes;
+    switch (v.type())
+    {
+        case simdjson::ondemand::json_type::object:
+            for (auto f : v.get_object())
+            {
+                st.str += std::string_view(f.unescaped_key()).size();
+                walk_od(f.value(), st);
+            }
+            break;
+        case simdjson::ondemand::json_type::array:
+            for (auto c : v.get_array())
+            {
+                walk_od(c.value(), st);
+            }
+            break;
+        case simdjson::ondemand::json_type::string:
+            st.str += std::string_view(v.get_string()).size();
+            break;
+        case simdjson::ondemand::json_type::number:
+        {
+            simdjson::ondemand::number n = v.get_number();
+            switch (n.get_number_type())
+            {
+                case simdjson::ondemand::number_type::signed_integer:
+                    st.num += static_cast<double>(n.get_int64());
+                    break;
+                case simdjson::ondemand::number_type::unsigned_integer:
+                    st.num += static_cast<double>(n.get_uint64());
+                    break;
+                default:
+                    st.num += n.get_double();
+                    break;
+            }
+            break;
+        }
+        case simdjson::ondemand::json_type::boolean:
+            (void)bool(v.get_bool());
+            break;
+        default:
+            (void)v.is_null();
+            break;
+    }
+}
+
+#if JSON_VIEW_BENCH_BOOST
+static void walk(const boost::json::value& v, stats& st)
+{
+    ++st.nodes;
+    switch (v.kind())
+    {
+        case boost::json::kind::object:
+            for (const auto& kv : v.get_object())
+            {
+                st.str += kv.key().size();
+                walk(kv.value(), st);
+            }
+            break;
+        case boost::json::kind::array:
+            for (const auto& c : v.get_array())
+            {
+                walk(c, st);
+            }
+            break;
+        case boost::json::kind::string:
+            st.str += v.get_string().size();
+            break;
+        case boost::json::kind::int64:
+            st.num += static_cast<double>(v.get_int64());
+            break;
+        case boost::json::kind::uint64:
+            st.num += static_cast<double>(v.get_uint64());
+            break;
+        case boost::json::kind::double_:
+            st.num += v.get_double();
+            break;
+        default:
+            break;
+    }
+}
+#endif
+
+// ---------------- selective access ----------------
+// twitter: per status id, user.screen_name, retweet_count
+// citm: per performance id, eventId, #seatCategories; #events
+// canada: type, features[0].geometry.type, #coordinates
+// jeopardy: per question: round == "Final Jeopardy!", len(category)
+// status (one tweet): id, user.screen_name, retweet_count
+// rpc: method, params.minuend, id
+
+static double pick(const std::string& name, json_view r)
+{
+    double acc = 0;
+    if (name == "twitter" || name == "status")
+    {
+        auto one = [&](json_view s)
+        {
+            acc += static_cast<double>(s["id"].get<std::uint64_t>());
+            acc += static_cast<double>(s["user"]["screen_name"].get_string().size());
+            acc += static_cast<double>(s["retweet_count"].get<std::int64_t>());
+        };
+        if (name == "twitter")
+        {
+            for (const json_view s : r["statuses"])
+            {
+                one(s);
+            }
+        }
+        else
+        {
+            one(r);
+        }
+    }
+    else if (name == "citm_catalog")
+    {
+        for (const json_view p : r["performances"])
+        {
+            acc += static_cast<double>(p["id"].get<std::uint64_t>() + p["eventId"].get<std::uint64_t>() + p["seatCategories"].size());
+        }
+        acc += static_cast<double>(r["events"].size());
+    }
+    else if (name == "canada")
+    {
+        const json_view g = r["features"][0]["geometry"];
+        acc += static_cast<double>(r["type"].get_string().size() + g["type"].get_string().size() + g["coordinates"].size());
+    }
+    else if (name == "jeopardy")
+    {
+        for (const json_view q : r)
+        {
+            acc += q["round"].get_string() == "Final Jeopardy!" ? 1 : 0;
+            acc += static_cast<double>(q["category"].get_string().size());
+        }
+    }
+    else if (name == "rpc")
+    {
+        acc += static_cast<double>(r["method"].get_string().size());
+        acc += static_cast<double>(r["params"]["minuend"].get<std::int64_t>() + r["id"].get<std::int64_t>());
+    }
+    return acc;
+}
+
+static double pick(const std::string& name, const json& r)
+{
+    double acc = 0;
+    if (name == "twitter" || name == "status")
+    {
+        auto one = [&](const json & s)
+        {
+            acc += static_cast<double>(s["id"].get<std::uint64_t>());
+            acc += static_cast<double>(s["user"]["screen_name"].get_ref<const std::string&>().size());
+            acc += static_cast<double>(s["retweet_count"].get<std::int64_t>());
+        };
+        if (name == "twitter")
+        {
+            for (const auto& s : r["statuses"])
+            {
+                one(s);
+            }
+        }
+        else
+        {
+            one(r);
+        }
+    }
+    else if (name == "citm_catalog")
+    {
+        for (const auto& p : r["performances"])
+        {
+            acc += static_cast<double>(p["id"].get<std::uint64_t>() + p["eventId"].get<std::uint64_t>() + p["seatCategories"].size());
+        }
+        acc += static_cast<double>(r["events"].size());
+    }
+    else if (name == "canada")
+    {
+        const json& g = r["features"][0]["geometry"];
+        acc += static_cast<double>(r["type"].get_ref<const std::string&>().size() + g["type"].get_ref<const std::string&>().size() + g["coordinates"].size());
+    }
+    else if (name == "jeopardy")
+    {
+        for (const auto& q : r)
+        {
+            acc += q["round"].get_ref<const std::string&>() == "Final Jeopardy!" ? 1 : 0;
+            acc += static_cast<double>(q["category"].get_ref<const std::string&>().size());
+        }
+    }
+    else if (name == "rpc")
+    {
+        acc += static_cast<double>(r["method"].get_ref<const std::string&>().size());
+        acc += static_cast<double>(r["params"]["minuend"].get<std::int64_t>() + r["id"].get<std::int64_t>());
+    }
+    return acc;
+}
+
+static double pick(const std::string& name, yyjson_val* r)
+{
+    double acc = 0;
+    auto get = [](yyjson_val * o, const char* k)
+    {
+        return yyjson_obj_get(o, k);
+    };
+    if (name == "twitter" || name == "status")
+    {
+        auto one = [&](yyjson_val * s)
+        {
+            acc += static_cast<double>(yyjson_get_uint(get(s, "id")));
+            acc += static_cast<double>(yyjson_get_len(get(get(s, "user"), "screen_name")));
+            acc += static_cast<double>(yyjson_get_sint(get(s, "retweet_count")));
+        };
+        if (name == "twitter")
+        {
+            std::size_t idx, max;
+            yyjson_val* s;
+            yyjson_arr_foreach(get(r, "statuses"), idx, max, s)
+            {
+                one(s);
+            }
+        }
+        else
+        {
+            one(r);
+        }
+    }
+    else if (name == "citm_catalog")
+    {
+        std::size_t idx, max;
+        yyjson_val* p;
+        yyjson_arr_foreach(get(r, "performances"), idx, max, p)
+        {
+            acc += static_cast<double>(yyjson_get_uint(get(p, "id")) + yyjson_get_uint(get(p, "eventId")) + yyjson_arr_size(get(p, "seatCategories")));
+        }
+        acc += static_cast<double>(yyjson_obj_size(get(r, "events")));
+    }
+    else if (name == "canada")
+    {
+        yyjson_val* g = get(yyjson_arr_get(get(r, "features"), 0), "geometry");
+        acc += static_cast<double>(yyjson_get_len(get(r, "type")) + yyjson_get_len(get(g, "type")) + yyjson_arr_size(get(g, "coordinates")));
+    }
+    else if (name == "jeopardy")
+    {
+        std::size_t idx, max;
+        yyjson_val* q;
+        yyjson_arr_foreach(r, idx, max, q)
+        {
+            acc += yyjson_equals_str(get(q, "round"), "Final Jeopardy!") ? 1 : 0;
+            acc += static_cast<double>(yyjson_get_len(get(q, "category")));
+        }
+    }
+    else if (name == "rpc")
+    {
+        acc += static_cast<double>(yyjson_get_len(get(r, "method")));
+        acc += static_cast<double>(yyjson_get_sint(get(get(r, "params"), "minuend")) + yyjson_get_sint(get(r, "id")));
+    }
+    return acc;
+}
+
+static double pick(const std::string& name, simdjson::dom::element r)
+{
+    double acc = 0;
+    if (name == "twitter" || name == "status")
+    {
+        auto one = [&](simdjson::dom::element s)
+        {
+            acc += static_cast<double>(uint64_t(s["id"]));
+            acc += static_cast<double>(std::string_view(s["user"]["screen_name"]).size());
+            acc += static_cast<double>(int64_t(s["retweet_count"]));
+        };
+        if (name == "twitter")
+        {
+            for (auto s : simdjson::dom::array(r["statuses"]))
+            {
+                one(s);
+            }
+        }
+        else
+        {
+            one(r);
+        }
+    }
+    else if (name == "citm_catalog")
+    {
+        for (auto p : simdjson::dom::array(r["performances"]))
+        {
+            acc += static_cast<double>(uint64_t(p["id"]) + uint64_t(p["eventId"]) + simdjson::dom::array(p["seatCategories"]).size());
+        }
+        acc += static_cast<double>(simdjson::dom::object(r["events"]).size());
+    }
+    else if (name == "canada")
+    {
+        auto g = r["features"].at(0)["geometry"];
+        acc += static_cast<double>(std::string_view(r["type"]).size() + std::string_view(g["type"]).size() + simdjson::dom::array(g["coordinates"]).size());
+    }
+    else if (name == "jeopardy")
+    {
+        for (auto q : simdjson::dom::array(r))
+        {
+            acc += std::string_view(q["round"]) == "Final Jeopardy!" ? 1 : 0;
+            acc += static_cast<double>(std::string_view(q["category"]).size());
+        }
+    }
+    else if (name == "rpc")
+    {
+        acc += static_cast<double>(std::string_view(r["method"]).size());
+        acc += static_cast<double>(int64_t(r["params"]["minuend"]) + int64_t(r["id"]));
+    }
+    return acc;
+}
+
+static double pick_od(const std::string& name, simdjson::ondemand::document& d)
+{
+    double acc = 0;
+    if (name == "twitter" || name == "status")
+    {
+        auto one = [&](simdjson::ondemand::object s)
+        {
+            acc += static_cast<double>(uint64_t(s["id"]));
+            acc += static_cast<double>(std::string_view(s["user"]["screen_name"]).size());
+            acc += static_cast<double>(int64_t(s["retweet_count"]));
+        };
+        if (name == "twitter")
+        {
+            for (auto s : d["statuses"])
+            {
+                one(s.get_object());
+            }
+        }
+        else
+        {
+            one(d.get_object());
+        }
+    }
+    else if (name == "citm_catalog")
+    {
+        simdjson::ondemand::object ev = d["events"].get_object();
+        acc += static_cast<double>(ev.count_fields());
+        for (auto p : d["performances"])
+        {
+            simdjson::ondemand::object o = p.get_object();
+            const auto a = uint64_t(o["eventId"]) + uint64_t(o["id"]);
+            simdjson::ondemand::array sc = o["seatCategories"].get_array();
+            acc += static_cast<double>(a + sc.count_elements());
+        }
+    }
+    else if (name == "canada")
+    {
+        acc += static_cast<double>(std::string_view(d["type"]).size());
+        auto g = d["features"].at(0)["geometry"];
+        acc += static_cast<double>(std::string_view(g["type"]).size());
+        simdjson::ondemand::array co = g["coordinates"].get_array();
+        acc += static_cast<double>(co.count_elements());
+    }
+    else if (name == "jeopardy")
+    {
+        for (auto q : d)
+        {
+            simdjson::ondemand::object o = q.get_object();
+            acc += static_cast<double>(std::string_view(o["category"]).size());
+            acc += std::string_view(o["round"]) == "Final Jeopardy!" ? 1 : 0;
+        }
+    }
+    else if (name == "rpc")
+    {
+        acc += static_cast<double>(std::string_view(d["method"]).size());
+        acc += static_cast<double>(int64_t(d["params"]["minuend"]));
+        acc += static_cast<double>(int64_t(d["id"]));
+    }
+    return acc;
+}
+
+// ---------------- harness ----------------
+
+static std::string slurp(const std::string& p)
+{
+    std::ifstream f(p, std::ios::binary);
+    if (!f)
+    {
+        std::fprintf(stderr, "cannot open %s\n", p.c_str());
+        std::exit(1);
+    }
+    std::stringstream ss;
+    ss << f.rdbuf();
+    return ss.str();
+}
+
+struct engine
+{
+    std::string name;
+    std::function<void()> fn;
+};
+
+int main(int argc, char** argv)
+{
+    if (argc < 2)
+    {
+        std::fprintf(stderr, "usage: %s <json_test_data directory> [rounds] [document]\n", argv[0]);
+        return 1;
+    }
+    const std::string T = std::string(argv[1]) + "/";
+    const int rounds = argc > 2 ? std::atoi(argv[2]) : 30;
+    const std::string only = argc > 3 ? argv[3] : "";
+    struct doc
+    {
+        std::string name, text;
+        int batch;
+    };
+    std::vector<doc> docs;
+    for (const char* f :
+            {"nativejson-benchmark/twitter.json", "nativejson-benchmark/citm_catalog.json", "nativejson-benchmark/canada.json", "jeopardy/jeopardy.json"
+            })
+    {
+        std::string n = std::string(f).substr(std::string(f).find('/') + 1);
+        docs.push_back({n.substr(0, n.size() - 5), slurp(T + f), 1});
+    }
+    docs.push_back({"status", json::parse(docs[0].text)["statuses"][0].dump(), 200});
+    docs.push_back({"rpc", R"({"jsonrpc": "2.0", "method": "subtract", "params": {"minuend": 42, "subtrahend": 23}, "id": 3})", 5000});
+
+    // correctness cross-check of the workloads
+    for (const auto& dc : docs)
+    {
+        stats a, b, c, dd;
+        walk(json::parse(dc.text), a);
+        auto d = json_document::parse(dc.text);
+        walk(d.root(), b);
+        yyjson_doc* y = yyjson_read(dc.text.data(), dc.text.size(), 0);
+        walk(yyjson_doc_get_root(y), c);
+        simdjson::dom::parser p;
+        walk(p.parse(dc.text).value(), dd);
+        const bool ok = a.nodes == b.nodes && a.nodes == c.nodes && a.nodes == dd.nodes && a.str == b.str && a.str == c.str && a.str == dd.str
+                        && std::fabs(a.num - b.num) <= 1e-9 * std::fabs(a.num) && std::fabs(a.num - c.num) <= 1e-9 * std::fabs(a.num);
+        const double pa = pick(dc.name, json::parse(dc.text)), pb = pick(dc.name, d.root()), pc = pick(dc.name, yyjson_doc_get_root(y)), pd = pick(dc.name, p.parse(dc.text).value());
+        std::printf("check %-13s traverse %s select %s\n", dc.name.c_str(), ok ? "OK" : "MISMATCH", (pa == pb && pa == pc && pa == pd) ? "OK" : "MISMATCH");
+        yyjson_doc_free(y);
+    }
+
+    std::FILE* csv = std::fopen("bench_view.csv", "w");
+    std::fprintf(csv, "doc,bytes,workload,engine,ns\n");
+    json_document reused;
+    simdjson::dom::parser sj;
+    simdjson::ondemand::parser od;
+    for (const auto& dc : docs)
+    {
+        if (!only.empty() && dc.name != only)
+        {
+            continue;
+        }
+        const std::string& s = dc.text;
+        const simdjson::padded_string ps(s);
+        const std::string name = dc.name;
+        std::vector<std::pair<std::string, std::vector<engine>>> workloads;
+
+        workloads.push_back({"parse", {
+                {"json_view", [&] { auto d = json_document::parse(s); g_sink = static_cast<double>(d.node_count()); }},
+                {"json_view (reused)", [&] { reused.read(s); g_sink = static_cast<double>(reused.node_count()); }},
+                {"yyjson", [&] { yyjson_doc* d = yyjson_read(s.data(), s.size(), 0); g_sink = static_cast<double>(yyjson_doc_get_val_count(d)); yyjson_doc_free(d); }},
+                {"simdjson DOM", [&] { auto e = sj.parse(ps).value_unsafe(); g_sink = e.is_object(); }},
+                {"simdjson DOM (fresh)", [&] { simdjson::dom::parser p; auto e = p.parse(ps).value_unsafe(); g_sink = e.is_object(); }},
+#if JSON_VIEW_BENCH_BOOST
+                {"Boost.JSON", [&] { boost::json::monotonic_resource mr; auto v = boost::json::parse(s, &mr); g_sink = v.is_object(); }},
+#endif
+                {"json::parse", [&] { json j = json::parse(s); g_sink = static_cast<double>(j.size()); }},
+            }});
+        workloads.push_back({"traverse", {
+                {"json_view", [&] { auto d = json_document::parse(s); stats st; walk(d.root(), st); g_sink = st.num; }},
+                {"json_view (reused)", [&] { reused.read(s); stats st; walk(reused.root(), st); g_sink = st.num; }},
+                {"yyjson", [&] { yyjson_doc* d = yyjson_read(s.data(), s.size(), 0); stats st; walk(yyjson_doc_get_root(d), st); g_sink = st.num; yyjson_doc_free(d); }},
+                {"simdjson DOM", [&] { stats st; walk(sj.parse(ps).value_unsafe(), st); g_sink = st.num; }},
+                {"simdjson OD", [&] { auto d = od.iterate(ps).value_unsafe(); stats st; walk_od(d.get_value().value_unsafe(), st); g_sink = st.num; }},
+#if JSON_VIEW_BENCH_BOOST
+                {"Boost.JSON", [&] { boost::json::monotonic_resource mr; auto v = boost::json::parse(s, &mr); stats st; walk(v, st); g_sink = st.num; }},
+#endif
+                {"json::parse", [&] { json j = json::parse(s); stats st; walk(j, st); g_sink = st.num; }},
+            }});
+        workloads.push_back({"select", {
+                {"json_view", [&] { auto d = json_document::parse(s); g_sink = pick(name, d.root()); }},
+                {"json_view (reused)", [&] { reused.read(s); g_sink = pick(name, reused.root()); }},
+                {"yyjson", [&] { yyjson_doc* d = yyjson_read(s.data(), s.size(), 0); g_sink = pick(name, yyjson_doc_get_root(d)); yyjson_doc_free(d); }},
+                {"simdjson DOM", [&] { g_sink = pick(name, sj.parse(ps).value_unsafe()); }},
+                {"simdjson OD", [&] { auto d = od.iterate(ps).value_unsafe(); g_sink = pick_od(name, d); }},
+                {"json::parse", [&] { json j = json::parse(s); g_sink = pick(name, j); }},
+            }});
+        {
+            // serialization of an already parsed document
+            static json_document vd;
+            vd.read(s);
+            static yyjson_doc* yd = nullptr;
+            if (yd)
+            {
+                yyjson_doc_free(yd);
+            }
+            yd = yyjson_read(s.data(), s.size(), 0);
+            static simdjson::dom::parser sjd;
+            static simdjson::dom::element se;
+            se = sjd.parse(ps).value_unsafe();
+            static json jd;
+            jd = json::parse(s);
+            workloads.push_back({"dump", {
+                    {"json_view", [&] { std::string o = vd.root().dump(); g_sink = static_cast<double>(o.size()); }},
+                    {"yyjson", [&] { std::size_t n = 0; char* o = yyjson_write(yd, 0, &n); g_sink = static_cast<double>(n); std::free(o); }},
+                    {"simdjson DOM", [&] { std::string o = simdjson::to_string(se); g_sink = static_cast<double>(o.size()); }},
+                    {"json::parse", [&] { std::string o = jd.dump(); g_sink = static_cast<double>(o.size()); }},
+                }});
+        }
+
+        for (auto& wl : workloads)
+        {
+            std::vector<double> best(wl.second.size(), 1e300);
+            const int r = s.size() > 10000000 ? std::max(3, rounds / 5) : rounds;
+            for (int i = 0; i < r; ++i)
+            {
+                for (std::size_t k = 0; k < wl.second.size(); ++k)
+                {
+                    // an untimed call first: whatever the previous engine left to the allocator
+                    // (e.g. thousands of freed json nodes) is cleaned up here, not in the timing
+                    wl.second[k].fn();
+                    const auto t0 = std::chrono::steady_clock::now();
+                    for (int b = 0; b < dc.batch; ++b)
+                    {
+                        wl.second[k].fn();
+                    }
+                    const double ns = std::chrono::duration<double, std::nano>(std::chrono::steady_clock::now() - t0).count() / dc.batch;
+                    best[k] = std::min(best[k], ns);
+                }
+            }
+            const double ref = best[0];
+            std::printf("%-13s %-9s", dc.name.c_str(), wl.first.c_str());
+            for (std::size_t k = 0; k < wl.second.size(); ++k)
+            {
+                const double us = best[k] / 1e3;
+                std::printf("  %s %s%s (%.2fx)", wl.second[k].name.c_str(), us >= 100 ? "" : "", (us >= 1000 ? std::to_string(static_cast<long>(us)) + "us" : (std::to_string(us).substr(0, 5) + "us")).c_str(), best[k] / ref);
+                std::fprintf(csv, "%s,%zu,%s,%s,%.1f\n", dc.name.c_str(), s.size(), wl.first.c_str(), wl.second[k].name.c_str(), best[k]);
+            }
+            std::printf("\n");
+            std::fflush(stdout);
+        }
+    }
+    std::fclose(csv);
+}
@@ -0,0 +1,313 @@
+#!/usr/bin/env python3
+#     __ _____ _____ _____
+#  __|  |   __|     |   | |  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
+
+"""Compare json_view with yyjson, simdjson, Boost.JSON, and json::parse.
+
+Builds bench_view.cpp, bench_corpus.cpp, and bench_edit.cpp against the include/ directory of
+this checkout, runs them, and writes the results with everything needed to
+reproduce them (date, commit, CPU, OS, compiler, library versions, flags) to
+results/<date>-<host>.md and .csv next to this script.
+
+The other libraries come from the system (--system, the default: pkg-config
+or Homebrew) or are downloaded as pinned releases and checked against their
+SHA-256 (--download). Boost.JSON is optional: without Boost headers, its
+columns are skipped, and the results say so.
+
+Only the Python 3 standard library is used; a C++17 compiler is needed.
+"""
+
+import argparse
+import datetime
+import hashlib
+import os
+import platform
+import re
+import shlex
+import shutil
+# runs only the compilers and benchmark binaries this script builds
+import subprocess  # nosec B404
+import sys
+import tarfile
+import urllib.request
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+REPO = os.path.abspath(os.path.join(HERE, '..', '..', '..'))
+
+# pinned releases for --download; the hashes are those of the archives
+PINNED = {
+    'yyjson': {
+        'version': '0.13.0',
+        'url': 'https://github.com/ibireme/yyjson/archive/refs/tags/0.13.0.tar.gz',
+        'sha256': '34e0f62a2bc11ab20d601e8ca1cc2b2079503aa45119a19133d89d19b94a0fae',
+        'dir': 'yyjson-0.13.0',
+    },
+    'simdjson': {
+        'version': '4.6.11',
+        'url': 'https://github.com/simdjson/simdjson/archive/refs/tags/v4.6.11.tar.gz',
+        'sha256': '61d948fc24f0d793829ad658058e7597d064988a89b4607ea02e401a82df98ff',
+        'dir': 'simdjson-4.6.11',
+    },
+    'boost': {
+        'version': '1.92.0',
+        'url': 'https://archives.boost.io/release/1.92.0/source/boost_1_92_0.tar.gz',
+        'sha256': 'c4a3b310ddd2472416e091067166b0713be97c63f38c212c484ada022fd296ce',
+        'dir': 'boost_1_92_0',
+    },
+}
+
+# the documents of bench_view.cpp, relative to the json_test_data directory
+DEFAULT_CORPUS = [
+    'nativejson-benchmark/twitter.json',
+    'nativejson-benchmark/citm_catalog.json',
+    'nativejson-benchmark/canada.json',
+    'jeopardy/jeopardy.json',
+]
+
+
+def run(cmd, **kwargs):
+    print('+ ' + ' '.join(shlex.quote(c) for c in cmd), flush=True)
+    # cmd is an argument list built by this script, never a shell string
+    return subprocess.run(cmd, check=True, **kwargs)  # nosec B603
+
+
+def output(cmd):
+    try:
+        # cmd is an argument list built by this script, never a shell string
+        return subprocess.run(cmd, check=True, capture_output=True, text=True).stdout.strip()  # nosec B603
+    except (OSError, subprocess.CalledProcessError):
+        return ''
+
+
+# ---------------------------------------------------------------------------
+# libraries
+# ---------------------------------------------------------------------------
+
+class Library:
+    """include directories, sources to compile, and linker flags of a library"""
+
+    def __init__(self, name, include=None, sources=None, link=None, version=''):
+        self.name = name
+        self.include = include or []
+        self.sources = sources or []
+        self.link = link or []
+        self.version = version
+
+
+def header_version(path, pattern):
+    try:
+        with open(path, encoding='utf-8', errors='replace') as f:
+            m = re.search(pattern, f.read())
+        return m.group(1) if m else ''
+    except OSError:
+        return ''
+
+
+def library_version(name, include_dirs):
+    patterns = {
+        'yyjson': ('yyjson.h', r'#define\s+YYJSON_VERSION_STRING\s+"([^"]+)"'),
+        'simdjson': ('simdjson.h', r'#define\s+SIMDJSON_VERSION\s+"?([0-9.]+)"?'),
+        'boost': (os.path.join('boost', 'version.hpp'), r'#define\s+BOOST_LIB_VERSION\s+"([^"]+)"'),
+    }
+    header, pattern = patterns[name]
+    for d in include_dirs:
+        v = header_version(os.path.join(d, header), pattern)
+        if v:
+            return v.replace('_', '.')
+    return ''
+
+
+def system_library(name):
+    """a library found with pkg-config or Homebrew, or None"""
+    flags = output(['pkg-config', '--cflags', '--libs', name]).split()
+    if flags:
+        include = [f[2:] for f in flags if f.startswith('-I')]
+        link = [f for f in flags if f.startswith('-L') or f.startswith('-l')]
+        libdirs = [f[2:] for f in link if f.startswith('-L')]
+        link += ['-Wl,-rpath,' + d for d in libdirs]
+        return Library(name, include, [], link, library_version(name, include))
+    prefix = output(['brew', '--prefix', name]) if shutil.which('brew') else ''
+    if prefix and os.path.isdir(os.path.join(prefix, 'include')):
+        include = [os.path.join(prefix, 'include')]
+        link = []
+        if name != 'boost':
+            lib = os.path.join(prefix, 'lib')
+            link = ['-L' + lib, '-l' + name, '-Wl,-rpath,' + lib]
+        return Library(name, include, [], link, library_version(name, include))
+    if name == 'boost':
+        for d in ['/usr/include', '/usr/local/include']:
+            if os.path.isfile(os.path.join(d, 'boost', 'json.hpp')):
+                return Library(name, [d], [], [], library_version(name, [d]))
+    return None
+
+
+def download_library(name, work):
+    """a pinned release, downloaded and checked, or an error"""
+    pin = PINNED[name]
+    archive = os.path.join(work, 'download', os.path.basename(pin['url']))
+    os.makedirs(os.path.dirname(archive), exist_ok=True)
+    if not os.path.isfile(archive):
+        print(f'downloading {pin["url"]}', flush=True)
+        # the URLs are the https constants in PINNED, and the SHA-256 is checked below
+        # (into a .part file first, so that an interrupted download is not kept)
+        urllib.request.urlretrieve(pin['url'], archive + '.part')  # nosec B310
+        os.replace(archive + '.part', archive)
+    with open(archive, 'rb') as f:
+        digest = hashlib.sha256(f.read()).hexdigest()
+    if digest != pin['sha256']:
+        os.remove(archive)  # downloaded again by the next run
+        sys.exit(f'error: SHA-256 of {archive} is {digest}, expected {pin["sha256"]} (removed)')
+    src = os.path.join(work, 'download', pin['dir'])
+    if not os.path.isdir(src):
+        with tarfile.open(archive) as t:
+            # (the 'data' filter rejects links and paths outside the target where Python has it)
+            kwargs = {'filter': 'data'} if hasattr(tarfile, 'data_filter') else {}
+            t.extractall(os.path.join(work, 'download'), **kwargs)  # noqa: S202 (checked archive)  # nosec B202
+    if name == 'yyjson':
+        return Library(name, [os.path.join(src, 'src')], [os.path.join(src, 'src', 'yyjson.c')], [], pin['version'])
+    if name == 'simdjson':
+        single = os.path.join(src, 'singleheader')
+        return Library(name, [single], [os.path.join(single, 'simdjson.cpp')], [], pin['version'])
+    return Library(name, [src], [], [], pin['version'])
+
+
+# ---------------------------------------------------------------------------
+# machine description
+# ---------------------------------------------------------------------------
+
+def cpu_model():
+    if sys.platform == 'darwin':
+        return output(['sysctl', '-n', 'machdep.cpu.brand_string'])
+    try:
+        with open('/proc/cpuinfo', encoding='utf-8') as f:
+            for line in f:
+                if line.startswith('model name') or line.startswith('Model'):
+                    return line.split(':', 1)[1].strip()
+    except OSError:
+        pass
+    # (AArch64 Linux: /proc/cpuinfo has no model name, lscpu knows it)
+    for line in output(['lscpu']).splitlines():
+        if line.startswith('Model name:'):
+            return line.split(':', 1)[1].strip()
+    return platform.processor() or platform.machine()
+
+
+def git_commit():
+    commit = output(['git', '-C', REPO, 'rev-parse', '--short=12', 'HEAD'])
+    dirty = output(['git', '-C', REPO, 'status', '--porcelain', '--untracked-files=no'])
+    return commit + (' (with local changes)' if dirty else '')
+
+
+# ---------------------------------------------------------------------------
+# main
+# ---------------------------------------------------------------------------
+
+def main():
+    ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument('--data', required=True, help='json_test_data directory (with nativejson-benchmark/ and jeopardy/)')
+    ap.add_argument('--download', action='store_true', help='use pinned downloads instead of system libraries')
+    ap.add_argument('--no-boost', action='store_true', help='skip Boost.JSON')
+    ap.add_argument('--native', action='store_true', help='compile for this CPU (-march=native / -mcpu=native)')
+    ap.add_argument('--rounds', type=int, default=30, help='rounds of bench_view (default: 30)')
+    ap.add_argument('--corpus', nargs='*', default=[], help='more files for bench_corpus')
+    ap.add_argument('--build-dir', default=os.path.join(HERE, 'build'), help='where to build (default: build/ next to this script)')
+    args = ap.parse_args()
+    # the benchmarks run in the build directory: make the paths absolute
+    args.data = os.path.abspath(args.data)
+    args.corpus = [os.path.abspath(f) for f in args.corpus]
+    args.build_dir = os.path.abspath(args.build_dir)
+
+    cxx = os.environ.get('CXX', 'c++')
+    cc = os.environ.get('CC', 'cc')
+    os.makedirs(args.build_dir, exist_ok=True)
+
+    libs = {}
+    for name in ['yyjson', 'simdjson', 'boost']:
+        if name == 'boost' and args.no_boost:
+            continue
+        lib = download_library(name, args.build_dir) if args.download else system_library(name)
+        if lib is None and name != 'boost':
+            sys.exit(f'error: {name} not found; install it, or use --download')
+        if lib is not None:
+            libs[name] = lib
+    with_boost = 'boost' in libs
+    if not with_boost:
+        print('Boost.JSON not found: its columns are skipped', flush=True)
+
+    flags = ['-std=c++17', '-O3', '-DNDEBUG', f'-DJSON_VIEW_BENCH_BOOST={1 if with_boost else 0}']
+    if args.native:
+        flags.append('-mcpu=native' if platform.machine().lower() in ('arm64', 'aarch64') else '-march=native')
+    include = ['-I' + os.path.join(REPO, 'include')] + ['-I' + d for lib in libs.values() for d in lib.include]
+    link = [f for lib in libs.values() for f in lib.link]
+
+    # C sources of downloaded libraries are compiled once
+    objects = []
+    for lib in libs.values():
+        for src in lib.sources:
+            obj = os.path.join(args.build_dir, os.path.basename(src) + '.o')
+            compiler = cc if src.endswith('.c') else cxx
+            run([compiler] + (['-std=c++17'] if compiler == cxx else []) + ['-O3', '-DNDEBUG', '-c', src, '-o', obj]
+                + ['-I' + d for d in lib.include])
+            objects.append(obj)
+
+    binaries = {}
+    for bench in ['bench_view', 'bench_corpus', 'bench_edit']:
+        exe = os.path.join(args.build_dir, bench)
+        run([cxx] + flags + include + [os.path.join(HERE, bench + '.cpp')] + objects + link + ['-o', exe])
+        binaries[bench] = exe
+
+    # run: bench_view on its documents, bench_corpus on those and the given files
+    corpus = [os.path.join(args.data, f) for f in DEFAULT_CORPUS] + args.corpus
+    outputs = {}
+    outputs['bench_view'] = run([binaries['bench_view'], args.data, str(args.rounds)], cwd=args.build_dir,
+                                capture_output=True, text=True).stdout
+    outputs['bench_corpus'] = run([binaries['bench_corpus']] + corpus, cwd=args.build_dir,
+                                  capture_output=True, text=True).stdout
+    outputs['bench_edit'] = run([binaries['bench_edit'], args.data, str(max(1, args.rounds // 2))], cwd=args.build_dir,
+                                capture_output=True, text=True).stdout
+    for name, text in outputs.items():
+        print(text)
+
+    # results with their metadata
+    now = datetime.datetime.now()
+    host = re.sub(r'[^A-Za-z0-9-]+', '-', platform.node().split('.')[0]) or 'host'
+    stem = os.path.join(HERE, 'results', f'{now:%Y-%m-%d}-{host}')
+    os.makedirs(os.path.dirname(stem), exist_ok=True)
+    meta = [
+        ('date', f'{now:%Y-%m-%d %H:%M}'),
+        ('commit', git_commit()),
+        ('CPU', cpu_model()),
+        ('OS', f'{platform.system()} {platform.release()} ({platform.machine()})'),
+        ('compiler', output([cxx, '--version']).splitlines()[0] if output([cxx, '--version']) else cxx),
+        ('flags', ' '.join(flags)),
+        ('yyjson', libs['yyjson'].version),
+        ('simdjson', libs['simdjson'].version),
+        ('Boost.JSON', libs['boost'].version if with_boost else 'skipped (not found)'),
+        ('libraries from', 'pinned downloads' if args.download else 'the system'),
+        ('rounds', str(args.rounds)),
+    ]
+    with open(stem + '.md', 'w', encoding='utf-8') as f:
+        f.write(f'# json_view comparison, {now:%Y-%m-%d}\n\n')
+        f.write('Generated by `tests/benchmarks/json_view/compare.py`; best of the interleaved rounds.\n\n')
+        f.write('| | |\n|---|---|\n')
+        for key, value in meta:
+            f.write(f'| {key} | {value} |\n')
+        for name, text in outputs.items():
+            f.write(f'\n## {name}\n\n```\n{text.rstrip()}\n```\n')
+    with open(stem + '.csv', 'w', encoding='utf-8') as out:
+        out.write(''.join(f'# {key}: {value}\n' for key, value in meta))
+        for name in ['bench_view', 'bench_corpus', 'bench_edit']:
+            path = os.path.join(args.build_dir, name + '.csv')
+            if os.path.isfile(path):
+                with open(path, encoding='utf-8') as f:
+                    out.write(f'# {name}\n' + f.read())
+    print(f'results: {stem}.md, {stem}.csv')
+
+
+if __name__ == '__main__':
+    main()
@@ -15,14 +15,6 @@ safely (with `image_check::full`, the document must also serialize to the JSON i
 image must load and serialize to the same text. A corpus of images can be made from JSON files with a small program
 that calls `json_document::parse(text).save()`; plain JSON files work as well.

-## What the fuzzers check
-
-Each fuzzer driver (`tests/src/fuzzer-parse_*.cpp`) parses its input twice: once with `allow_exceptions = false` and
-once with exceptions. Both calls must agree. Where parsing with exceptions fails, the call without exceptions must
-return a discarded value (or throw the same kind of non-parse error), and it must never throw a `parse_error`. Where
-parsing succeeds, both calls must return the same value. The drivers then serialize the value, parse the result back,
-and check that nothing was lost. The drivers check all of this with `assert`, so they refuse to build with `NDEBUG`.
-
 ## Corpus creation

 For most effective fuzzing, a [corpus](https://llvm.org/docs/LibFuzzer.html#corpus) should be provided. A corpus is a
@@ -74,9 +66,6 @@ Then pass the corpus directory as command-line argument (assuming it is located
 The fuzzer should be able to run indefinitely without crashing. In case of a crash, the tested input is dumped into
 a file starting with `crash-`.

-To also detect memory leaks, build with AddressSanitizer (`FUZZER_ENGINE="-fsanitize=fuzzer,address"`): libFuzzer then
-runs LeakSanitizer by default (`-detect_leaks=1`). LeakSanitizer is not available with Apple Clang on macOS.
-
 ## afl++

 To use afl++, you need to pass `-fsanitize=fuzzer` as `FUZZER_ENGINE`. It will be replaced by a `libAFLDriver.a` to
@@ -99,9 +88,7 @@ directory `out`.

 The library is further fuzz-tested 24/7 by Google's [OSS-Fuzz project](https://github.com/google/oss-fuzz). It uses
 the same `fuzzers` target as above and also relies on the `FUZZER_ENGINE` variable. See the used
-[build script](https://github.com/google/oss-fuzz/blob/master/projects/json/build.sh) for more information. Its default
-`address` sanitizer includes LeakSanitizer, so OSS-Fuzz and the CIFuzz workflow (`.github/workflows/cifuzz.yml`) report
-memory leaks, too.
+[build script](https://github.com/google/oss-fuzz/blob/master/projects/json/build.sh) for more information.

 In case the build at OSS-Fuzz fails, an issue will be created automatically.

@@ -10,9 +10,7 @@
 This file implements a parser test suitable for fuzz testing. Given a byte
 array data, it performs the following steps:

- j0 = from_bjdata(data, allow_exceptions = false)
 - j1 = from_bjdata(data)
- assert(j0 is discarded if parsing j1 fails, and j0 == j1 otherwise)
 - vec2 = to_bjdata(j1, use_size = false, use_type = false)
 - vec3 = to_bjdata(j1, use_size = true, use_type = false)
 - vec4 = to_bjdata(j1, use_size = true, use_type = true)
@@ -61,13 +59,6 @@ drivers.

 using json = nlohmann::json;

-// compares dumps rather than values, because NaN != NaN; keep writes strings
-// byte for byte, so ill-formed UTF-8 that a binary reader accepts cannot throw
-static bool same_value(const json& lhs, const json& rhs)
-{
-    return lhs.dump(-1, ' ', false, json::error_handler_t::keep) == rhs.dump(-1, ' ', false, json::error_handler_t::keep);
-}
-
 // 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)
@@ -78,37 +69,11 @@ static bool is_value_stable(const json& lhs, const json& rhs)
 // see http://llvm.org/docs/LibFuzzer.html
 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
 {
-    std::vector<uint8_t> const vec1(data, data + size);
-
-    // step 0: parse input without exceptions; a parse error must then be
-    // reported as a discarded value, never thrown
-    json j_noexcept;
-    bool noexcept_threw = false;
-    try
-    {
-        j_noexcept = json::from_bjdata(vec1, true, false);
-    }
-    catch (const json::parse_error&)
-    {
-        assert(false);
-    }
-    catch (const json::exception&)
-    {
-        // type and out-of-range errors are not parse errors and still throw
-        noexcept_threw = true;
-    }
-    // whether step 1 succeeded; if not, the catch blocks below check that
-    // step 0 failed, too
-    bool parsed = false;
-
    try
    {
        // step 1: parse input
+        std::vector<uint8_t> const vec1(data, data + size);
        json const j1 = json::from_bjdata(vec1);
-        parsed = true;
-
-        // without exceptions, the same input must give the same value
-        assert(!noexcept_threw && !j_noexcept.is_discarded() && same_value(j_noexcept, j1));

        try
        {
@@ -142,17 +107,14 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
    catch (const json::parse_error&)
    {
        // parse errors are ok, because input may be random bytes
-        assert(parsed || noexcept_threw || j_noexcept.is_discarded());
    }
    catch (const json::type_error&)
    {
        // type errors can occur during parsing, too
-        assert(parsed || noexcept_threw || j_noexcept.is_discarded());
    }
    catch (const json::out_of_range&)
    {
        // out of range errors may happen if provided sizes are excessive
-        assert(parsed || noexcept_threw || j_noexcept.is_discarded());
    }

    // return 0 - non-zero return values are reserved for future use
@@ -10,9 +10,7 @@
 This file implements a parser test suitable for fuzz testing. Given a byte
 array data, it performs the following steps:

- j0 = from_bon8(data, allow_exceptions = false)
 - j1 = from_bon8(data)
- assert(j0 is discarded if parsing j1 fails, and j0 == j1 otherwise)
 - vec = to_bon8(j1)
 - j2 = from_bon8(vec)
 - assert(to_bon8(j2) == vec)
@@ -36,13 +34,6 @@ drivers.

 using json = nlohmann::json;

-// compares dumps rather than values, because NaN != NaN; keep writes strings
-// byte for byte, so ill-formed UTF-8 that a binary reader accepts cannot throw
-static bool same_value(const json& lhs, const json& rhs)
-{
-    return lhs.dump(-1, ' ', false, json::error_handler_t::keep) == rhs.dump(-1, ' ', false, json::error_handler_t::keep);
-}
-
 namespace
 {
 // the serialization of the value read from @a input, or the error message
@@ -70,37 +61,11 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
        assert(read_bon8(std::vector<uint8_t>(data, data + size)) == read_bon8(stream));
    }

-    std::vector<uint8_t> const vec1(data, data + size);
-
-    // step 0: parse input without exceptions; a parse error must then be
-    // reported as a discarded value, never thrown
-    json j_noexcept;
-    bool noexcept_threw = false;
-    try
-    {
-        j_noexcept = json::from_bon8(vec1, true, false);
-    }
-    catch (const json::parse_error&)
-    {
-        assert(false);
-    }
-    catch (const json::exception&)
-    {
-        // type and out-of-range errors are not parse errors and still throw
-        noexcept_threw = true;
-    }
-    // whether step 1 succeeded; if not, the catch blocks below check that
-    // step 0 failed, too
-    bool parsed = false;
-
    try
    {
        // step 1: parse input
+        std::vector<uint8_t> const vec1(data, data + size);
        json const j1 = json::from_bon8(vec1);
-        parsed = true;
-
-        // without exceptions, the same input must give the same value
-        assert(!noexcept_threw && !j_noexcept.is_discarded() && same_value(j_noexcept, j1));

        try
        {
@@ -122,17 +87,14 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
    catch (const json::parse_error&)
    {
        // parse errors are ok, because input may be random bytes
-        assert(parsed || noexcept_threw || j_noexcept.is_discarded());
    }
    catch (const json::type_error&)
    {
        // type errors can occur during parsing, too
-        assert(parsed || noexcept_threw || j_noexcept.is_discarded());
    }
    catch (const json::out_of_range&)
    {
        // out of range errors may happen if provided sizes are excessive
-        assert(parsed || noexcept_threw || j_noexcept.is_discarded());
    }

    // return 0 - non-zero return values are reserved for future use
@@ -10,9 +10,7 @@
 This file implements a parser test suitable for fuzz testing. Given a byte
 array data, it performs the following steps:

- j0 = from_bson(data, allow_exceptions = false)
 - j1 = from_bson(data)
- assert(j0 is discarded if parsing j1 fails, and j0 == j1 otherwise)
 - vec = to_bson(j1)
 - j2 = from_bson(vec)
 - assert(to_bson(j2) == vec)
@@ -31,47 +29,14 @@ drivers.

 using json = nlohmann::json;

-// compares dumps rather than values, because NaN != NaN; keep writes strings
-// byte for byte, so ill-formed UTF-8 that a binary reader accepts cannot throw
-static bool same_value(const json& lhs, const json& rhs)
-{
-    return lhs.dump(-1, ' ', false, json::error_handler_t::keep) == rhs.dump(-1, ' ', false, json::error_handler_t::keep);
-}
-
 // see http://llvm.org/docs/LibFuzzer.html
 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
 {
-    std::vector<uint8_t> const vec1(data, data + size);
-
-    // step 0: parse input without exceptions; a parse error must then be
-    // reported as a discarded value, never thrown
-    json j_noexcept;
-    bool noexcept_threw = false;
-    try
-    {
-        j_noexcept = json::from_bson(vec1, true, false);
-    }
-    catch (const json::parse_error&)
-    {
-        assert(false);
-    }
-    catch (const json::exception&)
-    {
-        // type and out-of-range errors are not parse errors and still throw
-        noexcept_threw = true;
-    }
-    // whether step 1 succeeded; if not, the catch blocks below check that
-    // step 0 failed, too
-    bool parsed = false;
-
    try
    {
        // step 1: parse input
+        std::vector<uint8_t> const vec1(data, data + size);
        json const j1 = json::from_bson(vec1);
-        parsed = true;
-
-        // without exceptions, the same input must give the same value
-        assert(!noexcept_threw && !j_noexcept.is_discarded() && same_value(j_noexcept, j1));

        try
        {
@@ -93,17 +58,14 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
    catch (const json::parse_error&)
    {
        // parse errors are ok, because input may be random bytes
-        assert(parsed || noexcept_threw || j_noexcept.is_discarded());
    }
    catch (const json::type_error&)
    {
        // type errors can occur during parsing, too
-        assert(parsed || noexcept_threw || j_noexcept.is_discarded());
    }
    catch (const json::out_of_range&)
    {
        // out of range errors can occur during parsing, too
-        assert(parsed || noexcept_threw || j_noexcept.is_discarded());
    }

    // return 0 - non-zero return values are reserved for future use
@@ -10,9 +10,7 @@
 This file implements a parser test suitable for fuzz testing. Given a byte
 array data, it performs the following steps:

- j0 = from_cbor(data, allow_exceptions = false)
 - j1 = from_cbor(data)
- assert(j0 is discarded if parsing j1 fails, and j0 == j1 otherwise)
 - vec = to_cbor(j1)
 - j2 = from_cbor(vec)
 - assert(to_cbor(j2) == vec)
@@ -31,47 +29,14 @@ drivers.

 using json = nlohmann::json;

-// compares dumps rather than values, because NaN != NaN; keep writes strings
-// byte for byte, so ill-formed UTF-8 that a binary reader accepts cannot throw
-static bool same_value(const json& lhs, const json& rhs)
-{
-    return lhs.dump(-1, ' ', false, json::error_handler_t::keep) == rhs.dump(-1, ' ', false, json::error_handler_t::keep);
-}
-
 // see http://llvm.org/docs/LibFuzzer.html
 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
 {
-    std::vector<uint8_t> const vec1(data, data + size);
-
-    // step 0: parse input without exceptions; a parse error must then be
-    // reported as a discarded value, never thrown
-    json j_noexcept;
-    bool noexcept_threw = false;
-    try
-    {
-        j_noexcept = json::from_cbor(vec1, true, false);
-    }
-    catch (const json::parse_error&)
-    {
-        assert(false);
-    }
-    catch (const json::exception&)
-    {
-        // type and out-of-range errors are not parse errors and still throw
-        noexcept_threw = true;
-    }
-    // whether step 1 succeeded; if not, the catch blocks below check that
-    // step 0 failed, too
-    bool parsed = false;
-
    try
    {
        // step 1: parse input
+        std::vector<uint8_t> const vec1(data, data + size);
        json const j1 = json::from_cbor(vec1);
-        parsed = true;
-
-        // without exceptions, the same input must give the same value
-        assert(!noexcept_threw && !j_noexcept.is_discarded() && same_value(j_noexcept, j1));

        try
        {
@@ -93,17 +58,14 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
    catch (const json::parse_error&)
    {
        // parse errors are ok, because input may be random bytes
-        assert(parsed || noexcept_threw || j_noexcept.is_discarded());
    }
    catch (const json::type_error&)
    {
        // type errors can occur during parsing, too
-        assert(parsed || noexcept_threw || j_noexcept.is_discarded());
    }
    catch (const json::out_of_range&)
    {
        // out of range errors can occur during parsing, too
-        assert(parsed || noexcept_threw || j_noexcept.is_discarded());
    }

    // return 0 - non-zero return values are reserved for future use
@@ -10,9 +10,7 @@
 This file implements a parser test suitable for fuzz testing. Given a byte
 array data, it performs the following steps:

- j0 = parse(data, allow_exceptions = false)
 - j1 = parse(data)
- assert(j0 is discarded if parsing j1 fails, and j0 == j1 otherwise)
 - s1 = serialize(j1)
 - j2 = parse(s1)
 - s2 = serialize(j2)
@@ -32,45 +30,13 @@ drivers.

 using json = nlohmann::json;

-// compares dumps rather than values, because NaN != NaN; keep writes strings
-// byte for byte, so ill-formed UTF-8 that a binary reader accepts cannot throw
-static bool same_value(const json& lhs, const json& rhs)
-{
-    return lhs.dump(-1, ' ', false, json::error_handler_t::keep) == rhs.dump(-1, ' ', false, json::error_handler_t::keep);
-}
-
 // see http://llvm.org/docs/LibFuzzer.html
 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
 {
-    // step 0: parse input without exceptions; a parse error must then be
-    // reported as a discarded value, never thrown
-    json j_noexcept;
-    bool noexcept_threw = false;
-    try
-    {
-        j_noexcept = json::parse(data, data + size, nullptr, false);
-    }
-    catch (const json::parse_error&)
-    {
-        assert(false);
-    }
-    catch (const json::exception&)
-    {
-        // type and out-of-range errors are not parse errors and still throw
-        noexcept_threw = true;
-    }
-    // whether step 1 succeeded; if not, the catch blocks below check that
-    // step 0 failed, too
-    bool parsed = false;
-
    try
    {
        // step 1: parse input
        json const j1 = json::parse(data, data + size);
-        parsed = true;
-
-        // without exceptions, the same input must give the same value
-        assert(!noexcept_threw && !j_noexcept.is_discarded() && same_value(j_noexcept, j1));

        try
        {
@@ -97,12 +63,10 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
    catch (const json::parse_error&)
    {
        // parse errors are ok, because input may be random bytes
-        assert(parsed || noexcept_threw || j_noexcept.is_discarded());
    }
    catch (const json::out_of_range&)
    {
        // out of range errors may happen if provided sizes are excessive
-        assert(parsed || noexcept_threw || j_noexcept.is_discarded());
    }

    // return 0 - non-zero return values are reserved for future use
@@ -10,9 +10,7 @@
 This file implements a parser test suitable for fuzz testing. Given a byte
 array data, it performs the following steps:

- j0 = from_msgpack(data, allow_exceptions = false)
 - j1 = from_msgpack(data)
- assert(j0 is discarded if parsing j1 fails, and j0 == j1 otherwise)
 - vec = to_msgpack(j1)
 - j2 = from_msgpack(vec)
 - assert(to_msgpack(j2) == vec)
@@ -31,47 +29,14 @@ drivers.

 using json = nlohmann::json;

-// compares dumps rather than values, because NaN != NaN; keep writes strings
-// byte for byte, so ill-formed UTF-8 that a binary reader accepts cannot throw
-static bool same_value(const json& lhs, const json& rhs)
-{
-    return lhs.dump(-1, ' ', false, json::error_handler_t::keep) == rhs.dump(-1, ' ', false, json::error_handler_t::keep);
-}
-
 // see http://llvm.org/docs/LibFuzzer.html
 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
 {
-    std::vector<uint8_t> const vec1(data, data + size);
-
-    // step 0: parse input without exceptions; a parse error must then be
-    // reported as a discarded value, never thrown
-    json j_noexcept;
-    bool noexcept_threw = false;
-    try
-    {
-        j_noexcept = json::from_msgpack(vec1, true, false);
-    }
-    catch (const json::parse_error&)
-    {
-        assert(false);
-    }
-    catch (const json::exception&)
-    {
-        // type and out-of-range errors are not parse errors and still throw
-        noexcept_threw = true;
-    }
-    // whether step 1 succeeded; if not, the catch blocks below check that
-    // step 0 failed, too
-    bool parsed = false;
-
    try
    {
        // step 1: parse input
+        std::vector<uint8_t> const vec1(data, data + size);
        json const j1 = json::from_msgpack(vec1);
-        parsed = true;
-
-        // without exceptions, the same input must give the same value
-        assert(!noexcept_threw && !j_noexcept.is_discarded() && same_value(j_noexcept, j1));

        try
        {
@@ -93,17 +58,14 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
    catch (const json::parse_error&)
    {
        // parse errors are ok, because input may be random bytes
-        assert(parsed || noexcept_threw || j_noexcept.is_discarded());
    }
    catch (const json::type_error&)
    {
        // type errors can occur during parsing, too
-        assert(parsed || noexcept_threw || j_noexcept.is_discarded());
    }
    catch (const json::out_of_range&)
    {
        // out of range errors may happen if provided sizes are excessive
-        assert(parsed || noexcept_threw || j_noexcept.is_discarded());
    }

    // return 0 - non-zero return values are reserved for future use
@@ -10,9 +10,7 @@
 This file implements a parser test suitable for fuzz testing. Given a byte
 array data, it performs the following steps:

- j0 = from_ubjson(data, allow_exceptions = false)
 - j1 = from_ubjson(data)
- assert(j0 is discarded if parsing j1 fails, and j0 == j1 otherwise)
 - vec2 = to_ubjson(j1, use_size = false, use_type = false)
 - vec3 = to_ubjson(j1, use_size = true, use_type = false)
 - vec4 = to_ubjson(j1, use_size = true, use_type = true)
@@ -40,47 +38,14 @@ drivers.

 using json = nlohmann::json;

-// compares dumps rather than values, because NaN != NaN; keep writes strings
-// byte for byte, so ill-formed UTF-8 that a binary reader accepts cannot throw
-static bool same_value(const json& lhs, const json& rhs)
-{
-    return lhs.dump(-1, ' ', false, json::error_handler_t::keep) == rhs.dump(-1, ' ', false, json::error_handler_t::keep);
-}
-
 // see http://llvm.org/docs/LibFuzzer.html
 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
 {
-    std::vector<uint8_t> const vec1(data, data + size);
-
-    // step 0: parse input without exceptions; a parse error must then be
-    // reported as a discarded value, never thrown
-    json j_noexcept;
-    bool noexcept_threw = false;
-    try
-    {
-        j_noexcept = json::from_ubjson(vec1, true, false);
-    }
-    catch (const json::parse_error&)
-    {
-        assert(false);
-    }
-    catch (const json::exception&)
-    {
-        // type and out-of-range errors are not parse errors and still throw
-        noexcept_threw = true;
-    }
-    // whether step 1 succeeded; if not, the catch blocks below check that
-    // step 0 failed, too
-    bool parsed = false;
-
    try
    {
        // step 1: parse input
+        std::vector<uint8_t> const vec1(data, data + size);
        json const j1 = json::from_ubjson(vec1);
-        parsed = true;
-
-        // without exceptions, the same input must give the same value
-        assert(!noexcept_threw && !j_noexcept.is_discarded() && same_value(j_noexcept, j1));

        try
        {
@@ -112,17 +77,14 @@ extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
    catch (const json::parse_error&)
    {
        // parse errors are ok, because input may be random bytes
-        assert(parsed || noexcept_threw || j_noexcept.is_discarded());
    }
    catch (const json::type_error&)
    {
        // type errors can occur during parsing, too
-        assert(parsed || noexcept_threw || j_noexcept.is_discarded());
    }
    catch (const json::out_of_range&)
    {
        // out of range errors may happen if provided sizes are excessive
-        assert(parsed || noexcept_threw || j_noexcept.is_discarded());
    }

    // return 0 - non-zero return values are reserved for future use