diff --git a/doc/qbk/comparison.qbk b/doc/qbk/comparison.qbk
index 5ed80b5b..71ef1af2 100644
--- a/doc/qbk/comparison.qbk
+++ b/doc/qbk/comparison.qbk
@@ -10,14 +10,6 @@
 [section:comparison Comparison to Other Libraries]
 [block'''<?dbhtml stop-chunking?>''']
 
-We use these criteria for evaluating a library's JSON container (the
-"value type") for suitability as a vocabulary type:
-
-* The value type declaration is completely decoupled
-  from other facilities such as parsing and serialization.
-
-* The value type is not a class template
-
 [/-----------------------------------------------------------------------------]
 
 [heading Comparison to nlohmann JSON]
@@ -46,8 +38,16 @@ class basic_json
 
 ```
 
+This library adopts a "kitchen sink" approach. It contains a great many
+features, even those which have niche uses. Its weakness is that the
+many template parameters, while allowing for configurability, inhibit
+the best possible optimizations. The consequence is that the library
+performs poorly. The ability to configure every aspect of the value
+type has the paradoxical effect of making it less suitable as a
+vocabulary type.
+
 * __bad__ `basic_json` is a class template. Libraries must agree on
-  all the template parameters to be fully interoperable.
+  the choices of template parameters to be interoperable.
 
 * __bad__ Too much customization. We struggle to see a use case for
   making `BooleanType` anything other than `bool`.
@@ -61,7 +61,7 @@ class basic_json
 
 * __bad__ No incremental parsing, no incremental serialization.
 
-* __bad__ Mediocre parsing performance.
+* __bad__ Slow parsing and serialization performance.
 
 * __good__ Full-featured, including JSON Pointer, CBOR, and others.
 
@@ -82,84 +82,20 @@ template <bool Const, typename ValueT>
 class GenericObject;
 ```
 
-* __bad__ The value type is a class template.
+* __bad__ The value type is not regular.
 
-* __bad__ The value type is not __CopyConstructible__
+* __bad__ Object types have no hash table or index to reduce
+  the cost of lookups.
+
+* __bad__ Allocators have reference semantics. Problems with
+  lifetime are easily encountered.
 
 * __bad__ The interface of the array and object types are considerably
   different from their standard library equivalents, and not idiomatic.
 
 * __bad__ No incremental parsing, no incremental serialization.
 
-* __good__ Parsing performance is excellent.
-
-[/-----------------------------------------------------------------------------]
-
-[heading Comparison to TaoCPP JSON]
-
-* Value Type: [@https://github.com/taocpp/json/blob/e0944b3b2686a6b9749c16dd06f72445bf7eef0a/include/tao/json/basic_value.hpp#L38 `tao::json::basic_value`]
-
-*https://github.com/taocpp/json
-
-```
-template< template< typename... > class Traits >
-class basic_value
-{
-    ...
-public:
-    using array_t = std::vector< basic_value >;
-    using object_t = std::map< std::string, basic_value, std::less<> >;
-...
-```
-
-The `basic_value` type uses the `Traits` as a template parameter, where the
-traits provide specializations to convert each supported native or user defined
-type to and from JSON. This makes the value type unsuitable as a vocabulary
-type because the traits for a `basic_value` exported by two different
-libraries which each has added support for their own types, are not the same.
-
-* __bad__ C++17 or later is required.
-
-* __bad__ No allocator support.
-
-* __bad__ The value type is a class template.
-
-* __bad__ The array and object container interfaces change
-  depending on which version of the standard C++ library is used.
-
-* __bad__ The performance of the library changes significantly
-  depending on which version of the standard library is used.
-
-* __bad__ Parsing performance is the worst surveyed, by a large margin.
-
-* __bad__ No incremental parsing, no incremental serialization.
-
-[/-----------------------------------------------------------------------------]
-
-[heading Comparison to JSONCPP]
-
-* Value Type: [@https://github.com/open-source-parsers/jsoncpp/blob/41ffff01d39085222280791a23451d3e852b06c2/include/json/value.h#L188 `Json::Value`]
-
-[/-----------------------------------------------------------------------------]
-
-[heading Comparison to Ciere Labs json_spirit]
-
-* Value Type: [@https://github.com/cierelabs/json_spirit/blob/e885dc55054bf0e6ef250322923396aed4c3ece7/ciere/json/value.hpp#L72 `ciere::json::value`]
-
-
-```
-   typedef std::string                                  string_t;
-   typedef std::map<std::string, value>                 object_t;
-   typedef std::pair<std::string, value>                object_member_t;
-   typedef boost::container::stable_vector<value>       array_t;
-
-   class value : public boost::spirit::extended_variant<
-        null_t, bool_t, string_t, int_t, double_t, object_t, array_t>
-        { ... };
-
-```
-
-* No allocator support.
+* __good__ Parsing and serialization performance is best-in-class.
 
 [/-----------------------------------------------------------------------------]
 
@@ -176,38 +112,11 @@ with the SIMD parser. It makes very good design choices for the intended
 use-case. However it is not well suited as a vocabulary type due to the
 necessary limitations.
 
-* Read-only
-* Sequential access only, via `ParsedJson::BasicIterator`
-* Can only be realistically populated by the provided SIMD JSON parser.
+* __bad__ Sequential access only, via `ParsedJson::BasicIterator`
 
-[/-----------------------------------------------------------------------------]
+* __bad__ Read-only, can only be populated by the provided SIMD JSON parser.
 
-[heading Comparison to trial.protocol]
-
-https://github.com/breese/trial.protocol
-
-```
-template <template <typename> class Allocator>
-class basic_variable
-{
-    ....
-public:
-```
-
-* The value type is a class template.
-
-* Allocators may only be default-constructed
-
-[/-----------------------------------------------------------------------------]
-
-[heading Comparison to jbc-json]
-
-https://github.com/Julien-Blanc-tgcm/jbc-json
-
-```
-template<typename traits_>
-class basic_item
-```
+* __good__ The fastest available JSON parser.
 
 [/-----------------------------------------------------------------------------]
 
diff --git a/include/boost/json/array.hpp b/include/boost/json/array.hpp
index dd7079a8..948e8f06 100644
--- a/include/boost/json/array.hpp
+++ b/include/boost/json/array.hpp
@@ -1688,8 +1688,7 @@ private:
         value* src,
         std::size_t n) noexcept;
 
-    class undo_create;
-    class undo_assign;
+    class undo_construct;
     class undo_insert;
 
     storage_ptr sp_; // must come first
diff --git a/include/boost/json/detail/config.hpp b/include/boost/json/detail/config.hpp
index 98ffb202..4472ab88 100644
--- a/include/boost/json/detail/config.hpp
+++ b/include/boost/json/detail/config.hpp
@@ -83,6 +83,10 @@
 # define BOOST_JSON_NO_MAX_STRING_SIZE
 # define BOOST_JSON_MAX_STRING_SIZE  0x7ffffffe
 #endif
+#ifndef BOOST_JSON_MAX_STACK_SIZE
+# define BOOST_JSON_NO_MAX_STACK_SIZE
+# define BOOST_JSON_MAX_STACK_SIZE  ((std::size_t)(-1))
+#endif
 
 namespace boost {
 namespace json {
diff --git a/include/boost/json/detail/except.hpp b/include/boost/json/detail/except.hpp
index e98ec875..592cb4ef 100644
--- a/include/boost/json/detail/except.hpp
+++ b/include/boost/json/detail/except.hpp
@@ -16,6 +16,22 @@ namespace boost {
 namespace json {
 namespace detail {
 
+inline
+std::length_error
+object_too_large_exception() noexcept
+{
+    return std::length_error(
+        "object too large");
+}
+
+inline
+std::length_error
+array_too_large_exception() noexcept
+{
+    return std::length_error(
+        "array too large");
+}
+
 inline
 std::length_error
 string_too_large_exception() noexcept
@@ -24,6 +40,14 @@ string_too_large_exception() noexcept
         "string too large");
 }
 
+inline
+std::out_of_range
+string_pos_too_large() noexcept
+{
+    return std::out_of_range(
+        "pos > size()");
+}
+
 inline
 std::length_error
 key_too_large_exception() noexcept
@@ -32,14 +56,6 @@ key_too_large_exception() noexcept
         "key too large");
 }
 
-inline
-std::length_error
-object_too_large_exception() noexcept
-{
-    return std::length_error(
-        "object too large");
-}
-
 inline
 std::length_error
 stack_overflow_exception() noexcept
diff --git a/include/boost/json/detail/raw_stack.hpp b/include/boost/json/detail/raw_stack.hpp
index 5aa0ded8..62b503fb 100644
--- a/include/boost/json/detail/raw_stack.hpp
+++ b/include/boost/json/detail/raw_stack.hpp
@@ -113,7 +113,7 @@ private:
     std::size_t
     max_size() noexcept
     {
-        return std::size_t(-1);
+        return BOOST_JSON_MAX_STACK_SIZE;
     }
 
     BOOST_JSON_DECL
diff --git a/include/boost/json/detail/raw_stack.ipp b/include/boost/json/detail/raw_stack.ipp
index a2ed5b95..c45bc368 100644
--- a/include/boost/json/detail/raw_stack.ipp
+++ b/include/boost/json/detail/raw_stack.ipp
@@ -22,7 +22,7 @@ void
 raw_stack::
 grow(std::size_t n)
 {
-    if(n > max_size() - size_)
+    if(n > max_size() - capacity_)
         BOOST_JSON_THROW(
             stack_overflow_exception());
     auto new_capacity = capacity_ + n;
@@ -37,7 +37,7 @@ grow(std::size_t n)
     if(base_)
     {
         std::memcpy(base, base_, size_);
-        sp_->deallocate(base_, size_);
+        sp_->deallocate(base_, capacity_);
     }
     base_ = base;
     capacity_ = new_capacity;
diff --git a/include/boost/json/impl/array.hpp b/include/boost/json/impl/array.hpp
index 827cccc7..5d847057 100644
--- a/include/boost/json/impl/array.hpp
+++ b/include/boost/json/impl/array.hpp
@@ -11,6 +11,7 @@
 #define BOOST_JSON_IMPL_ARRAY_HPP
 
 #include <boost/json/value.hpp>
+#include <boost/json/detail/except.hpp>
 #include <algorithm>
 #include <stdexcept>
 #include <type_traits>
@@ -54,7 +55,7 @@ index_of(value const* pos) const noexcept ->
 
 //----------------------------------------------------------
 
-class array::undo_create
+class array::undo_construct
 {
     array& self_;
 
@@ -62,10 +63,10 @@ public:
     bool commit = false;
 
     BOOST_JSON_DECL
-    ~undo_create();
+    ~undo_construct();
 
     explicit
-    undo_create(
+    undo_construct(
         array& self) noexcept
         : self_(self)
     {
@@ -74,24 +75,6 @@ public:
 
 //----------------------------------------------------------
 
-class array::undo_assign
-{
-    array& self_;
-    impl_type impl_;
-
-public:
-    bool commit = false;
-
-    explicit
-    BOOST_JSON_DECL
-    undo_assign(array& self);
-
-    BOOST_JSON_DECL
-    ~undo_assign();
-};
-
-//----------------------------------------------------------
-
 class array::undo_insert
 {
     array& self_;
@@ -404,7 +387,7 @@ array(
     std::input_iterator_tag)
     : sp_(std::move(sp))
 {
-    undo_create u(*this);
+    undo_construct u(*this);
     while(first != last)
     {
         if(impl_.size >= impl_.capacity)
@@ -424,14 +407,13 @@ array(
     std::forward_iterator_tag)
     : sp_(std::move(sp))
 {
-    undo_create u(*this);
+    undo_construct u(*this);
     auto const n =
         static_cast<std::size_t>(
             std::distance(first, last));
     if(n > max_size())
         BOOST_JSON_THROW(
-            std::length_error(
-                "n > max_size"));
+            detail::array_too_large_exception());
     reserve(static_cast<std::size_t>(n));
     while(impl_.size < n)
     {
@@ -481,8 +463,7 @@ insert(
             std::distance(first, last));
     if(n > max_size())
         BOOST_JSON_THROW(
-            std::length_error(
-                "n > max_size"));
+            detail::array_too_large_exception());
     undo_insert u(pos, static_cast<
         std::size_t>(n), *this);
     while(first != last)
diff --git a/include/boost/json/impl/array.ipp b/include/boost/json/impl/array.ipp
index 6330ec5c..c5d86d91 100644
--- a/include/boost/json/impl/array.ipp
+++ b/include/boost/json/impl/array.ipp
@@ -33,7 +33,7 @@ impl_type(
 {
     if(capacity_ > max_size())
         BOOST_JSON_THROW(
-            detail::object_too_large_exception());
+            detail::array_too_large_exception());
     if(capacity_ > 0)
         vec = reinterpret_cast<value*>(
             sp->allocate(
@@ -102,8 +102,8 @@ destroy(
 //----------------------------------------------------------
 
 array::
-undo_create::
-~undo_create()
+undo_construct::
+~undo_construct()
 {
     if(! commit)
         self_.impl_.destroy(self_.sp_);
@@ -111,25 +111,6 @@ undo_create::
 
 //----------------------------------------------------------
 
-array::
-undo_assign::
-undo_assign(array& self)
-    : self_(self)
-    , impl_(std::move(self.impl_))
-{
-}
-
-array::
-undo_assign::
-~undo_assign()
-{
-    if(! commit)
-        impl_.swap(self_.impl_);
-    impl_.destroy(self_.sp_);
-}
-
-//----------------------------------------------------------
-
 array::
 undo_insert::
 undo_insert(
@@ -142,8 +123,7 @@ undo_insert(
 {
     if(n > max_size())
         BOOST_JSON_THROW(
-            std::length_error(
-                "size > max_size()"));
+            detail::array_too_large_exception());
     self_.reserve(
         self_.impl_.size + n_);
     // (iterators invalidated now)
@@ -192,7 +172,7 @@ array(
     storage_ptr sp)
     : sp_(std::move(sp))
 {
-    undo_create u(*this);
+    undo_construct u(*this);
     reserve(count);
     while(impl_.size < count)
     {
@@ -210,7 +190,7 @@ array(
     storage_ptr sp)
     : sp_(std::move(sp))
 {
-    undo_create u(*this);
+    undo_construct u(*this);
     reserve(count);
     while(impl_.size < count)
     {
@@ -226,7 +206,7 @@ array::
 array(array const& other)
     : sp_(other.sp_)
 {
-    undo_create u(*this);
+    undo_construct u(*this);
     copy(other);
     u.commit = true;
 }
@@ -237,7 +217,7 @@ array(
     storage_ptr sp)
     : sp_(std::move(sp))
 {
-    undo_create u(*this);
+    undo_construct u(*this);
     copy(other);
     u.commit = true;
 }
@@ -269,7 +249,7 @@ array(
     }
     else
     {
-        undo_create u(*this);
+        undo_construct u(*this);
         copy(other);
         u.commit = true;
     }
@@ -281,7 +261,7 @@ array(
     storage_ptr sp)
     : sp_(std::move(sp))
 {
-    undo_create u(*this);
+    undo_construct u(*this);
     copy(init);
     u.commit = true;
 }
diff --git a/include/boost/json/impl/object.hpp b/include/boost/json/impl/object.hpp
index ccfb0325..2683fdd7 100644
--- a/include/boost/json/impl/object.hpp
+++ b/include/boost/json/impl/object.hpp
@@ -115,22 +115,19 @@ bucket_begin() const noexcept ->
             begin() + capacity());
 }
 
-auto
-object::
-impl_type::
-bucket_end() const noexcept ->
-    value_type**
-{
-    return bucket_begin() + buckets();
-}
-
-
 //----------------------------------------------------------
 
 struct object::undo_construct
 {
     object* self;
 
+    explicit
+    undo_construct(
+        object* self_)
+        : self(self_)
+    {
+    }
+
     ~undo_construct()
     {
         if(self)
@@ -170,7 +167,7 @@ object(
     storage_ptr sp)
     : sp_(std::move(sp))
 {
-    undo_construct u{this};
+    undo_construct u(this);
     insert_range(
         first, last,
         min_capacity);
diff --git a/include/boost/json/impl/object.ipp b/include/boost/json/impl/object.ipp
index 08933c8e..df6f9057 100644
--- a/include/boost/json/impl/object.ipp
+++ b/include/boost/json/impl/object.ipp
@@ -110,14 +110,13 @@ build() noexcept
         --end;
         if(p != end)
         {
-            auto& head = bucket(end->key());
-            remove(head, end);
-            end->next_ = head;
-            head = p;
             std::memcpy(
                 reinterpret_cast<void*>(p),
                 reinterpret_cast<void const*>(end),
                 sizeof(*p));
+            auto& head = bucket(p->key());
+            p->next_ = head;
+            head = p;
         }
     }
 }
@@ -234,7 +233,7 @@ object(
     }
     else
     {
-        undo_construct u{this};
+        undo_construct u(this);
         insert_range(
             other.begin(),
             other.end(), 0);
@@ -254,7 +253,7 @@ object(
     object const& other)
     : sp_(other.sp_)
 {
-    undo_construct u{this};
+    undo_construct u(this);
     insert_range(
         other.begin(),
         other.end(), 0);
@@ -267,7 +266,7 @@ object(
     storage_ptr sp)
     : sp_(std::move(sp))
 {
-    undo_construct u{this};
+    undo_construct u(this);
     insert_range(
         other.begin(),
         other.end(), 0);
@@ -281,7 +280,7 @@ object(
     storage_ptr sp)
     : sp_(std::move(sp))
 {
-    undo_construct u{this};
+    undo_construct u(this);
     insert_range(
         init.begin(),
         init.end(),
diff --git a/include/boost/json/impl/parser.ipp b/include/boost/json/impl/parser.ipp
index 3b173798..b961615a 100644
--- a/include/boost/json/impl/parser.ipp
+++ b/include/boost/json/impl/parser.ipp
@@ -248,21 +248,16 @@ emplace(Args&&... args)
             ~U(){}
         };
         U u;
+        // perform stack reallocation up-front
+        // VFALCO This is more than we need
+        rs_.prepare(sizeof(u.v));
         std::size_t key_size;
         pop(key_size);
-        // remember the offset in case
-        // the stack is reallocated.
-        auto const offset =
-            rs_.pop(key_size) -
-            rs_.begin();
+        auto const key =
+            pop_chars(key_size);
         st_ = state::obj;
-        // prevent splits from exceptions
-        rs_.prepare(2 * sizeof(u.v));
         ::new(&u.v) object::value_type(
-            string_view(
-                rs_.begin() + offset,
-                key_size),
-            std::forward<Args>(args)...);
+            key, std::forward<Args>(args)...);
         rs_.subtract(sizeof(u.v));
         push(u.v);
         rs_.add(sizeof(u.v));
diff --git a/include/boost/json/impl/serializer.ipp b/include/boost/json/impl/serializer.ipp
index 6c4db0ed..be5d3bff 100644
--- a/include/boost/json/impl/serializer.ipp
+++ b/include/boost/json/impl/serializer.ipp
@@ -158,7 +158,7 @@ loop_init:
         case kind::uint64:
             if(p1 - p >= detail::max_number_chars)
             {
-                p += detail::format_int64(
+                p += detail::format_uint64(
                     p,  *jv.if_uint64());
                 stack_.pop();
                 goto loop;
@@ -370,7 +370,6 @@ loop_str:
                 std::memcpy(p, ss, n);
                 ss = s;
                 p += n;
-                //*p++ = ch;
                 *p++ = '\\';
                 *p++ = c;
                 if(c != 'u')
diff --git a/include/boost/json/impl/string.ipp b/include/boost/json/impl/string.ipp
index 8e4ef8ec..71cab5ed 100644
--- a/include/boost/json/impl/string.ipp
+++ b/include/boost/json/impl/string.ipp
@@ -11,6 +11,7 @@
 #define BOOST_JSON_IMPL_STRING_IPP
 
 #include <boost/json/detail/assert.hpp>
+#include <boost/json/detail/except.hpp>
 #include <algorithm>
 #include <new>
 #include <ostream>
@@ -54,8 +55,7 @@ growth(
 {
     if(new_size > max_size())
         BOOST_JSON_THROW(
-            std::length_error(
-                "size > max_size()"));
+            detail::string_too_large_exception());
     new_size |= mask_;
     if( new_size > max_size())
         return static_cast<
@@ -109,8 +109,7 @@ append(
 {
     if(n > max_size() - size)
         BOOST_JSON_THROW(
-            std::length_error(
-                "size > max_size()"));
+            detail::string_too_large_exception());
     if(n <= capacity - size)
     {
         term(size + n);
@@ -136,8 +135,7 @@ insert(
 {
     if(pos > size)
         BOOST_JSON_THROW(
-            std::out_of_range(
-                "pos > size()"));
+        detail::string_pos_too_large());
     if(n <= capacity - size)
     {
         auto const dest =
@@ -152,8 +150,7 @@ insert(
     }
     if(n > max_size() - size)
         BOOST_JSON_THROW(
-            std::length_error(
-                "size > max_size()"));
+            detail::string_too_large_exception());
     impl tmp(growth(
         size + n, capacity), sp);
     tmp.size = size + static_cast<
@@ -352,10 +349,9 @@ insert(
     char const* s,
     size_type count)
 {
-    if(pos >= impl_.size)
+    if(pos > impl_.size)
         BOOST_JSON_THROW(
-            std::out_of_range(
-                "pos >= size()"));
+            detail::string_pos_too_large());
     if(count > impl_.capacity - impl_.size)
     {
         traits_type::copy(
@@ -412,8 +408,7 @@ erase(
 {
     if(pos > impl_.size)
         BOOST_JSON_THROW(
-            std::out_of_range(
-                "pos > size()"));
+            detail::string_pos_too_large());
     if( count > impl_.size - pos)
         count = impl_.size - pos;
     traits_type::move(
diff --git a/include/boost/json/impl/value.hpp b/include/boost/json/impl/value.hpp
index b986bf33..15eca6ed 100644
--- a/include/boost/json/impl/value.hpp
+++ b/include/boost/json/impl/value.hpp
@@ -184,7 +184,7 @@ value_type(
         {
             if(key.size() > BOOST_JSON_MAX_STRING_SIZE)
                 BOOST_JSON_THROW(
-                    detail::string_too_large_exception());
+                    detail::key_too_large_exception());
             auto s = reinterpret_cast<
                 char*>(value_.get_storage()->
                     allocate(key.size() + 1));
diff --git a/include/boost/json/object.hpp b/include/boost/json/object.hpp
index 83402fc3..425d5881 100644
--- a/include/boost/json/object.hpp
+++ b/include/boost/json/object.hpp
@@ -219,10 +219,6 @@ private:
         inline
         value_type**
         bucket_begin() const noexcept;
-
-        inline
-        value_type**
-        bucket_end() const noexcept;
     };
 
     struct undo_construct;
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 6db147dd..10f61dfb 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -13,12 +13,6 @@ source_group (TREE ${PROJECT_SOURCE_DIR}/include/boost/json PREFIX json FILES ${
 
 GroupSources(test "/")
 
-#add_definitions(
-#    -DBOOST_JSON_MAX_STRING_SIZE=1000
-#    -DBOOST_JSON_MAX_OBJECT_SIZE=30
-#    -DBOOST_JSON_MAX_ARRAY_SIZE=100
-#    )
-
 add_executable (json-tests
     ${BEAST_FILES}
     ${PROJECT_FILES}
@@ -38,6 +32,7 @@ add_executable (json-tests
     error.cpp
     json.cpp
     kind.cpp
+    limits.cpp
     number.cpp
     object.cpp
     parser.cpp
diff --git a/test/Jamfile b/test/Jamfile
index 5861bc85..d83de6dc 100644
--- a/test/Jamfile
+++ b/test/Jamfile
@@ -11,6 +11,7 @@ import testing ;
 import ../../config/checks/config : requires ;
 
 local SOURCES =
+    array.cpp
     assign_string.cpp
     assign_vector.cpp
     basic_parser.cpp
@@ -19,20 +20,20 @@ local SOURCES =
     json.cpp
     kind.cpp
     number.cpp
+    object.cpp
     parser.cpp
     serializer.cpp
     storage.cpp
     storage_ptr.cpp
+    string.cpp
     value.cpp
     ryu/d2s_intrinsics_test.cpp
     ryu/d2s_table_test.cpp
     ryu/d2s_test.cpp
     ;
 
-local MOD_SOURCES =
-    array.cpp
-    object.cpp
-    string.cpp
+local LIMIT_SOURCES =
+    limits.cpp
     ;
 
 local RUN_TESTS ;
@@ -45,13 +46,14 @@ for local f in $(SOURCES)
         ] ;
 }
 
-for local f in $(MOD_SOURCES)
+for local f in $(LIMIT_SOURCES)
 {
     RUN_TESTS += [
         run $(f) main.cpp ../src/src.cpp : : :
             <define>BOOST_JSON_MAX_STRING_SIZE=1000
             <define>BOOST_JSON_MAX_OBJECT_SIZE=30
             <define>BOOST_JSON_MAX_ARRAY_SIZE=100
+            <define>BOOST_JSON_MAX_STACK_SIZE=1024
         ] ;
 }
 
diff --git a/test/array.cpp b/test/array.cpp
index c9c164c5..d691fbf4 100644
--- a/test/array.cpp
+++ b/test/array.cpp
@@ -280,6 +280,15 @@ public:
                 check_storage(a1, storage_ptr{});
                 check_storage(a2, sp);
             });
+
+            // self-assign
+            {
+                array a({1, true, str_});
+                auto& a1 = a;
+                auto& a2 = a;
+                a1 = a2;
+                check(a);
+            }
         }
 
         // operator=(array&&)
diff --git a/test/limits.cpp b/test/limits.cpp
new file mode 100644
index 00000000..dcefa779
--- /dev/null
+++ b/test/limits.cpp
@@ -0,0 +1,196 @@
+//
+// Copyright (c) 2018-2019 Vinnie Falco (vinnie dot falco at gmail dot com)
+//
+// Distributed under the Boost Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+//
+// Official repository: https://github.com/vinniefalco/json
+//
+
+#include <boost/json/array.hpp>
+#include <boost/json/object.hpp>
+#include <boost/json/string.hpp>
+#include <boost/json/value.hpp>
+#include <boost/json/parser.hpp>
+
+#include <boost/beast/_experimental/unit_test/suite.hpp>
+#include "test.hpp"
+#include <vector>
+
+namespace boost {
+namespace json {
+
+/*
+    This translation unit exercises code paths
+    related to library limits such as max string
+    length.
+*/
+
+class limits_test : public beast::unit_test::suite
+{
+public:
+    void
+    testObject()
+    {
+        // max size
+        {
+            BEAST_THROWS(
+                object(object::max_size()+1),
+                std::length_error);
+        }
+
+        // max size
+        {
+            std::initializer_list<std::pair<
+                string_view, value>> init = {
+            { "1", 1},{ "2", 2},{ "3", 3},{ "4", 4},{ "5", 5},
+            { "6", 6},{ "7", 7},{ "8", 8},{ "9", 9},{"10",10},
+            {"11",11},{"12",12},{"13",13},{"14",14},{"15",15},
+            {"16",16},{"17",17},{"18",18},{"19",19},{"10",10},
+            {"21",21},{"22",22},{"23",23},{"24",24},{"25",25},
+            {"26",26},{"27",27},{"28",28},{"29",29},{"30",30},
+            {"31",31}};
+            BEAST_EXPECT(init.size() > object::max_size());
+            BEAST_THROWS(
+                object(init.begin(), init.end()),
+                std::length_error);
+            BEAST_THROWS(
+                object(
+                    make_input_iterator(init.begin()),
+                    make_input_iterator(init.end())),
+                std::length_error);
+        }
+
+        // max key size
+        {
+            std::string const big(
+                string::max_size() + 1, '*');
+            BEAST_THROWS(
+                object({ {big, nullptr} }),
+                std::length_error);
+        }
+    }
+
+    void
+    testArray()
+    {
+        // max size
+        {
+            BEAST_THROWS(
+                array(
+                    array::max_size()+1,
+                    value(nullptr)),
+                std::length_error);
+        }
+
+        // max size
+        {
+            std::vector<int> v(
+                array::max_size()+1, 42);
+            BEAST_THROWS(
+                array(v.begin(), v.end()),
+                std::length_error);
+        }
+
+        // max size
+        {
+            array a;
+            BEAST_THROWS(
+                a.insert(a.begin(),
+                    array::max_size() + 1,
+                    nullptr),
+                std::length_error);
+        }
+    }
+
+    void
+    testString()
+    {
+        // exceed max size
+        {
+            {
+                string s;
+                BEAST_THROWS(
+                    (s.resize(s.max_size() + 1)),
+                    std::length_error);
+            }
+
+            {
+                string s;
+                s.resize(100);
+                BEAST_THROWS(
+                    (s.append(s.max_size() - 1, '*')),
+                    std::length_error);
+            }
+
+    #if 0
+            {
+                // VFALCO tsan doesn't like this
+                string s;
+                try
+                {
+                    s.resize(s.max_size() - 1);
+                }
+                catch(std::exception const&)
+                {
+                }
+            }
+    #endif
+        }
+    }
+
+    void
+    testParser()
+    {
+        // max raw_stack
+        {
+            std::string big;
+            BEAST_THROWS(
+                parse(
+                   "[1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,"
+                    "1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,"
+                    "1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,"
+                    "1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,"
+                    "1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,"
+                    "1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,"
+                    "1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,"
+                    "1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,"
+                    "1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,"
+                    "1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,"
+                    "1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,"
+                    "1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,"
+                    "1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,"
+                    "1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,"
+                    "1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,"
+                    "1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0]"),
+                std::length_error);
+        }
+    }
+
+    void
+    run() override
+    {
+    #ifndef BOOST_JSON_NO_MAX_OBJECT_SIZE
+        testObject();
+    #endif
+
+    #ifndef BOOST_JSON_NO_MAX_ARRAY_SIZE
+        testArray();
+    #endif
+
+    #ifndef BOOST_JSON_NO_MAX_STRING_SIZE
+        testString();
+    #endif
+
+    #ifndef BOOST_JSON_NO_MAX_STACK_SIZE
+        testParser();
+    #endif
+
+        pass();
+    }
+};
+
+BEAST_DEFINE_TESTSUITE(boost,json,limits);
+
+} // json
+} // boost
diff --git a/test/object.cpp b/test/object.cpp
index 00be3e59..dd13b627 100644
--- a/test/object.cpp
+++ b/test/object.cpp
@@ -160,14 +160,6 @@ public:
                 BEAST_EXPECT(o.size() == 0);
                 BEAST_EXPECT(o.capacity() >= 10);
             });
-
-        #ifndef BOOST_JSON_NO_MAX_ARRAY_SIZE
-            {
-                BEAST_THROWS(
-                    object(object::max_size()+1),
-                    std::length_error);
-            }
-        #endif
         }
 
         // object(InputIt, InputIt, size_type, storage_ptr)
@@ -224,28 +216,6 @@ public:
                 check(o, 7);
                 check_storage(o, sp);
             });
-        #ifndef BOOST_JSON_NO_MAX_ARRAY_SIZE
-            {
-                std::initializer_list<std::pair<
-                    string_view, value>> init = {
-                { "1", 1},{ "2", 2},{ "3", 3},{ "4", 4},{ "5", 5},
-                { "6", 6},{ "7", 7},{ "8", 8},{ "9", 9},{"10",10},
-                {"11",11},{"12",12},{"13",13},{"14",14},{"15",15},
-                {"16",16},{"17",17},{"18",18},{"19",19},{"10",10},
-                {"21",21},{"22",22},{"23",23},{"24",24},{"25",25},
-                {"26",26},{"27",27},{"28",28},{"29",29},{"30",30},
-                {"31",31}};
-                BEAST_EXPECT(init.size() > object::max_size());
-                BEAST_THROWS(
-                    object(init.begin(), init.end()),
-                    std::length_error);
-                BEAST_THROWS(
-                    object(
-                        make_input_iterator(init.begin()),
-                        make_input_iterator(init.end())),
-                    std::length_error);
-            }
-        #endif
         }
 
         // object(object&&)
@@ -705,15 +675,28 @@ public:
         }
 
         // insert(initializer_list)
-        fail_loop([&](storage_ptr const& sp)
         {
-            object o(sp);
-            o.emplace("a", 1);
-            o.insert({
-                { "b", true },
-                { "c", "hello" }});
-            check(o, 3);
-        });
+            fail_loop([&](storage_ptr const& sp)
+            {
+                object o(sp);
+                o.emplace("a", 1);
+                o.insert({
+                    { "b", true },
+                    { "c", "hello" }});
+                check(o, 3);
+            });
+
+            // do rollback in ~undo_insert
+            fail_loop([&](storage_ptr const& sp)
+            {
+                std::string const big(
+                    string().capacity() + 1, '*');
+                string_view const sv(big);
+                object o(sp);
+                o.insert({
+                    { "a", { 1, 2, 3, 4 } } });
+            });
+        }
 
         // insert_or_assign(key, o);
         {
diff --git a/test/parser.cpp b/test/parser.cpp
index dc35f5a7..caff2796 100644
--- a/test/parser.cpp
+++ b/test/parser.cpp
@@ -87,6 +87,7 @@ public:
             {
                 scoped_storage<
                     fail_storage> ss;
+                ss->fail_max = 0;
                 parser p;
                 error_code ec;
                 p.start(ss);
@@ -284,6 +285,12 @@ R"xx({
                 ec == error::need_start,
                 ec.message());
         }
+
+        // destroy after start
+        {
+            parser p;
+            p.start();
+        }
     }
 
     //------------------------------------------------------
diff --git a/test/serializer.cpp b/test/serializer.cpp
index 118538d9..73429f5e 100644
--- a/test/serializer.cpp
+++ b/test/serializer.cpp
@@ -13,8 +13,8 @@
 #include <boost/json/parser.hpp>
 #include <boost/beast/_experimental/unit_test/suite.hpp>
 #include "parse-vectors.hpp"
-
 #include "test.hpp"
+#include <iostream>
 
 namespace boost {
 namespace json {
@@ -56,21 +56,37 @@ public:
         value const& jv,
         string_view name = {})
     {
-        error_code ec;
-        auto const s1 = to_string(jv);
-        auto const jv2 = parse(s1, ec);
-        if(! BEAST_EXPECT(equal(jv, jv2)))
         {
-            if(name.empty())
-                log <<
-                    " " << s << "\n"
-                    " " << s1 <<
-                    std::endl;
-            else
-                log << name << ":\n"
-                    " " << s << "\n"
-                    " " << s1 <<
-                    std::endl;
+            error_code ec;
+            auto const s1 = to_string(jv);
+            auto const jv2 = parse(s1, ec);
+            if(! BEAST_EXPECT(equal(jv, jv2)))
+            {
+                if(name.empty())
+                    log <<
+                        " " << s << "\n"
+                        " " << s1 <<
+                        std::endl;
+                else
+                    log << name << ":\n"
+                        " " << s << "\n"
+                        " " << s1 <<
+                        std::endl;
+            }
+        }
+
+        // large buffer
+        {
+            error_code ec;
+            serializer sr(jv);
+            string js;
+            js.reserve(4096);
+            js.grow(sr.read(
+                js.data(), js.size()));
+
+            auto const s1 = to_string(jv);
+            auto const jv2 = parse(s1, ec);
+            BEAST_EXPECT(equal(jv, jv2));
         }
     }
 
@@ -391,6 +407,33 @@ public:
         }
     }
 
+    void
+    testOstream()
+    {
+        std::string js =
+            "{\"1\":{},\"2\":[],\"3\":\"x\",\"4\":1,"
+            "\"5\":-1,\"6\":144.0,\"7\":false,\"8\":null}";
+        error_code ec;
+        auto const jv1 = parse(js, ec);
+        if(! BEAST_EXPECTS(! ec,
+            ec.message()))
+            return;
+        std::stringstream ss;
+        ss << jv1;
+        auto const jv2 =
+            parse(ss.str(), ec);
+        if(! BEAST_EXPECTS(! ec,
+            ec.message()))
+            return;
+        if(! BEAST_EXPECT(equal(jv1, jv2)))
+            log <<
+                " " << js << "\n"
+                " " << jv1 << "\n"
+                " " << jv2 <<
+                std::endl;
+
+    }
+
     void
     run()
     {
@@ -401,6 +444,7 @@ public:
         testNumber();
         testScalar();
         testVectors();
+        //testOstream();
     }
 };
 
diff --git a/test/string.cpp b/test/string.cpp
index cd7a3c38..96cbbf02 100644
--- a/test/string.cpp
+++ b/test/string.cpp
@@ -2632,44 +2632,6 @@ public:
         BEAST_EXPECT(ss.str() == s);
     }
 
-    void
-    testImpl()
-    {
-        // exceed max size
-    #ifndef BOOST_JSON_NO_MAX_STRING_SIZE
-        {
-            {
-                string s;
-                BEAST_THROWS(
-                    (s.resize(s.max_size() + 1)),
-                    std::length_error);
-            }
-
-            {
-                string s;
-                s.resize(100);
-                BEAST_THROWS(
-                    (s.append(s.max_size() - 1, '*')),
-                    std::length_error);
-            }
-
-    #if 0
-            {
-                // VFALCO tsan doesn't like this
-                string s;
-                try
-                {
-                    s.resize(s.max_size() - 1);
-                }
-                catch(std::exception const&)
-                {
-                }
-            }
-    #endif
-        }
-    #endif
-    }
-
     void
     run() override
     {
@@ -2702,8 +2664,6 @@ public:
         testFindNotLastOf(); //
 
         testNonMembers();
-
-        testImpl();
     }
 };
 
diff --git a/test/test.hpp b/test/test.hpp
index 125c1362..950c4c6f 100644
--- a/test/test.hpp
+++ b/test/test.hpp
@@ -54,8 +54,7 @@ struct fail_storage
         return true;
     }
 
-    std::size_t fail_max =
-        std::size_t(-1);
+    std::size_t fail_max = 0;
     std::size_t fail = 0;
     std::size_t nalloc = 0;
 
@@ -97,6 +96,7 @@ void
 fail_loop(F&& f)
 {
     scoped_storage<fail_storage> ss;
+    ss->fail_max = 1;
     while(ss->fail < 200)
     {
         try