Merge branch 'develop' into guard-page-tests

Signed-off-by: Niels Lohmann <mail@nlohmann.me>

include/nlohmann/detail/iterators/iter_impl.hpp

@@ -280,11 +280,6 @@ class iter_impl // NOLINT(cppcoreguidelines-special-member-functions,hicpp-speci
     }
 
     /// @throw invalid_iterator.214 always
-    JSON_HEDLEY_NEVER_INLINE JSON_HEDLEY_NO_RETURN void throw_compare_different_values() const
-    {
-        JSON_THROW(invalid_iterator::create(exception_id::iterators_compare_different_values, "cannot compare iterators of different containers", m_object));
-    }
-
     JSON_HEDLEY_NO_RETURN void throw_cannot_get_value() const
     {
         JSON_THROW(invalid_iterator::create(exception_id::iterator_value_unavailable, "cannot get value", m_object));
@@ -299,18 +294,6 @@ class iter_impl // NOLINT(cppcoreguidelines-special-member-functions,hicpp-speci
     {
         JSON_ASSERT(m_object != nullptr);
 
-        if (JSON_HEDLEY_LIKELY(m_object->m_data.m_type == value_t::array))
-        {
-            JSON_ASSERT(m_it.array_iterator != m_object->m_data.m_value.array->end());
-            return *m_it.array_iterator;
-        }
-
-        if (JSON_HEDLEY_LIKELY(m_object->m_data.m_type == value_t::object))
-        {
-            JSON_ASSERT(m_it.object_iterator != m_object->m_data.m_value.object->end());
-            return m_it.object_iterator->second;
-        }
-
         switch (m_object->m_data.m_type)
         {
             case value_t::object:
@@ -355,12 +338,6 @@ class iter_impl // NOLINT(cppcoreguidelines-special-member-functions,hicpp-speci
     {
         JSON_ASSERT(m_object != nullptr);
 
-        if (JSON_HEDLEY_LIKELY(m_object->m_data.m_type == value_t::array))
-        {
-            JSON_ASSERT(m_it.array_iterator != m_object->m_data.m_value.array->end());
-            return &*m_it.array_iterator;
-        }
-
         switch (m_object->m_data.m_type)
         {
             case value_t::object:
@@ -414,18 +391,6 @@ class iter_impl // NOLINT(cppcoreguidelines-special-member-functions,hicpp-speci
     {
         JSON_ASSERT(m_object != nullptr);
 
-        if (JSON_HEDLEY_LIKELY(m_object->m_data.m_type == value_t::array))
-        {
-            ++m_it.array_iterator;
-            return *this;
-        }
-
-        if (JSON_HEDLEY_LIKELY(m_object->m_data.m_type == value_t::object))
-        {
-            std::advance(m_it.object_iterator, 1);
-            return *this;
-        }
-
         switch (m_object->m_data.m_type)
         {
             case value_t::object:
@@ -519,7 +484,7 @@ class iter_impl // NOLINT(cppcoreguidelines-special-member-functions,hicpp-speci
         // if objects are not the same, the comparison is undefined
         if (JSON_HEDLEY_UNLIKELY(m_object != other.m_object))
         {
-            throw_compare_different_values();
+            JSON_THROW(invalid_iterator::create(exception_id::iterators_compare_different_values, "cannot compare iterators of different containers", m_object));
         }
 
         // value-initialized forward iterators can be compared, and must compare equal to other value-initialized iterators of the same type #4493
@@ -528,16 +493,6 @@ class iter_impl // NOLINT(cppcoreguidelines-special-member-functions,hicpp-speci
             return true;
         }
 
-        if (JSON_HEDLEY_LIKELY(m_object->m_data.m_type == value_t::array))
-        {
-            return (m_it.array_iterator == other.m_it.array_iterator);
-        }
-
-        if (JSON_HEDLEY_LIKELY(m_object->m_data.m_type == value_t::object))
-        {
-            return (m_it.object_iterator == other.m_it.object_iterator);
-        }
-
         switch (m_object->m_data.m_type)
         {
             case value_t::object:

include/nlohmann/json.hpp

@@ -720,34 +720,6 @@ private:
             }
         }
 
-        // true if no child of the non-empty array/object v has children of
-        // its own, i.e. v can be freed in one go (its destructor then
-        // destroys scalars and empty containers only, so it recurses at most
-        // one level deep); stops at the first structured child it meets
-        static bool all_children_leaves(const basic_json& v) noexcept
-        {
-            if (v.m_data.m_type == value_t::array)
-            {
-                const auto& a = *v.m_data.m_value.array;
-                for (auto it = a.rbegin(); it != a.rend(); ++it)
-                {
-                    if (!has_no_children(*it))
-                    {
-                        return false;
-                    }
-                }
-                return true;
-            }
-            for (const auto& el : *v.m_data.m_value.object)
-            {
-                if (!has_no_children(el.second))
-                {
-                    return false;
-                }
-            }
-            return true;
-        }
-
         // The walk in destroy_container() may take the children of a
         // container in any order, as long as it picks the same child again
         // while that container is not modified in between. Arrays and
@@ -803,8 +775,7 @@ private:
             }
         }
 
-        // deallocates the array/object held by v (empty, or holding only scalars
-        // and empty containers); this is
+        // deallocates the (already empty) array/object held by v; this is
         // the same allocator-based free the old recursive implementation
         // used, just factored out so every level of the walk in destroy()
         // can share it
@@ -812,6 +783,7 @@ private:
         {
             if (v.m_data.m_type == value_t::array)
             {
+                JSON_ASSERT(v.m_data.m_value.array->empty());
                 AllocatorType<array_t> alloc;
                 std::allocator_traits<decltype(alloc)>::destroy(alloc, v.m_data.m_value.array);
                 std::allocator_traits<decltype(alloc)>::deallocate(alloc, v.m_data.m_value.array, 1);
@@ -819,6 +791,7 @@ private:
             else
             {
                 JSON_ASSERT(v.m_data.m_type == value_t::object);
+                JSON_ASSERT(v.m_data.m_value.object->empty());
                 AllocatorType<object_t> alloc;
                 std::allocator_traits<decltype(alloc)>::destroy(alloc, v.m_data.m_value.object);
                 std::allocator_traits<decltype(alloc)>::deallocate(alloc, v.m_data.m_value.object, 1);
@@ -894,17 +867,9 @@ public:
 
             basic_json prev; // value_t::null: no parent
 
-            // true right after cur was entered: its children have not been
-            // looked at yet. If none of them has children of its own, cur is
-            // freed in one go instead of child by child; this is tried once
-            // per container, so the walk stays linear.
-            bool fresh = true;
-
             while (true)
             {
-                const bool fresh_now = fresh;
-                fresh = false;
-                if (has_no_children(cur) || (fresh_now && all_children_leaves(cur)))
+                if (has_no_children(cur))
                 {
                     if (prev.m_data.m_type == value_t::null)
                     {
@@ -943,7 +908,6 @@ public:
                 take(cur_child_ref, prev);
                 take(prev, cur);
                 take(cur, tmp);
-                fresh = true;
             }
         }
 
@@ -6914,11 +6878,12 @@ public:
         std::size_t index = 0;
         /// objects: the next member of source to look at
         const_iterator member{}; // NOLINT(readability-redundant-member-init)
-        /// objects: for each member of source (in order), its value in
-        /// target, or nullptr if target has no such key; `index` is the next
-        std::vector<const basic_json*> target_values{}; // NOLINT(readability-redundant-member-init)
-        /// objects: the members only target has, in target's order
-        std::vector<const_iterator> added{}; // NOLINT(readability-redundant-member-init)
+        /// objects: the keys common to both, in source's order
+        std::vector<typename object_t::key_type> common_keys{}; // NOLINT(readability-redundant-member-init)
+        /// objects: the next entry of common_keys
+        std::size_t next_common = 0;
+        /// objects: the "add" operations for keys only target has
+        basic_json added_ops{}; // NOLINT(readability-redundant-member-init)
     };
 
     // The operations of a diff are built by the functions below rather than
@@ -6974,113 +6939,111 @@ public:
         }
     }
 
-    /// @brief appends the "add" operations for the members @a added to @a result
-    static void diff_added(basic_json& result, const std::vector<const_iterator>& added, const string_t& path)
-    {
-        for (const auto& it : added)
-        {
-            diff_add(result, detail::concat<string_t>(path, '/', detail::escape(it.key())), it.value());
-        }
-    }
-
     /*!
     @brief compare the keys of objects @a source and @a target
 
     If object_t does not keep its members in insertion order, or if the keys
     both objects have are in the same order in both, and the keys only
-    @a target has come after them, stores in @a target_values, for each member
-    of source in order, its value in target (nullptr for a key target does not
-    have), stores the members only target has in @a added, and returns true:
-    the caller then diffs the objects member by member. Otherwise, appends
-    operations that remove every member of @a source and add every member of
-    @a target to @a result, and returns false.
+    @a target has come after them, stores the keys common to both in
+    source's order in @a common_keys, stores the "add" operations for the keys
+    only @a target has in @a added_ops, and returns true: the caller then diffs
+    the objects member by member. Otherwise, appends operations that remove
+    every member of @a source and add every member of @a target to @a result,
+    and returns false.
     */
     static bool diff_object_keys(basic_json& result, const basic_json& source, const basic_json& target,
-                                 const string_t& path, std::vector<const basic_json*>& target_values,
-                                 std::vector<const_iterator>& added)
+                                 const string_t& path, std::vector<typename object_t::key_type>& common_keys,
+                                 basic_json& added_ops)
     {
-        // first pass: one lookup per source key
-        target_values.reserve(source.size());
-        std::size_t common = 0;
+        // first pass: record, for every source key, whether it is
+        // common to both objects (in source's iteration order) or
+        // was deleted (i.e., in source but not in target) -- this is
+        // a by-product of the target.find() call already needed to
+        // tell the two cases apart, so it adds no extra lookups. The
+        // "remove" ops themselves are emitted later, interleaved
+        // with the per-key diffs in the caller's fast path, to match
+        // source's original iteration order (as the original,
+        // pre-reordering-aware implementation did) instead of
+        // grouping all removes before all per-key diffs.
+        std::vector<typename object_t::key_type> common_keys_source_order;
         for (auto it = source.cbegin(); it != source.cend(); ++it)
         {
-            const auto found = target.find(it.key());
-            if (found != target.cend())
+            if (target.find(it.key()) != target.end())
             {
-                target_values.push_back(&found.value());
-                ++common;
-            }
-            else
-            {
-                target_values.push_back(nullptr);
+                common_keys_source_order.push_back(it.key());
             }
         }
 
-        // second pass: find the keys only target has. An object type that
-        // keeps its members in insertion order, such as the one backing
-        // ordered_json, also needs the common keys to be in the same order
-        // in both objects, and the new keys to come after them, as patch()
-        // appends a new member at the end of such an object. Any other
-        // object type places its members itself, so a member-by-member diff
-        // always reproduces target there.
+        // second pass: find keys that were added (i.e., in target but
+        // not in source), and record the keys common to both, in
+        // target's iteration order -- again a by-product of the
+        // source.find() call already needed to detect added keys. At
+        // the same time, determine whether every added key comes
+        // after every common key in target's order (a precondition
+        // for the fast path, which only ever appends new keys
+        // at the very end). Both are only needed for an object_t that
+        // keeps its members in insertion order, such as the one
+        // backing `ordered_json`; for any other object_t, the fast
+        // path is always taken and they are not computed.
+        // The patch ops for keys that were added (i.e., in target but not
+        // in source) are built here so the fast path can reuse
+        // them without a second source.find() per target key. Only
+        // used by the fast path -- the slow (reordering) path
+        // rebuilds "add" ops for every key itself.
+        std::vector<typename object_t::key_type> common_keys_target_order;
+        bool new_keys_form_suffix = true;
+        bool seen_new_key = false;
+        for (auto it = target.cbegin(); it != target.cend(); ++it)
+        {
+            if (source.find(it.key()) == source.end())
+            {
+                seen_new_key = true;
+                diff_add(added_ops, detail::concat<string_t>(path, '/', detail::escape(it.key())), it.value());
+            }
+            else
+            {
 #ifdef JSON_HEDLEY_MSVC_VERSION
 #pragma warning(push )
 #pragma warning(disable : 4127) // ignore warning to replace if with if constexpr
 #endif
-        bool fast_path = true;
-        if (detail::is_ordered_map<object_t>::value)
-        {
-            // walk the common keys of source in lockstep with target: a key
-            // of target that is not the next one is either new or out of order
-            auto src = source.cbegin();
-            std::size_t next = 0;
-            bool seen_new = false;
-            for (auto it = target.cbegin(); it != target.cend() && fast_path; ++it)
-            {
-                while (next < target_values.size() && target_values[next] == nullptr)
+                if (detail::is_ordered_map<object_t>::value)
                 {
-                    ++src;
-                    ++next;
-                }
-
-                if (next < target_values.size() && src.key() == it.key())
-                {
-                    // a common key after a new one: new keys are no suffix
-                    fast_path = !seen_new;
-                    ++src;
-                    ++next;
-                }
-                else if (source.find(it.key()) == source.cend())
-                {
-                    seen_new = true;
-                    added.push_back(it);
-                }
-                else
-                {
-                    // a common key out of order
-                    fast_path = false;
+                    common_keys_target_order.push_back(it.key());
+                    if (seen_new_key)
+                    {
+                        new_keys_form_suffix = false;
+                    }
                 }
+#ifdef JSON_HEDLEY_MSVC_VERSION
+#pragma warning( pop )
+#endif
             }
         }
-        else if (target.size() != common)
+
+        // Only an object type that keeps its members in insertion
+        // order, such as nlohmann::ordered_map, can need reordering:
+        // patch() appends a new member at the end of such an object.
+        // Any other object type places its members itself - std::map
+        // in key order, a hash map in an order its operator== ignores -
+        // so a member-by-member diff always reproduces target there.
+#ifdef JSON_HEDLEY_MSVC_VERSION
+#pragma warning(push )
+#pragma warning(disable : 4127) // ignore warning to replace if with if constexpr
+#endif
+        if (!detail::is_ordered_map<object_t>::value
+                || (common_keys_source_order == common_keys_target_order && new_keys_form_suffix))
         {
-            for (auto it = target.cbegin(); it != target.cend(); ++it)
-            {
-                if (source.find(it.key()) == source.cend())
-                {
-                    added.push_back(it);
-                }
-            }
+            // fast path: order of common keys already matches (or the
+            // object_t's iteration order does not depend on
+            // insertion history), so a plain per-key diff is correct
+            // and minimal, as before
+            common_keys = std::move(common_keys_source_order);
+            return true;
         }
 #ifdef JSON_HEDLEY_MSVC_VERSION
 #pragma warning( pop )
 #endif
 
-        if (fast_path)
-        {
-            return true;
-        }
-
         // slow path: the common keys are in a different relative
         // order in source and target (only possible for a
         // reorderable object_t like ordered_map). Building a
@@ -7130,14 +7093,6 @@ public:
             return;
         }
 
-        diff_unequal(result, source, target, path, depth);
-    }
-
-    /// @brief @ref diff_recursively for values known to be unequal; callers
-    ///        compare first so they build no path for equal ones
-    static void diff_unequal(basic_json& result, const basic_json& source, const basic_json& target,
-                             const string_t& path, const std::size_t depth)
-    {
         if (JSON_HEDLEY_UNLIKELY(depth >= detail::recursion_depth_limit()))
         {
             diff_iteratively(result, source, target, path);
@@ -7160,10 +7115,7 @@ public:
                 while (i < source.size() && i < target.size())
                 {
                     // recursive call to compare array values at index i
-                    if (!(source[i] == target[i]))
-                    {
-                        diff_unequal(result, source[i], target[i], detail::concat<string_t>(path, '/', detail::to_string<string_t>(i)), depth + 1);
-                    }
+                    diff_recursively(result, source[i], target[i], detail::concat<string_t>(path, '/', detail::to_string<string_t>(i)), depth + 1);
                     ++i;
                 }
 
@@ -7175,24 +7127,25 @@ public:
 
             case value_t::object:
             {
-                std::vector<const basic_json*> target_values;
-                std::vector<const_iterator> added;
-                if (diff_object_keys(result, source, target, path, target_values, added))
+                std::vector<typename object_t::key_type> common_keys;
+                basic_json added_ops(value_t::array);
+                if (diff_object_keys(result, source, target, path, common_keys, added_ops))
                 {
-                    // fast path: target_values holds, for every member of
-                    // source in order, its value in target -- so no further
-                    // lookup is needed. Deleted keys are interleaved here
-                    // too, in source's original order, to match the
+                    // fast path: common_keys is, by construction, the
+                    // subsequence of source's keys that are common to both
+                    // objects, in source's iteration order -- so it can be
+                    // walked in lockstep with `source` using a cheap key
+                    // comparison instead of another lookup. Deleted keys
+                    // (those source keys not in common_keys) are interleaved
+                    // here too, in source's original order, to match the
                     // historical (pre-reordering-aware) output order.
-                    std::size_t i = 0;
-                    for (auto it = source.cbegin(); it != source.cend(); ++it, ++i)
+                    auto common_it = common_keys.cbegin();
+                    for (auto it = source.cbegin(); it != source.cend(); ++it)
                     {
-                        if (target_values[i] != nullptr)
+                        if (common_it != common_keys.cend() && it.key() == *common_it)
                         {
-                            if (!(it.value() == *target_values[i]))
-                            {
-                                diff_unequal(result, it.value(), *target_values[i], detail::concat<string_t>(path, '/', detail::escape(it.key())), depth + 1);
-                            }
+                            diff_recursively(result, it.value(), target[it.key()], detail::concat<string_t>(path, '/', detail::escape(it.key())), depth + 1);
+                            ++common_it;
                         }
                         else
                         {
@@ -7201,8 +7154,10 @@ public:
                         }
                     }
 
-                    // append the "add" operations for brand-new keys
-                    diff_added(result, added, path);
+                    // append the "add" ops for brand-new keys collected by
+                    // diff_object_keys -- no second source.find() per target
+                    // key needed
+                    result.insert(result.end(), added_ops.begin(), added_ops.end());
                 }
                 break;
             }
@@ -7275,17 +7230,17 @@ public:
 
                 case value_t::object:
                 {
-                    std::vector<const basic_json*> target_values;
-                    std::vector<const_iterator> added;
-                    if (diff_object_keys(result, s, t, current_path, target_values, added))
+                    std::vector<typename object_t::key_type> common_keys;
+                    basic_json added_ops(value_t::array);
+                    if (diff_object_keys(result, s, t, current_path, common_keys, added_ops))
                     {
                         // fast path: the frame walks source in lockstep with
                         // common_keys, as diff_recursively does, and appends
                         // added_ops once all members are done
                         stack.emplace_back(&s, &t, current_path.size());
                         stack.back().member = s.cbegin();
-                        stack.back().target_values = std::move(target_values);
-                        stack.back().added = std::move(added);
+                        stack.back().common_keys = std::move(common_keys);
+                        stack.back().added_ops = std::move(added_ops);
                     }
                     return;
                 }
@@ -7347,10 +7302,11 @@ public:
                 if (it != s->cend())
                 {
                     ++stack.back().member;
-                    const basic_json* const target_value_ptr = stack.back().target_values[stack.back().index++];
-                    if (target_value_ptr != nullptr)
+                    const std::size_t next_common = stack.back().next_common;
+                    if (next_common < stack.back().common_keys.size() && it.key() == stack.back().common_keys[next_common])
                     {
-                        const basic_json& target_value = *target_value_ptr;
+                        ++stack.back().next_common;
+                        const basic_json& target_value = (*t)[it.key()];
                         detail::concat_into(current_path, '/', detail::escape(it.key()));
                         enter(it.value(), target_value);
                         if (stack.size() == depth)
@@ -7368,7 +7324,7 @@ public:
 
                 // append the "add" ops for brand-new keys collected when the
                 // object was entered
-                diff_added(result, stack.back().added, current_path);
+                result.insert(result.end(), stack.back().added_ops.begin(), stack.back().added_ops.end());
             }
 
             // this array or object is done: continue with the one it is in

single_include/nlohmann/json.hpp

@@ -19929,11 +19929,6 @@ class iter_impl // NOLINT(cppcoreguidelines-special-member-functions,hicpp-speci
     }
 
     /// @throw invalid_iterator.214 always
-    JSON_HEDLEY_NEVER_INLINE JSON_HEDLEY_NO_RETURN void throw_compare_different_values() const
-    {
-        JSON_THROW(invalid_iterator::create(exception_id::iterators_compare_different_values, "cannot compare iterators of different containers", m_object));
-    }
-
     JSON_HEDLEY_NO_RETURN void throw_cannot_get_value() const
     {
         JSON_THROW(invalid_iterator::create(exception_id::iterator_value_unavailable, "cannot get value", m_object));
@@ -19948,18 +19943,6 @@ class iter_impl // NOLINT(cppcoreguidelines-special-member-functions,hicpp-speci
     {
         JSON_ASSERT(m_object != nullptr);
 
-        if (JSON_HEDLEY_LIKELY(m_object->m_data.m_type == value_t::array))
-        {
-            JSON_ASSERT(m_it.array_iterator != m_object->m_data.m_value.array->end());
-            return *m_it.array_iterator;
-        }
-
-        if (JSON_HEDLEY_LIKELY(m_object->m_data.m_type == value_t::object))
-        {
-            JSON_ASSERT(m_it.object_iterator != m_object->m_data.m_value.object->end());
-            return m_it.object_iterator->second;
-        }
-
         switch (m_object->m_data.m_type)
         {
             case value_t::object:
@@ -20004,12 +19987,6 @@ class iter_impl // NOLINT(cppcoreguidelines-special-member-functions,hicpp-speci
     {
         JSON_ASSERT(m_object != nullptr);
 
-        if (JSON_HEDLEY_LIKELY(m_object->m_data.m_type == value_t::array))
-        {
-            JSON_ASSERT(m_it.array_iterator != m_object->m_data.m_value.array->end());
-            return &*m_it.array_iterator;
-        }
-
         switch (m_object->m_data.m_type)
         {
             case value_t::object:
@@ -20063,18 +20040,6 @@ class iter_impl // NOLINT(cppcoreguidelines-special-member-functions,hicpp-speci
     {
         JSON_ASSERT(m_object != nullptr);
 
-        if (JSON_HEDLEY_LIKELY(m_object->m_data.m_type == value_t::array))
-        {
-            ++m_it.array_iterator;
-            return *this;
-        }
-
-        if (JSON_HEDLEY_LIKELY(m_object->m_data.m_type == value_t::object))
-        {
-            std::advance(m_it.object_iterator, 1);
-            return *this;
-        }
-
         switch (m_object->m_data.m_type)
         {
             case value_t::object:
@@ -20168,7 +20133,7 @@ class iter_impl // NOLINT(cppcoreguidelines-special-member-functions,hicpp-speci
         // if objects are not the same, the comparison is undefined
         if (JSON_HEDLEY_UNLIKELY(m_object != other.m_object))
         {
-            throw_compare_different_values();
+            JSON_THROW(invalid_iterator::create(exception_id::iterators_compare_different_values, "cannot compare iterators of different containers", m_object));
         }
 
         // value-initialized forward iterators can be compared, and must compare equal to other value-initialized iterators of the same type #4493
@@ -20177,16 +20142,6 @@ class iter_impl // NOLINT(cppcoreguidelines-special-member-functions,hicpp-speci
             return true;
         }
 
-        if (JSON_HEDLEY_LIKELY(m_object->m_data.m_type == value_t::array))
-        {
-            return (m_it.array_iterator == other.m_it.array_iterator);
-        }
-
-        if (JSON_HEDLEY_LIKELY(m_object->m_data.m_type == value_t::object))
-        {
-            return (m_it.object_iterator == other.m_it.object_iterator);
-        }
-
         switch (m_object->m_data.m_type)
         {
             case value_t::object:
@@ -30113,34 +30068,6 @@ private:
             }
         }
 
-        // true if no child of the non-empty array/object v has children of
-        // its own, i.e. v can be freed in one go (its destructor then
-        // destroys scalars and empty containers only, so it recurses at most
-        // one level deep); stops at the first structured child it meets
-        static bool all_children_leaves(const basic_json& v) noexcept
-        {
-            if (v.m_data.m_type == value_t::array)
-            {
-                const auto& a = *v.m_data.m_value.array;
-                for (auto it = a.rbegin(); it != a.rend(); ++it)
-                {
-                    if (!has_no_children(*it))
-                    {
-                        return false;
-                    }
-                }
-                return true;
-            }
-            for (const auto& el : *v.m_data.m_value.object)
-            {
-                if (!has_no_children(el.second))
-                {
-                    return false;
-                }
-            }
-            return true;
-        }
-
         // The walk in destroy_container() may take the children of a
         // container in any order, as long as it picks the same child again
         // while that container is not modified in between. Arrays and
@@ -30196,8 +30123,7 @@ private:
             }
         }
 
-        // deallocates the array/object held by v (empty, or holding only scalars
-        // and empty containers); this is
+        // deallocates the (already empty) array/object held by v; this is
         // the same allocator-based free the old recursive implementation
         // used, just factored out so every level of the walk in destroy()
         // can share it
@@ -30205,6 +30131,7 @@ private:
         {
             if (v.m_data.m_type == value_t::array)
             {
+                JSON_ASSERT(v.m_data.m_value.array->empty());
                 AllocatorType<array_t> alloc;
                 std::allocator_traits<decltype(alloc)>::destroy(alloc, v.m_data.m_value.array);
                 std::allocator_traits<decltype(alloc)>::deallocate(alloc, v.m_data.m_value.array, 1);
@@ -30212,6 +30139,7 @@ private:
             else
             {
                 JSON_ASSERT(v.m_data.m_type == value_t::object);
+                JSON_ASSERT(v.m_data.m_value.object->empty());
                 AllocatorType<object_t> alloc;
                 std::allocator_traits<decltype(alloc)>::destroy(alloc, v.m_data.m_value.object);
                 std::allocator_traits<decltype(alloc)>::deallocate(alloc, v.m_data.m_value.object, 1);
@@ -30287,17 +30215,9 @@ public:
 
             basic_json prev; // value_t::null: no parent
 
-            // true right after cur was entered: its children have not been
-            // looked at yet. If none of them has children of its own, cur is
-            // freed in one go instead of child by child; this is tried once
-            // per container, so the walk stays linear.
-            bool fresh = true;
-
             while (true)
             {
-                const bool fresh_now = fresh;
-                fresh = false;
-                if (has_no_children(cur) || (fresh_now && all_children_leaves(cur)))
+                if (has_no_children(cur))
                 {
                     if (prev.m_data.m_type == value_t::null)
                     {
@@ -30336,7 +30256,6 @@ public:
                 take(cur_child_ref, prev);
                 take(prev, cur);
                 take(cur, tmp);
-                fresh = true;
             }
         }
 
@@ -36307,11 +36226,12 @@ public:
         std::size_t index = 0;
         /// objects: the next member of source to look at
         const_iterator member{}; // NOLINT(readability-redundant-member-init)
-        /// objects: for each member of source (in order), its value in
-        /// target, or nullptr if target has no such key; `index` is the next
-        std::vector<const basic_json*> target_values{}; // NOLINT(readability-redundant-member-init)
-        /// objects: the members only target has, in target's order
-        std::vector<const_iterator> added{}; // NOLINT(readability-redundant-member-init)
+        /// objects: the keys common to both, in source's order
+        std::vector<typename object_t::key_type> common_keys{}; // NOLINT(readability-redundant-member-init)
+        /// objects: the next entry of common_keys
+        std::size_t next_common = 0;
+        /// objects: the "add" operations for keys only target has
+        basic_json added_ops{}; // NOLINT(readability-redundant-member-init)
     };
 
     // The operations of a diff are built by the functions below rather than
@@ -36367,113 +36287,111 @@ public:
         }
     }
 
-    /// @brief appends the "add" operations for the members @a added to @a result
-    static void diff_added(basic_json& result, const std::vector<const_iterator>& added, const string_t& path)
-    {
-        for (const auto& it : added)
-        {
-            diff_add(result, detail::concat<string_t>(path, '/', detail::escape(it.key())), it.value());
-        }
-    }
-
     /*!
     @brief compare the keys of objects @a source and @a target
 
     If object_t does not keep its members in insertion order, or if the keys
     both objects have are in the same order in both, and the keys only
-    @a target has come after them, stores in @a target_values, for each member
-    of source in order, its value in target (nullptr for a key target does not
-    have), stores the members only target has in @a added, and returns true:
-    the caller then diffs the objects member by member. Otherwise, appends
-    operations that remove every member of @a source and add every member of
-    @a target to @a result, and returns false.
+    @a target has come after them, stores the keys common to both in
+    source's order in @a common_keys, stores the "add" operations for the keys
+    only @a target has in @a added_ops, and returns true: the caller then diffs
+    the objects member by member. Otherwise, appends operations that remove
+    every member of @a source and add every member of @a target to @a result,
+    and returns false.
     */
     static bool diff_object_keys(basic_json& result, const basic_json& source, const basic_json& target,
-                                 const string_t& path, std::vector<const basic_json*>& target_values,
-                                 std::vector<const_iterator>& added)
+                                 const string_t& path, std::vector<typename object_t::key_type>& common_keys,
+                                 basic_json& added_ops)
     {
-        // first pass: one lookup per source key
-        target_values.reserve(source.size());
-        std::size_t common = 0;
+        // first pass: record, for every source key, whether it is
+        // common to both objects (in source's iteration order) or
+        // was deleted (i.e., in source but not in target) -- this is
+        // a by-product of the target.find() call already needed to
+        // tell the two cases apart, so it adds no extra lookups. The
+        // "remove" ops themselves are emitted later, interleaved
+        // with the per-key diffs in the caller's fast path, to match
+        // source's original iteration order (as the original,
+        // pre-reordering-aware implementation did) instead of
+        // grouping all removes before all per-key diffs.
+        std::vector<typename object_t::key_type> common_keys_source_order;
         for (auto it = source.cbegin(); it != source.cend(); ++it)
         {
-            const auto found = target.find(it.key());
-            if (found != target.cend())
+            if (target.find(it.key()) != target.end())
             {
-                target_values.push_back(&found.value());
-                ++common;
-            }
-            else
-            {
-                target_values.push_back(nullptr);
+                common_keys_source_order.push_back(it.key());
             }
         }
 
-        // second pass: find the keys only target has. An object type that
-        // keeps its members in insertion order, such as the one backing
-        // ordered_json, also needs the common keys to be in the same order
-        // in both objects, and the new keys to come after them, as patch()
-        // appends a new member at the end of such an object. Any other
-        // object type places its members itself, so a member-by-member diff
-        // always reproduces target there.
+        // second pass: find keys that were added (i.e., in target but
+        // not in source), and record the keys common to both, in
+        // target's iteration order -- again a by-product of the
+        // source.find() call already needed to detect added keys. At
+        // the same time, determine whether every added key comes
+        // after every common key in target's order (a precondition
+        // for the fast path, which only ever appends new keys
+        // at the very end). Both are only needed for an object_t that
+        // keeps its members in insertion order, such as the one
+        // backing `ordered_json`; for any other object_t, the fast
+        // path is always taken and they are not computed.
+        // The patch ops for keys that were added (i.e., in target but not
+        // in source) are built here so the fast path can reuse
+        // them without a second source.find() per target key. Only
+        // used by the fast path -- the slow (reordering) path
+        // rebuilds "add" ops for every key itself.
+        std::vector<typename object_t::key_type> common_keys_target_order;
+        bool new_keys_form_suffix = true;
+        bool seen_new_key = false;
+        for (auto it = target.cbegin(); it != target.cend(); ++it)
+        {
+            if (source.find(it.key()) == source.end())
+            {
+                seen_new_key = true;
+                diff_add(added_ops, detail::concat<string_t>(path, '/', detail::escape(it.key())), it.value());
+            }
+            else
+            {
 #ifdef JSON_HEDLEY_MSVC_VERSION
 #pragma warning(push )
 #pragma warning(disable : 4127) // ignore warning to replace if with if constexpr
 #endif
-        bool fast_path = true;
-        if (detail::is_ordered_map<object_t>::value)
-        {
-            // walk the common keys of source in lockstep with target: a key
-            // of target that is not the next one is either new or out of order
-            auto src = source.cbegin();
-            std::size_t next = 0;
-            bool seen_new = false;
-            for (auto it = target.cbegin(); it != target.cend() && fast_path; ++it)
-            {
-                while (next < target_values.size() && target_values[next] == nullptr)
+                if (detail::is_ordered_map<object_t>::value)
                 {
-                    ++src;
-                    ++next;
-                }
-
-                if (next < target_values.size() && src.key() == it.key())
-                {
-                    // a common key after a new one: new keys are no suffix
-                    fast_path = !seen_new;
-                    ++src;
-                    ++next;
-                }
-                else if (source.find(it.key()) == source.cend())
-                {
-                    seen_new = true;
-                    added.push_back(it);
-                }
-                else
-                {
-                    // a common key out of order
-                    fast_path = false;
+                    common_keys_target_order.push_back(it.key());
+                    if (seen_new_key)
+                    {
+                        new_keys_form_suffix = false;
+                    }
                 }
+#ifdef JSON_HEDLEY_MSVC_VERSION
+#pragma warning( pop )
+#endif
             }
         }
-        else if (target.size() != common)
+
+        // Only an object type that keeps its members in insertion
+        // order, such as nlohmann::ordered_map, can need reordering:
+        // patch() appends a new member at the end of such an object.
+        // Any other object type places its members itself - std::map
+        // in key order, a hash map in an order its operator== ignores -
+        // so a member-by-member diff always reproduces target there.
+#ifdef JSON_HEDLEY_MSVC_VERSION
+#pragma warning(push )
+#pragma warning(disable : 4127) // ignore warning to replace if with if constexpr
+#endif
+        if (!detail::is_ordered_map<object_t>::value
+                || (common_keys_source_order == common_keys_target_order && new_keys_form_suffix))
         {
-            for (auto it = target.cbegin(); it != target.cend(); ++it)
-            {
-                if (source.find(it.key()) == source.cend())
-                {
-                    added.push_back(it);
-                }
-            }
+            // fast path: order of common keys already matches (or the
+            // object_t's iteration order does not depend on
+            // insertion history), so a plain per-key diff is correct
+            // and minimal, as before
+            common_keys = std::move(common_keys_source_order);
+            return true;
         }
 #ifdef JSON_HEDLEY_MSVC_VERSION
 #pragma warning( pop )
 #endif
 
-        if (fast_path)
-        {
-            return true;
-        }
-
         // slow path: the common keys are in a different relative
         // order in source and target (only possible for a
         // reorderable object_t like ordered_map). Building a
@@ -36523,14 +36441,6 @@ public:
             return;
         }
 
-        diff_unequal(result, source, target, path, depth);
-    }
-
-    /// @brief @ref diff_recursively for values known to be unequal; callers
-    ///        compare first so they build no path for equal ones
-    static void diff_unequal(basic_json& result, const basic_json& source, const basic_json& target,
-                             const string_t& path, const std::size_t depth)
-    {
         if (JSON_HEDLEY_UNLIKELY(depth >= detail::recursion_depth_limit()))
         {
             diff_iteratively(result, source, target, path);
@@ -36553,10 +36463,7 @@ public:
                 while (i < source.size() && i < target.size())
                 {
                     // recursive call to compare array values at index i
-                    if (!(source[i] == target[i]))
-                    {
-                        diff_unequal(result, source[i], target[i], detail::concat<string_t>(path, '/', detail::to_string<string_t>(i)), depth + 1);
-                    }
+                    diff_recursively(result, source[i], target[i], detail::concat<string_t>(path, '/', detail::to_string<string_t>(i)), depth + 1);
                     ++i;
                 }
 
@@ -36568,24 +36475,25 @@ public:
 
             case value_t::object:
             {
-                std::vector<const basic_json*> target_values;
-                std::vector<const_iterator> added;
-                if (diff_object_keys(result, source, target, path, target_values, added))
+                std::vector<typename object_t::key_type> common_keys;
+                basic_json added_ops(value_t::array);
+                if (diff_object_keys(result, source, target, path, common_keys, added_ops))
                 {
-                    // fast path: target_values holds, for every member of
-                    // source in order, its value in target -- so no further
-                    // lookup is needed. Deleted keys are interleaved here
-                    // too, in source's original order, to match the
+                    // fast path: common_keys is, by construction, the
+                    // subsequence of source's keys that are common to both
+                    // objects, in source's iteration order -- so it can be
+                    // walked in lockstep with `source` using a cheap key
+                    // comparison instead of another lookup. Deleted keys
+                    // (those source keys not in common_keys) are interleaved
+                    // here too, in source's original order, to match the
                     // historical (pre-reordering-aware) output order.
-                    std::size_t i = 0;
-                    for (auto it = source.cbegin(); it != source.cend(); ++it, ++i)
+                    auto common_it = common_keys.cbegin();
+                    for (auto it = source.cbegin(); it != source.cend(); ++it)
                     {
-                        if (target_values[i] != nullptr)
+                        if (common_it != common_keys.cend() && it.key() == *common_it)
                         {
-                            if (!(it.value() == *target_values[i]))
-                            {
-                                diff_unequal(result, it.value(), *target_values[i], detail::concat<string_t>(path, '/', detail::escape(it.key())), depth + 1);
-                            }
+                            diff_recursively(result, it.value(), target[it.key()], detail::concat<string_t>(path, '/', detail::escape(it.key())), depth + 1);
+                            ++common_it;
                         }
                         else
                         {
@@ -36594,8 +36502,10 @@ public:
                         }
                     }
 
-                    // append the "add" operations for brand-new keys
-                    diff_added(result, added, path);
+                    // append the "add" ops for brand-new keys collected by
+                    // diff_object_keys -- no second source.find() per target
+                    // key needed
+                    result.insert(result.end(), added_ops.begin(), added_ops.end());
                 }
                 break;
             }
@@ -36668,17 +36578,17 @@ public:
 
                 case value_t::object:
                 {
-                    std::vector<const basic_json*> target_values;
-                    std::vector<const_iterator> added;
-                    if (diff_object_keys(result, s, t, current_path, target_values, added))
+                    std::vector<typename object_t::key_type> common_keys;
+                    basic_json added_ops(value_t::array);
+                    if (diff_object_keys(result, s, t, current_path, common_keys, added_ops))
                     {
                         // fast path: the frame walks source in lockstep with
                         // common_keys, as diff_recursively does, and appends
                         // added_ops once all members are done
                         stack.emplace_back(&s, &t, current_path.size());
                         stack.back().member = s.cbegin();
-                        stack.back().target_values = std::move(target_values);
-                        stack.back().added = std::move(added);
+                        stack.back().common_keys = std::move(common_keys);
+                        stack.back().added_ops = std::move(added_ops);
                     }
                     return;
                 }
@@ -36740,10 +36650,11 @@ public:
                 if (it != s->cend())
                 {
                     ++stack.back().member;
-                    const basic_json* const target_value_ptr = stack.back().target_values[stack.back().index++];
-                    if (target_value_ptr != nullptr)
+                    const std::size_t next_common = stack.back().next_common;
+                    if (next_common < stack.back().common_keys.size() && it.key() == stack.back().common_keys[next_common])
                     {
-                        const basic_json& target_value = *target_value_ptr;
+                        ++stack.back().next_common;
+                        const basic_json& target_value = (*t)[it.key()];
                         detail::concat_into(current_path, '/', detail::escape(it.key()));
                         enter(it.value(), target_value);
                         if (stack.size() == depth)
@@ -36761,7 +36672,7 @@ public:
 
                 // append the "add" ops for brand-new keys collected when the
                 // object was entered
-                diff_added(result, stack.back().added, current_path);
+                result.insert(result.end(), stack.back().added_ops.begin(), stack.back().added_ops.end());
             }
 
             // this array or object is done: continue with the one it is in

tests/src/unit-guard-page.cpp

@@ -0,0 +1,447 @@
+//     __ _____ _____ _____
+//  __|  |   __|     |   | |  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
+
+// The fast paths for contiguous input (bulk string scanning, SWAR searches,
+// UTF-8 prefix validation, the 8-digit number loop, the 8-byte indentation
+// skip, the BSON/BON8 bulk string readers) load several bytes at a time. This
+// test places every input directly in front of (or directly behind) an
+// inaccessible page, so reading even one byte outside the input crashes, with
+// or without sanitizers. ASan alone misses over-reads into the slack of the
+// same heap allocation.
+
+#include "doctest_compatibility.h"
+
+#include <nlohmann/json.hpp>
+using nlohmann::json;
+
+#include <cstdint>
+#include <cstring>
+#include <string>
+#include <utility>
+#include <vector>
+
+#if defined(_WIN32)
+    #define JSON_TEST_GUARD_PAGE_WINDOWS
+    #ifndef NOMINMAX
+        #define NOMINMAX
+    #endif
+    #ifndef WIN32_LEAN_AND_MEAN
+        #define WIN32_LEAN_AND_MEAN
+    #endif
+    #include <windows.h>
+#elif defined(__unix__) || defined(__APPLE__)
+    #define JSON_TEST_GUARD_PAGE_POSIX
+    #include <sys/mman.h>
+    #include <unistd.h>
+#endif
+
+#if defined(JSON_TEST_GUARD_PAGE_WINDOWS) || defined(JSON_TEST_GUARD_PAGE_POSIX)
+
+namespace
+{
+// Three pages: an inaccessible one, a readable one, an inaccessible one. An
+// input is copied either to the end of the middle page (any read past its last
+// byte faults) or to its start (any read before its first byte faults).
+class guarded_buffer
+{
+  public:
+    guarded_buffer()
+        : page(page_size())
+    {
+#if defined(JSON_TEST_GUARD_PAGE_WINDOWS)
+        void* const p = VirtualAlloc(nullptr, 3 * page, MEM_RESERVE | MEM_COMMIT, PAGE_NOACCESS);
+        REQUIRE(p != nullptr);
+        base = static_cast<unsigned char*>(p);
+        DWORD old_protect = 0;
+        REQUIRE(VirtualProtect(base + page, page, PAGE_READWRITE, &old_protect) != 0);
+#else
+        void* const p = mmap(nullptr, 3 * page, PROT_NONE, MAP_PRIVATE | MAP_ANON, -1, 0);
+        REQUIRE(p != MAP_FAILED);
+        base = static_cast<unsigned char*>(p);
+        REQUIRE(mprotect(base + page, page, PROT_READ | PROT_WRITE) == 0);
+#endif
+    }
+
+    ~guarded_buffer()
+    {
+#if defined(JSON_TEST_GUARD_PAGE_WINDOWS)
+        VirtualFree(base, 0, MEM_RELEASE);
+#else
+        munmap(base, 3 * page);
+#endif
+    }
+
+    guarded_buffer(const guarded_buffer&) = delete;
+    guarded_buffer& operator=(const guarded_buffer&) = delete;
+    guarded_buffer(guarded_buffer&&) = delete;
+    guarded_buffer& operator=(guarded_buffer&&) = delete;
+
+    // copies @a input so its last byte is the last readable byte
+    const std::uint8_t* at_end(const std::string& input)
+    {
+        REQUIRE(input.size() <= page);
+        unsigned char* const first = base + (2 * page) - input.size();
+        std::memcpy(first, input.data(), input.size());
+        return first;
+    }
+
+    // copies @a input so its first byte is the first readable byte
+    const std::uint8_t* at_start(const std::string& input)
+    {
+        REQUIRE(input.size() <= page);
+        unsigned char* const first = base + page;
+        std::memcpy(first, input.data(), input.size());
+        return first;
+    }
+
+  private:
+    static std::size_t page_size()
+    {
+#if defined(JSON_TEST_GUARD_PAGE_WINDOWS)
+        SYSTEM_INFO info;
+        GetSystemInfo(&info);
+        return static_cast<std::size_t>(info.dwPageSize);
+#else
+        return static_cast<std::size_t>(sysconf(_SC_PAGESIZE));
+#endif
+    }
+
+    std::size_t page = 0;
+    unsigned char* base = nullptr;
+};
+
+// the serialization of the result of @a f, or the exception message; @a f
+// takes the allow_exceptions flag, which is false without exceptions, where
+// an error yields a discarded value instead
+template<typename F>
+std::string outcome(F f)
+{
+#if defined(JSON_NOEXCEPTION)
+    return "value: " + f(false).dump(-1, ' ', false, json::error_handler_t::keep);
+#else
+    try
+    {
+        return "value: " + f(true).dump(-1, ' ', false, json::error_handler_t::keep);
+    }
+    catch (const json::exception& e)
+    {
+        return std::string("error: ") + e.what();
+    }
+#endif
+}
+
+// a SAX handler that only counts events, so sax_parse runs without a DOM
+struct counting_sax : nlohmann::json_sax<json>
+{
+    std::size_t events = 0;
+    std::string error{}; // NOLINT(readability-redundant-member-init)
+
+    bool null() override
+    {
+        return count();
+    }
+    bool boolean(bool /*val*/) override
+    {
+        return count();
+    }
+    bool number_integer(number_integer_t /*val*/) override
+    {
+        return count();
+    }
+    bool number_unsigned(number_unsigned_t /*val*/) override
+    {
+        return count();
+    }
+    bool number_float(number_float_t /*val*/, const string_t& /*s*/) override
+    {
+        return count();
+    }
+    bool string(string_t& /*val*/) override
+    {
+        return count();
+    }
+    bool binary(binary_t& /*val*/) override
+    {
+        return count();
+    }
+    bool start_object(std::size_t /*elements*/) override
+    {
+        return count();
+    }
+    bool key(string_t& /*val*/) override
+    {
+        return count();
+    }
+    bool end_object() override
+    {
+        return count();
+    }
+    bool start_array(std::size_t /*elements*/) override
+    {
+        return count();
+    }
+    bool end_array() override
+    {
+        return count();
+    }
+    bool parse_error(std::size_t position, const std::string& /*last_token*/, const nlohmann::detail::exception& ex) override
+    {
+        error = std::to_string(position) + " " + ex.what();
+        return false;
+    }
+
+  private:
+    bool count()
+    {
+        ++events;
+        return true;
+    }
+};
+
+// all prefixes of each seed, so the input ends at every byte of it
+std::vector<std::string> all_prefixes(const std::vector<std::string>& seeds)
+{
+    std::vector<std::string> result;
+    for (const auto& seed : seeds)
+    {
+        for (std::size_t n = 0; n <= seed.size(); ++n)
+        {
+            result.push_back(seed.substr(0, n));
+        }
+    }
+    return result;
+}
+
+std::vector<std::string> json_seeds()
+{
+    std::vector<std::string> seeds =
+    {
+        // string runs: ASCII, escapes, \u escapes, surrogate pairs
+        "\"abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ\"",
+        R"("ab\ncd\"ef\\gh\u00e4ij\uD83D\uDE00kl\u12")",
+        // 2-, 3- and 4-byte UTF-8 sequences, then invalid UTF-8
+        std::string("\"\xC3\xA4\xE2\x82\xAC\xF0\x9F\x98\x80\xC3\xA4\xE2\x82\xAC\xF0\x9F\x98\x80") + "abcdefgh\"",
+        "\"abcdefgh\xC3\x28 \xED\xA0\x80 \xF4\x90\x80\x80 \xF8 \xC0\xAF\"",
+        std::string("\"abcdefg\x01") + "abcdefgh\"",
+        // numbers, so the 8-digit loop runs up to the end
+        "12345678",
+        "1234567890123456",
+        "12345678901234567890123",
+        "-0.000000001234567890123456789",
+        "3.14159265358979323846264338327950288e+100",
+        "-1.2345678901234567e-12",
+        "1E-5",
+        "[1.5,2e10,-3E-5,0.000000001,123456789012345678]",
+        // literals
+        "[true,false,null]",
+        // comments (only parsed with ignore_comments)
+        "/* comment */ [1, // line comment\n 2] /**/",
+        // a pretty-printed document
+        json::parse(R"({"a": [1, 2.5, "three", {"b": null, "c": [true, false]}], "d": {"e": {"f": {"g": "h"}}}})").dump(4),
+        json::parse(R"({"a": [1, 2.5, "three", {"b": null, "c": [true, false]}], "d": {"e": {"f": {"g": "h"}}}})").dump(8, '\t'),
+    };
+
+    // indentation runs of every length, with and without a closing bracket
+    for (std::size_t n = 0; n <= 20; ++n)
+    {
+        seeds.push_back("[\n" + std::string(n, ' ') + "1,\n" + std::string(n, ' ') + "2\n]");
+    }
+
+    return all_prefixes(seeds);
+}
+
+// a value whose binary serializations contain long strings and keys, numbers
+// of every width, and nested containers
+json binary_document()
+{
+    json j;
+    j["a key that is longer than eight bytes"] = "a string value that is longer than eight bytes";
+    j["\xC3\xA4\xE2\x82\xAC\xF0\x9F\x98\x80"] = "\xF0\x9F\x98\x80\xE2\x82\xAC\xC3\xA4 utf-8 0123456789";
+    j["numbers"] = {0, 1, -1, 255, -256, 65536, -2147483649LL, 4294967296ULL, 1.5, -2.25e100};
+    j["nested"] = {{"x", {{"y", {true, false, nullptr}}}}};
+    j["s"] = "";
+    return j;
+}
+
+// readers for check_binary(), callable with a container or an iterator range
+// followed by the allow_exceptions flag
+#define JSON_TEST_GUARD_PAGE_READER(name, from)                                     \
+    struct name                                                                     \
+    {                                                                               \
+        template<typename... Args>                                                  \
+        json operator()(bool allow_exceptions, Args&& ... args) const               \
+        {                                                                           \
+            return json::from(std::forward<Args>(args)..., true, allow_exceptions); \
+        }                                                                           \
+    };
+JSON_TEST_GUARD_PAGE_READER(read_bson, from_bson)
+JSON_TEST_GUARD_PAGE_READER(read_bon8, from_bon8)
+JSON_TEST_GUARD_PAGE_READER(read_cbor, from_cbor)
+JSON_TEST_GUARD_PAGE_READER(read_msgpack, from_msgpack)
+JSON_TEST_GUARD_PAGE_READER(read_ubjson, from_ubjson)
+JSON_TEST_GUARD_PAGE_READER(read_bjdata, from_bjdata)
+#undef JSON_TEST_GUARD_PAGE_READER
+
+// reads every prefix of @a bytes at both ends of the guarded page and from a
+// std::string, which must give the same outcome
+template<typename Reader>
+void check_binary(guarded_buffer& guard, const std::vector<std::uint8_t>& bytes, Reader parse)
+{
+    for (const auto& input : all_prefixes({std::string(bytes.begin(), bytes.end())}))
+    {
+        CAPTURE(input)
+        const std::string expected = outcome([&](bool allow)
+        {
+            return parse(allow, input);
+        });
+        for (int placement = 0; placement < 2; ++placement)
+        {
+            const std::uint8_t* const first = placement == 0 ? guard.at_end(input) : guard.at_start(input);
+            CHECK(outcome([&](bool allow)
+            {
+                return parse(allow, first, first + input.size());
+            }) == expected);
+        }
+    }
+}
+} // namespace
+
+TEST_CASE("guard page")
+{
+    guarded_buffer guard;
+
+    SECTION("string scanning")
+    {
+        // fills that drive each function to a different stop
+        const std::vector<std::string> fills =
+        {
+            std::string(64, 'a'),
+            std::string(64, '"'),
+            std::string(64, '\\'),
+            std::string(64, '\x01'),
+            std::string(64, '\x7F'),
+            std::string(64, '\xFF'),
+        };
+        std::vector<std::string> patterns = fills;
+        {
+            std::string utf8;
+            while (utf8.size() < 64)
+            {
+                utf8 += "\xC3\xA4\xE2\x82\xAC\xF0\x9F\x98\x80" "ab";
+            }
+            patterns.push_back(utf8);
+        }
+        {
+            std::string bytes;
+            for (unsigned int i = 0; i < 64; ++i)
+            {
+                bytes.push_back(static_cast<char>((i * 37u) & 0xFFu));
+            }
+            patterns.push_back(bytes);
+        }
+
+        for (const auto& pattern : patterns)
+        {
+            for (std::size_t n = 0; n <= 64; ++n)
+            {
+                const std::string input = pattern.substr(0, n);
+                for (int placement = 0; placement < 2; ++placement)
+                {
+                    const unsigned char* const p = placement == 0 ? guard.at_end(input) : guard.at_start(input);
+
+                    CHECK(nlohmann::detail::find_string_special(p, n) <= n);
+                    CHECK(nlohmann::detail::find_ascii_copyable_run(p, n) <= n);
+                    CHECK(nlohmann::detail::valid_utf8_prefix(p, n) <= n);
+#if defined(JSON_USE_SIMDUTF) && defined(JSON_HAS_CPP_17)
+                    CHECK(nlohmann::detail::find_string_delimiter(p, n) <= n);
+#endif
+                    CHECK(nlohmann::detail::string_bulk_run(p, n) <= n);
+                    CHECK(nlohmann::detail::scalar_string_bulk_run(p, n) <= n);
+                    for (std::size_t i = 0; i < n; ++i)
+                    {
+                        CHECK(nlohmann::detail::validate_one_utf8(p + i, n - i) <= n - i);
+                    }
+                }
+            }
+        }
+    }
+
+    SECTION("Eisel-Lemire")
+    {
+        const std::vector<std::string> numbers = all_prefixes(
+        {
+            "1234567812345678123456781234567812345678",
+            "-1.2345678901234567890123456789e-123",
+            "0.00000000000000000000000000000000000001",
+            "98765432.10987654",
+        });
+        for (const auto& number : numbers)
+        {
+            double out = 0;
+            const char* const end = reinterpret_cast<const char*>(guard.at_end(number));
+            static_cast<void>(nlohmann::detail::parse_float_eisel_lemire(end, end + number.size(), out));
+            const char* const start = reinterpret_cast<const char*>(guard.at_start(number));
+            static_cast<void>(nlohmann::detail::parse_float_eisel_lemire(start, start + number.size(), out));
+        }
+    }
+
+    SECTION("JSON")
+    {
+        for (const auto& input : json_seeds())
+        {
+            CAPTURE(input)
+            const std::string expected = outcome([&](bool allow)
+            {
+                return json::parse(input, nullptr, allow);
+            });
+            const std::string expected_comments = outcome([&](bool allow)
+            {
+                return json::parse(input, nullptr, allow, true);
+            });
+            const bool expected_accept = json::accept(input);
+            counting_sax expected_sax;
+            const bool expected_sax_result = json::sax_parse(input, &expected_sax);
+
+            for (int placement = 0; placement < 2; ++placement)
+            {
+                const std::uint8_t* const first = placement == 0 ? guard.at_end(input) : guard.at_start(input);
+                const std::uint8_t* const last = first + input.size();
+
+                CHECK(outcome([&](bool allow)
+                {
+                    return json::parse(first, last, nullptr, allow);
+                }) == expected);
+                CHECK(outcome([&](bool allow)
+                {
+                    return json::parse(first, last, nullptr, allow, true);
+                }) == expected_comments);
+                CHECK(json::accept(first, last) == expected_accept);
+
+                counting_sax sax;
+                CHECK(json::sax_parse(first, last, &sax) == expected_sax_result);
+                CHECK(sax.events == expected_sax.events);
+                CHECK(sax.error == expected_sax.error);
+            }
+        }
+    }
+
+    SECTION("binary formats")
+    {
+        // every prefix ends inside a value, e.g., inside a BSON key or BON8
+        // string without its terminator
+        const json j = binary_document();
+        check_binary(guard, json::to_bson(j), read_bson());
+        check_binary(guard, json::to_bon8(j), read_bon8());
+        check_binary(guard, json::to_cbor(j), read_cbor());
+        check_binary(guard, json::to_msgpack(j), read_msgpack());
+        check_binary(guard, json::to_ubjson(j), read_ubjson());
+        check_binary(guard, json::to_bjdata(j), read_bjdata());
+    }
+}
+
+#endif