diff --git a/CHANGELOG.md b/CHANGELOG.md
index 59559b54..116766f1 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3,6 +3,7 @@ Version 221:
 * Rename to async_base, stable_async_base
 * role_type is in boost/beast/core/role.hpp (API Change)
 * Cleanup in test::stream internals
+* Pass references as pointers to async_initiate
 
 Actions Required:
 
diff --git a/include/boost/beast/_experimental/http/impl/icy_stream.hpp b/include/boost/beast/_experimental/http/impl/icy_stream.hpp
index a35ad015..3879dd5c 100644
--- a/include/boost/beast/_experimental/http/impl/icy_stream.hpp
+++ b/include/boost/beast/_experimental/http/impl/icy_stream.hpp
@@ -304,7 +304,7 @@ struct run_read_op
     void
     operator()(
         ReadHandler&& h,
-        icy_stream& s,
+        icy_stream* s,
         Buffers const& b)
     {
         // If you get an error on the following line it means
@@ -319,7 +319,7 @@ struct run_read_op
         read_op<
             Buffers,
             typename std::decay<ReadHandler>::type>(
-                std::forward<ReadHandler>(h), s, b);
+                std::forward<ReadHandler>(h), *s, b);
     }
 };
 
@@ -490,7 +490,7 @@ async_read_some(
         void(error_code, std::size_t)>(
             typename ops::run_read_op{},
             handler,
-            *this,
+            this,
             buffers);
 }
 
diff --git a/include/boost/beast/_experimental/test/impl/stream.hpp b/include/boost/beast/_experimental/test/impl/stream.hpp
index 62fa57e2..65a48138 100644
--- a/include/boost/beast/_experimental/test/impl/stream.hpp
+++ b/include/boost/beast/_experimental/test/impl/stream.hpp
@@ -114,7 +114,7 @@ struct stream::run_read_op
     void
     operator()(
         ReadHandler&& h,
-        stream& s,
+        std::shared_ptr<state> const& in,
         MutableBufferSequence const& buffers)
     {
         // If you get an error on the following line it means
@@ -126,13 +126,14 @@ struct stream::run_read_op
                 void(error_code, std::size_t)>::value,
             "ReadHandler type requirements not met");
 
-        s.initiate_read(
+        initiate_read(
+            in,
             std::unique_ptr<read_op_base>{
             new read_op<
                 typename std::decay<ReadHandler>::type,
                 MutableBufferSequence>(
                     std::move(h),
-                    *s.in_,
+                    *in,
                     buffers)},
             buffer_size(buffers));
     }
@@ -278,7 +279,7 @@ async_read_some(
         void(error_code, std::size_t)>(
             run_read_op{},
             handler,
-            *this,
+            in_,
             buffers);
 }
 
diff --git a/include/boost/beast/_experimental/test/impl/stream.ipp b/include/boost/beast/_experimental/test/impl/stream.ipp
index 1aecc216..b5ebf614 100644
--- a/include/boost/beast/_experimental/test/impl/stream.ipp
+++ b/include/boost/beast/_experimental/test/impl/stream.ipp
@@ -21,7 +21,9 @@ namespace beast {
 namespace test {
 
 //------------------------------------------------------------------------------
+
 void stream::initiate_read(
+    std::shared_ptr<state> const& in_,
     std::unique_ptr<stream::read_op_base>&& op,
     std::size_t buf_size)
 {
diff --git a/include/boost/beast/_experimental/test/stream.hpp b/include/boost/beast/_experimental/test/stream.hpp
index 81d56719..0c1132a6 100644
--- a/include/boost/beast/_experimental/test/stream.hpp
+++ b/include/boost/beast/_experimental/test/stream.hpp
@@ -96,19 +96,10 @@ namespace test {
 */
 class stream
 {
-    struct read_op_base
-    {
-        virtual ~read_op_base() = default;
-        virtual void operator()(error_code ec) = 0;
-    };
+    struct state;
 
-    BOOST_BEAST_DECL void initiate_read(std::unique_ptr<read_op_base>&& op, std::size_t buf_size);
-
-    template<class Handler, class Buffers>
-    class read_op;
-
-    struct run_read_op;
-    struct run_write_op;
+    std::shared_ptr<state> in_;
+    std::weak_ptr<state> out_;
 
     enum class status
     {
@@ -116,6 +107,12 @@ class stream
         eof,
     };
 
+    struct read_op_base
+    {
+        virtual ~read_op_base() = default;
+        virtual void operator()(error_code ec) = 0;
+    };
+
     struct state
     {
         friend class stream;
@@ -146,8 +143,19 @@ class stream
         notify_read();
     };
 
-    std::shared_ptr<state> in_;
-    std::weak_ptr<state> out_;
+    template<class Handler, class Buffers>
+    class read_op;
+
+    struct run_read_op;
+    struct run_write_op;
+
+    BOOST_BEAST_DECL
+    static
+    void
+    initiate_read(
+        std::shared_ptr<state> const& in,
+        std::unique_ptr<read_op_base>&& op,
+        std::size_t buf_size);
 
 public:
     using buffer_type = flat_buffer;
diff --git a/include/boost/beast/core/detail/impl/read.hpp b/include/boost/beast/core/detail/impl/read.hpp
index 7d50a8e6..c237ce20 100644
--- a/include/boost/beast/core/detail/impl/read.hpp
+++ b/include/boost/beast/core/detail/impl/read.hpp
@@ -119,8 +119,8 @@ struct run_read_op
     void
     operator()(
         ReadHandler&& h,
-        AsyncReadStream& s,
-        DynamicBuffer& b,
+        AsyncReadStream* s,
+        DynamicBuffer* b,
         Condition&& c)
     {
         // If you get an error on the following line it means
@@ -138,8 +138,8 @@ struct run_read_op
             typename std::decay<Condition>::type,
             typename std::decay<ReadHandler>::type>(
                 std::forward<ReadHandler>(h),
-                s,
-                b,
+                *s,
+                *b,
                 std::forward<Condition>(c));
     }
 
@@ -248,8 +248,8 @@ async_read(
         void(error_code, std::size_t)>(
             typename dynamic_read_ops::run_read_op{},
             handler,
-            stream,
-            buffer,
+            &stream,
+            &buffer,
             std::forward<CompletionCondition>(cond));
 }
 
diff --git a/include/boost/beast/core/detect_ssl.hpp b/include/boost/beast/core/detect_ssl.hpp
index b4ca2511..1da3a355 100644
--- a/include/boost/beast/core/detect_ssl.hpp
+++ b/include/boost/beast/core/detect_ssl.hpp
@@ -370,16 +370,14 @@ struct run_detect_ssl_op
         class DynamicBuffer>
     void operator()(
         DetectHandler&& h,
-        AsyncReadStream& s,
+        AsyncReadStream* s, // references are passed as pointers
         DynamicBuffer& b)
     {
         detect_ssl_op<
             typename std::decay<DetectHandler>::type,
             AsyncReadStream,
             DynamicBuffer>(
-                std::forward<DetectHandler>(h),
-                s,
-                b);
+                std::forward<DetectHandler>(h), *s, b);
     }
 };
 
@@ -423,14 +421,18 @@ async_detect_ssl(
     // `net::async_result` for the type of `CompletionToken`,
     // the `initiation` object will be invoked with the saved
     // parameters and the actual completion handler. Our
-    // initiating object is `run_detect_ssl_op`
+    // initiating object is `run_detect_ssl_op`.
+    //
+    // Non-const references need to be passed as pointers,
+    // since we don't want a decay-copy.
+
 
     return net::async_initiate<
         CompletionToken,
         void(error_code, boost::tribool)>(
             detail::run_detect_ssl_op{},
             token,
-            stream,
+            &stream, // pass the reference by pointer
             buffer);
 }
 
diff --git a/include/boost/beast/core/impl/basic_stream.hpp b/include/boost/beast/core/impl/basic_stream.hpp
index 6fce29df..214907d5 100644
--- a/include/boost/beast/core/impl/basic_stream.hpp
+++ b/include/boost/beast/core/impl/basic_stream.hpp
@@ -538,7 +538,7 @@ struct run_read_op
     void
     operator()(
         ReadHandler&& h,
-        basic_stream& s,
+        basic_stream* s,
         Buffers const& b)
     {
         // If you get an error on the following line it means
@@ -554,7 +554,7 @@ struct run_read_op
             true,
             Buffers,
             typename std::decay<ReadHandler>::type>(
-                std::forward<ReadHandler>(h), s, b);
+                std::forward<ReadHandler>(h), *s, b);
     }
 };
 
@@ -564,7 +564,7 @@ struct run_write_op
     void
     operator()(
         WriteHandler&& h,
-        basic_stream& s,
+        basic_stream* s,
         Buffers const& b)
     {
         // If you get an error on the following line it means
@@ -580,7 +580,7 @@ struct run_write_op
             false,
             Buffers,
             typename std::decay<WriteHandler>::type>(
-                std::forward<WriteHandler>(h), s, b);
+                std::forward<WriteHandler>(h), *s, b);
     }
 };
 
@@ -590,7 +590,7 @@ struct run_connect_op
     void
     operator()(
         ConnectHandler&& h,
-        basic_stream& s,
+        basic_stream* s,
         endpoint_type const& ep)
     {
         // If you get an error on the following line it means
@@ -603,7 +603,7 @@ struct run_connect_op
             "ConnectHandler type requirements not met");
 
         connect_op<typename std::decay<ConnectHandler>::type>(
-            std::forward<ConnectHandler>(h), s, ep);
+            std::forward<ConnectHandler>(h), *s, ep);
     }
 };
 
@@ -616,7 +616,7 @@ struct run_connect_range_op
     void
     operator()(
         RangeConnectHandler&& h,
-        basic_stream& s,
+        basic_stream* s,
         EndpointSequence const& eps,
         Condition const& cond)
     {
@@ -630,7 +630,7 @@ struct run_connect_range_op
             "RangeConnectHandler type requirements not met");
 
         connect_op<typename std::decay<RangeConnectHandler>::type>(
-            std::forward<RangeConnectHandler>(h), s, eps, cond);
+            std::forward<RangeConnectHandler>(h), *s, eps, cond);
     }
 };
 
@@ -643,7 +643,7 @@ struct run_connect_iter_op
     void
     operator()(
         IteratorConnectHandler&& h,
-        basic_stream& s,
+        basic_stream* s,
         Iterator begin, Iterator end,
         Condition const& cond)
     {
@@ -657,7 +657,7 @@ struct run_connect_iter_op
             "IteratorConnectHandler type requirements not met");
 
         connect_op<typename std::decay<IteratorConnectHandler>::type>(
-            std::forward<IteratorConnectHandler>(h), s, begin, end, cond);
+            std::forward<IteratorConnectHandler>(h), *s, begin, end, cond);
     }
 };
 
@@ -813,7 +813,7 @@ async_connect(
         void(error_code)>(
             typename ops::run_connect_op{},
             handler,
-            *this,
+            this,
             ep);
 }
 
@@ -834,7 +834,7 @@ async_connect(
         void(error_code, typename Protocol::endpoint)>(
             typename ops::run_connect_range_op{},
             handler,
-            *this,
+            this,
             endpoints,
             detail::any_endpoint{});
 }
@@ -858,7 +858,7 @@ async_connect(
         void(error_code, typename Protocol::endpoint)>(
             typename ops::run_connect_range_op{},
             handler,
-            *this,
+            this,
             endpoints,
             connect_condition);
 }
@@ -879,7 +879,7 @@ async_connect(
         void(error_code, Iterator)>(
             typename ops::run_connect_iter_op{},
             handler,
-            *this,
+            this,
             begin, end,
             detail::any_endpoint{});
 }
@@ -902,7 +902,7 @@ async_connect(
         void(error_code, Iterator)>(
             typename ops::run_connect_iter_op{},
             handler,
-            *this,
+            this,
             begin, end,
             connect_condition);
 }
@@ -926,7 +926,7 @@ async_read_some(
         void(error_code, std::size_t)>(
             typename ops::run_read_op{},
             handler,
-            *this,
+            this,
             buffers);
 }
 
@@ -947,7 +947,7 @@ async_write_some(
         void(error_code, std::size_t)>(
             typename ops::run_write_op{},
             handler,
-            *this,
+            this,
             buffers);
 }
 
diff --git a/include/boost/beast/core/impl/buffered_read_stream.hpp b/include/boost/beast/core/impl/buffered_read_stream.hpp
index 0513c52d..39380688 100644
--- a/include/boost/beast/core/impl/buffered_read_stream.hpp
+++ b/include/boost/beast/core/impl/buffered_read_stream.hpp
@@ -109,7 +109,7 @@ struct run_read_op
     void
     operator()(
         ReadHandler&& h,
-        buffered_read_stream& s,
+        buffered_read_stream* s,
         Buffers const& b)
     {
         // If you get an error on the following line it means
@@ -124,9 +124,7 @@ struct run_read_op
         read_op<
             Buffers,
             typename std::decay<ReadHandler>::type>(
-                std::forward<ReadHandler>(h),
-                s,
-                b);
+                std::forward<ReadHandler>(h), *s, b);
     }
 };
 
@@ -236,7 +234,7 @@ async_read_some(
         void(error_code, std::size_t)>(
             typename ops::run_read_op{},
             handler,
-            *this,
+            this,
             buffers);
 }
 
diff --git a/include/boost/beast/core/impl/flat_stream.hpp b/include/boost/beast/core/impl/flat_stream.hpp
index dea3b789..10249053 100644
--- a/include/boost/beast/core/impl/flat_stream.hpp
+++ b/include/boost/beast/core/impl/flat_stream.hpp
@@ -81,7 +81,7 @@ struct run_write_op
     void
     operator()(
         WriteHandler&& h,
-        flat_stream& s,
+        flat_stream* s,
         Buffers const& b)
     {
         // If you get an error on the following line it means
@@ -95,9 +95,7 @@ struct run_write_op
 
         write_op<
             typename std::decay<WriteHandler>::type>(
-                std::forward<WriteHandler>(h),
-                s,
-                b);
+                std::forward<WriteHandler>(h), *s, b);
     }
 };
 
@@ -248,7 +246,7 @@ async_write_some(
         void(error_code, std::size_t)>(
             typename ops::run_write_op{},
             handler,
-            *this,
+            this,
             buffers);
 }
 
diff --git a/include/boost/beast/http/impl/file_body_win32.hpp b/include/boost/beast/http/impl/file_body_win32.hpp
index 35db52bf..1bf65d08 100644
--- a/include/boost/beast/http/impl/file_body_win32.hpp
+++ b/include/boost/beast/http/impl/file_body_win32.hpp
@@ -444,9 +444,9 @@ struct run_write_some_win32_op
     operator()(
         WriteHandler&& h,
         net::basic_stream_socket<
-            Protocol, Executor>& s,
+            Protocol, Executor>* s,
         serializer<isRequest,
-            basic_file_body<file_win32>, Fields>& sr)
+            basic_file_body<file_win32>, Fields>* sr)
     {
         // If you get an error on the following line it means
         // that your handler does not meet the documented type
@@ -461,9 +461,7 @@ struct run_write_some_win32_op
             Protocol, Executor,
             isRequest, Fields,
             typename std::decay<WriteHandler>::type>(
-                std::forward<WriteHandler>(h),
-                s,
-                sr);
+                std::forward<WriteHandler>(h), *s, *sr);
     }
 };
 
@@ -560,8 +558,8 @@ async_write_some(
         void(error_code, std::size_t)>(
             detail::run_write_some_win32_op{},
             handler,
-            sock,
-            sr);
+            &sock,
+            &sr);
 }
 
 #endif
diff --git a/include/boost/beast/http/impl/read.hpp b/include/boost/beast/http/impl/read.hpp
index 6d69da3f..1e49b292 100644
--- a/include/boost/beast/http/impl/read.hpp
+++ b/include/boost/beast/http/impl/read.hpp
@@ -223,10 +223,10 @@ struct run_read_msg_op
     void
     operator()(
         ReadHandler&& h,
-        AsyncReadStream& s,
-        DynamicBuffer& b,
+        AsyncReadStream* s,
+        DynamicBuffer* b,
         message<isRequest, Body,
-            basic_fields<Allocator>>& m)
+            basic_fields<Allocator>>* m)
     {
         // If you get an error on the following line it means
         // that your handler does not meet the documented type
@@ -242,10 +242,7 @@ struct run_read_msg_op
             DynamicBuffer,
             isRequest, Body, Allocator,
             typename std::decay<ReadHandler>::type>(
-                std::forward<ReadHandler>(h),
-                s,
-                b,
-                m);
+                std::forward<ReadHandler>(h), *s, *b, *m);
     }
 };
 
@@ -556,10 +553,7 @@ async_read(
         ReadHandler,
         void(error_code, std::size_t)>(
             detail::run_read_msg_op{},
-            handler,
-            stream,
-            buffer,
-            msg);
+                handler, &stream, &buffer, &msg);
 }
 
 } // http
diff --git a/include/boost/beast/http/impl/write.hpp b/include/boost/beast/http/impl/write.hpp
index e0bdba33..b770af89 100644
--- a/include/boost/beast/http/impl/write.hpp
+++ b/include/boost/beast/http/impl/write.hpp
@@ -267,8 +267,8 @@ struct run_write_some_op
     void
     operator()(
         WriteHandler&& h,
-        Stream& s,
-        serializer<isRequest, Body, Fields>& sr)
+        Stream* s,
+        serializer<isRequest, Body, Fields>* sr)
     {
         // If you get an error on the following line it means
         // that your handler does not meet the documented type
@@ -283,9 +283,7 @@ struct run_write_some_op
             typename std::decay<WriteHandler>::type,
             Stream,
             isRequest, Body, Fields>(
-                std::forward<WriteHandler>(h),
-                s,
-                sr);
+                std::forward<WriteHandler>(h), *s, *sr);
     }
 };
 
@@ -299,9 +297,9 @@ struct run_write_op
     void
     operator()(
         WriteHandler&& h,
-        Stream& s,
+        Stream* s,
         Predicate const&,
-        serializer<isRequest, Body, Fields>& sr)
+        serializer<isRequest, Body, Fields>* sr)
     {
         // If you get an error on the following line it means
         // that your handler does not meet the documented type
@@ -317,9 +315,7 @@ struct run_write_op
             Stream,
             Predicate,
             isRequest, Body, Fields>(
-                std::forward<WriteHandler>(h),
-                s,
-                sr);
+                std::forward<WriteHandler>(h), *s, *sr);
     }
 };
 
@@ -333,8 +329,8 @@ struct run_write_msg_op
     void
     operator()(
         WriteHandler&& h,
-        Stream& s,
-        message<isRequest, Body, Fields>& m,
+        Stream* s,
+        message<isRequest, Body, Fields>* m,
         std::false_type,
         Args&&... args)
     {
@@ -351,9 +347,7 @@ struct run_write_msg_op
             typename std::decay<WriteHandler>::type,
             Stream,
             isRequest, Body, Fields>(
-                std::forward<WriteHandler>(h),
-                s,
-                m,
+                std::forward<WriteHandler>(h), *s, *m,
                 std::forward<Args>(args)...);
     }
 
@@ -365,8 +359,8 @@ struct run_write_msg_op
     void
     operator()(
         WriteHandler&& h,
-        Stream& s,
-        message<isRequest, Body, Fields> const& m,
+        Stream* s,
+        message<isRequest, Body, Fields> const* m,
         std::true_type,
         Args&&... args)
     {
@@ -383,9 +377,7 @@ struct run_write_msg_op
             typename std::decay<WriteHandler>::type,
             Stream,
             isRequest, Body, Fields>(
-                std::forward<WriteHandler>(h),
-                s,
-                m,
+                std::forward<WriteHandler>(h), *s, *m,
                 std::forward<Args>(args)...);
     }
 };
@@ -483,8 +475,8 @@ async_write_some_impl(
         void(error_code, std::size_t)>(
             run_write_some_op{},
             handler,
-            stream,
-            sr);
+            &stream,
+            &sr);
 }
 
 } // detail
@@ -638,9 +630,9 @@ async_write_header(
         void(error_code, std::size_t)>(
             detail::run_write_op{},
             handler,
-            stream,
+            &stream,
             detail::serializer_is_header_done{},
-            sr);
+            &sr);
 }
 
 //------------------------------------------------------------------------------
@@ -712,9 +704,9 @@ async_write(
         void(error_code, std::size_t)>(
             detail::run_write_op{},
             handler,
-            stream,
+            &stream,
             detail::serializer_is_done{},
-            sr);
+            &sr);
 }
 
 //------------------------------------------------------------------------------
@@ -834,8 +826,8 @@ async_write(
         void(error_code, std::size_t)>(
             detail::run_write_msg_op{},
             handler,
-            stream,
-            msg,
+            &stream,
+            &msg,
             std::false_type{});
 }
 
@@ -864,8 +856,8 @@ async_write(
         void(error_code, std::size_t)>(
             detail::run_write_msg_op{},
             handler,
-            stream,
-            msg,
+            &stream,
+            &msg,
             std::true_type{});
 }
 
diff --git a/include/boost/beast/websocket/impl/accept.hpp b/include/boost/beast/websocket/impl/accept.hpp
index ca2e631e..1c6e1574 100644
--- a/include/boost/beast/websocket/impl/accept.hpp
+++ b/include/boost/beast/websocket/impl/accept.hpp
@@ -338,7 +338,7 @@ struct stream<NextLayer, deflateSupported>::
         AcceptHandler&& h,
         boost::shared_ptr<impl_type> const& sp,
         http::request<Body,
-            http::basic_fields<Allocator>> const& m,
+            http::basic_fields<Allocator>> const* m,
         Decorator const& d)
     {
         // If you get an error on the following line it means
@@ -352,10 +352,7 @@ struct stream<NextLayer, deflateSupported>::
 
         response_op<
             typename std::decay<AcceptHandler>::type>(
-                std::forward<AcceptHandler>(h),
-                sp,
-                m,
-                d);
+                std::forward<AcceptHandler>(h), sp, *m, d);
     }
 };
 
@@ -677,7 +674,7 @@ async_accept(
             run_response_op{},
             handler,
             impl_,
-            req,
+            &req,
             &default_decorate_res);
 }
 
@@ -706,7 +703,7 @@ async_accept_ex(
             run_response_op{},
             handler,
             impl_,
-            req,
+            &req,
             decorator);
 }
 
diff --git a/include/boost/beast/websocket/impl/handshake.hpp b/include/boost/beast/websocket/impl/handshake.hpp
index 2d9d8b91..62f6aa31 100644
--- a/include/boost/beast/websocket/impl/handshake.hpp
+++ b/include/boost/beast/websocket/impl/handshake.hpp
@@ -41,15 +41,19 @@ class stream<NextLayer, deflateSupported>::handshake_op
 {
     struct data
     {
-        data() = default; // for msvc
-
         // VFALCO This really should be two separate
         //        composed operations, to save on memory
-        http::request<http::empty_body> req;
+        request_type req;
         http::response_parser<
             typename response_type::body_type> p;
         flat_buffer fb;
-        bool overflow;
+        bool overflow = false; // could be a member of the op
+
+        explicit
+        data(request_type&& req_)
+            : req(std::move(req_))
+        {
+        }
     };
 
     boost::weak_ptr<impl_type> wp_;
@@ -58,23 +62,23 @@ class stream<NextLayer, deflateSupported>::handshake_op
     data& d_;
 
 public:
-    template<class Handler_, class Decorator>
+    template<class Handler_>
     handshake_op(
         Handler_&& h,
         boost::shared_ptr<impl_type> const& sp,
-        response_type* res_p,
-        string_view host, string_view target,
-        Decorator const& decorator)
+        request_type&& req,
+        detail::sec_ws_key_type key,
+        response_type* res_p)
         : stable_async_base<Handler,
             beast::executor_type<stream>>(
                 std::forward<Handler_>(h),
                     sp->stream.get_executor())
         , wp_(sp)
+        , key_(key)
         , res_p_(res_p)
-        , d_(beast::allocate_stable<data>(*this))
+        , d_(beast::allocate_stable<data>(
+            *this, std::move(req)))
     {
-        d_.req = sp->build_request(
-            key_, host, target, decorator);
         sp->reset(); // VFALCO I don't like this
         (*this)({}, 0, false);
     }
@@ -164,13 +168,13 @@ template<class NextLayer, bool deflateSupported>
 struct stream<NextLayer, deflateSupported>::
     run_handshake_op
 {
-    template<class HandshakeHandler, class Decorator>
+    template<class HandshakeHandler>
     void operator()(
         HandshakeHandler&& h,
         boost::shared_ptr<impl_type> const& sp,
-        response_type* r,
-        string_view host, string_view target,
-        Decorator const& d)
+        request_type&& req,
+        detail::sec_ws_key_type key,
+        response_type* res_p)
     {
         // If you get an error on the following line it means
         // that your handler does not meet the documented type
@@ -184,10 +188,7 @@ struct stream<NextLayer, deflateSupported>::
         handshake_op<
             typename std::decay<HandshakeHandler>::type>(
                 std::forward<HandshakeHandler>(h),
-                sp,
-                r,
-                host, target,
-                d);
+                    sp, std::move(req), key, res_p);
     }
 };
 
@@ -269,21 +270,25 @@ template<class HandshakeHandler>
 BOOST_ASIO_INITFN_RESULT_TYPE(
     HandshakeHandler, void(error_code))
 stream<NextLayer, deflateSupported>::
-async_handshake(string_view host,
+async_handshake(
+    string_view host,
     string_view target,
-        HandshakeHandler&& handler)
+    HandshakeHandler&& handler)
 {
     static_assert(is_async_stream<next_layer_type>::value,
         "AsyncStream type requirements not met");
+    detail::sec_ws_key_type key;
+    auto req = impl_->build_request(
+        key, host, target, &default_decorate_req);
     return net::async_initiate<
         HandshakeHandler,
         void(error_code)>(
             run_handshake_op{},
             handler,
             impl_,
-            nullptr,
-            host, target,
-            &default_decorate_req);
+            std::move(req),
+            key,
+            nullptr);
 }
 
 template<class NextLayer, bool deflateSupported>
@@ -291,22 +296,26 @@ template<class HandshakeHandler>
 BOOST_ASIO_INITFN_RESULT_TYPE(
     HandshakeHandler, void(error_code))
 stream<NextLayer, deflateSupported>::
-async_handshake(response_type& res,
+async_handshake(
+    response_type& res,
     string_view host,
-        string_view target,
-            HandshakeHandler&& handler)
+    string_view target,
+    HandshakeHandler&& handler)
 {
     static_assert(is_async_stream<next_layer_type>::value,
         "AsyncStream type requirements not met");
+    detail::sec_ws_key_type key;
+    auto req = impl_->build_request(
+        key, host, target, &default_decorate_req);
     return net::async_initiate<
         HandshakeHandler,
         void(error_code)>(
             run_handshake_op{},
             handler,
             impl_,
-            &res,
-            host, target,
-            &default_decorate_req);
+            std::move(req),
+            key,
+            &res);
 }
 
 template<class NextLayer, bool deflateSupported>
@@ -478,15 +487,18 @@ async_handshake_ex(string_view host,
     static_assert(detail::is_request_decorator<
             RequestDecorator>::value,
         "RequestDecorator requirements not met");
+    detail::sec_ws_key_type key;
+    auto req = impl_->build_request(
+        key, host, target, decorator);
     return net::async_initiate<
         HandshakeHandler,
         void(error_code)>(
             run_handshake_op{},
             handler,
             impl_,
-            nullptr,
-            host, target,
-            decorator);
+            std::move(req),
+            key,
+            nullptr);
 }
 
 template<class NextLayer, bool deflateSupported>
@@ -509,15 +521,18 @@ async_handshake_ex(response_type& res,
     static_assert(detail::is_request_decorator<
             RequestDecorator>::value,
         "RequestDecorator requirements not met");
+    detail::sec_ws_key_type key;
+    auto req = impl_->build_request(
+        key, host, target, decorator);
     return net::async_initiate<
         HandshakeHandler,
         void(error_code)>(
             run_handshake_op{},
             handler,
             impl_,
-            &res,
-            host, target,
-            decorator);
+            std::move(req),
+            key,
+            &res);
 }
 
 } // websocket
diff --git a/include/boost/beast/websocket/impl/read.hpp b/include/boost/beast/websocket/impl/read.hpp
index fe11d81c..ea8a278d 100644
--- a/include/boost/beast/websocket/impl/read.hpp
+++ b/include/boost/beast/websocket/impl/read.hpp
@@ -727,7 +727,7 @@ struct stream<NextLayer, deflateSupported>::
     operator()(
         ReadHandler&& h,
         boost::shared_ptr<impl_type> const& sp,
-        DynamicBuffer& b,
+        DynamicBuffer* b,
         std::size_t limit,
         bool some)
     {
@@ -745,7 +745,7 @@ struct stream<NextLayer, deflateSupported>::
             DynamicBuffer>(
                 std::forward<ReadHandler>(h),
                 sp,
-                b,
+                *b,
                 limit,
                 some);
     }
@@ -811,7 +811,7 @@ async_read(DynamicBuffer& buffer, ReadHandler&& handler)
             run_read_op{},
             handler,
             impl_,
-            buffer,
+            &buffer,
             0,
             false);
 }
@@ -889,7 +889,7 @@ async_read_some(
             run_read_op{},
             handler,
             impl_,
-            buffer,
+            &buffer,
             limit,
             true);
 }
diff --git a/test/beast/core/rate_policy.cpp b/test/beast/core/rate_policy.cpp
index 09abe44b..bb520945 100644
--- a/test/beast/core/rate_policy.cpp
+++ b/test/beast/core/rate_policy.cpp
@@ -18,9 +18,6 @@ class RatePolicy
 {
     friend class rate_policy_access;
 
-    static std::size_t constexpr all =
-        (std::numeric_limits<std::size_t>::max)();
-
     std::size_t
     available_read_bytes();
 
diff --git a/test/doc/core_1_refresher.cpp b/test/doc/core_1_refresher.cpp
index 30f22c61..d2d68470 100644
--- a/test/doc/core_1_refresher.cpp
+++ b/test/doc/core_1_refresher.cpp
@@ -343,7 +343,7 @@ template<
     class CompletionToken>
 auto
 async_write(
-    AsyncWriteStream& stream,
+    AsyncWriteStream* stream,                       // references are passed as pointers
     ConstBufferSequence const& buffers,
     CompletionToken&& token)                        // a handler, or a special object.
     ->
@@ -379,9 +379,9 @@ async_write(
     return net::async_initiate<
         CompletionToken,
         void(error_code, std::size_t)>(
-            run_async_write{},              // the "initiation" object.
-            token,                          // must be first.
-            stream,                         // additional captured arguments are
+            run_async_write{},              // The "initiation" object.
+            token,                          // Token must come before other arguments.
+            &stream,                        // Additional captured arguments are
             buffers);                       //   forwarded to the initiation object.
 
 //]